@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-6FZYCKXB.js

@@ -0,0 +1,2065 @@
+import {
+  EXTENDED_CHART_DOORS,
+  parseChart,
+  parseFunctionChart,
+  parseFunnel,
+  parseHeatmap,
+  parseSankey,
+  parseScatter
+} from "./chunk-P235SVAH.js";
+import {
+  parseCycle
+} from "./chunk-6HO5ZTXK.js";
+import {
+  parseJourneyMap
+} from "./chunk-44CM72SQ.js";
+import {
+  parsePyramid
+} from "./chunk-76OWZ3BA.js";
+import {
+  parseRing
+} from "./chunk-MO5YHHMQ.js";
+import {
+  parseTreemap
+} from "./chunk-WCSOJFU3.js";
+import {
+  parseBlock
+} from "./chunk-7JEGTRLD.js";
+import {
+  allTasks,
+  parseRaci
+} from "./chunk-RYEGFMUO.js";
+import {
+  parseInfra
+} from "./chunk-33LCUH4H.js";
+import {
+  parseGantt
+} from "./chunk-XAKEUMEJ.js";
+import {
+  parseMap
+} from "./chunk-BUPDIHML.js";
+import {
+  parseBoxesAndLines
+} from "./chunk-BUVJFRPY.js";
+import {
+  parseSwimlane
+} from "./chunk-WVAJFAIA.js";
+import {
+  parseMindmap
+} from "./chunk-EB6FPQUP.js";
+import {
+  parseWireframe
+} from "./chunk-EVCVDTXE.js";
+import {
+  parseTechRadar
+} from "./chunk-NURGB5Z4.js";
+import {
+  looksLikeERDiagram,
+  parseERDiagram
+} from "./chunk-L66GEFB6.js";
+import {
+  looksLikeOrg,
+  parseOrg
+} from "./chunk-RVMRZAPB.js";
+import {
+  looksLikeSitemap,
+  parseSitemap
+} from "./chunk-AN2MOO5T.js";
+import {
+  looksLikePert,
+  parsePert
+} from "./chunk-RTLBSQ3G.js";
+import {
+  parseEventLine
+} from "./chunk-5QXL4NYS.js";
+import {
+  parseTimelineEventLine
+} from "./chunk-GMR5MFHJ.js";
+import {
+  parseVersionControl
+} from "./chunk-ERLBPDGU.js";
+import {
+  parseKanban
+} from "./chunk-AELOBFW5.js";
+import {
+  parseC4
+} from "./chunk-2DXMZRWJ.js";
+import {
+  looksLikeSequence,
+  parseSequenceDgmo
+} from "./chunk-SML67VPV.js";
+import {
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  looksLikeFlowchart,
+  parseFlowchart
+} from "./chunk-LIOHW36Z.js";
+import {
+  looksLikeState,
+  parseState
+} from "./chunk-3MQQNXPD.js";
+import {
+  looksLikeClassDiagram,
+  parseClassDiagram
+} from "./chunk-RUNNI6VE.js";
+import {
+  TIMELINE_REGISTRY,
+  collectIndentedValues,
+  extractColor,
+  measureIndent,
+  normalizeNumericToken,
+  parseFirstLine,
+  peelTrailingColorName,
+  splitNameAndMeta,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  dedupeDiagnostics,
+  formatDgmoError,
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/visualizations/types.ts
+var DEFAULT_CLOUD_OPTIONS = {
+  rotate: "none",
+  max: 0,
+  minSize: 14,
+  maxSize: 80
+};
+
+// src/visualizations/parse.ts
+function parseVisualization(content, palette) {
+  return parseVisualizationFull(content, palette);
+}
+function parseVisualizationFull(content, palette) {
+  const result = {
+    type: null,
+    title: null,
+    titleLineNumber: null,
+    orientation: "horizontal",
+    periods: [],
+    data: [],
+    words: [],
+    cloudOptions: { ...DEFAULT_CLOUD_OPTIONS },
+    links: [],
+    arcOrder: "appearance",
+    arcNodeGroups: [],
+    timelineEvents: [],
+    timelineGroups: [],
+    timelineEras: [],
+    timelineMarkers: [],
+    timelineTagGroups: [],
+    timelineSort: null,
+    timelineScale: true,
+    timelineSwimlanes: false,
+    vennSets: [],
+    vennOverlaps: [],
+    quadrantLabels: {
+      topRight: null,
+      topLeft: null,
+      bottomLeft: null,
+      bottomRight: null
+    },
+    quadrantPoints: [],
+    quadrantXAxis: null,
+    quadrantXAxisLineNumber: null,
+    quadrantYAxis: null,
+    quadrantYAxisLineNumber: null,
+    quadrantTitleLineNumber: null,
+    diagnostics: [],
+    error: null
+  };
+  const fail = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return result;
+  };
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!content?.trim()) {
+    return fail(0, "Empty content");
+  }
+  const lines = content.split("\n");
+  const freeformLines = [];
+  let currentArcGroup = null;
+  let currentTimelineGroup = null;
+  let currentTimelineGroupMeta = {};
+  let currentTimelineTagGroup = null;
+  let inTimelineEraBlock = false;
+  let timelineEraBlockIndent = 0;
+  let inTimelineMarkerBlock = false;
+  let timelineMarkerBlockIndent = 0;
+  let inSlopePeriodBlock = false;
+  const timelineAliasMap = /* @__PURE__ */ new Map();
+  const VALID_D3_TYPES = /* @__PURE__ */ new Set([
+    "slope",
+    "wordcloud",
+    "arc",
+    "timeline",
+    "venn",
+    "quadrant",
+    "sequence"
+  ]);
+  let firstLineParsed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = rawLine.trim();
+    const indent = measureIndent(rawLine);
+    const lineNumber = i + 1;
+    if (!line) continue;
+    if (line.startsWith("//")) continue;
+    if (!firstLineParsed) {
+      firstLineParsed = true;
+      const firstLineResult = parseFirstLine(line);
+      if (firstLineResult && VALID_D3_TYPES.has(firstLineResult.chartType)) {
+        result.type = firstLineResult.chartType;
+        if (firstLineResult.title) {
+          result.title = firstLineResult.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    if (result.type === "timeline" && indent === 0) {
+      const tagBlockMatch = matchTagBlockHeading(line);
+      if (tagBlockMatch) {
+        const newGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        currentTimelineTagGroup = newGroup;
+        if (tagBlockMatch.alias) {
+          timelineAliasMap.set(
+            tagBlockMatch.alias.toLowerCase(),
+            tagBlockMatch.name.toLowerCase()
+          );
+        } else {
+          timelineAliasMap.set(
+            tagBlockMatch.name.toLowerCase(),
+            tagBlockMatch.name.toLowerCase()
+          );
+        }
+        result.timelineTagGroups.push(newGroup);
+        continue;
+      }
+    }
+    if (currentTimelineTagGroup && indent > 0) {
+      const { text: entryText, isDefault } = stripDefaultModifier(line);
+      const { label, color } = extractColor(
+        entryText,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      if (color) {
+        if (isDefault) {
+          currentTimelineTagGroup.defaultValue = label;
+        } else if (currentTimelineTagGroup.entries.length === 0) {
+          currentTimelineTagGroup.defaultValue = label;
+        }
+        currentTimelineTagGroup.entries.push({
+          value: label,
+          color,
+          lineNumber
+        });
+        continue;
+      }
+    }
+    if (currentTimelineTagGroup && indent === 0) {
+      currentTimelineTagGroup = null;
+    }
+    if (result.type === "timeline") {
+      const tlGroupMatch = line.match(/^\[(.+?)\]\s*(.*?)\s*$/);
+      if (tlGroupMatch) {
+        const name = tlGroupMatch[1].trim();
+        const trailing = tlGroupMatch[2] ?? "";
+        let color = null;
+        let groupMeta = {};
+        if (trailing) {
+          const { label: peeled, colorName } = peelTrailingColorName(
+            " " + trailing
+          );
+          if (colorName && peeled.trim() === "") {
+            color = resolveColorWithDiagnostic(
+              colorName,
+              lineNumber,
+              result.diagnostics,
+              palette
+            ) ?? null;
+          } else {
+            const tlRegistry = withTagAliases(
+              TIMELINE_REGISTRY,
+              /* @__PURE__ */ new Set([
+                ...timelineAliasMap.keys(),
+                ...timelineAliasMap.values()
+              ])
+            );
+            const split = splitNameAndMeta(
+              trailing,
+              tlRegistry,
+              timelineAliasMap
+            );
+            if (split.color) {
+              color = resolveColorWithDiagnostic(
+                split.color,
+                lineNumber,
+                result.diagnostics,
+                palette
+              ) ?? null;
+            }
+            groupMeta = { ...split.meta };
+            if (groupMeta["color"]) {
+              color = resolveColorWithDiagnostic(
+                groupMeta["color"],
+                lineNumber,
+                result.diagnostics,
+                palette
+              ) ?? null;
+              delete groupMeta["color"];
+            }
+          }
+        }
+        result.timelineGroups.push({
+          name,
+          color,
+          metadata: groupMeta,
+          lineNumber
+        });
+        currentTimelineGroup = name;
+        currentTimelineGroupMeta = groupMeta;
+        continue;
+      }
+    }
+    const groupMatch = line.match(
+      /^\[(.+?)\](?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+    );
+    if (groupMatch) {
+      if (result.type === "arc") {
+        const name = groupMatch[1].trim();
+        const color = groupMatch[2] ? resolveColorWithDiagnostic(
+          groupMatch[2].trim(),
+          lineNumber,
+          result.diagnostics,
+          palette
+        ) ?? null : null;
+        result.arcNodeGroups.push({ name, nodes: [], color, lineNumber });
+        currentArcGroup = name;
+      }
+      continue;
+    }
+    if (/^#{2,}\s+/.test(line) && (result.type === "arc" || result.type === "timeline")) {
+      const name = line.replace(/^#{2,}\s+/, "").replace(/\s*\([^)]*\)\s*$/, "").trim();
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `'## ${name}' is no longer supported. Use '[${name}]' instead`,
+          "warning"
+        )
+      );
+      continue;
+    }
+    if (indent === 0) {
+      currentArcGroup = null;
+      currentTimelineGroup = null;
+      currentTimelineGroupMeta = {};
+    }
+    if (result.type === "arc") {
+      const linkMatch = line.match(
+        /^(.+?)\s*->\s*(.+?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?(?:\s+(-?[\d,_]+(?:\.[\d]+)?))?$/
+      );
+      if (linkMatch) {
+        const source = linkMatch[1].trim();
+        const target = linkMatch[2].trim();
+        if (source.endsWith(":") || target.endsWith(":")) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              `Trailing colon is not valid in arc edges \u2014 write '${source.replace(/:$/, "")} -> ${target.replace(/:$/, "")}' instead`
+            )
+          );
+          continue;
+        }
+        const linkColor = linkMatch[3] ? resolveColorWithDiagnostic(
+          linkMatch[3].trim(),
+          lineNumber,
+          result.diagnostics,
+          palette
+        ) ?? null : null;
+        const arcValue = linkMatch[4] ? parseFloat(normalizeNumericToken(linkMatch[4]) ?? linkMatch[4]) : 1;
+        result.links.push({
+          source,
+          target,
+          value: arcValue,
+          color: linkColor,
+          lineNumber
+        });
+        if (currentArcGroup !== null) {
+          const group = result.arcNodeGroups.find(
+            (g) => g.name === currentArcGroup
+          );
+          if (group) {
+            const allGrouped = new Set(
+              result.arcNodeGroups.flatMap((g) => g.nodes)
+            );
+            if (!allGrouped.has(source)) group.nodes.push(source);
+            if (!allGrouped.has(target)) group.nodes.push(target);
+          }
+        }
+        continue;
+      }
+    }
+    if (result.type === "timeline" && inTimelineEraBlock) {
+      if (indent <= timelineEraBlockIndent) {
+        inTimelineEraBlock = false;
+      } else {
+        if (line.startsWith("//")) continue;
+        const eraEntryMatch = line.match(
+          /^(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s*(?:->|\u2013>)\s*(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s+(.+?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+        );
+        if (eraEntryMatch) {
+          const colorAnnotation = eraEntryMatch[4]?.trim() || null;
+          result.timelineEras.push({
+            // Capture groups 1-3 guaranteed by the regex match.
+            startDate: eraEntryMatch[1],
+            endDate: eraEntryMatch[2],
+            label: eraEntryMatch[3].trim(),
+            color: colorAnnotation ? resolveColorWithDiagnostic(
+              colorAnnotation,
+              lineNumber,
+              result.diagnostics,
+              palette
+            ) ?? null : null,
+            lineNumber
+          });
+        } else {
+          warn(
+            lineNumber,
+            `Unrecognized era entry: "${line}" \u2014 use '<start> -> <end> Label [color]' (e.g. '1716 -> 1717 Reign').`
+          );
+        }
+        continue;
+      }
+    }
+    if (result.type === "timeline" && inTimelineMarkerBlock) {
+      if (indent <= timelineMarkerBlockIndent) {
+        inTimelineMarkerBlock = false;
+      } else {
+        if (line.startsWith("//")) continue;
+        const markerEntryMatch = line.match(
+          /^(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s+(.+?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+        );
+        if (markerEntryMatch) {
+          const colorAnnotation = markerEntryMatch[3]?.trim() || null;
+          result.timelineMarkers.push({
+            // Capture groups 1-2 guaranteed by the regex match.
+            date: markerEntryMatch[1],
+            label: markerEntryMatch[2].trim(),
+            color: colorAnnotation ? resolveColorWithDiagnostic(
+              colorAnnotation,
+              lineNumber,
+              result.diagnostics,
+              palette
+            ) ?? null : null,
+            lineNumber
+          });
+        } else {
+          warn(
+            lineNumber,
+            `Unrecognized marker entry: "${line}" \u2014 use '<date> Label [color]' (e.g. '1776 Independence').`
+          );
+        }
+        continue;
+      }
+    }
+    if (result.type === "timeline") {
+      if (line.toLowerCase() === "era") {
+        inTimelineEraBlock = true;
+        timelineEraBlockIndent = indent;
+        continue;
+      }
+      if (line.toLowerCase() === "marker") {
+        inTimelineMarkerBlock = true;
+        timelineMarkerBlockIndent = indent;
+        continue;
+      }
+      const eraMatch = line.match(
+        /^era\s+(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s*(?:->|\u2013>)\s*(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s+(.+?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+      );
+      if (eraMatch) {
+        const colorAnnotation = eraMatch[4]?.trim() || null;
+        result.timelineEras.push({
+          // Capture groups 1-3 guaranteed by the regex match.
+          startDate: eraMatch[1],
+          endDate: eraMatch[2],
+          label: eraMatch[3].trim(),
+          color: colorAnnotation ? resolveColorWithDiagnostic(
+            colorAnnotation,
+            lineNumber,
+            result.diagnostics,
+            palette
+          ) ?? null : null,
+          lineNumber
+        });
+        continue;
+      }
+      const markerMatch = line.match(
+        /^marker\s+(\d{4}(?:-\d{2})?(?:-\d{2}(?: \d{2}:\d{2})?)?)\s+(.+?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+      );
+      if (markerMatch) {
+        const colorAnnotation = markerMatch[3]?.trim() || null;
+        result.timelineMarkers.push({
+          // Capture groups 1-2 guaranteed by the regex match.
+          date: markerMatch[1],
+          label: markerMatch[2].trim(),
+          color: colorAnnotation ? resolveColorWithDiagnostic(
+            colorAnnotation,
+            lineNumber,
+            result.diagnostics,
+            palette
+          ) ?? null : null,
+          lineNumber
+        });
+        continue;
+      }
+    }
+    if (result.type === "timeline") {
+      const sortMatch = line.match(/^sort\s+(time|group|tag:(.+))$/i);
+      if (sortMatch) {
+        const kind = sortMatch[1].toLowerCase();
+        if (kind === "time") result.timelineSort = "time";
+        else if (kind === "group") result.timelineSort = "group";
+        else {
+          result.timelineSort = "tag";
+          result.timelineDefaultSwimlaneTG = sortMatch[2].trim();
+        }
+        continue;
+      }
+    }
+    if (result.type === "timeline") {
+      const lower = line.toLowerCase();
+      if (lower === "no-scale") {
+        result.timelineScale = false;
+        continue;
+      }
+      if (lower === "swimlanes") {
+        result.timelineSwimlanes = true;
+        continue;
+      }
+      const laneByMatch = line.match(/^lane-by\s+(.+)$/i);
+      if (laneByMatch) {
+        result.timelineSort = "tag";
+        result.timelineDefaultSwimlaneTG = laneByMatch[1].trim();
+        continue;
+      }
+      const activeTagMatch = line.match(/^active-tag\s+(.+)$/i);
+      if (activeTagMatch) {
+        result.timelineActiveTag = activeTagMatch[1].trim();
+        continue;
+      }
+    }
+    if (result.type === "timeline") {
+      const tlRegistry = withTagAliases(
+        TIMELINE_REGISTRY,
+        /* @__PURE__ */ new Set([...timelineAliasMap.keys(), ...timelineAliasMap.values()])
+      );
+      const eventResult = parseTimelineEventLine(
+        line,
+        lineNumber,
+        currentTimelineGroup,
+        currentTimelineGroupMeta,
+        timelineAliasMap,
+        tlRegistry
+      );
+      if (eventResult) {
+        result.diagnostics.push(...eventResult.diagnostics);
+        if (eventResult.event) {
+          result.timelineEvents.push(eventResult.event);
+        }
+        continue;
+      }
+      if (!/^(era|marker|tag|sort|active-tag|swimlanes|no-scale|lane-by)\b/i.test(
+        line
+      ) && !line.startsWith("[")) {
+        warn(lineNumber, `Expected a date at the start \u2014 e.g., '1718 ${line}'`);
+        continue;
+      }
+    }
+    if (result.type === "venn") {
+      if (/^(solid-fill|no-name|no-value|no-percent|no-title)$/i.test(line)) {
+      } else if (/\+/.test(line)) {
+        const knownSetRefs = /* @__PURE__ */ new Set();
+        for (const s of result.vennSets) {
+          knownSetRefs.add(s.name.toLowerCase());
+          if (s.alias) knownSetRefs.add(s.alias.toLowerCase());
+        }
+        const segments = line.split("+").map((s) => s.trim()).filter(Boolean);
+        if (segments.length >= 2) {
+          const rawSets = segments.slice(0, -1);
+          const lastSeg = segments[segments.length - 1];
+          const words = lastSeg.split(/\s+/);
+          let matchLen = 0;
+          for (let w = words.length; w >= 1; w--) {
+            const candidate = words.slice(0, w).join(" ");
+            if (knownSetRefs.has(candidate.toLowerCase())) {
+              matchLen = w;
+              break;
+            }
+          }
+          let lastSetRef;
+          let label;
+          if (matchLen > 0) {
+            lastSetRef = words.slice(0, matchLen).join(" ");
+            label = words.length > matchLen ? words.slice(matchLen).join(" ") : null;
+          } else {
+            lastSetRef = words[0];
+            label = words.length > 1 ? words.slice(1).join(" ") : null;
+          }
+          rawSets.push(lastSetRef);
+          result.vennOverlaps.push({ sets: rawSets, label, lineNumber });
+          continue;
+        }
+      }
+      if (!/^(solid-fill|no-name|no-value|no-percent|no-title)$/i.test(line)) {
+        const { label: lineWithoutColor, colorName } = peelTrailingColorName(line);
+        let color = null;
+        if (colorName) {
+          color = resolveColorWithDiagnostic(
+            colorName,
+            lineNumber,
+            result.diagnostics,
+            palette
+          ) ?? null;
+        }
+        const setDeclMatch = lineWithoutColor.match(
+          /^(.+?)(?:\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11}))?\s*$/i
+        );
+        if (setDeclMatch) {
+          const name = setDeclMatch[1].trim();
+          const alias = setDeclMatch[2]?.trim() ?? null;
+          result.vennSets.push({ name, alias, color, lineNumber });
+          continue;
+        }
+      }
+    }
+    if (result.type === "quadrant") {
+      const xAxisMatch = line.match(/^x-label\s+(.*)/i);
+      if (xAxisMatch) {
+        const val = xAxisMatch[1].trim();
+        let parts;
+        if (val) {
+          parts = val.split(",").map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
+        if (parts.length >= 2) {
+          result.quadrantXAxis = [parts[0], parts[1]];
+          result.quadrantXAxisLineNumber = lineNumber;
+        }
+        continue;
+      }
+      const yAxisMatch = line.match(/^y-label\s+(.*)/i);
+      if (yAxisMatch) {
+        const val = yAxisMatch[1].trim();
+        let parts;
+        if (val) {
+          parts = val.split(",").map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
+        if (parts.length >= 2) {
+          result.quadrantYAxis = [parts[0], parts[1]];
+          result.quadrantYAxisLineNumber = lineNumber;
+        }
+        continue;
+      }
+      const quadrantLabelRe = /^(top-right|top-left|bottom-left|bottom-right)\s+(.+)/i;
+      const quadrantMatch = line.match(quadrantLabelRe);
+      if (quadrantMatch) {
+        const position = quadrantMatch[1].toLowerCase();
+        const labelPart = quadrantMatch[2].trim();
+        const { label: text, colorName } = peelTrailingColorName(labelPart);
+        const color = colorName ? resolveColorWithDiagnostic(
+          colorName,
+          lineNumber,
+          result.diagnostics,
+          palette
+        ) ?? null : null;
+        const label = { text, color, lineNumber };
+        if (position === "top-right") result.quadrantLabels.topRight = label;
+        else if (position === "top-left") result.quadrantLabels.topLeft = label;
+        else if (position === "bottom-left")
+          result.quadrantLabels.bottomLeft = label;
+        else if (position === "bottom-right")
+          result.quadrantLabels.bottomRight = label;
+        continue;
+      }
+      const pointMatch = line.match(
+        /^(.+?)\s+(-?[0-9][0-9,_]*(?:\.[0-9]+)?)\s*([,\s])\s*(-?[0-9][0-9,_]*(?:\.[0-9]+)?)\s*$/
+      );
+      if (pointMatch) {
+        const label = pointMatch[1].trim();
+        const lowerLabel = label.toLowerCase();
+        if (lowerLabel !== "top-right" && lowerLabel !== "top-left" && lowerLabel !== "bottom-left" && lowerLabel !== "bottom-right") {
+          const x = parseFloat(
+            normalizeNumericToken(pointMatch[2]) ?? pointMatch[2]
+          );
+          const y = parseFloat(
+            normalizeNumericToken(pointMatch[4]) ?? pointMatch[4]
+          );
+          result.quadrantPoints.push({
+            label,
+            x,
+            y,
+            lineNumber
+          });
+        }
+        continue;
+      }
+    }
+    const spaceIdx = line.indexOf(" ");
+    if (spaceIdx >= 0) {
+      const firstToken = line.substring(0, spaceIdx).toLowerCase();
+      const restValue = line.substring(spaceIdx + 1).trim();
+      if (firstToken === "chart" && VALID_D3_TYPES.has(restValue.toLowerCase())) {
+        result.type = restValue.toLowerCase();
+        continue;
+      }
+      if (firstToken === "title") {
+        result.title = restValue;
+        result.titleLineNumber = lineNumber;
+        if (result.type === "quadrant") {
+          result.quadrantTitleLineNumber = lineNumber;
+        }
+        continue;
+      }
+      if (firstToken === "order") {
+        const v = restValue.toLowerCase();
+        if (v === "name" || v === "group" || v === "degree") {
+          result.arcOrder = v;
+        }
+        continue;
+      }
+      if (firstToken === "layout") {
+        const v = restValue.toLowerCase();
+        if (v === "arc" || v === "chord") result.layout = v;
+        continue;
+      }
+      if (firstToken === "rotate") {
+        const v = restValue.toLowerCase();
+        if (v === "none" || v === "mixed" || v === "angled") {
+          result.cloudOptions.rotate = v;
+        }
+        continue;
+      }
+      if (firstToken === "max") {
+        const v = parseInt(restValue, 10);
+        if (!isNaN(v) && v > 0) {
+          result.cloudOptions.max = v;
+        }
+        continue;
+      }
+      if (firstToken === "size") {
+        const parts = restValue.split(",").map((s) => parseInt(s.trim(), 10));
+        if (parts.length === 2 && parts.every((n) => !isNaN(n) && n > 0) && // In-bounds by length === 2 check.
+        parts[0] < parts[1]) {
+          result.cloudOptions.minSize = parts[0];
+          result.cloudOptions.maxSize = parts[1];
+        }
+        continue;
+      }
+    }
+    {
+      const bareToken = line.toLowerCase();
+      if (bareToken === "no-name") {
+        result.noName = true;
+        continue;
+      }
+      if (bareToken === "no-value") {
+        result.noValue = true;
+        continue;
+      }
+      if (bareToken === "no-percent") {
+        result.noPercent = true;
+        continue;
+      }
+      if (bareToken === "solid-fill") {
+        result.solidFill = true;
+        continue;
+      }
+      if (bareToken === "no-title") {
+        result.noTitle = true;
+        continue;
+      }
+      if (bareToken.startsWith("no-")) {
+        continue;
+      }
+    }
+    if (result.type === "slope") {
+      if (inSlopePeriodBlock) {
+        if (indent > 0) {
+          result.periods.push(line);
+          continue;
+        }
+        inSlopePeriodBlock = false;
+      }
+      if (result.data.length === 0) {
+        const periodMatch = line.match(/^period\b(.*)$/i);
+        if (periodMatch) {
+          if (result.periods.length > 0 && !inSlopePeriodBlock) {
+            warn(
+              lineNumber,
+              `Duplicate 'period' directive \u2014 periods are already defined`
+            );
+          }
+          const rest = periodMatch[1].trim();
+          if (rest) {
+            const periodLabels = rest.split(/\s+/);
+            result.periods.push(...periodLabels);
+          } else {
+            inSlopePeriodBlock = true;
+          }
+          continue;
+        }
+      }
+      if (result.periods.length === 0 && line.includes(",") && !line.includes(":")) {
+        const tokens = line.split(",").map((t) => t.trim()).filter(Boolean);
+        const looksLikePeriods = tokens.length >= 2 && tokens.every((t) => t.length <= 20);
+        if (looksLikePeriods) {
+          return fail(
+            lineNumber,
+            `Period lines require the 'period' keyword \u2014 use 'period ${tokens.join(" ")}'`
+          );
+        }
+      }
+      if (line.includes(":")) {
+        const colonPos = line.indexOf(":");
+        const afterColon = line.substring(colonPos + 1).trim();
+        const numericTokens = afterColon.split(/[,\s]+/).filter((v) => /^-?\d/.test(v));
+        if (numericTokens.length >= 1) {
+          const allTokens = afterColon.split(/[,\s]+/).filter(Boolean);
+          if (numericTokens.length >= allTokens.length * 0.5) {
+            const label = line.substring(0, colonPos).trim();
+            return fail(
+              lineNumber,
+              `Colons are no longer used in slope data rows \u2014 use '${label} ${numericTokens.join(" ")}'`
+            );
+          }
+        }
+      }
+      if (result.periods.length >= 2) {
+        const P = result.periods.length;
+        const tokens = line.split(/\s+/);
+        const values = [];
+        let rightIdx = tokens.length - 1;
+        while (rightIdx >= 0 && values.length < P) {
+          const tok = tokens[rightIdx];
+          const raw = normalizeNumericToken(tok) ?? tok;
+          const num = parseFloat(raw);
+          if (!isNaN(num) && /^-?\d/.test(raw)) {
+            values.unshift(num);
+            rightIdx--;
+          } else {
+            break;
+          }
+        }
+        if (values.length < P) {
+          warn(
+            lineNumber,
+            `Data row has ${values.length} numeric value(s) but ${P} period(s) are defined \u2014 expected ${P} values`
+          );
+          continue;
+        }
+        const labelTokens = tokens.slice(0, rightIdx + 1);
+        const joinedLabel = labelTokens.join(" ");
+        if (!joinedLabel) {
+          warn(
+            lineNumber,
+            `Data row has no label \u2014 add a label before the numeric values`
+          );
+          continue;
+        }
+        const { label: labelPart, colorName: colorWord } = peelTrailingColorName(joinedLabel);
+        const colorPart = colorWord ? resolveColorWithDiagnostic(
+          colorWord,
+          lineNumber,
+          result.diagnostics,
+          palette
+        ) ?? null : null;
+        if (!labelPart) {
+          warn(
+            lineNumber,
+            `Data row has no label \u2014 add a label before the numeric values`
+          );
+          continue;
+        }
+        if (/^\d[\d,.]*$/.test(labelPart)) {
+          warn(
+            lineNumber,
+            `Label '${labelPart}' looks numeric \u2014 this may indicate too many values or a missing label`
+          );
+        }
+        result.data.push({
+          label: labelPart,
+          values,
+          color: colorPart,
+          lineNumber
+        });
+        continue;
+      }
+      if (firstLineParsed) {
+        warn(lineNumber, `Unexpected line: '${line}'.`);
+      }
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex !== -1) {
+      const rawKey = line.substring(0, colonIndex).trim();
+      const key = rawKey.toLowerCase();
+      const colorMatch = rawKey.match(/^(.+?)\(([^)]+)\)\s*$/);
+      if (key === "title") {
+        result.title = line.substring(colonIndex + 1).trim();
+        result.titleLineNumber = lineNumber;
+        if (result.type === "quadrant") {
+          result.quadrantTitleLineNumber = lineNumber;
+        }
+        continue;
+      }
+      if (key === "order") {
+        const v = line.substring(colonIndex + 1).trim().toLowerCase();
+        if (v === "name" || v === "group" || v === "degree") {
+          result.arcOrder = v;
+        }
+        continue;
+      }
+      if (key === "rotate") {
+        const v = line.substring(colonIndex + 1).trim().toLowerCase();
+        if (v === "none" || v === "mixed" || v === "angled") {
+          result.cloudOptions.rotate = v;
+        }
+        continue;
+      }
+      if (key === "max") {
+        const v = parseInt(line.substring(colonIndex + 1).trim(), 10);
+        if (!isNaN(v) && v > 0) {
+          result.cloudOptions.max = v;
+        }
+        continue;
+      }
+      if (key === "size") {
+        const v = line.substring(colonIndex + 1).trim();
+        const parts = v.split(",").map((s) => parseInt(s.trim(), 10));
+        if (parts.length === 2 && parts.every((n) => !isNaN(n) && n > 0) && // In-bounds by length === 2 check.
+        parts[0] < parts[1]) {
+          result.cloudOptions.minSize = parts[0];
+          result.cloudOptions.maxSize = parts[1];
+        }
+        continue;
+      }
+      const labelPart = colorMatch ? colorMatch[1].trim() : rawKey;
+      const colorPart = colorMatch ? resolveColorWithDiagnostic(
+        colorMatch[2].trim(),
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) ?? null : null;
+      const valuePart = line.substring(colonIndex + 1).trim();
+      const values = valuePart.split(",").map((v) => v.trim());
+      const numericValues = [];
+      let allNumeric = true;
+      for (const v of values) {
+        const num = parseFloat(v);
+        if (isNaN(num)) {
+          allNumeric = false;
+          break;
+        }
+        numericValues.push(num);
+      }
+      if (allNumeric && numericValues.length > 0) {
+        if (result.type !== "wordcloud") {
+          result.data.push({
+            label: labelPart,
+            values: numericValues,
+            color: colorPart,
+            lineNumber
+          });
+          continue;
+        }
+      }
+    }
+    if (result.type === "wordcloud") {
+      if (colonIndex === -1 && !line.includes(" ")) {
+        result.words.push({ text: line, weight: 10, lineNumber });
+      } else if (colonIndex === -1) {
+        const lastSpace = line.lastIndexOf(" ");
+        const rawWeight = lastSpace >= 0 ? line.substring(lastSpace + 1) : "";
+        const maybeWeight = lastSpace >= 0 ? parseFloat(normalizeNumericToken(rawWeight) ?? rawWeight) : NaN;
+        if (lastSpace >= 0 && !isNaN(maybeWeight) && maybeWeight > 0) {
+          const wordText = line.substring(0, lastSpace).trim();
+          result.words.push({
+            text: wordText,
+            weight: maybeWeight,
+            lineNumber
+          });
+        } else {
+          freeformLines.push(line);
+        }
+      } else {
+        freeformLines.push(line);
+      }
+      continue;
+    }
+    if (firstLineParsed) {
+      warn(lineNumber, `Unexpected line: '${line}'.`);
+    }
+  }
+  if (!result.type) {
+    const validD3Types = [...VALID_D3_TYPES];
+    const firstNonEmpty = lines.find((l) => l.trim() && !l.trim().startsWith("//"))?.trim() ?? "";
+    const hint = suggest(
+      firstNonEmpty.split(/\s/)[0].toLowerCase(),
+      validD3Types
+    );
+    let msg = `Unsupported chart type: "${firstNonEmpty.split(/\s/)[0]}". Supported types: ${validD3Types.join(", ")}`;
+    if (hint) msg += `. ${hint}`;
+    return fail(1, msg);
+  }
+  if (result.type === "sequence") {
+    return result;
+  }
+  if (result.type === "wordcloud") {
+    if (result.words.length === 0 && freeformLines.length > 0) {
+      result.words = tokenizeFreeformText(freeformLines.join(" "));
+    }
+    if (result.words.length === 0) {
+      warn(
+        1,
+        'No words found. Add words as "word weight" (space-separated), one per line, or paste freeform text'
+      );
+    }
+    if (result.cloudOptions.max > 0 && result.words.length > result.cloudOptions.max) {
+      result.words = result.words.slice().sort((a, b) => b.weight - a.weight).slice(0, result.cloudOptions.max);
+    }
+    return result;
+  }
+  if (result.type === "arc") {
+    if (result.links.length === 0) {
+      warn(
+        1,
+        'No links found. Add links as "Source -> Target weight" (e.g., "Alice -> Bob 5")'
+      );
+    }
+    if (result.arcNodeGroups.length > 0) {
+      if (result.arcOrder === "name" || result.arcOrder === "degree") {
+        warn(
+          1,
+          `Cannot use "order ${result.arcOrder}" with [Group] headers. Use "order group" or remove group headers.`
+        );
+        result.arcOrder = "group";
+      }
+      if (result.arcOrder === "appearance") {
+        result.arcOrder = "group";
+      }
+    }
+    return result;
+  }
+  if (result.type === "timeline") {
+    if (result.timelineEvents.length === 0) {
+      warn(
+        1,
+        'No events found. Add events like "1718 Event Name" or "1716 -> 1717 Event Name"'
+      );
+    }
+    if (result.timelineTagGroups.length > 0) {
+      validateTagValues(
+        result.timelineEvents,
+        result.timelineTagGroups,
+        (line, msg) => result.diagnostics.push(makeDgmoError(line, msg, "warning")),
+        suggest
+      );
+      validateTagGroupNames(
+        result.timelineTagGroups,
+        (line, msg) => result.diagnostics.push(makeDgmoError(line, msg, "warning")),
+        (line, msg) => {
+          const diag = makeDgmoError(line, msg);
+          result.diagnostics.push(diag);
+          if (!result.error) result.error = formatDgmoError(diag);
+        }
+      );
+      for (const group of result.timelineTagGroups) {
+        if (!group.defaultValue) continue;
+        const key = tagAttrKey(group.name);
+        for (const event of result.timelineEvents) {
+          if (!event.metadata[key]) {
+            event.metadata[key] = group.defaultValue;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  if (result.type === "venn") {
+    if (result.vennSets.length < 2) {
+      return fail(
+        1,
+        'At least 2 sets are required. Add set names (e.g., "Apples", "Oranges")'
+      );
+    }
+    if (result.vennSets.length > 3) {
+      return fail(1, "Venn diagrams support 2\u20133 sets");
+    }
+    const setNameLower = new Map(
+      result.vennSets.map((s) => [s.name.toLowerCase(), s.name])
+    );
+    const aliasLower = /* @__PURE__ */ new Map();
+    for (const s of result.vennSets) {
+      if (s.alias) aliasLower.set(s.alias.toLowerCase(), s.name);
+    }
+    const resolveSetRef = (ref) => setNameLower.get(ref.toLowerCase()) ?? aliasLower.get(ref.toLowerCase()) ?? null;
+    const validOverlaps = [];
+    for (const ov of result.vennOverlaps) {
+      const resolvedSets = [];
+      let valid = true;
+      for (const ref of ov.sets) {
+        const resolved = resolveSetRef(ref);
+        if (!resolved) {
+          result.diagnostics.push(
+            makeDgmoError(
+              ov.lineNumber,
+              `Intersection references unknown set or alias "${ref}" \u2014 declare the set first on its own line ('Name [as <alias>] [color]', e.g. 'Navigation as nav blue'), then reference it by that name or alias. (\xA716.4)`
+            )
+          );
+          if (!result.error)
+            result.error = formatDgmoError(
+              result.diagnostics[result.diagnostics.length - 1]
+            );
+          valid = false;
+          break;
+        }
+        resolvedSets.push(resolved);
+      }
+      if (valid) validOverlaps.push({ ...ov, sets: resolvedSets.sort() });
+    }
+    result.vennOverlaps = validOverlaps;
+    return result;
+  }
+  if (result.type === "quadrant") {
+    if (result.quadrantPoints.length === 0) {
+      warn(
+        1,
+        'No data points found. Add points as "Label x, y" (e.g., "Item A 0.5, 0.7")'
+      );
+    }
+    return result;
+  }
+  if (result.periods.length < 2) {
+    return fail(
+      1,
+      "Missing 'period' directive. Add 'period 2020 2024' before data rows (minimum 2 periods required)"
+    );
+  }
+  if (result.data.length === 0) {
+    warn(
+      1,
+      "No data lines found. Add data as 'Label value1 value2' (e.g., 'Blackbeard 40 4')"
+    );
+  }
+  for (const item of result.data) {
+    if (item.values.length !== result.periods.length) {
+      warn(
+        item.lineNumber,
+        `Data item "${item.label}" has ${item.values.length} value(s) but ${result.periods.length} period(s) are defined`
+      );
+    }
+  }
+  result.data = result.data.filter(
+    (item) => item.values.length === result.periods.length
+  );
+  return result;
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "is",
+  "am",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "me",
+  "my",
+  "we",
+  "us",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "they",
+  "them",
+  "their",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "how",
+  "when",
+  "where",
+  "why",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "if",
+  "then",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "up",
+  "out",
+  "from",
+  "into",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "again",
+  "there",
+  "here",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "only",
+  "own",
+  "same",
+  "also",
+  "as",
+  "because",
+  "until",
+  "while",
+  "during",
+  "through"
+]);
+function tokenizeFreeformText(text) {
+  const counts = /* @__PURE__ */ new Map();
+  const tokens = text.toLowerCase().split(/[^a-zA-Z']+/).filter(Boolean);
+  for (const raw of tokens) {
+    const word = raw.replace(/^'+|'+$/g, "");
+    if (word.length < 2 || STOP_WORDS.has(word)) continue;
+    counts.set(word, (counts.get(word) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).map(([text2, count]) => ({ text: text2, weight: count, lineNumber: 0 })).sort((a, b) => b.weight - a.weight);
+}
+
+// src/chart-types.ts
+var chartTypes = [
+  // ── Tier 1 — Narrative / architecture diagrams ────────────
+  {
+    id: "journey-map",
+    description: "User experience flow with emotion scores, phases, and annotations"
+  },
+  {
+    id: "c4",
+    description: "System architecture (context, container, component, deployment)"
+  },
+  {
+    id: "er",
+    description: "Database schemas and relationships"
+  },
+  {
+    id: "class",
+    description: "UML class hierarchies"
+  },
+  {
+    id: "sequence",
+    description: "Message request and response interaction flows",
+    fallback: true
+  },
+  {
+    id: "state",
+    description: "State machine / lifecycle transitions"
+  },
+  {
+    id: "infra",
+    description: "Infrastructure traffic flow with RPS computation"
+  },
+  {
+    id: "gantt",
+    description: "Project scheduling with task dependencies and milestones"
+  },
+  {
+    id: "pert",
+    description: "Project network with three-point estimates, critical path, and uncertainty (Beta-PERT, Monte Carlo)"
+  },
+  {
+    id: "swimlane",
+    description: "Cross-functional process flow with lanes, phases and gateways (BPMN-style)"
+  },
+  {
+    id: "version-control",
+    description: "Git / version-control branch-and-merge graph: commits, branches, merges, rebase, HEAD and remote-tracking (gitGraph-style)"
+  },
+  // ── Tier 2 — Specialized structural diagrams ──────────────
+  {
+    id: "timeline",
+    description: "Events, eras, and date ranges"
+  },
+  {
+    id: "event-line",
+    description: "Annotated narrative timeline \u2014 events on a horizontal line with descriptions (not the date-scaled timeline)"
+  },
+  {
+    id: "org",
+    description: "Reporting hierarchy"
+  },
+  {
+    id: "sitemap",
+    description: "Site / app navigation structure"
+  },
+  {
+    id: "kanban",
+    description: "Task board columns"
+  },
+  {
+    id: "raci",
+    description: "Tasks \xD7 roles responsibility matrix with constraint linting"
+  },
+  {
+    id: "tech-radar",
+    description: "Technology adoption quadrants (adopt/trial/assess/hold)"
+  },
+  {
+    id: "mindmap",
+    description: "Radial hierarchy of ideas branching from a central topic"
+  },
+  {
+    id: "wireframe",
+    description: "Low-fidelity UI layout with panels, controls, and annotations"
+  },
+  {
+    id: "cycle",
+    description: "Cyclical process visualization (PDCA, OODA, DevOps loops)"
+  },
+  {
+    id: "pyramid",
+    description: "Stacked hierarchy of layers with descriptions (Maslow, DIKW)"
+  },
+  {
+    id: "ring",
+    description: "Concentric rings showing nested or hierarchical categories (read core-out)"
+  },
+  {
+    id: "treemap",
+    description: "Nested rectangles sized by value \u2014 show a hierarchy\u2019s proportions (budgets, disk usage, portfolios) with color by category, value heatmap, or branch"
+  },
+  {
+    id: "block",
+    description: "Block diagram: an author-controlled grid of rectangular blocks with nested, collapsible containers \u2014 system/hardware/architecture layouts where the 2-D arrangement is the meaning"
+  },
+  {
+    id: "map",
+    description: "Geographic concept map: highlight/score regions, drop points of interest, connect with routes or edges"
+  },
+  // ── Tier 3 — Specialized analytical charts ────────────────
+  {
+    id: "quadrant",
+    description: "2x2 positioning matrix"
+  },
+  {
+    id: "venn",
+    description: "Set overlaps"
+  },
+  {
+    id: "funnel",
+    description: "Conversion pipeline"
+  },
+  {
+    id: "slope",
+    description: "Change between 2 time periods"
+  },
+  {
+    id: "sankey",
+    description: "Flow / allocation visualization"
+  },
+  {
+    id: "arc",
+    description: "Network relationships (linear or circular via `layout`)"
+  },
+  {
+    id: "wordcloud",
+    description: "Term frequency visualization"
+  },
+  {
+    id: "heatmap",
+    description: "Matrix intensity visualization"
+  },
+  {
+    id: "function",
+    description: "Mathematical expressions"
+  },
+  // ── Tier 4 — General-purpose data charts ──────────────────
+  {
+    id: "bar",
+    description: "Categorical comparisons for 3 - 5 figures",
+    fallback: true
+  },
+  {
+    id: "line",
+    description: "Trends over time",
+    fallback: true
+  },
+  {
+    id: "pie",
+    description: "Part-to-whole proportions"
+  },
+  {
+    id: "radar",
+    description: "Multi-dimensional metrics"
+  },
+  {
+    id: "polar-area",
+    description: "Radial bar chart"
+  },
+  {
+    id: "scatter",
+    description: "2D data points or bubble chart"
+  },
+  // ── Tier 5 — Generic catch-alls (listed last on purpose) ──
+  {
+    id: "flowchart",
+    description: "Decision trees and process flows",
+    fallback: true
+  },
+  {
+    id: "boxes-and-lines",
+    description: "General-purpose node-edge diagrams with groups and tags",
+    fallback: true
+  }
+];
+
+// src/slope/parser.ts
+function parseSlope(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/arc/parser.ts
+function parseArc(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/timeline/viz-parser.ts
+function parseTimeline(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/wordcloud/parser.ts
+function parseWordcloud(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/venn/parser.ts
+function parseVenn(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/quadrant/parser.ts
+function parseQuadrant(content, palette) {
+  return parseVisualization(content, palette);
+}
+
+// src/chart-type-registry.ts
+function measureSequence(content) {
+  const parsed = parseSequenceDgmo(content);
+  return {
+    participants: parsed.participants.length,
+    messages: parsed.messages.length
+  };
+}
+function measureRaci(content) {
+  const parsed = parseRaci(content);
+  let taskCount = 0;
+  for (const _task of allTasks(parsed)) taskCount++;
+  return {
+    roles: parsed.roles.length,
+    tasks: taskCount
+  };
+}
+function walkTree(nodes, depth, acc) {
+  for (const node of nodes) {
+    acc.nodes++;
+    if (depth > acc.depth) acc.depth = depth;
+    walkTree(
+      node.children,
+      depth + 1,
+      acc
+    );
+  }
+}
+function measureMindmap(content) {
+  const parsed = parseMindmap(content);
+  const acc = { nodes: 0, depth: 0 };
+  walkTree(parsed.roots, 1, acc);
+  return { nodes: acc.nodes, depth: acc.depth };
+}
+function measureTechRadar(content) {
+  const parsed = parseTechRadar(content);
+  let blipCount = 0;
+  for (const q of parsed.quadrants) blipCount += q.blips.length;
+  return { blips: blipCount };
+}
+function measureHeatmap(content) {
+  const parsed = parseHeatmap(content);
+  return {
+    columns: parsed.columns?.length ?? 0,
+    rows: parsed.heatmapRows?.length ?? parsed.rows?.length ?? 0
+  };
+}
+function measureArc(content) {
+  const parsed = parseArc(content);
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const g of parsed.arcNodeGroups) {
+    for (const n of g.nodes) allNodes.add(n);
+  }
+  return { nodes: allNodes.size };
+}
+function measureOrg(content) {
+  const parsed = parseOrg(content);
+  const acc = { nodes: 0, depth: 0 };
+  walkTree(parsed.roots, 1, acc);
+  return { nodes: acc.nodes, depth: acc.depth };
+}
+function measureGantt(content) {
+  const parsed = parseGantt(content);
+  const taskCount = parsed.nodes.filter(
+    (n) => n.kind === "task"
+  ).length;
+  return { tasks: taskCount };
+}
+function measureKanban(content) {
+  const parsed = parseKanban(content);
+  return { columns: parsed.columns.length };
+}
+function measureER(content) {
+  const parsed = parseERDiagram(content);
+  return { nodes: parsed.tables.length };
+}
+function measureClass(content) {
+  const parsed = parseClassDiagram(content);
+  return { nodes: parsed.classes.length };
+}
+function measureFlowchart(content) {
+  const parsed = parseFlowchart(content);
+  return { nodes: parsed.nodes.length };
+}
+function measureStateGraph(content) {
+  const parsed = parseState(content);
+  return { nodes: parsed.nodes.length };
+}
+function measurePert(content) {
+  const parsed = parsePert(content);
+  return { tasks: parsed.activities.length };
+}
+function measureInfra(content) {
+  const parsed = parseInfra(content);
+  return { nodes: parsed.nodes.length };
+}
+function measureSwimlane(content) {
+  const parsed = parseSwimlane(content);
+  return { lanes: parsed.lanes.length, nodes: parsed.nodes.length };
+}
+function minDimsSequence(c) {
+  return {
+    width: Math.max((c.participants ?? 2) * 80, 320),
+    height: Math.max((c.messages ?? 1) * 20 + 120, 200)
+  };
+}
+function minDimsRaci(c) {
+  return {
+    width: Math.max((c.roles ?? 2) * 50 + 180, 300),
+    height: Math.max((c.tasks ?? 1) * 28 + 80, 200)
+  };
+}
+function minDimsMindmap(c) {
+  return {
+    width: Math.max((c.nodes ?? 3) * 30, 300),
+    height: Math.max((c.depth ?? 2) * 60, 200)
+  };
+}
+function minDimsTechRadar() {
+  return { width: 360, height: 400 };
+}
+function minDimsHeatmap(c) {
+  return {
+    width: Math.max((c.columns ?? 3) * 40, 300),
+    height: Math.max((c.rows ?? 3) * 30 + 60, 200)
+  };
+}
+function minDimsArc(c) {
+  return {
+    width: 300,
+    height: Math.max((c.nodes ?? 3) * 20 + 120, 200)
+  };
+}
+function measureEventLine(content) {
+  return { items: parseEventLine(content).events.length };
+}
+function minDimsEventLine(c) {
+  return {
+    width: Math.max(640, 120 + (c.items ?? 3) * 100),
+    height: 420
+  };
+}
+function measureVersionControl(content) {
+  return { nodes: parseVersionControl(content).nodes.length };
+}
+function minDimsVersionControl(c) {
+  return {
+    width: Math.max(480, 160 + (c.nodes ?? 3) * 86),
+    height: 360
+  };
+}
+function minDimsOrg(c) {
+  return {
+    width: Math.max((c.nodes ?? 3) * 60, 300),
+    height: Math.max((c.depth ?? 2) * 80, 200)
+  };
+}
+function minDimsGantt(c) {
+  return {
+    width: 400,
+    height: Math.max((c.tasks ?? 3) * 24 + 80, 200)
+  };
+}
+function minDimsKanban(c) {
+  return {
+    width: Math.max((c.columns ?? 3) * 120, 360),
+    height: 300
+  };
+}
+function minDimsEntities(c) {
+  return {
+    width: Math.max((c.nodes ?? 2) * 140, 300),
+    height: Math.max((c.nodes ?? 2) * 80, 200)
+  };
+}
+function minDimsGraph(c) {
+  return {
+    width: Math.max((c.nodes ?? 3) * 60, 300),
+    height: Math.max((c.nodes ?? 3) * 50, 200)
+  };
+}
+function minDimsPert(c) {
+  return {
+    width: Math.max((c.tasks ?? 3) * 80, 340),
+    height: Math.max((c.tasks ?? 3) * 40 + 80, 200)
+  };
+}
+function minDimsInfra(c) {
+  return {
+    width: Math.max((c.nodes ?? 3) * 80, 300),
+    height: Math.max((c.nodes ?? 3) * 60, 200)
+  };
+}
+function minDimsSwimlane(c) {
+  return {
+    width: Math.max((c.nodes ?? 4) * 90, 480),
+    height: Math.max((c.lanes ?? 3) * 100 + 60, 240)
+  };
+}
+var CHART_TYPE_REGISTRY = [
+  // ── Structured diagrams ───────────────────────────────────
+  {
+    id: "sequence",
+    category: "diagram",
+    parse: parseSequenceDgmo,
+    measure: measureSequence,
+    minDims: minDimsSequence
+  },
+  {
+    id: "flowchart",
+    category: "diagram",
+    parse: parseFlowchart,
+    measure: measureFlowchart,
+    minDims: minDimsGraph
+  },
+  {
+    id: "class",
+    category: "diagram",
+    parse: parseClassDiagram,
+    measure: measureClass,
+    minDims: minDimsEntities
+  },
+  {
+    id: "er",
+    category: "diagram",
+    parse: parseERDiagram,
+    measure: measureER,
+    minDims: minDimsEntities
+  },
+  {
+    id: "state",
+    category: "diagram",
+    parse: parseState,
+    measure: measureStateGraph,
+    minDims: minDimsGraph
+  },
+  {
+    id: "org",
+    category: "diagram",
+    parse: parseOrg,
+    measure: measureOrg,
+    minDims: minDimsOrg
+  },
+  {
+    id: "kanban",
+    category: "diagram",
+    parse: parseKanban,
+    measure: measureKanban,
+    minDims: minDimsKanban
+  },
+  { id: "c4", category: "diagram", parse: parseC4 },
+  { id: "sitemap", category: "diagram", parse: parseSitemap },
+  {
+    id: "infra",
+    category: "diagram",
+    parse: parseInfra,
+    measure: measureInfra,
+    minDims: minDimsInfra
+  },
+  {
+    id: "gantt",
+    category: "diagram",
+    parse: parseGantt,
+    measure: measureGantt,
+    minDims: minDimsGantt
+  },
+  {
+    id: "pert",
+    category: "diagram",
+    parse: parsePert,
+    measure: measurePert,
+    minDims: minDimsPert
+  },
+  { id: "boxes-and-lines", category: "diagram", parse: parseBoxesAndLines },
+  {
+    id: "swimlane",
+    category: "diagram",
+    parse: parseSwimlane,
+    measure: measureSwimlane,
+    minDims: minDimsSwimlane
+  },
+  {
+    id: "version-control",
+    category: "diagram",
+    parse: parseVersionControl,
+    measure: measureVersionControl,
+    minDims: minDimsVersionControl
+  },
+  {
+    id: "mindmap",
+    category: "diagram",
+    parse: parseMindmap,
+    measure: measureMindmap,
+    minDims: minDimsMindmap
+  },
+  { id: "wireframe", category: "diagram", parse: parseWireframe },
+  { id: "journey-map", category: "diagram", parse: parseJourneyMap },
+  {
+    id: "raci",
+    category: "diagram",
+    parse: parseRaci,
+    measure: measureRaci,
+    minDims: minDimsRaci
+  },
+  // ── Standard ECharts charts (parseChart) ──────────────────
+  { id: "bar", category: "data-chart", parse: parseChart },
+  { id: "line", category: "data-chart", parse: parseChart },
+  { id: "pie", category: "data-chart", parse: parseChart },
+  { id: "radar", category: "data-chart", parse: parseChart },
+  { id: "polar-area", category: "data-chart", parse: parseChart },
+  // ── Extended ECharts charts — own per-type parser door (Story 109.2a) ──
+  { id: "scatter", category: "data-chart", parse: parseScatter },
+  { id: "sankey", category: "data-chart", parse: parseSankey },
+  { id: "function", category: "data-chart", parse: parseFunctionChart },
+  {
+    id: "heatmap",
+    category: "data-chart",
+    parse: parseHeatmap,
+    measure: measureHeatmap,
+    minDims: minDimsHeatmap
+  },
+  { id: "funnel", category: "data-chart", parse: parseFunnel },
+  // ── D3 visualizations — own per-viz parser door (Story 109.2) ──
+  { id: "slope", category: "visualization", parse: parseSlope },
+  { id: "wordcloud", category: "visualization", parse: parseWordcloud },
+  {
+    id: "arc",
+    category: "visualization",
+    parse: parseArc,
+    measure: measureArc,
+    minDims: minDimsArc
+  },
+  { id: "timeline", category: "visualization", parse: parseTimeline },
+  {
+    id: "event-line",
+    category: "visualization",
+    parse: parseEventLine,
+    measure: measureEventLine,
+    minDims: minDimsEventLine
+  },
+  { id: "venn", category: "visualization", parse: parseVenn },
+  { id: "quadrant", category: "visualization", parse: parseQuadrant },
+  // ── Visualizations with their own parsers ─────────────────
+  {
+    id: "tech-radar",
+    category: "visualization",
+    parse: parseTechRadar,
+    measure: measureTechRadar,
+    minDims: minDimsTechRadar
+  },
+  { id: "cycle", category: "visualization", parse: parseCycle },
+  { id: "pyramid", category: "visualization", parse: parsePyramid },
+  { id: "ring", category: "visualization", parse: parseRing },
+  // Treemap: squarified hierarchy. No measure/minDims — a treemap fills whatever
+  // rectangle it's given and has no intrinsic aspect/size (F11).
+  { id: "treemap", category: "visualization", parse: parseTreemap },
+  // Block diagram: deterministic grid (no measure/minDims — it sizes to content
+  // and is scaled to fit whatever rectangle it's given).
+  { id: "block", category: "visualization", parse: parseBlock },
+  // ── Geographic map (own parser → resolver → layout → renderer) ──
+  { id: "map", category: "visualization", parse: parseMap }
+];
+var REGISTRY_BY_ID = new Map(
+  CHART_TYPE_REGISTRY.map((d) => [d.id, d])
+);
+function isExtendedChartParser(parse) {
+  return EXTENDED_CHART_DOORS.has(parse);
+}
+
+// src/dgmo-router.ts
+var GANTT_DURATION_RE = /^\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h)(?:\?)?\s+/;
+var GANTT_DATE_RE = /^\d{4}-\d{2}-\d{2}(?:\s\d{2}:\d{2})?\s+/;
+function looksLikeGantt(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (GANTT_DURATION_RE.test(trimmed) || GANTT_DATE_RE.test(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+var C4_TYPE_RE = /\bis\s+an?\s+(person|system|container|component)\b/i;
+function looksLikeC4(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (C4_TYPE_RE.test(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseDgmoChartType(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const firstLineResult = parseFirstLine(trimmed);
+    if (firstLineResult) return firstLineResult.chartType;
+    break;
+  }
+  if (looksLikeSequence(content)) return "sequence";
+  if (looksLikeFlowchart(content)) return "flowchart";
+  if (looksLikeClassDiagram(content)) return "class";
+  if (looksLikeERDiagram(content)) return "er";
+  if (looksLikeState(content)) return "state";
+  if (looksLikeSitemap(content)) return "sitemap";
+  if (looksLikeOrg(content)) return "org";
+  if (looksLikeC4(content)) return "c4";
+  if (looksLikeGantt(content)) return "gantt";
+  if (looksLikePert(content)) return "pert";
+  return null;
+}
+function getRenderCategory(chartType) {
+  return REGISTRY_BY_ID.get(chartType.toLowerCase())?.category ?? null;
+}
+function isExtendedChartType(chartType) {
+  const descriptor = REGISTRY_BY_ID.get(chartType.toLowerCase());
+  return descriptor ? isExtendedChartParser(descriptor.parse) : false;
+}
+function getAllChartTypes() {
+  return chartTypes.map((c) => c.id);
+}
+var CHART_TYPE_DESCRIPTIONS = Object.fromEntries(chartTypes.map((c) => [c.id, c.description]));
+var chartTypeParsers = CHART_TYPE_REGISTRY.map((d) => [d.id, d.parse]);
+var knownChartTypeIds = chartTypeParsers.map(
+  ([id]) => id
+);
+var PARSER_BY_ID = new Map(chartTypeParsers);
+var ALL_KNOWN_TYPES = new Set(knownChartTypeIds);
+function parseDgmo(content) {
+  const result = parseDgmoUndeduped(content);
+  return {
+    diagnostics: dedupeDiagnostics(result.diagnostics),
+    chartType: result.chartType
+  };
+}
+function parseDgmoUndeduped(content) {
+  const chartType = parseDgmoChartType(content);
+  if (!chartType) {
+    const colonDiag = detectColonChartType(content);
+    if (colonDiag) {
+      const fallback = parseVisualization(content).diagnostics;
+      return { diagnostics: [colonDiag, ...fallback], chartType: null };
+    }
+    return {
+      diagnostics: parseVisualization(content).diagnostics,
+      chartType: null
+    };
+  }
+  const parser = PARSER_BY_ID.get(chartType);
+  if (parser) {
+    const result2 = parser(content);
+    return {
+      diagnostics: [...result2.diagnostics, ...detectEmptyContent(content)],
+      chartType
+    };
+  }
+  const result = parseVisualization(content);
+  return {
+    diagnostics: [...result.diagnostics, ...detectEmptyContent(content)],
+    chartType
+  };
+}
+function detectColonChartType(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("//"))
+      continue;
+    const match = trimmed.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+    if (!match) return null;
+    const word = match[1].toLowerCase();
+    const rest = match[2].trim();
+    if (ALL_KNOWN_TYPES.has(word)) {
+      const example = rest ? `${word} ${rest}` : word;
+      return makeDgmoError(
+        i + 1,
+        `Remove the colon \u2014 use '${example}' instead of '${trimmed}'. DGMO chart types don't use colons.`
+      );
+    }
+    const hint = suggest(word, [...ALL_KNOWN_TYPES]);
+    if (hint) {
+      return makeDgmoError(
+        i + 1,
+        `Unknown chart type: ${word}. ${hint} Also, DGMO chart types don't use colons.`
+      );
+    }
+    return null;
+  }
+  return null;
+}
+function detectEmptyContent(content) {
+  const lines = content.split("\n");
+  const nonEmpty = lines.filter(
+    (l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("//")
+  );
+  if (nonEmpty.length <= 1) {
+    return [
+      makeDgmoError(1, "No content after chart type declaration.", "warning")
+    ];
+  }
+  return [];
+}
+
+export {
+  parseVisualization,
+  parseSlope,
+  parseArc,
+  parseTimeline,
+  parseWordcloud,
+  parseVenn,
+  parseQuadrant,
+  chartTypes,
+  REGISTRY_BY_ID,
+  looksLikeGantt,
+  looksLikeC4,
+  parseDgmoChartType,
+  getRenderCategory,
+  isExtendedChartType,
+  getAllChartTypes,
+  CHART_TYPE_DESCRIPTIONS,
+  chartTypeParsers,
+  knownChartTypeIds,
+  parseDgmo
+};
+//# sourceMappingURL=chunk-6FZYCKXB.js.map