@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-P235SVAH.js

@@ -0,0 +1,1057 @@
+import {
+  collectIndentedValues,
+  extractColor,
+  measureIndent,
+  normalizeNumericToken,
+  parseFirstLine,
+  parseSeriesNames
+} from "./chunk-Y3J7VR52.js";
+import {
+  RECOGNIZED_COLOR_NAMES,
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/chart.ts
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "bar",
+  "line",
+  "pie",
+  "polar-area",
+  "radar"
+]);
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set([
+  "chart",
+  "title",
+  "series",
+  "stack",
+  "group",
+  "hole",
+  "x-label",
+  "y-label",
+  "y-right-label",
+  "label",
+  "no-name",
+  "no-value",
+  "no-percent",
+  "color"
+]);
+var DEFAULT_HOLE = 0.6;
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set([
+  "orientation-horizontal",
+  "solid-fill",
+  "no-title",
+  "fill",
+  "hole"
+]);
+function rejectSeriesHeader(result, keyword, lineNumber) {
+  if (result.type === "bar" && keyword === "series") {
+    const diag = makeDgmoError(
+      lineNumber,
+      "On bar charts, declare multiple series with a 'stack' or 'group' block header, not 'series'."
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return true;
+  }
+  if ((keyword === "stack" || keyword === "group") && result.type !== "bar") {
+    result.diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `'${keyword}' is a bar layout header; ${result.type} charts use a 'series' block.`,
+        "warning"
+      )
+    );
+  }
+  return false;
+}
+function applySeriesAxes(result, parsed, lineNumber) {
+  if (parsed.leftLabel !== void 0) {
+    result.ylabel = parsed.leftLabel;
+    result.ylabelLineNumber = lineNumber;
+  }
+  if (parsed.rightLabel !== void 0) {
+    result.yrlabel = parsed.rightLabel;
+    result.yrlabelLineNumber = lineNumber;
+  }
+  if (parsed.axes?.includes("right")) {
+    result.seriesAxes = parsed.axes;
+  }
+}
+function parseChart(content, palette) {
+  const lines = content.split("\n");
+  const parsedEras = [];
+  const rawEras = [];
+  const result = {
+    type: "bar",
+    data: [],
+    eras: parsedEras,
+    diagnostics: [],
+    error: null
+  };
+  const fail = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return result;
+  };
+  let firstLineParsed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const lineNumber = i + 1;
+    if (!trimmed) continue;
+    if (/^#{2,}\s+/.test(trimmed)) {
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `'${trimmed}' removed \u2014 use a bracket container '[${trimmed.replace(/^#+\s*/, "")}]' instead (## headers are no longer supported).`
+        )
+      );
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!firstLineParsed) {
+      firstLineParsed = true;
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine) {
+        const raw = firstLine.chartType.toLowerCase();
+        const chartType = raw;
+        if (VALID_TYPES.has(chartType)) {
+          result.type = chartType;
+          if (firstLine.title) {
+            result.title = firstLine.title;
+            result.titleLineNumber = lineNumber;
+          }
+          continue;
+        } else {
+          let msg2 = `Unsupported chart type: ${firstLine.chartType}. Supported types: ${[...VALID_TYPES].join(", ")}.`;
+          const hint2 = suggest(raw, [...VALID_TYPES]);
+          if (hint2) msg2 += ` ${hint2}`;
+          return fail(lineNumber, msg2);
+        }
+      }
+      if (!trimmed.includes(" ") && !trimmed.includes(":") && !/\d/.test(trimmed)) {
+        let msg2 = `Unsupported chart type: ${trimmed}. Supported types: ${[...VALID_TYPES].join(", ")}.`;
+        const hint2 = suggest(trimmed.toLowerCase(), [...VALID_TYPES]);
+        if (hint2) msg2 += ` ${hint2}`;
+        return fail(lineNumber, msg2);
+      }
+    }
+    const eraMatch = trimmed.match(/^era\s+(.+?)\s*->\s*(.+?)\s*$/);
+    if (eraMatch) {
+      const afterArrow = eraMatch[2].trim();
+      const spaceIdx2 = afterArrow.indexOf(" ");
+      if (spaceIdx2 >= 0) {
+        const lastSpaceIdx = afterArrow.lastIndexOf(" ");
+        const trailing = afterArrow.substring(lastSpaceIdx + 1);
+        const hasColor = RECOGNIZED_COLOR_NAMES.includes(
+          trailing
+        );
+        const labelPart = hasColor ? afterArrow.substring(0, lastSpaceIdx).trimEnd() : afterArrow;
+        rawEras.push({
+          // Capture group 1 guaranteed present after regex match.
+          start: eraMatch[1].trim(),
+          afterArrow: labelPart,
+          color: hasColor ? resolveColorWithDiagnostic(
+            trailing,
+            lineNumber,
+            result.diagnostics,
+            palette
+          ) ?? null : null,
+          lineNumber
+        });
+      }
+      continue;
+    }
+    const spaceIdx = trimmed.indexOf(" ");
+    const firstToken = (spaceIdx >= 0 ? trimmed.substring(0, spaceIdx) : trimmed).toLowerCase();
+    if (KNOWN_BOOLEANS.has(firstToken) && spaceIdx < 0) {
+      if (firstToken === "orientation-horizontal") {
+        result.orientation = "horizontal";
+      } else if (firstToken === "solid-fill") {
+        result.solidFill = true;
+      } else if (firstToken === "no-title") {
+        result.noTitle = true;
+      } else if (firstToken === "fill") {
+        result.fill = true;
+      } else if (firstToken === "hole") {
+        result.hole = DEFAULT_HOLE;
+      }
+      continue;
+    }
+    if (KNOWN_OPTIONS.has(firstToken) && spaceIdx >= 0) {
+      const value = trimmed.substring(spaceIdx + 1).trim();
+      if (firstToken === "chart") {
+        const raw = value.toLowerCase();
+        const chartType = raw;
+        if (VALID_TYPES.has(chartType)) {
+          result.type = chartType;
+        } else {
+          let msg2 = `Unsupported chart type: ${value}. Supported types: ${[...VALID_TYPES].join(", ")}.`;
+          const hint2 = suggest(raw, [...VALID_TYPES]);
+          if (hint2) msg2 += ` ${hint2}`;
+          return fail(lineNumber, msg2);
+        }
+        continue;
+      }
+      if (firstToken === "title") {
+        result.title = value;
+        result.titleLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "x-label") {
+        result.xlabel = value;
+        result.xlabelLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "y-label") {
+        result.ylabel = value;
+        result.ylabelLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "y-right-label") {
+        result.yrlabel = value;
+        result.yrlabelLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "label") {
+        result.label = value;
+        continue;
+      }
+      if (firstToken === "hole") {
+        const ratio = parseFloat(value);
+        if (Number.isFinite(ratio) && ratio >= 0 && ratio < 1) {
+          result.hole = ratio;
+        } else {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              'hole must be a ratio between 0 and 0.9 (e.g. "hole 0.6"). Using the default.',
+              "warning"
+            )
+          );
+          result.hole = DEFAULT_HOLE;
+        }
+        continue;
+      }
+      if (firstToken === "color") {
+        const resolvedColor = resolveColorWithDiagnostic(
+          value.trim(),
+          lineNumber,
+          result.diagnostics,
+          palette
+        );
+        if (resolvedColor !== void 0) result.color = resolvedColor;
+        continue;
+      }
+      if (firstToken === "series" || firstToken === "stack" || firstToken === "group") {
+        const rejected = rejectSeriesHeader(result, firstToken, lineNumber);
+        const parsed = parseSeriesNames(
+          value,
+          lines,
+          i,
+          palette,
+          rejected ? void 0 : result.diagnostics
+        );
+        i = parsed.newIndex;
+        if (rejected) continue;
+        result.series = parsed.series;
+        result.seriesLineNumber = lineNumber;
+        if (parsed.names.length > 1) {
+          result.seriesNames = parsed.names;
+          result.seriesNameLineNumbers = parsed.nameLineNumbers;
+        }
+        if (parsed.nameColors.some(Boolean))
+          result.seriesNameColors = parsed.nameColors;
+        applySeriesAxes(result, parsed, lineNumber);
+        if (firstToken === "stack" || firstToken === "group")
+          result.barLayout = firstToken;
+        continue;
+      }
+    }
+    if (firstToken === "no-name") {
+      result.noName = true;
+      continue;
+    }
+    if (firstToken === "no-value") {
+      result.noValue = true;
+      continue;
+    }
+    if (firstToken === "no-percent") {
+      result.noPercent = true;
+      continue;
+    }
+    if (firstToken === "no-center-total") {
+      result.noCenterTotal = true;
+      continue;
+    }
+    if (firstToken.startsWith("no-") && spaceIdx < 0) {
+      continue;
+    }
+    if ((firstToken === "series" || firstToken === "stack" || firstToken === "group") && spaceIdx === -1) {
+      const rejected = rejectSeriesHeader(result, firstToken, lineNumber);
+      const parsed = parseSeriesNames("", lines, i, palette);
+      i = parsed.newIndex;
+      if (rejected) continue;
+      result.series = parsed.series;
+      result.seriesLineNumber = lineNumber;
+      if (parsed.names.length > 1) {
+        result.seriesNames = parsed.names;
+        result.seriesNameLineNumbers = parsed.nameLineNumbers;
+      }
+      if (parsed.nameColors.some(Boolean))
+        result.seriesNameColors = parsed.nameColors;
+      applySeriesAxes(result, parsed, lineNumber);
+      if (firstToken === "stack" || firstToken === "group")
+        result.barLayout = firstToken;
+      continue;
+    }
+    const seriesCount = result.seriesNames?.length ?? 0;
+    const multiValue = seriesCount >= 2;
+    const dataValues = parseDataRowValues(trimmed, {
+      multiValue,
+      ...multiValue && { expectedValues: seriesCount }
+    });
+    if (dataValues) {
+      const { label: rawLabel, color: pointColor } = extractColor(
+        dataValues.label,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      const [first, ...rest] = dataValues.values;
+      result.data.push({
+        label: rawLabel,
+        // parseDataRowValues guarantees values.length >= 1.
+        value: first,
+        ...rest.length > 0 && { extraValues: rest },
+        ...pointColor && { color: pointColor },
+        lineNumber
+      });
+      continue;
+    }
+    let msg = `Unexpected line: '${trimmed}'.`;
+    const hint = suggest(firstToken, [...KNOWN_OPTIONS, ...KNOWN_BOOLEANS]);
+    if (hint) msg += ` ${hint}`;
+    result.diagnostics.push(makeDgmoError(lineNumber, msg, "warning"));
+  }
+  const knownLabels = new Set(result.data.map((d) => d.label));
+  for (const raw of rawEras) {
+    const words = raw.afterArrow.split(" ");
+    let end = "";
+    let label = "";
+    let matched = false;
+    for (let w = words.length - 1; w >= 1; w--) {
+      const candidateEnd = words.slice(0, w).join(" ");
+      if (knownLabels.has(candidateEnd)) {
+        end = candidateEnd;
+        label = words.slice(w).join(" ");
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      end = words[0];
+      label = words.slice(1).join(" ");
+    }
+    parsedEras.push({
+      start: raw.start,
+      end,
+      label,
+      color: raw.color,
+      lineNumber: raw.lineNumber
+    });
+  }
+  if (result.type !== "line") {
+    result.eras = [];
+  }
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!result.error && result.data.length === 0) {
+    warn(1, "No data points found. Add data in format: Label 123");
+  }
+  if (!result.error && result.seriesNames) {
+    const expectedCount = result.seriesNames.length;
+    for (const dp of result.data) {
+      const actualCount = 1 + (dp.extraValues?.length ?? 0);
+      if (actualCount !== expectedCount) {
+        warn(
+          dp.lineNumber,
+          `Data point "${dp.label}" has ${actualCount} value(s), but ${expectedCount} series defined. Each row must have ${expectedCount} values.`
+        );
+      }
+    }
+    result.data = result.data.filter((dp) => {
+      const actualCount = 1 + (dp.extraValues?.length ?? 0);
+      return actualCount === expectedCount;
+    });
+  }
+  if (!result.error && result.seriesAxes && result.type !== "line") {
+    warn(
+      result.seriesLineNumber ?? 1,
+      `Dual y-axes (y-right-label) are only supported on line / multi-line charts; ignoring the secondary axis for "${result.type}".`
+    );
+    delete result.seriesAxes;
+    delete result.yrlabel;
+  }
+  if (!result.error && result.yrlabel && !result.seriesAxes?.includes("right")) {
+    warn(
+      result.yrlabelLineNumber ?? 1,
+      `y-right-label is set but no series is assigned to the right axis. Group the series under a "y-right-label" header (see \xA715.1).`
+    );
+  }
+  return result;
+}
+function parseDataRowValues(line, options) {
+  const tokens = line.split(/\s+/);
+  if (tokens.length < 2) return null;
+  if (options?.multiValue) {
+    const limit = options.expectedValues ?? Infinity;
+    const values = [];
+    let idx = tokens.length - 1;
+    while (idx >= 1 && values.length < limit) {
+      const tok = tokens[idx];
+      const normTok = normalizeNumericToken(tok) ?? tok;
+      const num2 = parseFloat(normTok);
+      if (isNaN(num2) || !isFinite(Number(normTok))) break;
+      values.unshift(num2);
+      idx--;
+    }
+    if (values.length === 0) return null;
+    const label2 = tokens.slice(0, idx + 1).join(" ");
+    if (!label2) return null;
+    return { label: label2, values };
+  }
+  const lastToken = tokens[tokens.length - 1];
+  const normalizedLast = normalizeNumericToken(lastToken) ?? lastToken;
+  const num = parseFloat(normalizedLast);
+  if (isNaN(num) || !isFinite(Number(normalizedLast))) return null;
+  const label = tokens.slice(0, -1).join(" ");
+  if (!label) return null;
+  return { label, values: [num] };
+}
+
+// src/data-chart-parser.ts
+var VALID_EXTENDED_TYPES = /* @__PURE__ */ new Set([
+  "sankey",
+  "chord",
+  "function",
+  "scatter",
+  "heatmap",
+  "funnel"
+]);
+var KNOWN_EXTENDED_OPTIONS = /* @__PURE__ */ new Set([
+  "chart",
+  "title",
+  "series",
+  "x-label",
+  "y-label",
+  "size-label",
+  "layout",
+  "no-name",
+  "no-value",
+  "no-percent",
+  "columns",
+  "rows",
+  "x"
+]);
+function parseScatterRow(line, palette, currentCategory, lineNumber, diagnostics) {
+  const dataRow = parseDataRowValues(line, { multiValue: true });
+  if (!dataRow || dataRow.values.length < 2) return null;
+  const { label: rawLabel, color: pointColor } = extractColor(
+    dataRow.label,
+    palette,
+    diagnostics,
+    lineNumber
+  );
+  return {
+    name: rawLabel,
+    // In-bounds by length >= 2 guard above.
+    x: dataRow.values[0],
+    y: dataRow.values[1],
+    ...dataRow.values[2] !== void 0 && { size: dataRow.values[2] },
+    ...pointColor && { color: pointColor },
+    ...currentCategory !== "Default" && { category: currentCategory },
+    lineNumber
+  };
+}
+function parseExtendedChart(content, palette) {
+  return parseExtendedChartFull(content, palette);
+}
+function parseSankey(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+function parseChord(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+function parseFunctionChart(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+function parseScatter(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+function parseHeatmap(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+function parseFunnel(content, palette) {
+  return parseExtendedChart(content, palette);
+}
+var EXTENDED_CHART_DOORS = /* @__PURE__ */ new Set([
+  parseSankey,
+  parseChord,
+  parseFunctionChart,
+  parseScatter,
+  parseHeatmap,
+  parseFunnel
+]);
+function parseExtendedChartFull(content, palette) {
+  const lines = content.split("\n");
+  const result = {
+    type: "scatter",
+    data: [],
+    diagnostics: [],
+    error: null
+  };
+  let currentCategory = "Default";
+  const sankeyStack = [];
+  let firstLineParsed = false;
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function resolveSlot(raw) {
+    const trimmed = raw.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (m) {
+      const canonical = m[1].trim();
+      nameAliasMap.set(m[2], canonical);
+      return canonical;
+    }
+    const aliased = nameAliasMap.get(trimmed);
+    return aliased !== void 0 ? aliased : trimmed;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const lineNumber = i + 1;
+    if (!trimmed) continue;
+    if (/^#{2,}\s+/.test(trimmed)) {
+      const name = trimmed.replace(/^#{2,}\s+/, "").replace(/\s*\([^)]*\)\s*$/, "").trim();
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `'## ${name}' is no longer supported. Use '[${name}]' instead`
+        )
+      );
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!firstLineParsed) {
+      firstLineParsed = true;
+      const firstLine = parseFirstLine(trimmed);
+      if (!firstLine) {
+        const rawType = trimmed.split(/\s+/)[0].toLowerCase();
+        if (VALID_EXTENDED_TYPES.has(rawType)) {
+          result.type = rawType;
+          const rest = trimmed.slice(rawType.length).trim();
+          if (rest) {
+            result.title = rest;
+            result.titleLineNumber = lineNumber;
+          }
+          continue;
+        }
+      }
+      if (firstLine) {
+        const chartType = firstLine.chartType.toLowerCase();
+        if (VALID_EXTENDED_TYPES.has(chartType)) {
+          result.type = chartType;
+          if (firstLine.title) {
+            result.title = firstLine.title;
+            result.titleLineNumber = lineNumber;
+          }
+          continue;
+        } else {
+          const validTypes = [...VALID_EXTENDED_TYPES];
+          let msg = `Unsupported chart type: ${firstLine.chartType}. Supported types: ${validTypes.join(", ")}.`;
+          const hint = suggest(chartType, validTypes);
+          if (hint) msg += ` ${hint}`;
+          const diag = makeDgmoError(lineNumber, msg);
+          result.diagnostics.push(diag);
+          result.error = formatDgmoError(diag);
+          return result;
+        }
+      }
+      if (!trimmed.includes(" ") && !trimmed.includes(":") && !/\d/.test(trimmed)) {
+        const validTypes = [...VALID_EXTENDED_TYPES];
+        let msg = `Unsupported chart type: ${trimmed}. Supported types: ${validTypes.join(", ")}.`;
+        const hint = suggest(trimmed.toLowerCase(), validTypes);
+        if (hint) msg += ` ${hint}`;
+        const diag = makeDgmoError(lineNumber, msg);
+        result.diagnostics.push(diag);
+        result.error = formatDgmoError(diag);
+        return result;
+      }
+    }
+    const categoryMatch = trimmed.match(/^\[(.+?)\](?:\s+(\S+))?\s*$/);
+    if (categoryMatch) {
+      const catName = categoryMatch[1].trim();
+      const rawCatColor = categoryMatch[2]?.trim();
+      const catColor = rawCatColor ? resolveColorWithDiagnostic(
+        rawCatColor,
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) ?? null : null;
+      if (catColor) {
+        if (!result.categoryColors) result.categoryColors = {};
+        result.categoryColors[catName] = catColor;
+      }
+      if (!result.categoryLineNumbers) result.categoryLineNumbers = {};
+      result.categoryLineNumbers[catName] = lineNumber;
+      currentCategory = catName;
+      continue;
+    }
+    const arrowMatch = trimmed.match(
+      /^(.+?)\s*(->|--)\s*(.+?)\s+(-?[\d_]+(?:\.[\d]+)?)(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?\s*$/
+    );
+    if (arrowMatch) {
+      const [, rawSource, arrow, rawTarget, rawVal, rawLinkColor] = arrowMatch;
+      const val = normalizeNumericToken(rawVal) ?? rawVal;
+      const sourceResolved = resolveSlot(rawSource);
+      const targetResolved = resolveSlot(rawTarget);
+      const { label: source, color: sourceColor } = extractColor(
+        sourceResolved,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      const { label: target, color: targetColor } = extractColor(
+        targetResolved,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      if (sourceColor || targetColor) {
+        if (!result.nodeColors) result.nodeColors = {};
+        if (sourceColor) result.nodeColors[source] = sourceColor;
+        if (targetColor) result.nodeColors[target] = targetColor;
+      }
+      const linkColor = rawLinkColor ? resolveColorWithDiagnostic(
+        rawLinkColor.trim(),
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) : void 0;
+      if (!result.links) result.links = [];
+      result.links.push({
+        source,
+        target,
+        value: parseFloat(val),
+        ...linkColor && { color: linkColor },
+        directed: arrow === "->",
+        lineNumber
+      });
+      continue;
+    }
+    if (result.type === "sankey") {
+      const indent = measureIndent(lines[i]);
+      if (indent > 0 && sankeyStack.length > 0) {
+        while (sankeyStack.length && sankeyStack.at(-1).indent >= indent) {
+          sankeyStack.pop();
+        }
+        if (sankeyStack.length > 0) {
+          const valColorMatch = trimmed.match(
+            /(-?[\d_]+(?:\.[\d]+)?)\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\s*$/
+          );
+          const strippedLine = valColorMatch ? trimmed.replace(
+            /\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\s*$/,
+            ""
+          ) : trimmed;
+          const dataRow2 = parseDataRowValues(strippedLine);
+          if (dataRow2?.values.length === 1) {
+            const source = sankeyStack.at(-1).name;
+            const linkColor = valColorMatch?.[2] ? resolveColorWithDiagnostic(
+              valColorMatch[2].trim(),
+              lineNumber,
+              result.diagnostics,
+              palette
+            ) : void 0;
+            const targetResolved = resolveSlot(dataRow2.label);
+            const { label: target, color: targetColor } = extractColor(
+              targetResolved,
+              palette,
+              result.diagnostics,
+              lineNumber
+            );
+            if (targetColor) {
+              if (!result.nodeColors) result.nodeColors = {};
+              result.nodeColors[target] = targetColor;
+            }
+            if (!result.links) result.links = [];
+            result.links.push({
+              source,
+              target,
+              // In-bounds by values.length === 1 guard above.
+              value: dataRow2.values[0],
+              ...linkColor && { color: linkColor },
+              lineNumber
+            });
+            sankeyStack.push({ name: target, indent });
+            continue;
+          }
+        }
+      }
+      const spaceIdx2 = trimmed.indexOf(" ");
+      const lastTok = trimmed.substring(trimmed.lastIndexOf(" ") + 1);
+      const hasNumericSuffix = spaceIdx2 >= 0 && !isNaN(parseFloat(normalizeNumericToken(lastTok) ?? lastTok));
+      const isBareKeywordOption = spaceIdx2 < 0 && /^(solid-fill|no-name|no-value|no-percent|shade|no-title)$/i.test(
+        trimmed
+      );
+      const isLayoutDirective = spaceIdx2 >= 0 && trimmed.substring(0, spaceIdx2).toLowerCase() === "layout";
+      if (!hasNumericSuffix && !isBareKeywordOption && !isLayoutDirective) {
+        while (sankeyStack.length && sankeyStack.at(-1).indent >= indent) {
+          sankeyStack.pop();
+        }
+        const trimmedResolved = resolveSlot(trimmed);
+        const { label: nodeName, color: nodeColor } = extractColor(
+          trimmedResolved,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (nodeColor) {
+          if (!result.nodeColors) result.nodeColors = {};
+          result.nodeColors[nodeName] = nodeColor;
+        }
+        sankeyStack.push({ name: nodeName, indent });
+        continue;
+      }
+    }
+    const spaceIdx = trimmed.indexOf(" ");
+    const firstToken = (spaceIdx >= 0 ? trimmed.substring(0, spaceIdx) : trimmed).toLowerCase();
+    if (KNOWN_EXTENDED_OPTIONS.has(firstToken) && spaceIdx >= 0) {
+      const value = trimmed.substring(spaceIdx + 1).trim();
+      if (firstToken === "chart") {
+        const chartType = value.toLowerCase();
+        if (VALID_EXTENDED_TYPES.has(chartType)) {
+          result.type = chartType;
+        } else {
+          const validTypes = [...VALID_EXTENDED_TYPES];
+          let msg = `Unsupported chart type: ${value}. Supported types: ${validTypes.join(", ")}.`;
+          const hint = suggest(chartType, validTypes);
+          if (hint) msg += ` ${hint}`;
+          const diag = makeDgmoError(lineNumber, msg);
+          result.diagnostics.push(diag);
+          result.error = formatDgmoError(diag);
+          return result;
+        }
+        continue;
+      }
+      if (firstToken === "title") {
+        result.title = value;
+        result.titleLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "series") {
+        const parsed = parseSeriesNames(value, lines, i, palette);
+        i = parsed.newIndex;
+        result.series = parsed.series;
+        result.seriesLineNumber = lineNumber;
+        if (parsed.names.length > 1) {
+          result.seriesNames = parsed.names;
+          result.seriesNameLineNumbers = parsed.nameLineNumbers;
+        }
+        if (parsed.nameColors.some(Boolean))
+          result.seriesNameColors = parsed.nameColors;
+        continue;
+      }
+      if (firstToken === "x-label") {
+        result.xlabel = value;
+        result.xlabelLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "y-label") {
+        result.ylabel = value;
+        result.ylabelLineNumber = lineNumber;
+        continue;
+      }
+      if (firstToken === "size-label") {
+        result.sizelabel = value;
+        continue;
+      }
+      if (firstToken === "layout") {
+        const v = value.toLowerCase();
+        if (v === "arc" || v === "chord") result.layout = v;
+        continue;
+      }
+      if (firstToken === "columns") {
+        if (value) {
+          result.columns = value.includes(",") ? value.split(",").map((s) => s.trim()) : value.split(/\s+/);
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          result.columns = collected.values;
+        }
+        continue;
+      }
+      if (firstToken === "rows") {
+        if (value) {
+          result.rows = value.includes(",") ? value.split(",").map((s) => s.trim()) : value.split(/\s+/);
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          result.rows = collected.values;
+        }
+        continue;
+      }
+      if (firstToken === "x") {
+        const rangeMatch = value.match(/^(-?[\d.]+)\s+to\s+(-?[\d.]+)$/);
+        if (rangeMatch) {
+          result.xRange = {
+            // Regex capture groups [1] and [2] are non-optional in the pattern.
+            min: parseFloat(rangeMatch[1]),
+            max: parseFloat(rangeMatch[2])
+          };
+          continue;
+        }
+        if (!(result.type === "function" && trimmed.includes(":"))) {
+          continue;
+        }
+      }
+    }
+    if (firstToken === "no-name") {
+      result.noName = true;
+      continue;
+    }
+    if (firstToken === "no-value") {
+      result.noValue = true;
+      continue;
+    }
+    if (firstToken === "no-percent") {
+      result.noPercent = true;
+      continue;
+    }
+    if (firstToken === "shade") {
+      result.shade = true;
+      continue;
+    }
+    if (firstToken === "solid-fill") {
+      result.solidFill = true;
+      continue;
+    }
+    if (firstToken === "no-title" && spaceIdx < 0) {
+      result.noTitle = true;
+      continue;
+    }
+    if (firstToken.startsWith("no-") && spaceIdx < 0) {
+      continue;
+    }
+    if (firstToken === "series" && spaceIdx === -1) {
+      const parsed = parseSeriesNames("", lines, i, palette);
+      i = parsed.newIndex;
+      result.series = parsed.series;
+      result.seriesLineNumber = lineNumber;
+      if (parsed.names.length > 1) {
+        result.seriesNames = parsed.names;
+        result.seriesNameLineNumbers = parsed.nameLineNumbers;
+      }
+      if (parsed.nameColors.some(Boolean))
+        result.seriesNameColors = parsed.nameColors;
+      continue;
+    }
+    if (firstToken === "columns" && spaceIdx === -1) {
+      const collected = collectIndentedValues(lines, i);
+      i = collected.newIndex;
+      result.columns = collected.values;
+      continue;
+    }
+    if (firstToken === "rows" && spaceIdx === -1) {
+      const collected = collectIndentedValues(lines, i);
+      i = collected.newIndex;
+      result.rows = collected.values;
+      continue;
+    }
+    if (result.type === "function") {
+      const colonIndex = trimmed.indexOf(":");
+      if (colonIndex >= 0) {
+        const { label: fnName, color: fnColor } = extractColor(
+          trimmed.substring(0, colonIndex).trim(),
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        const fnValue = trimmed.substring(colonIndex + 1).trim();
+        if (!result.functions) result.functions = [];
+        result.functions.push({
+          name: fnName,
+          expression: fnValue,
+          ...fnColor && { color: fnColor },
+          lineNumber
+        });
+        continue;
+      }
+    }
+    if (result.type === "scatter") {
+      const scatterData = parseScatterRow(
+        trimmed,
+        palette,
+        currentCategory,
+        lineNumber,
+        result.diagnostics
+      );
+      if (scatterData) {
+        if (!result.scatterPoints) result.scatterPoints = [];
+        result.scatterPoints.push(scatterData);
+        continue;
+      }
+    }
+    if (result.type === "heatmap") {
+      const dataRow2 = parseDataRowValues(trimmed, { multiValue: true });
+      if (dataRow2 && dataRow2.values.length > 0) {
+        if (!result.heatmapRows) result.heatmapRows = [];
+        result.heatmapRows.push({
+          label: dataRow2.label,
+          values: dataRow2.values,
+          lineNumber
+        });
+        continue;
+      }
+    }
+    const dataRow = parseDataRowValues(trimmed);
+    if (dataRow?.values.length === 1) {
+      const { label: rawLabel, color: pointColor } = extractColor(
+        dataRow.label,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      result.data.push({
+        label: rawLabel,
+        // In-bounds by values.length === 1 guard above.
+        value: dataRow.values[0],
+        ...pointColor && { color: pointColor },
+        lineNumber
+      });
+      continue;
+    }
+    result.diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unexpected line: '${trimmed}'. Expected a data row ('Label value', space-separated) or a known option.`,
+        "warning"
+      )
+    );
+  }
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!result.error) {
+    if (result.type === "sankey") {
+      if (!result.links || result.links.length === 0) {
+        warn(1, "No links found. Add links in format: Source -> Target 123");
+      }
+    } else if (result.type === "chord") {
+      if (!result.links || result.links.length === 0) {
+        warn(1, "No links found. Add links in format: Source -> Target 123");
+      }
+    } else if (result.type === "function") {
+      if (!result.functions || result.functions.length === 0) {
+        warn(
+          1,
+          "No functions found. Add functions in format: Name: expression"
+        );
+      }
+      if (!result.xRange) {
+        result.xRange = { min: -10, max: 10 };
+      }
+    } else if (result.type === "scatter") {
+      if (!result.scatterPoints || result.scatterPoints.length === 0) {
+        warn(
+          1,
+          "No scatter points found. Add points in format: Name: x, y or Name: x, y, size"
+        );
+      }
+    } else if (result.type === "heatmap") {
+      if (!result.heatmapRows || result.heatmapRows.length === 0) {
+        warn(
+          1,
+          "No heatmap data found. Add data in format: RowLabel: val1, val2, val3"
+        );
+      }
+      if (!result.columns || result.columns.length === 0) {
+        warn(
+          1,
+          "No columns defined. Add columns in format: columns: Col1, Col2, Col3"
+        );
+      }
+    } else if (result.type === "funnel") {
+      if (result.data.length === 0) {
+        warn(1, "No data found. Add data in format: Label: value");
+      }
+    }
+  }
+  return result;
+}
+function getSimpleChartLegendGroups(parsed, colors) {
+  if (!parsed.seriesNames || parsed.seriesNames.length <= 1) return [];
+  return [
+    {
+      name: "Series",
+      entries: parsed.seriesNames.map((name, i) => ({
+        value: name,
+        // colors is a non-empty palette array; modulo index is always in-bounds.
+        color: parsed.seriesNameColors?.[i] ?? colors[i % colors.length]
+      }))
+    }
+  ];
+}
+function getExtendedChartLegendGroups(parsed, colors) {
+  if (parsed.type === "scatter") {
+    const points = parsed.scatterPoints ?? [];
+    const categories = [
+      ...new Set(points.map((p) => p.category).filter(Boolean))
+    ];
+    if (categories.length === 0) return [];
+    return [
+      {
+        name: "Group",
+        entries: categories.map((cat, i) => ({
+          value: cat,
+          // colors is a non-empty palette array; modulo index is always in-bounds.
+          color: parsed.categoryColors?.[cat] ?? colors[i % colors.length]
+        }))
+      }
+    ];
+  }
+  if (parsed.type === "function") {
+    const fns = parsed.functions ?? [];
+    if (fns.length === 0) return [];
+    return [
+      {
+        name: "Function",
+        entries: fns.map((fn, i) => ({
+          value: fn.name,
+          // colors is a non-empty palette array; modulo index is always in-bounds.
+          color: fn.color ?? colors[i % colors.length]
+        }))
+      }
+    ];
+  }
+  return [];
+}
+
+export {
+  parseChart,
+  parseDataRowValues,
+  parseExtendedChart,
+  parseSankey,
+  parseFunctionChart,
+  parseScatter,
+  parseHeatmap,
+  parseFunnel,
+  EXTENDED_CHART_DOORS,
+  getSimpleChartLegendGroups,
+  getExtendedChartLegendGroups
+};
+//# sourceMappingURL=chunk-P235SVAH.js.map