@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-XAKEUMEJ.js

@@ -0,0 +1,1256 @@
+import {
+  GANTT_BOOLEAN_SET,
+  GANTT_OPTION_SET
+} from "./chunk-DKEPS5LH.js";
+import {
+  parseDuration,
+  parseOffset,
+  parseOffsetPrefix
+} from "./chunk-USZW2HHU.js";
+import {
+  getSeriesColors
+} from "./chunk-P6T66CCZ.js";
+import {
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  GANTT_REGISTRY,
+  extractColor,
+  isReservedKey,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/gantt/parser.ts
+var GROUP_RE = /^\[(.+?)\]\s*(.*)$/;
+var DEPENDENCY_RE = /^(?:-(.+?))?->\s*(.+)$/;
+var COMMENT_RE = /^\/\//;
+var ERA_RE = /^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+(.+)$/i;
+var MARKER_RE = /^marker\s+(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/i;
+var HOLIDAY_DATE_RE = /^(\d{4}-\d{2}-\d{2})\s+(.+)$/;
+var HOLIDAY_RANGE_RE = /^(\d{4}-\d{2}-\d{2})\s*(?:->|\u2013>)\s*(\d{4}-\d{2}-\d{2})\s+(.+)$/;
+var WORKWEEK_RE = /^workweek\s+(.+)$/i;
+var ERA_ENTRY_RE = /^(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s*(?:->|\u2013>)\s*(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/;
+var MARKER_ENTRY_RE = /^(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/;
+var OFFSET_PREFIX_RE = /^\+(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))\s+(.*)/;
+var DURATION_TOKEN_RE = /^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)(\?)?$/;
+var LAG_ARROW_RE = /^-(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))->\s*(.*)/;
+var LEAD_ARROW_RE = /^--(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))->\s*(.*)/;
+var BASIC_ARROW_RE = /^->\s*(.*)/;
+var ERA_OFFSET_RE = /^era\s+\+(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))\s*(?:->|–>)\s*\+(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))\s+(.+)$/i;
+var MARKER_OFFSET_RE = /^marker\s+\+(\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h|s))\s+(.+)$/i;
+var WEEKDAY_MAP = {
+  mon: "mon",
+  tue: "tue",
+  wed: "wed",
+  thu: "thu",
+  fri: "fri",
+  sat: "sat",
+  sun: "sun",
+  monday: "mon",
+  tuesday: "tue",
+  wednesday: "wed",
+  thursday: "thu",
+  friday: "fri",
+  saturday: "sat",
+  sunday: "sun"
+};
+function parseGantt(content, palette) {
+  const lines = content.split("\n");
+  const diagnostics = [];
+  const holidays = {
+    dates: [],
+    ranges: [],
+    workweek: ["mon", "tue", "wed", "thu", "fri"]
+  };
+  const result = {
+    nodes: [],
+    holidays,
+    tagGroups: [],
+    eras: [],
+    markers: [],
+    options: {
+      start: null,
+      title: null,
+      titleLineNumber: null,
+      todayMarker: "off",
+      criticalPath: false,
+      dependencies: true,
+      sort: "default",
+      defaultSwimlaneGroup: null,
+      activeTag: null,
+      optionLineNumbers: {},
+      holidaysLineNumber: null,
+      sprintLength: null,
+      sprintNumber: null,
+      sprintStart: null,
+      sprintMode: null,
+      solidFill: false,
+      noTitle: false
+    },
+    diagnostics,
+    error: null,
+    syntaxMode: "new"
+    // always new-mode at 1.0
+  };
+  const fail = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return result;
+  };
+  const warn = (line, message) => {
+    diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const softError = (line, message) => {
+    diagnostics.push(makeDgmoError(line, message, "error"));
+  };
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function peelAlias(label) {
+    const trimmed = label.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (!m) return { label: trimmed };
+    return { label: m[1].trim(), alias: m[2] };
+  }
+  function resolveAliasTarget(token) {
+    return nameAliasMap.get(token.trim()) ?? token;
+  }
+  const blockStack = [];
+  const currentContainer = () => {
+    for (let k = blockStack.length - 1; k >= 0; k--) {
+      if (blockStack[k].containerType !== "task") {
+        return blockStack[k].node.children;
+      }
+    }
+    return result.nodes;
+  };
+  const currentGroupPath = () => {
+    const path = [];
+    for (const entry of blockStack) {
+      if (entry.containerType === "group") {
+        path.push(entry.node.name);
+      }
+    }
+    return path;
+  };
+  let seenChartType = false;
+  let inHolidaysBlock = false;
+  let holidaysBlockIndent = 0;
+  let inTagBlock = false;
+  let currentTagGroup = null;
+  let tagBlockIndent = 0;
+  let inEraBlock = false;
+  let eraBlockIndent = 0;
+  let inMarkerBlock = false;
+  let markerBlockIndent = 0;
+  let lastTaskNode = null;
+  let taskIdCounter = 0;
+  const seriesColors = palette ? getSeriesColors(palette) : [];
+  const syntaxMode = "new";
+  result.syntaxMode = syntaxMode;
+  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) {
+      if (inHolidaysBlock && indent <= holidaysBlockIndent) {
+        inHolidaysBlock = false;
+      }
+      if (inEraBlock && indent <= eraBlockIndent) {
+        inEraBlock = false;
+      }
+      if (inMarkerBlock && indent <= markerBlockIndent) {
+        inMarkerBlock = false;
+      }
+      if (inTagBlock && indent <= tagBlockIndent) {
+        inTagBlock = false;
+        if (currentTagGroup) {
+          result.tagGroups.push(currentTagGroup);
+          currentTagGroup = null;
+        }
+      }
+      continue;
+    }
+    if (!seenChartType) {
+      const firstLineResult = parseFirstLine(line);
+      if (firstLineResult) {
+        if (firstLineResult.chartType !== "gantt") {
+          return fail(
+            lineNumber,
+            `Expected chart type "gantt", got "${firstLineResult.chartType}"`
+          );
+        }
+        seenChartType = true;
+        if (firstLineResult.title) {
+          result.options.title = firstLineResult.title;
+          result.options.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    if (inHolidaysBlock) {
+      if (indent <= holidaysBlockIndent) {
+        inHolidaysBlock = false;
+      } else {
+        const rangeMatch = line.match(HOLIDAY_RANGE_RE);
+        if (rangeMatch) {
+          holidays.ranges.push({
+            startDate: rangeMatch[1],
+            endDate: rangeMatch[2],
+            label: rangeMatch[3].trim(),
+            lineNumber
+          });
+          continue;
+        }
+        const dateMatch = line.match(HOLIDAY_DATE_RE);
+        if (dateMatch) {
+          holidays.dates.push({
+            date: dateMatch[1],
+            label: dateMatch[2].trim(),
+            lineNumber
+          });
+          continue;
+        }
+        const workweekMatch = line.match(WORKWEEK_RE);
+        if (workweekMatch) {
+          const days = parseWorkweek(workweekMatch[1].trim());
+          if (days) {
+            holidays.workweek = days;
+          } else {
+            warn(
+              lineNumber,
+              `Invalid workweek format: "${workweekMatch[1]}". Use day range like "sun-thu" or comma-separated days.`
+            );
+          }
+          continue;
+        }
+        if (COMMENT_RE.test(line)) continue;
+        warn(
+          lineNumber,
+          `Unrecognized holiday entry: "${line}". Use a date '2024-02-19 Presidents Day' or a range '2024-05-27 -> 2024-05-29 Memorial Weekend'. (\xA713.3)`
+        );
+        continue;
+      }
+    }
+    if (inEraBlock) {
+      if (indent <= eraBlockIndent) {
+        inEraBlock = false;
+      } else {
+        if (COMMENT_RE.test(line)) continue;
+        const eraEntryMatch = line.match(ERA_ENTRY_RE);
+        if (eraEntryMatch) {
+          const eraLabelRaw = eraEntryMatch[3].trim();
+          const eraExtracted = extractColor(
+            eraLabelRaw,
+            palette,
+            diagnostics,
+            lineNumber
+          );
+          result.eras.push({
+            startDate: eraEntryMatch[1],
+            endDate: eraEntryMatch[2],
+            label: eraExtracted.label,
+            color: eraExtracted.color || null,
+            lineNumber
+          });
+        } else {
+          warn(
+            lineNumber,
+            `Unrecognized era entry: "${line}". Use 'YYYY-MM-DD -> YYYY-MM-DD Label [color]' (e.g. '2026-04-06 -> 2026-04-10 Conference purple'). (\xA713.5)`
+          );
+        }
+        continue;
+      }
+    }
+    if (inMarkerBlock) {
+      if (indent <= markerBlockIndent) {
+        inMarkerBlock = false;
+      } else {
+        if (COMMENT_RE.test(line)) continue;
+        const markerEntryMatch = line.match(MARKER_ENTRY_RE);
+        if (markerEntryMatch) {
+          const markerLabelRaw = markerEntryMatch[2].trim();
+          const markerExtracted = extractColor(
+            markerLabelRaw,
+            palette,
+            diagnostics,
+            lineNumber
+          );
+          result.markers.push({
+            date: markerEntryMatch[1],
+            label: markerExtracted.label,
+            color: markerExtracted.color || null,
+            lineNumber
+          });
+        } else {
+          warn(
+            lineNumber,
+            `Unrecognized marker entry: "${line}". Use 'YYYY-MM-DD Label [color]' (e.g. '2026-03-27 Board Review' or '2026-06-15 Release green'). (\xA713.6)`
+          );
+        }
+        continue;
+      }
+    }
+    if (inTagBlock && currentTagGroup) {
+      if (indent <= tagBlockIndent) {
+        inTagBlock = false;
+        result.tagGroups.push(currentTagGroup);
+        currentTagGroup = null;
+      } else {
+        if (COMMENT_RE.test(line)) continue;
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(line);
+        const extracted = extractColor(
+          cleanEntry,
+          palette,
+          diagnostics,
+          lineNumber
+        );
+        const color = extracted.color || seriesColors[currentTagGroup.entries.length % seriesColors.length] || "#888888";
+        const isFirstEntry = currentTagGroup.entries.length === 0;
+        currentTagGroup.entries.push({
+          value: extracted.label,
+          color,
+          lineNumber
+        });
+        if (isDefault) {
+          currentTagGroup.defaultValue = extracted.label;
+        } else if (isFirstEntry) {
+          currentTagGroup.defaultValue = extracted.label;
+        }
+        continue;
+      }
+    }
+    {
+      let hadDeeperPop = false;
+      let lastPoppedTaskRef = null;
+      while (blockStack.length > 0) {
+        const top = blockStack[blockStack.length - 1];
+        if (indent <= top.indent) {
+          if (top.indent > indent) hadDeeperPop = true;
+          if (top.containerType === "task" && top.taskRef) {
+            lastPoppedTaskRef = top.taskRef;
+          }
+          blockStack.pop();
+        } else {
+          break;
+        }
+      }
+      if (hadDeeperPop) {
+        for (let k = blockStack.length - 1; k >= 0; k--) {
+          if (blockStack[k].containerType === "task" && blockStack[k].taskRef) {
+            lastTaskNode = blockStack[k].taskRef;
+            break;
+          }
+        }
+        if (blockStack.length === 0 || !blockStack.some((e) => e.containerType === "task")) {
+          lastTaskNode = null;
+        }
+      } else if (lastPoppedTaskRef) {
+        lastTaskNode = lastPoppedTaskRef;
+      }
+    }
+    if (syntaxMode === "new") {
+      const arrowResult = matchArrowLine(line);
+      if (arrowResult) {
+        const content2 = parseNewTaskContent(arrowResult.rest, lineNumber);
+        if (content2.duration || content2.explicitStart) {
+          const task = makeTask(
+            content2.name,
+            content2.duration,
+            content2.uncertain,
+            lineNumber,
+            content2.explicitStart,
+            content2.preExtracted
+          );
+          const taskNode = { kind: "task", ...task };
+          if (lastTaskNode) {
+            lastTaskNode.dependencies.push({
+              targetName: content2.name,
+              ...arrowResult.label !== void 0 && {
+                label: arrowResult.label
+              },
+              ...arrowResult.lag !== void 0 && { offset: arrowResult.lag },
+              lineNumber
+            });
+          }
+          currentContainer().push(taskNode);
+          const writableTask = taskNode;
+          lastTaskNode = writableTask;
+          blockStack.push({
+            node: taskNode,
+            indent,
+            containerType: "task",
+            taskRef: writableTask
+          });
+        } else {
+          if (lastTaskNode) {
+            const depBody = arrowResult.rest;
+            let targetSegment;
+            let meta;
+            {
+              const depRegistry = withTagAliases(
+                GANTT_REGISTRY,
+                new Set(metaAliasMap.keys())
+              );
+              const split = splitNameAndMeta(
+                depBody.trim(),
+                depRegistry,
+                metaAliasMap
+              );
+              warnUnknownMetaKeys(
+                split.meta,
+                depRegistry,
+                (msg) => warn(lineNumber, msg),
+                split.name
+              );
+              targetSegment = split.name;
+              meta = split.meta;
+            }
+            const targetName = resolveAliasTarget(targetSegment);
+            let offset = arrowResult.lag;
+            if (meta["lag"] || meta["lead"]) {
+              const key = meta["lag"] ? "lag" : "lead";
+              softError(
+                lineNumber,
+                `"${key}" is no longer supported \u2014 use "offset: ${meta[key]}" instead.${key === "lead" ? ' Negate the value for lead behavior: "offset: -...".' : ""}`
+              );
+            }
+            if (meta["offset"]) {
+              const raw = meta["offset"];
+              if (raw.trim().startsWith("+")) {
+                warn(
+                  lineNumber,
+                  `Invalid offset: "${raw}". Explicit "+" is not supported \u2014 use "${raw.trim().slice(1)}" instead.`
+                );
+              } else {
+                offset = parseOffset(raw) ?? void 0;
+                if (!offset) {
+                  warn(
+                    lineNumber,
+                    `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`
+                  );
+                }
+              }
+            }
+            lastTaskNode.dependencies.push({
+              targetName,
+              ...arrowResult.label !== void 0 && {
+                label: arrowResult.label
+              },
+              ...offset !== void 0 && { offset },
+              lineNumber
+            });
+          } else {
+            softError(
+              lineNumber,
+              `Arrow '-> ${content2.name}' has no source task \u2014 indent it under the task it follows (e.g. 'Design 5bd' then indented '-> ${content2.name} 3bd'). (\xA713)`
+            );
+          }
+        }
+        continue;
+      }
+      if (indent > 0 && lastTaskNode) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          const candidateKey = line.substring(0, colonIdx).trim().toLowerCase();
+          const registry = withTagAliases(
+            GANTT_REGISTRY,
+            new Set(metaAliasMap.keys())
+          );
+          const resolvedKey = metaAliasMap.get(normalizeName(candidateKey)) ?? candidateKey;
+          if (isReservedKey(registry, resolvedKey)) {
+            const value = line.substring(colonIdx + 1).trim();
+            const ownerTask = findOwningTask(blockStack, indent) ?? lastTaskNode;
+            if (ownerTask) {
+              const mutableMeta = ownerTask.metadata;
+              if (resolvedKey === "progress") {
+                const p = parseFloat(value);
+                if (!Number.isNaN(p)) {
+                  ownerTask.progress = p;
+                }
+              } else if (resolvedKey === "offset") {
+                const off = parseOffsetPrefix(value) ?? parseOffset(value);
+                if (off) ownerTask.offset = off;
+              } else {
+                mutableMeta[resolvedKey] = value;
+              }
+            }
+            continue;
+          }
+        }
+      }
+      if (lastTaskNode && indent > 0 && COMMENT_RE.test(line)) {
+        const commentText = line.replace(/^\/\/\s?/, "");
+        lastTaskNode.comment = lastTaskNode.comment ? lastTaskNode.comment + "\n" + commentText : commentText;
+        continue;
+      }
+      if (COMMENT_RE.test(line)) continue;
+      const eraOffsetMatch = line.match(ERA_OFFSET_RE);
+      if (eraOffsetMatch) {
+        const startOff = parseOffsetPrefix("+" + eraOffsetMatch[1]);
+        const endOff = parseOffsetPrefix("+" + eraOffsetMatch[2]);
+        const eraLabelRaw = eraOffsetMatch[3].trim();
+        const eraExtracted = extractColor(
+          eraLabelRaw,
+          palette,
+          diagnostics,
+          lineNumber
+        );
+        result.eras.push({
+          startDate: "",
+          endDate: "",
+          label: eraExtracted.label,
+          color: eraExtracted.color || null,
+          lineNumber,
+          ...startOff && { offsetStart: startOff },
+          ...endOff && { offsetEnd: endOff }
+        });
+        continue;
+      }
+      const markerOffsetMatch = line.match(MARKER_OFFSET_RE);
+      if (markerOffsetMatch) {
+        const dateOff = parseOffsetPrefix("+" + markerOffsetMatch[1]);
+        const markerLabelRaw = markerOffsetMatch[2].trim();
+        const markerExtracted = extractColor(
+          markerLabelRaw,
+          palette,
+          diagnostics,
+          lineNumber
+        );
+        result.markers.push({
+          date: "",
+          label: markerExtracted.label,
+          color: markerExtracted.color || null,
+          lineNumber,
+          ...dateOff && { offsetDate: dateOff }
+        });
+        continue;
+      }
+    }
+    if (COMMENT_RE.test(line)) continue;
+    if (line.toLowerCase() === "holiday" || line.toLowerCase() === "holidays") {
+      inHolidaysBlock = true;
+      holidaysBlockIndent = indent;
+      result.options.holidaysLineNumber = lineNumber;
+      continue;
+    }
+    const holidayInlineMatch = line.match(
+      /^holiday\s+(\d{4}-\d{2}-\d{2})\s+(.+)$/i
+    );
+    if (holidayInlineMatch) {
+      holidays.dates.push({
+        date: holidayInlineMatch[1],
+        label: holidayInlineMatch[2].trim(),
+        lineNumber
+      });
+      result.options.holidaysLineNumber ??= lineNumber;
+      continue;
+    }
+    const tagMatch = matchTagBlockHeading(line);
+    if (tagMatch) {
+      inTagBlock = true;
+      tagBlockIndent = indent;
+      currentTagGroup = {
+        name: tagMatch.name,
+        ...tagMatch.alias !== void 0 && { alias: tagMatch.alias },
+        entries: [],
+        lineNumber
+      };
+      if (tagMatch.alias) {
+        metaAliasMap.set(
+          normalizeName(tagMatch.alias),
+          tagAttrKey(tagMatch.name)
+        );
+      }
+      metaAliasMap.set(normalizeName(tagMatch.name), tagAttrKey(tagMatch.name));
+      continue;
+    }
+    const topWorkweekMatch = line.match(WORKWEEK_RE);
+    if (topWorkweekMatch) {
+      const days = parseWorkweek(topWorkweekMatch[1].trim());
+      if (days) {
+        holidays.workweek = days;
+      } else {
+        warn(
+          lineNumber,
+          `Invalid workweek format: "${topWorkweekMatch[1]}". Use day range like "sun-thu" or comma-separated days.`
+        );
+      }
+      continue;
+    }
+    if (line.toLowerCase() === "era") {
+      inEraBlock = true;
+      eraBlockIndent = indent;
+      continue;
+    }
+    const eraMatch = line.match(ERA_RE);
+    if (eraMatch) {
+      const eraLabelRaw = eraMatch[3].trim();
+      const eraExtracted = extractColor(
+        eraLabelRaw,
+        palette,
+        diagnostics,
+        lineNumber
+      );
+      result.eras.push({
+        startDate: eraMatch[1],
+        endDate: eraMatch[2],
+        label: eraExtracted.label,
+        color: eraExtracted.color || null,
+        lineNumber
+      });
+      continue;
+    }
+    if (line.toLowerCase() === "marker") {
+      inMarkerBlock = true;
+      markerBlockIndent = indent;
+      continue;
+    }
+    const markerMatch = line.match(MARKER_RE);
+    if (markerMatch) {
+      const markerLabelRaw = markerMatch[2].trim();
+      const markerExtracted = extractColor(
+        markerLabelRaw,
+        palette,
+        diagnostics,
+        lineNumber
+      );
+      result.markers.push({
+        date: markerMatch[1],
+        label: markerExtracted.label,
+        color: markerExtracted.color || null,
+        lineNumber
+      });
+      continue;
+    }
+    {
+      const registry = withTagAliases(
+        GANTT_REGISTRY,
+        new Set(metaAliasMap.keys())
+      );
+      const split = splitNameAndMeta(
+        line,
+        registry,
+        metaAliasMap,
+        void 0,
+        diagnostics,
+        lineNumber
+      );
+      warnUnknownMetaKeys(
+        split.meta,
+        registry,
+        (msg) => warn(lineNumber, msg),
+        split.name
+      );
+      const rawDur = split.meta["duration"];
+      const rawStart = split.meta["start"];
+      if (rawDur !== void 0 || rawStart !== void 0) {
+        let duration = null;
+        let uncertain = false;
+        if (rawDur !== void 0) {
+          const uncertainMatch = rawDur.match(/^(.+)\?$/);
+          const durStr = uncertainMatch ? uncertainMatch[1] : rawDur;
+          if (uncertainMatch) uncertain = true;
+          duration = parseDuration(durStr);
+          if (!duration) {
+            softError(
+              lineNumber,
+              `Invalid duration: "${rawDur}". Expected format like "30bd", "5d", "1.5w".`
+            );
+            continue;
+          }
+        }
+        let explicitStart;
+        if (rawStart !== void 0) {
+          if (!/^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?$/.test(rawStart)) {
+            softError(
+              lineNumber,
+              `Invalid start date: "${rawStart}". Expected YYYY-MM-DD or YYYY-MM-DD HH:MM.`
+            );
+            continue;
+          }
+          explicitStart = rawStart;
+        }
+        const taskName = split.name.trim();
+        if (!taskName) {
+          softError(lineNumber, `Task name cannot be empty.`);
+          continue;
+        }
+        if (split.alias) nameAliasMap.set(split.alias, taskName);
+        const preExtracted = { ...split.meta };
+        delete preExtracted["duration"];
+        delete preExtracted["start"];
+        if (split.color) preExtracted["color"] = split.color;
+        const task = makeTask(
+          taskName,
+          duration,
+          uncertain,
+          lineNumber,
+          explicitStart,
+          preExtracted
+        );
+        const taskNode = { kind: "task", ...task };
+        currentContainer().push(taskNode);
+        const writableTaskN = taskNode;
+        lastTaskNode = writableTaskN;
+        blockStack.push({
+          node: taskNode,
+          indent,
+          containerType: "task",
+          taskRef: writableTaskN
+        });
+        continue;
+      }
+    }
+    const optNoColonMatch = line.match(/^([a-z][a-z0-9-]*)\s+(.+)$/i);
+    const bareKeyword = line.match(/^([a-z][a-z0-9-]*)$/i);
+    if (bareKeyword && KNOWN_BOOLEANS.has(bareKeyword[1].toLowerCase())) {
+      const key = bareKeyword[1].toLowerCase();
+      result.options.optionLineNumbers[key] = lineNumber;
+      switch (key) {
+        case "critical-path":
+          result.options.criticalPath = true;
+          break;
+        case "today-marker":
+          result.options.todayMarker = "on";
+          break;
+        case "solid-fill":
+          result.options.solidFill = true;
+          break;
+        case "no-title":
+          result.options.noTitle = true;
+          break;
+      }
+      continue;
+    }
+    if (bareKeyword && bareKeyword[1].toLowerCase().startsWith("no-")) {
+      const base = bareKeyword[1].toLowerCase().substring(3);
+      if (KNOWN_BOOLEANS.has(base)) {
+        result.options.optionLineNumbers[base] = lineNumber;
+        switch (base) {
+          case "dependencies":
+            result.options.dependencies = false;
+            break;
+          case "critical-path":
+            result.options.criticalPath = false;
+            break;
+          case "today-marker":
+            result.options.todayMarker = "off";
+            break;
+        }
+        continue;
+      }
+    }
+    if (optNoColonMatch && isKnownOption(optNoColonMatch[1].toLowerCase())) {
+      const key = optNoColonMatch[1].toLowerCase();
+      const value = optNoColonMatch[2].trim();
+      result.options.optionLineNumbers[key] = lineNumber;
+      switch (key) {
+        case "start":
+          result.options.start = value;
+          break;
+        case "title":
+          result.options.title = value;
+          result.options.titleLineNumber = lineNumber;
+          break;
+        case "today-marker":
+          if (/^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?$/.test(value)) {
+            result.options.todayMarker = value;
+          } else {
+            warn(
+              lineNumber,
+              `Invalid today-marker value: "${value}". Expected YYYY-MM-DD.`
+            );
+          }
+          break;
+        case "critical-path":
+          result.options.criticalPath = true;
+          break;
+        case "dependencies":
+          result.options.dependencies = true;
+          break;
+        case "sort":
+          if (value === "tag" || value.startsWith("tag:")) {
+            result.options.sort = "tag";
+            const colonIdx = value.indexOf(":");
+            if (colonIdx !== -1) {
+              result.options.defaultSwimlaneGroup = value.slice(colonIdx + 1).trim() || null;
+            }
+          } else {
+            warn(
+              lineNumber,
+              `Invalid sort value: "${value}". Expected "tag" or "tag:GroupName".`
+            );
+          }
+          break;
+        // `lane-by <group>`: the canonical swimlane-axis directive (view-state).
+        // Equivalent to `sort: tag:<group>` — enables tag swimlanes on the named
+        // group. `sort tag` remains a back-compat spelling.
+        case "lane-by":
+          result.options.sort = "tag";
+          result.options.defaultSwimlaneGroup = value.trim() || null;
+          break;
+        case "active-tag":
+          result.options.activeTag = value;
+          break;
+        case "sprint-length": {
+          const dur = parseDuration(value);
+          if (!dur) {
+            warn(
+              lineNumber,
+              `Invalid sprint-length value: "${value}". Expected a duration like "2w" or "10d".`
+            );
+          } else if (dur.unit !== "d" && dur.unit !== "w") {
+            warn(
+              lineNumber,
+              `sprint-length only accepts "d" or "w" units, got "${dur.unit}".`
+            );
+          } else if (dur.amount <= 0) {
+            warn(lineNumber, `sprint-length must be greater than 0.`);
+          } else if (!Number.isInteger(dur.amount * (dur.unit === "w" ? 7 : 1))) {
+            warn(
+              lineNumber,
+              `sprint-length must resolve to a whole number of days.`
+            );
+          } else {
+            result.options.sprintLength = dur;
+          }
+          break;
+        }
+        case "sprint-number": {
+          const n = Number(value);
+          if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+            warn(
+              lineNumber,
+              `sprint-number must be a positive integer, got "${value}".`
+            );
+          } else {
+            result.options.sprintNumber = n;
+          }
+          break;
+        }
+        case "sprint-start": {
+          if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+            warn(
+              lineNumber,
+              `sprint-start requires a full date (YYYY-MM-DD), got "${value}".`
+            );
+          } else if (Number.isNaN((/* @__PURE__ */ new Date(value + "T00:00:00")).getTime())) {
+            warn(lineNumber, `sprint-start is not a valid date: "${value}".`);
+          } else {
+            result.options.sprintStart = value;
+          }
+          break;
+        }
+      }
+      continue;
+    }
+    if (syntaxMode === "new") {
+      let restAfterOffset = line;
+      let lineOffset;
+      const offMatch = line.match(OFFSET_PREFIX_RE);
+      if (offMatch) {
+        lineOffset = parseOffsetPrefix("+" + offMatch[1]) ?? void 0;
+        restAfterOffset = offMatch[2];
+      }
+      const gm = restAfterOffset.match(GROUP_RE);
+      if (gm) {
+        if (blockStack.length > 0 && blockStack[blockStack.length - 1].containerType === "task") {
+          softError(
+            lineNumber,
+            `Cannot nest a group inside a task. Groups must be inside other groups.`
+          );
+          continue;
+        }
+        const afterBrackets = gm[2].trim();
+        let metadata = {};
+        if (afterBrackets) {
+          const groupRegistry = withTagAliases(
+            GANTT_REGISTRY,
+            new Set(metaAliasMap.keys())
+          );
+          const split = splitNameAndMeta(
+            `_ ${afterBrackets}`,
+            groupRegistry,
+            metaAliasMap,
+            void 0,
+            result.diagnostics,
+            lineNumber
+          );
+          warnUnknownMetaKeys(
+            split.meta,
+            groupRegistry,
+            (msg) => warn(lineNumber, msg),
+            split.name
+          );
+          metadata = split.meta;
+        }
+        let collapsed = false;
+        if (metadata["collapsed"]?.toLowerCase() === "true") {
+          collapsed = true;
+          delete metadata["collapsed"];
+        }
+        const groupPeeled = peelAlias(gm[1]);
+        if (groupPeeled.alias)
+          nameAliasMap.set(groupPeeled.alias, groupPeeled.label);
+        const group = {
+          name: groupPeeled.label,
+          color: null,
+          metadata,
+          ...lineOffset && { offset: lineOffset },
+          ...collapsed && { collapsed: true },
+          lineNumber,
+          children: []
+        };
+        const groupNode = { kind: "group", ...group };
+        currentContainer().push(groupNode);
+        blockStack.push({
+          node: groupNode,
+          indent,
+          containerType: "group"
+        });
+        lastTaskNode = null;
+        continue;
+      }
+      {
+        const content2 = parseNewTaskContent(restAfterOffset, lineNumber);
+        if (content2.name && !content2.duration && !content2.explicitStart && !lineOffset) {
+          softError(
+            lineNumber,
+            `Expected task with duration/start (e.g., "${content2.name} 5d"), group brackets (e.g., "[Group]"), or keyword. Got: "${line}"`
+          );
+          continue;
+        }
+        if (content2.name || content2.duration || content2.explicitStart) {
+          const task = makeTask(
+            content2.name,
+            content2.duration,
+            content2.uncertain,
+            lineNumber,
+            content2.explicitStart,
+            content2.preExtracted
+          );
+          if (lineOffset) {
+            task.offset = lineOffset;
+          }
+          const taskNode = { kind: "task", ...task };
+          currentContainer().push(taskNode);
+          const writableTask = taskNode;
+          lastTaskNode = writableTask;
+          blockStack.push({
+            node: taskNode,
+            indent,
+            containerType: "task",
+            taskRef: writableTask
+          });
+          continue;
+        }
+      }
+      softError(
+        lineNumber,
+        `Expected task (e.g., "Task Name 5d"), arrow (e.g., "-> Task 3w"), group (e.g., "[Group]"), or directive. Got: "${line}"`
+      );
+      continue;
+    }
+  }
+  if (currentTagGroup) {
+    result.tagGroups.push(currentTagGroup);
+  }
+  if (result.options.sort === "tag" && result.tagGroups.length === 0) {
+    warn(0, "sort tag has no effect \u2014 no tag groups defined.");
+    result.options.sort = "default";
+  }
+  validateTagGroupNames(result.tagGroups, warn, (line, msg) => {
+    const diag = makeDgmoError(line, msg);
+    diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
+  const hasSprintOption = result.options.sprintLength !== null || result.options.sprintNumber !== null || result.options.sprintStart !== null;
+  const hasSprintUnit = hasSprintDurationUnit(result.nodes);
+  if (hasSprintOption) {
+    result.options.sprintMode = "explicit";
+  } else if (hasSprintUnit) {
+    result.options.sprintMode = "auto";
+  }
+  if (result.options.sprintMode) {
+    if (!result.options.sprintLength) {
+      result.options.sprintLength = { amount: 2, unit: "w" };
+    }
+    if (result.options.sprintNumber === null) {
+      result.options.sprintNumber = 1;
+    }
+  }
+  return result;
+  function matchArrowLine(trimmedLine) {
+    const leadMatch = trimmedLine.match(LEAD_ARROW_RE);
+    if (leadMatch) {
+      const dur = parseDuration(leadMatch[1]);
+      const match = { rest: leadMatch[2] };
+      if (dur) match.lag = { duration: dur, direction: -1 };
+      return match;
+    }
+    const lagMatch = trimmedLine.match(LAG_ARROW_RE);
+    if (lagMatch) {
+      const dur = parseDuration(lagMatch[1]);
+      const match = { rest: lagMatch[2] };
+      if (dur) match.lag = { duration: dur, direction: 1 };
+      return match;
+    }
+    const basicMatch = trimmedLine.match(BASIC_ARROW_RE);
+    if (basicMatch) {
+      return { rest: basicMatch[1] };
+    }
+    const labeledMatch = trimmedLine.match(DEPENDENCY_RE);
+    if (labeledMatch?.[1]) {
+      return { rest: labeledMatch[2], label: labeledMatch[1].trim() };
+    }
+    return null;
+  }
+  function parseNewTaskContent(rawContent, ln) {
+    const registry = withTagAliases(
+      GANTT_REGISTRY,
+      new Set(metaAliasMap.keys())
+    );
+    const split = splitNameAndMeta(
+      rawContent,
+      registry,
+      metaAliasMap,
+      void 0,
+      diagnostics,
+      ln
+    );
+    warnUnknownMetaKeys(
+      split.meta,
+      registry,
+      (msg) => warn(ln, msg),
+      split.name
+    );
+    let name = split.name;
+    let duration = null;
+    let uncertain = false;
+    let explicitStart;
+    const metadata = { ...split.meta };
+    if (metadata["duration"]) {
+      const durStr = metadata["duration"];
+      const uncertainMatch = durStr.match(/^(.+)\?$/);
+      const cleanDur = uncertainMatch ? uncertainMatch[1] : durStr;
+      if (uncertainMatch) uncertain = true;
+      duration = parseDuration(cleanDur);
+      if (!duration) {
+        softError(
+          ln,
+          `Invalid duration: "${durStr}". Expected format like "30bd", "5d", "1.5w".`
+        );
+      }
+      delete metadata["duration"];
+    }
+    if (metadata["start"]) {
+      const raw = metadata["start"];
+      if (!/^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?$/.test(raw)) {
+        softError(ln, `Invalid start date: "${raw}". Expected YYYY-MM-DD.`);
+      } else {
+        explicitStart = raw;
+      }
+      delete metadata["start"];
+    }
+    if (!duration && !explicitStart) {
+      const tokens = name.split(/\s+/).filter(Boolean);
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        const m = tokens[j].match(DURATION_TOKEN_RE);
+        if (m) {
+          duration = { amount: parseFloat(m[1]), unit: m[2] };
+          uncertain = !!m[3];
+          name = tokens.slice(0, j).join(" ");
+          break;
+        }
+      }
+    }
+    const preExtracted = { ...metadata };
+    if (split.color) preExtracted["color"] = split.color;
+    return {
+      name: name.trim(),
+      duration,
+      uncertain,
+      explicitStart,
+      preExtracted
+    };
+  }
+  function findOwningTask(stack, metaIndent) {
+    for (let k = stack.length - 1; k >= 0; k--) {
+      const entry = stack[k];
+      if (entry.containerType === "task" && entry.taskRef && entry.indent < metaIndent) {
+        return entry.taskRef;
+      }
+    }
+    return null;
+  }
+  function makeTask(labelRaw, duration, uncertain, ln, explicitStart, preExtractedMeta) {
+    const peeled = peelAlias(labelRaw);
+    let label = peeled.label;
+    if (peeled.alias) nameAliasMap.set(peeled.alias, label);
+    if (label.toLowerCase() === "parallel") {
+      softError(
+        ln,
+        `"parallel" is a reserved keyword and cannot be used as a task name.`
+      );
+    }
+    const metadata = {};
+    {
+      const registry = withTagAliases(
+        GANTT_REGISTRY,
+        new Set(metaAliasMap.keys())
+      );
+      const split = splitNameAndMeta(
+        label,
+        registry,
+        metaAliasMap,
+        void 0,
+        result.diagnostics,
+        ln
+      );
+      warnUnknownMetaKeys(
+        split.meta,
+        registry,
+        (msg) => warn(ln, msg),
+        split.name
+      );
+      if (Object.keys(split.meta).length > 0) {
+        label = split.name;
+        Object.assign(metadata, split.meta);
+      }
+    }
+    if (preExtractedMeta) {
+      Object.assign(metadata, preExtractedMeta);
+    }
+    let progress = null;
+    if (metadata["progress"]) {
+      progress = parseFloat(metadata["progress"]);
+      delete metadata["progress"];
+    }
+    if (metadata["lag"] || metadata["lead"]) {
+      const key = metadata["lag"] ? "lag" : "lead";
+      softError(
+        ln,
+        `"${key}" is no longer supported \u2014 use "offset: ${metadata[key]}" instead.${key === "lead" ? ' Negate the value for lead behavior: "offset: -...".' : ""}`
+      );
+    }
+    let taskOffset;
+    if (metadata["offset"]) {
+      const raw = metadata["offset"];
+      if (raw.trim().startsWith("+")) {
+        warn(
+          ln,
+          `Invalid offset: "${raw}". Explicit "+" is not supported \u2014 use "${raw.trim().slice(1)}" instead.`
+        );
+      } else {
+        taskOffset = parseOffset(raw) ?? void 0;
+        if (!taskOffset) {
+          warn(
+            ln,
+            `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`
+          );
+        }
+      }
+      delete metadata["offset"];
+    }
+    const groupPath = currentGroupPath();
+    const inheritedMeta = {};
+    for (const entry of blockStack) {
+      if (entry.containerType === "group") {
+        const groupNode = entry.node;
+        Object.assign(inheritedMeta, groupNode.metadata);
+      }
+    }
+    const effectiveMetadata = { ...inheritedMeta, ...metadata };
+    const id = `task_${taskIdCounter++}`;
+    return {
+      id,
+      label,
+      duration,
+      ...explicitStart !== void 0 && { explicitStart },
+      uncertain,
+      progress,
+      ...taskOffset !== void 0 && { offset: taskOffset },
+      isDefinition: duration !== null || explicitStart !== void 0,
+      dependencies: [],
+      metadata: effectiveMetadata,
+      lineNumber: ln,
+      groupPath
+    };
+  }
+}
+function parseWorkweek(s) {
+  const rangeParts = s.toLowerCase().split("-");
+  if (rangeParts.length === 2) {
+    const start = WEEKDAY_MAP[rangeParts[0].trim()];
+    const end = WEEKDAY_MAP[rangeParts[1].trim()];
+    if (start && end) {
+      const allDays = [
+        "mon",
+        "tue",
+        "wed",
+        "thu",
+        "fri",
+        "sat",
+        "sun"
+      ];
+      const startIdx = allDays.indexOf(start);
+      const endIdx = allDays.indexOf(end);
+      const days2 = [];
+      let idx = startIdx;
+      while (true) {
+        days2.push(allDays[idx]);
+        if (idx === endIdx) break;
+        idx = (idx + 1) % 7;
+      }
+      return days2;
+    }
+  }
+  const parts = s.toLowerCase().split(",").map((p) => p.trim());
+  const days = [];
+  for (const part of parts) {
+    const day = WEEKDAY_MAP[part];
+    if (!day) return null;
+    days.push(day);
+  }
+  return days.length > 0 ? days : null;
+}
+var GANTT_KNOWN_OPTIONS = GANTT_OPTION_SET;
+var KNOWN_OPTIONS = GANTT_KNOWN_OPTIONS;
+var GANTT_KNOWN_BOOLEANS = GANTT_BOOLEAN_SET;
+var KNOWN_BOOLEANS = GANTT_KNOWN_BOOLEANS;
+function isKnownOption(key) {
+  return KNOWN_OPTIONS.has(key);
+}
+function hasSprintDurationUnit(nodes) {
+  for (const node of nodes) {
+    if (node.kind === "task") {
+      if (node.duration?.unit === "s") return true;
+    } else if (node.kind === "group" || node.kind === "parallel") {
+      if (hasSprintDurationUnit(node.children)) return true;
+    }
+  }
+  return false;
+}
+
+export {
+  parseGantt,
+  GANTT_KNOWN_OPTIONS,
+  GANTT_KNOWN_BOOLEANS
+};
+//# sourceMappingURL=chunk-XAKEUMEJ.js.map