@diagrammo/dgmo 0.8.16 → 0.8.18

package/dist/index.js

@@ -1,12 +1,35 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/diagnostics.ts
 function makeDgmoError(line10, message, severity = "error") {
@@ -2229,13 +2252,13 @@ function capsuleWidth(name, entries, containerWidth, addonWidth = 0) {
       visibleEntries: entries.length
     };
   }
-  const rowWidth = maxCapsuleW - LEGEND_CAPSULE_PAD * 2;
+  const rowWidth = maxCapsuleW - LEGEND_CAPSULE_PAD;
   let row = 1;
-  let rowX = pw + 4;
+  let rowX = LEGEND_CAPSULE_PAD + pw + 4 + addonWidth;
   let visible = 0;
   for (let i = 0; i < entries.length; i++) {
     const ew2 = entryWidth(entries[i].value);
-    if (rowX + ew2 > rowWidth && rowX > pw + 4) {
+    if (rowX + ew2 > rowWidth && i > 0) {
       row++;
       rowX = 0;
       if (row > LEGEND_MAX_ENTRY_ROWS) {
@@ -2401,7 +2424,7 @@ function buildCapsuleLayout(group, containerWidth, addonWidth = 0) {
   let ex = LEGEND_CAPSULE_PAD + pw + 4 + addonWidth;
   let ey = 0;
   let rowX = ex;
-  const maxRowW = containerWidth - LEGEND_CAPSULE_PAD * 2;
+  const maxRowW = containerWidth - LEGEND_CAPSULE_PAD;
   let currentRow = 0;
   for (let i = 0; i < info.visibleEntries; i++) {
     const entry = group.entries[i];
@@ -10337,7 +10360,7 @@ function addBusinessDays(startDate, count, workweek, holidaySet, direction = 1)
   }
   return current;
 }
-function addGanttDuration(startDate, duration, holidays, holidaySet, direction = 1) {
+function addGanttDuration(startDate, duration, holidays, holidaySet, direction = 1, opts) {
   const { amount, unit } = duration;
   switch (unit) {
     case "bd":
@@ -10399,10 +10422,22 @@ function addGanttDuration(startDate, duration, holidays, holidaySet, direction =
       result.setTime(result.getTime() + amount * 6e4 * direction);
       return result;
     }
+    case "s": {
+      if (!opts?.sprintLength) {
+        throw new Error(
+          'Sprint duration unit "s" requires sprintLength configuration'
+        );
+      }
+      const sl = opts.sprintLength;
+      const totalDays = amount * sl.amount * (sl.unit === "w" ? 7 : 1);
+      const result = new Date(startDate);
+      result.setDate(result.getDate() + Math.round(totalDays) * direction);
+      return result;
+    }
   }
 }
 function parseDuration(s) {
-  const match = s.trim().match(/^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)$/);
+  const match = s.trim().match(/^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)$/);
   if (!match) return null;
   return { amount: parseFloat(match[1]), unit: match[2] };
 }
@@ -10489,7 +10524,11 @@ function parseGantt(content, palette) {
       defaultSwimlaneGroup: null,
       activeTag: null,
       optionLineNumbers: {},
-      holidaysLineNumber: null
+      holidaysLineNumber: null,
+      sprintLength: null,
+      sprintNumber: null,
+      sprintStart: null,
+      sprintMode: null
     },
     diagnostics,
     error: null
@@ -10905,6 +10944,55 @@ function parseGantt(content, palette) {
         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;
     }
@@ -11085,6 +11173,21 @@ function parseGantt(content, palette) {
     result.options.sort = "default";
   }
   validateTagGroupNames(result.tagGroups, warn);
+  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 makeTask(labelRaw, duration, uncertain, ln, explicitStart) {
     const segments = labelRaw.split("|");
@@ -11202,6 +11305,16 @@ function parseWorkweek(s) {
 function isKnownOption(key) {
   return KNOWN_OPTIONS5.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;
+}
 var DURATION_RE, EXPLICIT_DATE_RE, TIMELINE_DURATION_RE, GROUP_RE2, DEPENDENCY_RE, COMMENT_RE, ERA_RE, MARKER_RE, HOLIDAY_DATE_RE, HOLIDAY_RANGE_RE, WORKWEEK_RE, ERA_ENTRY_RE, MARKER_ENTRY_RE, WEEKDAY_MAP, KNOWN_OPTIONS5, KNOWN_BOOLEANS4;
 var init_parser9 = __esm({
   "src/gantt/parser.ts"() {
@@ -11211,9 +11324,9 @@ var init_parser9 = __esm({
     init_parsing();
     init_duration();
     init_palettes();
-    DURATION_RE = /^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)(\?)?\s+(.+)$/;
+    DURATION_RE = /^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)(\?)?\s+(.+)$/;
     EXPLICIT_DATE_RE = /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s+(.+)$/;
-    TIMELINE_DURATION_RE = /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s*(?:->|\u2013>)\s*(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)(\?)?\s+(.+)$/;
+    TIMELINE_DURATION_RE = /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s*(?:->|\u2013>)\s*(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)(\?)?\s+(.+)$/;
     GROUP_RE2 = /^\[(.+?)\]\s*(.*)$/;
     DEPENDENCY_RE = /^(?:-(.+?))?->\s*(.+)$/;
     COMMENT_RE = /^\/\//;
@@ -11248,7 +11361,10 @@ var init_parser9 = __esm({
       "dependencies",
       "chart",
       "sort",
-      "active-tag"
+      "active-tag",
+      "sprint-length",
+      "sprint-number",
+      "sprint-start"
     ]);
     KNOWN_BOOLEANS4 = /* @__PURE__ */ new Set([
       "critical-path",
@@ -22645,6 +22761,7 @@ function calculateSchedule(parsed) {
     tagGroups: parsed.tagGroups,
     eras: parsed.eras,
     markers: parsed.markers,
+    sprints: [],
     options: parsed.options,
     diagnostics,
     error: parsed.error
@@ -22666,6 +22783,7 @@ function calculateSchedule(parsed) {
   } else {
     projectStart = new Date(2e3, 0, 1);
   }
+  const sprintOpts = parsed.options.sprintLength ? { sprintLength: parsed.options.sprintLength } : void 0;
   const depOffsetMap = /* @__PURE__ */ new Map();
   const allTasks = collectTasks(parsed.nodes);
   if (allTasks.length === 0) {
@@ -22747,7 +22865,8 @@ function calculateSchedule(parsed) {
             depOffset.duration,
             parsed.holidays,
             holidaySet,
-            depOffset.direction
+            depOffset.direction,
+            sprintOpts
           );
         }
         if (predEnd.getTime() > start.getTime()) {
@@ -22761,7 +22880,8 @@ function calculateSchedule(parsed) {
         task.offset.duration,
         parsed.holidays,
         holidaySet,
-        task.offset.direction
+        task.offset.direction,
+        sprintOpts
       );
       if (start.getTime() < projectStart.getTime()) {
         warn(
@@ -22801,7 +22921,9 @@ function calculateSchedule(parsed) {
           start,
           task.duration,
           parsed.holidays,
-          holidaySet
+          holidaySet,
+          1,
+          sprintOpts
         );
       }
     } else {
@@ -22815,7 +22937,8 @@ function calculateSchedule(parsed) {
     taskMap,
     depOffsetMap,
     parsed.holidays,
-    holidaySet
+    holidaySet,
+    sprintOpts
   ) : /* @__PURE__ */ new Set();
   const uncertainSet = /* @__PURE__ */ new Set();
   for (const taskId of sortedIds) {
@@ -22855,6 +22978,20 @@ function calculateSchedule(parsed) {
     result.startDate = minDate;
     result.endDate = maxDate;
   }
+  if (parsed.options.sprintMode && parsed.options.sprintLength && result.tasks.length > 0) {
+    result.sprints = generateSprintBands(
+      parsed.options,
+      result.startDate,
+      result.endDate,
+      projectStart
+    );
+    if (result.sprints.length > 0) {
+      const lastSprintEnd = result.sprints[result.sprints.length - 1].endDate;
+      if (lastSprintEnd.getTime() > result.endDate.getTime()) {
+        result.endDate = lastSprintEnd;
+      }
+    }
+  }
   const topLevelGroups = parsed.nodes.filter((n) => n.kind === "group");
   if (topLevelGroups.length >= 2) {
     const names = topLevelGroups.map(
@@ -23055,7 +23192,7 @@ function breakCycle(cycle, taskMap, depOffsetMap) {
     }
   }
 }
-function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holidaySet) {
+function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holidaySet, sprintOpts) {
   if (sortedIds.length === 0) return /* @__PURE__ */ new Set();
   const latestEnd = /* @__PURE__ */ new Map();
   const latestStart = /* @__PURE__ */ new Map();
@@ -23093,7 +23230,8 @@ function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holiday
             succTask.offset.duration,
             holidays,
             holidaySet,
-            reverseDir
+            reverseDir,
+            sprintOpts
           );
           succLS = adjusted.getTime();
         }
@@ -23105,7 +23243,8 @@ function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holiday
             depOffset.duration,
             holidays,
             holidaySet,
-            reverseDir
+            reverseDir,
+            sprintOpts
           );
           succLS = adjusted.getTime();
         }
@@ -23180,6 +23319,51 @@ function buildResolvedGroups(nodes, taskMap, groups, depth) {
     }
   }
 }
+function generateSprintBands(options, chartStart, chartEnd, projectStart) {
+  const sprintLength = options.sprintLength;
+  const sprintNumber = options.sprintNumber ?? 1;
+  let anchorDate;
+  if (options.sprintStart) {
+    anchorDate = /* @__PURE__ */ new Date(options.sprintStart + "T00:00:00");
+  } else if (options.start) {
+    anchorDate = new Date(projectStart);
+  } else {
+    const now = /* @__PURE__ */ new Date();
+    anchorDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  }
+  anchorDate.setHours(0, 0, 0, 0);
+  const sprintDays = Math.round(
+    sprintLength.amount * (sprintLength.unit === "w" ? 7 : 1)
+  );
+  if (sprintDays <= 0) return [];
+  if (Number.isNaN(anchorDate.getTime())) return [];
+  const chartStartTime = new Date(chartStart);
+  chartStartTime.setHours(0, 0, 0, 0);
+  const chartEndTime = new Date(chartEnd);
+  chartEndTime.setHours(0, 0, 0, 0);
+  const msPerDay = 864e5;
+  const dayDiff = Math.floor(
+    (chartStartTime.getTime() - anchorDate.getTime()) / msPerDay
+  );
+  const startSprintIndex = Math.floor(dayDiff / sprintDays);
+  const sprints = [];
+  const maxSprints = 1e3;
+  for (let i = startSprintIndex; sprints.length < maxSprints; i++) {
+    const sprintStartDate = new Date(anchorDate);
+    sprintStartDate.setDate(sprintStartDate.getDate() + i * sprintDays);
+    sprintStartDate.setHours(0, 0, 0, 0);
+    const sprintEndDate = new Date(sprintStartDate);
+    sprintEndDate.setDate(sprintEndDate.getDate() + sprintDays);
+    sprintEndDate.setHours(0, 0, 0, 0);
+    if (sprintStartDate.getTime() >= chartEndTime.getTime() + msPerDay) break;
+    sprints.push({
+      number: sprintNumber + i,
+      startDate: sprintStartDate,
+      endDate: sprintEndDate
+    });
+  }
+  return sprints;
+}
 function formatDate(d) {
   const y = d.getFullYear();
   const m = String(d.getMonth() + 1).padStart(2, "0");
@@ -23286,14 +23470,16 @@ function renderGantt(container, resolved, palette, isDark, options, exportDims)
   const tagLegendReserve = resolved.tagGroups.length > 0 ? LEGEND_HEIGHT + 8 : 0;
   const topDateLabelReserve = 22;
   const hasOverheadLabels = resolved.markers.length > 0 || resolved.eras.length > 0;
-  const markerLabelReserve = hasOverheadLabels ? 18 : 0;
+  const markerLabelReserve = hasOverheadLabels ? 28 : 0;
+  const sprintLabelReserve = resolved.sprints.length > 0 ? 16 : 0;
   const CONTENT_TOP_PAD = 16;
-  const marginTop = titleHeight + tagLegendReserve + topDateLabelReserve + markerLabelReserve;
+  const marginTop = titleHeight + tagLegendReserve + topDateLabelReserve + markerLabelReserve + sprintLabelReserve;
   const contentH = isTagMode ? totalRows * (BAR_H + ROW_GAP) : totalRows * (BAR_H + ROW_GAP) + GROUP_GAP2 * resolved.groups.length;
   const innerHeight = CONTENT_TOP_PAD + contentH;
   const outerHeight = marginTop + innerHeight + BOTTOM_MARGIN;
   const containerWidth = exportDims?.width ?? (container.clientWidth || 800);
-  const innerWidth = containerWidth - leftMargin - RIGHT_MARGIN;
+  const sprintRightPad = resolved.sprints.length > 0 ? 50 : 0;
+  const innerWidth = containerWidth - leftMargin - RIGHT_MARGIN - sprintRightPad;
   const svg = d3Selection10.select(container).append("svg").attr("viewBox", `0 0 ${containerWidth} ${outerHeight}`).attr("width", exportDims ? containerWidth : "100%").attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY).style("overflow", "visible");
   const g = svg.append("g").attr("transform", `translate(${leftMargin}, ${marginTop})`);
   if (title) {
@@ -23373,6 +23559,7 @@ function renderGantt(container, resolved, palette, isDark, options, exportDims)
     onClickItem
   );
   renderErasAndMarkers(g, svg, resolved, xScale, innerHeight, palette);
+  renderSprintBands(g, svg, resolved, xScale, innerHeight, palette);
   let todayDate = null;
   let todayX = -1;
   const todayColor = palette.accent || "#e74c3c";
@@ -24276,7 +24463,7 @@ function renderErasAndMarkers(g, svg, resolved, xScale, innerHeight, palette) {
     const eraEndDate = parseDateStringToDate(era.endDate);
     const eraG = g.append("g").attr("class", "gantt-era-group").attr("data-line-number", String(era.lineNumber));
     const eraRect = eraG.append("rect").attr("class", "gantt-era").attr("x", sx).attr("y", 0).attr("width", ex - sx).attr("height", innerHeight).attr("fill", color).attr("opacity", baseEraOpacity);
-    eraG.append("text").attr("class", "gantt-era-label").attr("x", (sx + ex) / 2).attr("y", -24).attr("text-anchor", "middle").attr("font-size", "10px").attr("fill", color).attr("opacity", 0.7).style("cursor", "pointer").text(era.label);
+    eraG.append("text").attr("class", "gantt-era-label").attr("x", (sx + ex) / 2).attr("y", -34).attr("text-anchor", "middle").attr("font-size", "10px").attr("fill", color).attr("opacity", 0.7).style("cursor", "pointer").text(era.label);
     eraG.on("mouseenter", () => {
       g.selectAll(".gantt-task").attr(
         "opacity",
@@ -24322,8 +24509,8 @@ function renderErasAndMarkers(g, svg, resolved, xScale, innerHeight, palette) {
     const mx = xScale(parseDateToFractionalYear(marker.date));
     const markerDate = parseDateStringToDate(marker.date);
     const diamondSize = 5;
-    const labelY = -24;
-    const diamondY = labelY + 14;
+    const labelY = -34;
+    const diamondY = -2;
     const markerG = g.append("g").attr("class", "gantt-marker-group").attr("data-line-number", String(marker.lineNumber)).style("cursor", "pointer");
     markerG.append("rect").attr("x", mx - 40).attr("y", labelY - 12).attr("width", 80).attr("height", innerHeight - labelY + 12).attr("fill", "transparent").attr("pointer-events", "all");
     markerG.append("text").attr("class", "gantt-marker-label").attr("x", mx).attr("y", labelY).attr("text-anchor", "middle").attr("font-size", "11px").attr("font-weight", "600").attr("fill", color).text(marker.label);
@@ -24383,6 +24570,139 @@ function renderErasAndMarkers(g, svg, resolved, xScale, innerHeight, palette) {
     });
   }
 }
+function renderSprintBands(g, svg, resolved, xScale, innerHeight, palette) {
+  if (resolved.sprints.length === 0) return;
+  if (resolved.eras.length > 0) return;
+  const bandColor = palette.textMuted || palette.text || "#888";
+  const chartMinX = 0;
+  for (let i = 0; i < resolved.sprints.length; i++) {
+    const sprint = resolved.sprints[i];
+    const rawSx = xScale(dateToFractionalYear(sprint.startDate));
+    const rawEx = xScale(dateToFractionalYear(sprint.endDate));
+    if (rawEx <= rawSx) continue;
+    const sx = Math.max(rawSx, chartMinX);
+    const ex = rawEx;
+    const bandWidth = ex - sx;
+    if (bandWidth <= 0) continue;
+    const sprintG = g.append("g").attr("class", "gantt-sprint-group").style("cursor", "pointer");
+    const sprintRect = sprintG.append("rect").attr("class", "gantt-sprint-band").attr("x", sx).attr("y", 0).attr("width", bandWidth).attr("height", innerHeight).attr("fill", bandColor).attr("opacity", sprint.number % 2 === 0 ? SPRINT_BAND_OPACITY : 0);
+    if (sprint.number % 2 !== 0) {
+      sprintG.append("rect").attr("x", sx).attr("y", 0).attr("width", bandWidth).attr("height", innerHeight).attr("fill", "transparent");
+    }
+    const sprintLabel = sprintG.append("text").attr("class", "gantt-sprint-label").attr("x", (sx + ex) / 2).attr("y", -22).attr("text-anchor", "middle").attr("font-size", "10px").attr("font-weight", "600").attr("fill", bandColor).attr("opacity", 0.4).text(String(sprint.number));
+    if (i > 0 && rawSx >= chartMinX) {
+      sprintG.append("line").attr("class", "gantt-sprint-boundary").attr("x1", sx).attr("y1", -6).attr("x2", sx).attr("y2", innerHeight).attr("stroke", bandColor).attr("stroke-width", 1).attr("stroke-dasharray", "3 3").attr("opacity", SPRINT_BOUNDARY_OPACITY);
+    }
+    const sprintStartMs = sprint.startDate.getTime();
+    const sprintEndMs = sprint.endDate.getTime();
+    const overlappingTaskIds = /* @__PURE__ */ new Set();
+    for (const rt of resolved.tasks) {
+      const taskStart = rt.startDate.getTime();
+      const taskEnd = rt.endDate.getTime();
+      if (taskStart < sprintEndMs && taskEnd > sprintStartMs) {
+        overlappingTaskIds.add(rt.task.id);
+      }
+      if (taskStart === taskEnd && taskStart >= sprintStartMs && taskStart < sprintEndMs) {
+        overlappingTaskIds.add(rt.task.id);
+      }
+    }
+    const overlappingGroupNames = /* @__PURE__ */ new Set();
+    for (const rg of resolved.groups) {
+      const gStart = rg.startDate.getTime();
+      const gEnd = rg.endDate.getTime();
+      if (gStart < sprintEndMs && gEnd > sprintStartMs) {
+        overlappingGroupNames.add(rg.name);
+      }
+    }
+    const baseOpacity = sprint.number % 2 === 0 ? SPRINT_BAND_OPACITY : 0;
+    sprintG.on("mouseenter", () => {
+      g.selectAll(".gantt-task").each(function() {
+        const el = d3Selection10.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      g.selectAll(".gantt-milestone").each(function() {
+        const el = d3Selection10.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-task-label").each(function() {
+        const el = d3Selection10.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      g.selectAll(
+        ".gantt-group-bar, .gantt-group-summary"
+      ).each(function() {
+        const el = d3Selection10.select(this);
+        const name = el.attr("data-group");
+        el.attr(
+          "opacity",
+          name && overlappingGroupNames.has(name) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-group-label").each(function() {
+        const el = d3Selection10.select(this);
+        const name = el.attr("data-group");
+        el.attr(
+          "opacity",
+          name && overlappingGroupNames.has(name) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(".gantt-marker-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      sprintRect.attr("opacity", SPRINT_HOVER_OPACITY);
+      const startVisible = rawSx >= chartMinX;
+      if (startVisible) {
+        showGanttDateIndicators(
+          g,
+          xScale,
+          sprint.startDate,
+          sprint.endDate,
+          innerHeight,
+          bandColor
+        );
+      } else {
+        showGanttDateIndicators(
+          g,
+          xScale,
+          sprint.endDate,
+          null,
+          innerHeight,
+          bandColor
+        );
+      }
+      const accentColor = palette.accent || palette.text || bandColor;
+      sprintLabel.text(`Sprint ${sprint.number}`).attr("font-size", "13px").attr("font-weight", "700").attr("fill", accentColor).attr("opacity", 1);
+    }).on("mouseleave", () => {
+      resetHighlight(g, svg);
+      sprintRect.attr("opacity", baseOpacity);
+      sprintLabel.text(String(sprint.number)).attr("font-size", "10px").attr("font-weight", "600").attr("fill", bandColor).attr("opacity", 0.4);
+      hideGanttDateIndicators(g);
+    });
+  }
+  const lastSprint = resolved.sprints[resolved.sprints.length - 1];
+  const lastEx = xScale(dateToFractionalYear(lastSprint.endDate));
+  g.append("line").attr("class", "gantt-sprint-boundary").attr("x1", lastEx).attr("y1", -6).attr("x2", lastEx).attr("y2", innerHeight).attr("stroke", bandColor).attr("stroke-width", 1).attr("stroke-dasharray", "3 3").attr("opacity", SPRINT_BOUNDARY_OPACITY);
+}
 function parseDateStringToDate(s) {
   const parts = s.split("-").map((p) => parseInt(p, 10));
   const year = parts[0];
@@ -24855,7 +25175,7 @@ function renderTimeScaleHorizontal(g, scale, innerWidth, innerHeight, textColor)
     g.append("text").attr("class", "gantt-scale-tick").attr("x", tick.pos).attr("y", innerHeight + tickLen + 12).attr("text-anchor", "middle").attr("font-size", "10px").attr("fill", textColor).attr("opacity", opacity).text(tick.label);
   }
 }
-var BAR_H, ROW_GAP, GROUP_GAP2, MILESTONE_SIZE, MIN_LEFT_MARGIN, BOTTOM_MARGIN, RIGHT_MARGIN, CHAR_W2, LABEL_PAD, LABEL_GAP, BAND_ACCENT_W, BAND_RADIUS, bandClipCounter, JS_DAY_TO_WEEKDAY2, ERA_COLORS, FADE_OPACITY, MONTH_ABBR;
+var BAR_H, ROW_GAP, GROUP_GAP2, MILESTONE_SIZE, MIN_LEFT_MARGIN, BOTTOM_MARGIN, RIGHT_MARGIN, CHAR_W2, LABEL_PAD, LABEL_GAP, BAND_ACCENT_W, BAND_RADIUS, bandClipCounter, JS_DAY_TO_WEEKDAY2, ERA_COLORS, SPRINT_BAND_OPACITY, SPRINT_HOVER_OPACITY, SPRINT_BOUNDARY_OPACITY, FADE_OPACITY, MONTH_ABBR;
 var init_renderer9 = __esm({
   "src/gantt/renderer.ts"() {
     "use strict";
@@ -24890,6 +25210,9 @@ var init_renderer9 = __esm({
       "sat"
     ];
     ERA_COLORS = ["#5e81ac", "#a3be8c", "#ebcb8b", "#d08770", "#b48ead"];
+    SPRINT_BAND_OPACITY = 0.05;
+    SPRINT_HOVER_OPACITY = 0.12;
+    SPRINT_BOUNDARY_OPACITY = 0.3;
     FADE_OPACITY = 0.1;
     MONTH_ABBR = [
       "Jan",
@@ -30945,6 +31268,463 @@ var init_d3 = __esm({
   }
 });
 
+// node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js
+var require_lz_string = __commonJS({
+  "node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js"(exports, module) {
+    "use strict";
+    var LZString = (function() {
+      var f = String.fromCharCode;
+      var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+      var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+      var baseReverseDic = {};
+      function getBaseValue(alphabet, character) {
+        if (!baseReverseDic[alphabet]) {
+          baseReverseDic[alphabet] = {};
+          for (var i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+          }
+        }
+        return baseReverseDic[alphabet][character];
+      }
+      var LZString2 = {
+        compressToBase64: function(input) {
+          if (input == null) return "";
+          var res = LZString2._compress(input, 6, function(a) {
+            return keyStrBase64.charAt(a);
+          });
+          switch (res.length % 4) {
+            // To produce valid Base64
+            default:
+            // When could this happen ?
+            case 0:
+              return res;
+            case 1:
+              return res + "===";
+            case 2:
+              return res + "==";
+            case 3:
+              return res + "=";
+          }
+        },
+        decompressFromBase64: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrBase64, input.charAt(index));
+          });
+        },
+        compressToUTF16: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 15, function(a) {
+            return f(a + 32);
+          }) + " ";
+        },
+        decompressFromUTF16: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 16384, function(index) {
+            return compressed.charCodeAt(index) - 32;
+          });
+        },
+        //compress into uint8array (UCS-2 big endian format)
+        compressToUint8Array: function(uncompressed) {
+          var compressed = LZString2.compress(uncompressed);
+          var buf = new Uint8Array(compressed.length * 2);
+          for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
+            var current_value = compressed.charCodeAt(i);
+            buf[i * 2] = current_value >>> 8;
+            buf[i * 2 + 1] = current_value % 256;
+          }
+          return buf;
+        },
+        //decompress from uint8array (UCS-2 big endian format)
+        decompressFromUint8Array: function(compressed) {
+          if (compressed === null || compressed === void 0) {
+            return LZString2.decompress(compressed);
+          } else {
+            var buf = new Array(compressed.length / 2);
+            for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
+              buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+            }
+            var result = [];
+            buf.forEach(function(c) {
+              result.push(f(c));
+            });
+            return LZString2.decompress(result.join(""));
+          }
+        },
+        //compress into a string that is already URI encoded
+        compressToEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 6, function(a) {
+            return keyStrUriSafe.charAt(a);
+          });
+        },
+        //decompress from an output of compressToEncodedURIComponent
+        decompressFromEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          input = input.replace(/ /g, "+");
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrUriSafe, input.charAt(index));
+          });
+        },
+        compress: function(uncompressed) {
+          return LZString2._compress(uncompressed, 16, function(a) {
+            return f(a);
+          });
+        },
+        _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
+          if (uncompressed == null) return "";
+          var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+          for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+              context_dictionary[context_c] = context_dictSize++;
+              context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+              context_w = context_wc;
+            } else {
+              if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                if (context_w.charCodeAt(0) < 256) {
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 8; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                } else {
+                  value = 1;
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1 | value;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = 0;
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 16; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                  context_enlargeIn = Math.pow(2, context_numBits);
+                  context_numBits++;
+                }
+                delete context_dictionaryToCreate[context_w];
+              } else {
+                value = context_dictionary[context_w];
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              context_dictionary[context_wc] = context_dictSize++;
+              context_w = String(context_c);
+            }
+          }
+          if (context_w !== "") {
+            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+              if (context_w.charCodeAt(0) < 256) {
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 8; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              } else {
+                value = 1;
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = 0;
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 16; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              delete context_dictionaryToCreate[context_w];
+            } else {
+              value = context_dictionary[context_w];
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = context_data_val << 1 | value & 1;
+                if (context_data_position == bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn == 0) {
+              context_enlargeIn = Math.pow(2, context_numBits);
+              context_numBits++;
+            }
+          }
+          value = 2;
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+          while (true) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data.push(getCharFromInt(context_data_val));
+              break;
+            } else context_data_position++;
+          }
+          return context_data.join("");
+        },
+        decompress: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 32768, function(index) {
+            return compressed.charCodeAt(index);
+          });
+        },
+        _decompress: function(length, resetValue, getNextValue) {
+          var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = { val: getNextValue(0), position: resetValue, index: 1 };
+          for (i = 0; i < 3; i += 1) {
+            dictionary[i] = i;
+          }
+          bits = 0;
+          maxpower = Math.pow(2, 2);
+          power = 1;
+          while (power != maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = resetValue;
+              data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+          switch (next = bits) {
+            case 0:
+              bits = 0;
+              maxpower = Math.pow(2, 8);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 1:
+              bits = 0;
+              maxpower = Math.pow(2, 16);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 2:
+              return "";
+          }
+          dictionary[3] = c;
+          w = c;
+          result.push(c);
+          while (true) {
+            if (data.index > length) {
+              return "";
+            }
+            bits = 0;
+            maxpower = Math.pow(2, numBits);
+            power = 1;
+            while (power != maxpower) {
+              resb = data.val & data.position;
+              data.position >>= 1;
+              if (data.position == 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+              }
+              bits |= (resb > 0 ? 1 : 0) * power;
+              power <<= 1;
+            }
+            switch (c = bits) {
+              case 0:
+                bits = 0;
+                maxpower = Math.pow(2, 8);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 1:
+                bits = 0;
+                maxpower = Math.pow(2, 16);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 2:
+                return result.join("");
+            }
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+            if (dictionary[c]) {
+              entry = dictionary[c];
+            } else {
+              if (c === dictSize) {
+                entry = w + w.charAt(0);
+              } else {
+                return null;
+              }
+            }
+            result.push(entry);
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+          }
+        }
+      };
+      return LZString2;
+    })();
+    if (typeof define === "function" && define.amd) {
+      define(function() {
+        return LZString;
+      });
+    } else if (typeof module !== "undefined" && module != null) {
+      module.exports = LZString;
+    } else if (typeof angular !== "undefined" && angular != null) {
+      angular.module("LZString", []).factory("LZString", function() {
+        return LZString;
+      });
+    }
+  }
+});
+
 // src/index.ts
 init_diagnostics();
 
@@ -31731,13 +32511,12 @@ init_colors();
 init_palettes();
 
 // src/sharing.ts
-import lzString from "lz-string";
-var { compressToEncodedURIComponent, decompressFromEncodedURIComponent } = lzString;
+var import_lz_string = __toESM(require_lz_string(), 1);
 var DEFAULT_BASE_URL = "https://online.diagrammo.app";
 var COMPRESSED_SIZE_LIMIT = 8192;
 function encodeDiagramUrl(dsl, options) {
   const baseUrl = options?.baseUrl ?? DEFAULT_BASE_URL;
-  const compressed = compressToEncodedURIComponent(dsl);
+  const compressed = (0, import_lz_string.compressToEncodedURIComponent)(dsl);
   const byteSize = new TextEncoder().encode(compressed).byteLength;
   if (byteSize > COMPRESSED_SIZE_LIMIT) {
     return {
@@ -31808,7 +32587,7 @@ function decodeDiagramUrl(hash) {
   }
   if (!payload) return { dsl: "", viewState, filename };
   try {
-    const result = decompressFromEncodedURIComponent(payload);
+    const result = (0, import_lz_string.decompressFromEncodedURIComponent)(payload);
     return { dsl: result ?? "", viewState, filename };
   } catch {
     return { dsl: "", viewState, filename };