@ganttloom/gantt-core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,3268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PALETTE: () => DEFAULT_PALETTE,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  DENSITY_PRESETS: () => DENSITY_PRESETS,
+  EventEmitter: () => EventEmitter,
+  GanttChart: () => GanttChart,
+  HistoryManager: () => HistoryManager,
+  applyColorByField: () => applyColorByField,
+  applyConstraint: () => applyConstraint,
+  colorByField: () => colorByField,
+  computeCriticalPath: () => computeCriticalPath,
+  computeLayout: () => computeLayout,
+  computeResourceHistogram: () => computeResourceHistogram,
+  computeWBSCodes: () => computeWBSCodes,
+  dateUtils: () => date_utils_exports,
+  filterTasks: () => filterTasks,
+  isHoliday: () => isHoliday,
+  isSafeHref: () => isSafeHref,
+  isWithinWorkingHours: () => isWithinWorkingHours,
+  isWorkingDay: () => isWorkingDay,
+  isWorkingTime: () => isWorkingTime,
+  levelResources: () => levelResources,
+  mergeTheme: () => mergeTheme,
+  nextWorkingDay: () => nextWorkingDay,
+  previousWorkingDay: () => previousWorkingDay,
+  renderResourceHistogramSVG: () => renderResourceHistogramSVG,
+  shiftToWorkingDay: () => shiftToWorkingDay,
+  shiftToWorkingTime: () => shiftToWorkingTime,
+  tasksFromCSV: () => tasksFromCSV,
+  tasksToCSV: () => tasksToCSV,
+  themeToCssVars: () => themeToCssVars
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/theme.ts
+var DEFAULT_THEME = {
+  rowHeight: 36,
+  barHeight: 22,
+  headerHeight: 50,
+  gridColor: "#e5e7eb",
+  weekendColor: "#f3f4f6",
+  todayColor: "#ef4444",
+  barColor: "#3b82f6",
+  barProgressColor: "#2563eb",
+  groupBarColor: "#64748b",
+  linkColor: "#94a3b8",
+  criticalColor: "#dc2626",
+  baselineColor: "#9ca3af",
+  deadlineColor: "#f59e0b",
+  markerColor: "#8b5cf6",
+  selectionColor: "#0ea5e9",
+  textColor: "#1f2937",
+  backgroundColor: "#ffffff",
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif",
+  fontSize: 12,
+  borderRadius: 4
+};
+var DARK_THEME = {
+  ...DEFAULT_THEME,
+  gridColor: "#2d3341",
+  weekendColor: "#252a35",
+  todayColor: "#f87171",
+  barColor: "#60a5fa",
+  barProgressColor: "#3b82f6",
+  groupBarColor: "#94a3b8",
+  linkColor: "#64748b",
+  criticalColor: "#f87171",
+  baselineColor: "#4b5563",
+  deadlineColor: "#fbbf24",
+  markerColor: "#a78bfa",
+  selectionColor: "#38bdf8",
+  textColor: "#e5e7eb",
+  backgroundColor: "#181c24"
+};
+var DENSITY_PRESETS = {
+  compact: { rowHeight: 26, barHeight: 16, headerHeight: 38, fontSize: 11 },
+  comfortable: { rowHeight: 36, barHeight: 22, headerHeight: 50, fontSize: 12 },
+  spacious: { rowHeight: 48, barHeight: 30, headerHeight: 60, fontSize: 13 }
+};
+function prefersDark() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function baseThemeForScheme(scheme = "auto") {
+  if (scheme === "dark") return DARK_THEME;
+  if (scheme === "light") return DEFAULT_THEME;
+  return prefersDark() ? DARK_THEME : DEFAULT_THEME;
+}
+function mergeTheme(partial, scheme = "light") {
+  const base = scheme === "light" ? DEFAULT_THEME : baseThemeForScheme(scheme);
+  return { ...base, ...partial };
+}
+var CSS_VAR_NAMES = {
+  rowHeight: "--gantt-row-height",
+  barHeight: "--gantt-bar-height",
+  headerHeight: "--gantt-header-height",
+  gridColor: "--gantt-grid-color",
+  weekendColor: "--gantt-weekend-color",
+  todayColor: "--gantt-today-color",
+  barColor: "--gantt-bar-color",
+  barProgressColor: "--gantt-bar-progress-color",
+  groupBarColor: "--gantt-group-bar-color",
+  linkColor: "--gantt-link-color",
+  criticalColor: "--gantt-critical-color",
+  baselineColor: "--gantt-baseline-color",
+  deadlineColor: "--gantt-deadline-color",
+  markerColor: "--gantt-marker-color",
+  selectionColor: "--gantt-selection-color",
+  textColor: "--gantt-text-color",
+  backgroundColor: "--gantt-background-color",
+  fontFamily: "--gantt-font-family",
+  fontSize: "--gantt-font-size",
+  borderRadius: "--gantt-border-radius"
+};
+var PX_FIELDS = /* @__PURE__ */ new Set([
+  "rowHeight",
+  "barHeight",
+  "headerHeight",
+  "fontSize",
+  "borderRadius"
+]);
+function themeToCssVars(theme) {
+  const vars = {};
+  for (const key of Object.keys(CSS_VAR_NAMES)) {
+    const varName = CSS_VAR_NAMES[key];
+    const value = theme[key];
+    vars[varName] = PX_FIELDS.has(key) ? `${value}px` : String(value);
+  }
+  return vars;
+}
+function explicitThemeToCssVars(partial) {
+  if (!partial) return {};
+  const vars = {};
+  for (const key of Object.keys(partial)) {
+    const value = partial[key];
+    if (value === void 0) continue;
+    vars[CSS_VAR_NAMES[key]] = PX_FIELDS.has(key) ? `${value}px` : String(value);
+  }
+  return vars;
+}
+function themedFill(key, resolvedValue) {
+  return `var(${CSS_VAR_NAMES[key]}, ${resolvedValue})`;
+}
+
+// src/critical-path.ts
+function linkKey(fromId, toId) {
+  return `${fromId}->${toId}`;
+}
+function isValidTask(task) {
+  return task.start instanceof Date && task.end instanceof Date && !Number.isNaN(task.start.getTime()) && !Number.isNaN(task.end.getTime());
+}
+function durationOf(task) {
+  const d = task.end.getTime() - task.start.getTime();
+  return d > 0 ? d : 0;
+}
+function computeCriticalPath(tasks, dependencies) {
+  const empty = { criticalTasks: /* @__PURE__ */ new Set(), criticalLinks: /* @__PURE__ */ new Set() };
+  const leafTasks = tasks.filter((t) => !t.isGroup && isValidTask(t));
+  const leafIds = new Set(leafTasks.map((t) => t.id));
+  if (leafTasks.length === 0) return empty;
+  const edges = dependencies.filter(
+    (d) => leafIds.has(d.fromId) && leafIds.has(d.toId) && d.fromId !== d.toId
+  );
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  for (const id of leafIds) {
+    outgoing.set(id, []);
+    incoming.set(id, []);
+  }
+  for (const e of edges) {
+    outgoing.get(e.fromId)?.push(e);
+    incoming.get(e.fromId) === void 0 ? void 0 : void 0;
+    incoming.get(e.toId)?.push(e);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const id of leafIds) inDegree.set(id, incoming.get(id)?.length ?? 0);
+  const queue = [];
+  for (const id of leafIds) {
+    if ((inDegree.get(id) ?? 0) === 0) queue.push(id);
+  }
+  const topoOrder = [];
+  const maxOps = leafIds.size + edges.length + 1;
+  let ops = 0;
+  let qi = 0;
+  while (qi < queue.length) {
+    if (ops++ > maxOps) return empty;
+    const nodeId = queue[qi++];
+    if (nodeId === void 0) break;
+    topoOrder.push(nodeId);
+    for (const e of outgoing.get(nodeId) ?? []) {
+      const nextDeg = (inDegree.get(e.toId) ?? 0) - 1;
+      inDegree.set(e.toId, nextDeg);
+      if (nextDeg === 0) queue.push(e.toId);
+    }
+  }
+  if (topoOrder.length !== leafIds.size) {
+    return empty;
+  }
+  const taskById = new Map(leafTasks.map((t) => [t.id, t]));
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  for (const id of topoOrder) {
+    const task = taskById.get(id);
+    if (!task) continue;
+    let start = 0;
+    for (const e of incoming.get(id) ?? []) {
+      const predEf = ef.get(e.fromId);
+      if (predEf === void 0) continue;
+      const lag = e.lagMs ?? 0;
+      start = Math.max(start, predEf + lag);
+    }
+    es.set(id, start);
+    ef.set(id, start + durationOf(task));
+  }
+  let projectEnd = 0;
+  for (const id of topoOrder) {
+    projectEnd = Math.max(projectEnd, ef.get(id) ?? 0);
+  }
+  const lf = /* @__PURE__ */ new Map();
+  const ls = /* @__PURE__ */ new Map();
+  for (let i = topoOrder.length - 1; i >= 0; i--) {
+    const id = topoOrder[i];
+    if (id === void 0) continue;
+    const task = taskById.get(id);
+    if (!task) continue;
+    const succs = outgoing.get(id) ?? [];
+    let finish = projectEnd;
+    if (succs.length > 0) {
+      finish = Infinity;
+      for (const e of succs) {
+        const succLs = ls.get(e.toId);
+        if (succLs === void 0) continue;
+        const lag = e.lagMs ?? 0;
+        finish = Math.min(finish, succLs - lag);
+      }
+      if (!Number.isFinite(finish)) finish = projectEnd;
+    }
+    lf.set(id, finish);
+    ls.set(id, finish - durationOf(task));
+  }
+  const EPSILON = 1;
+  const criticalTasks = /* @__PURE__ */ new Set();
+  for (const id of topoOrder) {
+    const slack = (ls.get(id) ?? 0) - (es.get(id) ?? 0);
+    if (Math.abs(slack) < EPSILON) criticalTasks.add(id);
+  }
+  const criticalLinks = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (!criticalTasks.has(e.fromId) || !criticalTasks.has(e.toId)) continue;
+    const predEf = ef.get(e.fromId) ?? 0;
+    const succEs = es.get(e.toId) ?? 0;
+    const lag = e.lagMs ?? 0;
+    if (Math.abs(succEs - (predEf + lag)) < EPSILON) {
+      criticalLinks.add(linkKey(e.fromId, e.toId));
+    }
+  }
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  for (const task of tasks) {
+    if (!task.isGroup) continue;
+    let hasCriticalDescendant = false;
+    let cur = task;
+    const descendantStack = [task.id];
+    const visited = /* @__PURE__ */ new Set();
+    while (descendantStack.length > 0) {
+      const id = descendantStack.pop();
+      if (id === void 0 || visited.has(id)) continue;
+      visited.add(id);
+      for (const t of tasks) {
+        if (t.parentId === id) {
+          if (criticalTasks.has(t.id)) hasCriticalDescendant = true;
+          descendantStack.push(t.id);
+        }
+      }
+    }
+    if (hasCriticalDescendant) criticalTasks.add(task.id);
+    void cur;
+    void taskMap;
+  }
+  return { criticalTasks, criticalLinks };
+}
+
+// src/date-utils.ts
+var date_utils_exports = {};
+__export(date_utils_exports, {
+  MS_PER_DAY: () => MS_PER_DAY,
+  MS_PER_HOUR: () => MS_PER_HOUR,
+  MS_PER_WEEK: () => MS_PER_WEEK,
+  addUnit: () => addUnit,
+  approxUnitMs: () => approxUnitMs,
+  dateToX: () => dateToX,
+  generateTicks: () => generateTicks,
+  isSameDay: () => isSameDay,
+  isValidDate: () => isValidDate,
+  isWeekend: () => isWeekend,
+  pxPerMs: () => pxPerMs,
+  snapToGrid: () => snapToGrid,
+  startOfUnit: () => startOfUnit
+});
+
+// src/calendar.ts
+var DEFAULT_WORKING_DAYS = [false, true, true, true, true, true, false];
+function workingDaysOf(calendar) {
+  return calendar?.workingDays ?? DEFAULT_WORKING_DAYS;
+}
+function toISODate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function isHoliday(date, calendar) {
+  if (!calendar?.holidays || calendar.holidays.length === 0) return false;
+  const iso = toISODate(date);
+  return calendar.holidays.includes(iso);
+}
+function isWorkingDay(date, calendar) {
+  const days = workingDaysOf(calendar);
+  const dow = date.getDay();
+  if (!days[dow]) return false;
+  return !isHoliday(date, calendar);
+}
+function isNonWorkingDay(date, calendar) {
+  return !isWorkingDay(date, calendar);
+}
+function nextWorkingDay(date, calendar) {
+  let cursor = new Date(date.getTime());
+  let guard = 0;
+  while (!isWorkingDay(cursor, calendar) && guard++ < 366) {
+    cursor = new Date(cursor.getTime() + MS_PER_DAY);
+  }
+  return cursor;
+}
+function previousWorkingDay(date, calendar) {
+  let cursor = new Date(date.getTime());
+  let guard = 0;
+  while (!isWorkingDay(cursor, calendar) && guard++ < 366) {
+    cursor = new Date(cursor.getTime() - MS_PER_DAY);
+  }
+  return cursor;
+}
+function shiftToWorkingDay(date, calendar, direction) {
+  if (!calendar) return new Date(date.getTime());
+  return direction === 1 ? nextWorkingDay(date, calendar) : previousWorkingDay(date, calendar);
+}
+function hourOfDay(date) {
+  return date.getHours() + date.getMinutes() / 60 + date.getSeconds() / 3600;
+}
+function isWithinWorkingHours(date, calendar) {
+  const hours = calendar?.workingHours;
+  if (!hours) return true;
+  const h = hourOfDay(date);
+  return h >= hours.start && h < hours.end;
+}
+function isWorkingTime(date, calendar) {
+  return isWorkingDay(date, calendar) && isWithinWorkingHours(date, calendar);
+}
+function applyHour(date, hour) {
+  const wholeHours = Math.floor(hour);
+  const minutes = Math.round((hour - wholeHours) * 60);
+  date.setHours(wholeHours, minutes, 0, 0);
+}
+function shiftToWorkingTime(date, calendar, direction) {
+  if (!calendar) return new Date(date.getTime());
+  const wh = calendar.workingHours;
+  let guard = 0;
+  let cursor = new Date(date.getTime());
+  while (guard++ < 400) {
+    if (!isWorkingDay(cursor, calendar)) {
+      cursor = direction === 1 ? nextWorkingDay(cursor, calendar) : previousWorkingDay(cursor, calendar);
+      if (wh) applyHour(cursor, direction === 1 ? wh.start : wh.end);
+      continue;
+    }
+    if (!wh) return cursor;
+    const h = hourOfDay(cursor);
+    if (h < wh.start) {
+      if (direction === 1) {
+        applyHour(cursor, wh.start);
+        return cursor;
+      }
+      cursor = previousWorkingDay(new Date(cursor.getTime() - MS_PER_DAY), calendar);
+      applyHour(cursor, wh.end);
+      return new Date(cursor.getTime() - 1);
+    }
+    if (h >= wh.end) {
+      if (direction === 1) {
+        cursor = new Date(cursor.getTime() + MS_PER_DAY);
+        applyHour(cursor, wh.start);
+        continue;
+      }
+      applyHour(cursor, wh.end);
+      return new Date(cursor.getTime() - 1);
+    }
+    return cursor;
+  }
+  return cursor;
+}
+
+// src/date-utils.ts
+var MS_PER_HOUR = 60 * 60 * 1e3;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+var MS_PER_WEEK = 7 * MS_PER_DAY;
+var WEEKDAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTH_LABELS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function approxUnitMs(viewMode) {
+  switch (viewMode) {
+    case "hour":
+      return MS_PER_HOUR;
+    case "day":
+      return MS_PER_DAY;
+    case "week":
+      return MS_PER_WEEK;
+    case "month":
+      return 30 * MS_PER_DAY;
+    case "quarter":
+      return 91 * MS_PER_DAY;
+    case "year":
+      return 365 * MS_PER_DAY;
+  }
+}
+function pxPerMs(viewMode, columnWidth) {
+  return columnWidth / approxUnitMs(viewMode);
+}
+function dateToX(date, rangeStart, viewMode, columnWidth) {
+  return (date.getTime() - rangeStart.getTime()) * pxPerMs(viewMode, columnWidth);
+}
+function isWeekend(date) {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+function isValidDate(date) {
+  return date instanceof Date && !Number.isNaN(date.getTime());
+}
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function startOfDay(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function startOfWeek(date) {
+  const d = startOfDay(date);
+  const day = d.getDay();
+  const diff = (day + 6) % 7;
+  d.setDate(d.getDate() - diff);
+  return d;
+}
+function startOfMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function startOfQuarter(date) {
+  const q = Math.floor(date.getMonth() / 3);
+  return new Date(date.getFullYear(), q * 3, 1);
+}
+function startOfYear(date) {
+  return new Date(date.getFullYear(), 0, 1);
+}
+function startOfHour(date) {
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours()
+  );
+}
+function startOfUnit(date, viewMode) {
+  switch (viewMode) {
+    case "hour":
+      return startOfHour(date);
+    case "day":
+      return startOfDay(date);
+    case "week":
+      return startOfWeek(date);
+    case "month":
+      return startOfMonth(date);
+    case "quarter":
+      return startOfQuarter(date);
+    case "year":
+      return startOfYear(date);
+  }
+}
+function addUnit(date, viewMode, count) {
+  const d = new Date(date.getTime());
+  switch (viewMode) {
+    case "hour":
+      d.setHours(d.getHours() + count);
+      return d;
+    case "day":
+      d.setDate(d.getDate() + count);
+      return d;
+    case "week":
+      d.setDate(d.getDate() + count * 7);
+      return d;
+    case "month":
+      d.setMonth(d.getMonth() + count);
+      return d;
+    case "quarter":
+      d.setMonth(d.getMonth() + count * 3);
+      return d;
+    case "year":
+      d.setFullYear(d.getFullYear() + count);
+      return d;
+  }
+}
+function snapToGrid(date, viewMode) {
+  const floor = startOfUnit(date, viewMode);
+  const ceil = addUnit(floor, viewMode, 1);
+  const mid = (floor.getTime() + ceil.getTime()) / 2;
+  return date.getTime() < mid ? floor : ceil;
+}
+function isMajorBoundary(date, viewMode) {
+  switch (viewMode) {
+    case "hour":
+      return date.getHours() === 0;
+    case "day":
+      return date.getDate() === 1;
+    case "week":
+      return date.getDate() <= 7 && date.getDay() === 1;
+    case "month":
+      return date.getMonth() === 0;
+    case "quarter":
+      return date.getMonth() === 0;
+    case "year":
+      return false;
+  }
+}
+function labelFor(date, viewMode) {
+  switch (viewMode) {
+    case "hour": {
+      const h = date.getHours();
+      const period = h >= 12 ? "PM" : "AM";
+      const h12 = h % 12 === 0 ? 12 : h % 12;
+      return `${h12} ${period}`;
+    }
+    case "day":
+      return `${WEEKDAY_LABELS[date.getDay()]} ${date.getDate()}`;
+    case "week":
+      return `${MONTH_LABELS[date.getMonth()]} ${date.getDate()}`;
+    case "month":
+      return `${MONTH_LABELS[date.getMonth()]} ${date.getFullYear()}`;
+    case "quarter": {
+      const q = Math.floor(date.getMonth() / 3) + 1;
+      return `Q${q} ${date.getFullYear()}`;
+    }
+    case "year":
+      return `${date.getFullYear()}`;
+  }
+}
+function generateTicks(rangeStart, rangeEnd, viewMode, columnWidth, today = /* @__PURE__ */ new Date(), calendar) {
+  if (!isValidDate(rangeStart) || !isValidDate(rangeEnd)) return [];
+  const ticks = [];
+  let cursor = startOfUnit(rangeStart, viewMode);
+  const scale = pxPerMs(viewMode, columnWidth);
+  let guard = 0;
+  const MAX_TICKS = 2e3;
+  const dayLevel = viewMode === "day" || viewMode === "hour";
+  while (cursor.getTime() < rangeEnd.getTime() && guard < MAX_TICKS) {
+    guard++;
+    const x = (cursor.getTime() - rangeStart.getTime()) * scale;
+    ticks.push({
+      date: new Date(cursor.getTime()),
+      x,
+      label: labelFor(cursor, viewMode),
+      isWeekend: dayLevel ? isWeekend(cursor) : false,
+      isNonWorking: viewMode === "hour" && calendar?.workingHours ? !isWorkingTime(cursor, calendar) : dayLevel ? isNonWorkingDay(cursor, calendar) : false,
+      isToday: isSameDay(cursor, today) && dayLevel,
+      isMajorBoundary: isMajorBoundary(cursor, viewMode)
+    });
+    cursor = addUnit(cursor, viewMode, 1);
+  }
+  return ticks;
+}
+
+// src/layout.ts
+function buildTree(tasks) {
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    nodeById.set(task.id, { task, children: [], computedStart: null, computedEnd: null, computedProgress: 0 });
+  }
+  const roots = [];
+  for (const task of tasks) {
+    const node = nodeById.get(task.id);
+    if (!node) continue;
+    const parent = task.parentId ? nodeById.get(task.parentId) : void 0;
+    if (parent) {
+      parent.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return { roots, nodeById };
+}
+function computeSpans(node) {
+  for (const child of node.children) computeSpans(child);
+  const hasExplicit = isValidDate(node.task.start) && isValidDate(node.task.end);
+  if (hasExplicit) {
+    node.computedStart = node.task.start;
+    node.computedEnd = node.task.end;
+    return;
+  }
+  if (node.children.length === 0) {
+    node.computedStart = null;
+    node.computedEnd = null;
+    return;
+  }
+  let min = null;
+  let max = null;
+  for (const child of node.children) {
+    if (child.computedStart) {
+      const t = child.computedStart.getTime();
+      min = min === null ? t : Math.min(min, t);
+    }
+    if (child.computedEnd) {
+      const t = child.computedEnd.getTime();
+      max = max === null ? t : Math.max(max, t);
+    }
+  }
+  node.computedStart = min === null ? null : new Date(min);
+  node.computedEnd = max === null ? null : new Date(max);
+}
+function computeProgressRollup(node) {
+  for (const child of node.children) computeProgressRollup(child);
+  if (node.task.progress !== void 0) {
+    node.computedProgress = Math.min(100, Math.max(0, node.task.progress));
+    return;
+  }
+  if (node.children.length === 0) {
+    node.computedProgress = 0;
+    return;
+  }
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const child of node.children) {
+    const duration = child.computedStart && child.computedEnd ? Math.max(1, child.computedEnd.getTime() - child.computedStart.getTime()) : 1;
+    weightedSum += child.computedProgress * duration;
+    totalWeight += duration;
+  }
+  node.computedProgress = totalWeight > 0 ? weightedSum / totalWeight : 0;
+}
+function flatten(roots) {
+  const out = [];
+  const stack = [];
+  for (let i = roots.length - 1; i >= 0; i--) {
+    const r = roots[i];
+    if (r) stack.push({ node: r, depth: 0, parentCollapsed: false });
+  }
+  while (stack.length > 0) {
+    const item = stack.pop();
+    if (!item) continue;
+    const { node, depth, parentCollapsed } = item;
+    if (parentCollapsed) continue;
+    out.push({ node, depth, visible: true });
+    const collapsedHere = !!node.task.collapsed;
+    for (let i = node.children.length - 1; i >= 0; i--) {
+      const child = node.children[i];
+      if (child) stack.push({ node: child, depth: depth + 1, parentCollapsed: collapsedHere });
+    }
+  }
+  return out;
+}
+function anchorPoint(bar, side) {
+  const y = bar.y + bar.height / 2;
+  return side === "start" ? { x: bar.x, y } : { x: bar.x + bar.width, y };
+}
+function devWarn(message) {
+  const isProd = typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production";
+  if (!isProd) console.warn(`[gantt-core] ${message}`);
+}
+function validateInputs(tasks, dependencies) {
+  const ids = new Set(tasks.map((t) => t.id));
+  for (const dep of dependencies) {
+    if (!ids.has(dep.fromId) || !ids.has(dep.toId)) {
+      devWarn(
+        `dependency references a non-existent task: ${dep.fromId} -> ${dep.toId}`
+      );
+    }
+  }
+  for (const task of tasks) {
+    if (isValidDate(task.start) && isValidDate(task.end) && task.end < task.start) {
+      devWarn(`task "${task.id}" has end date before start date`);
+    }
+  }
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const dep of dependencies) {
+    if (!ids.has(dep.fromId) || !ids.has(dep.toId)) continue;
+    const list = outgoing.get(dep.fromId) ?? [];
+    list.push(dep.toId);
+    outgoing.set(dep.fromId, list);
+  }
+  const indegree = /* @__PURE__ */ new Map();
+  for (const id of ids) indegree.set(id, 0);
+  for (const [, targets] of outgoing) {
+    for (const t of targets) indegree.set(t, (indegree.get(t) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [id, deg] of indegree) if (deg === 0) queue.push(id);
+  let visited = 0;
+  let qi = 0;
+  const maxOps = ids.size + dependencies.length + 1;
+  let ops = 0;
+  while (qi < queue.length && ops++ <= maxOps) {
+    const id = queue[qi++];
+    if (id === void 0) break;
+    visited++;
+    for (const next of outgoing.get(id) ?? []) {
+      const d = (indegree.get(next) ?? 0) - 1;
+      indegree.set(next, d);
+      if (d === 0) queue.push(next);
+    }
+  }
+  if (visited !== ids.size) {
+    devWarn("circular dependency detected; critical path / scheduling for affected tasks is skipped");
+  }
+}
+function linkPath(from, to) {
+  const dx = Math.max(20, Math.abs(to.x - from.x) / 2);
+  const c1x = from.x + dx;
+  const c1y = from.y;
+  const c2x = to.x - dx;
+  const c2y = to.y;
+  return `M ${from.x} ${from.y} C ${c1x} ${c1y}, ${c2x} ${c2y}, ${to.x} ${to.y}`;
+}
+function computeLayout(input) {
+  const {
+    tasks,
+    dependencies,
+    viewMode,
+    columnWidth,
+    theme,
+    columns,
+    showCriticalPath = false,
+    showBaseline = false,
+    showDeadlines = true,
+    calendar,
+    markers = [],
+    autoRollupProgress = false,
+    selectedTaskIds,
+    pagination
+  } = input;
+  validateInputs(tasks, dependencies);
+  const { roots, nodeById } = buildTree(tasks);
+  for (const root of roots) computeSpans(root);
+  if (autoRollupProgress) {
+    for (const root of roots) computeProgressRollup(root);
+  }
+  let visibleRoots = roots;
+  if (pagination && pagination.pageSize > 0) {
+    const start = Math.max(0, (pagination.page - 1) * pagination.pageSize);
+    visibleRoots = roots.slice(start, start + pagination.pageSize);
+  }
+  const flatRows = flatten(visibleRoots);
+  const visibleIds = new Set(flatRows.map((f) => f.node.task.id));
+  const { criticalTasks, criticalLinks } = showCriticalPath ? computeCriticalPath(tasks, dependencies) : { criticalTasks: /* @__PURE__ */ new Set(), criticalLinks: /* @__PURE__ */ new Set() };
+  let rangeMin = null;
+  let rangeMax = null;
+  for (const row of flatRows) {
+    const s = row.node.computedStart;
+    const e = row.node.computedEnd;
+    if (s) rangeMin = rangeMin === null ? s.getTime() : Math.min(rangeMin, s.getTime());
+    if (e) rangeMax = rangeMax === null ? e.getTime() : Math.max(rangeMax, e.getTime());
+  }
+  const now = Date.now();
+  const rawRangeStart = rangeMin === null ? new Date(now) : new Date(rangeMin);
+  const rawRangeEnd = rangeMax === null ? new Date(now + 1) : new Date(rangeMax);
+  const paddedStart = addUnit(rawRangeStart, viewMode, -1);
+  const paddedEnd = addUnit(rawRangeEnd, viewMode, 1);
+  const rows = [];
+  const bars = [];
+  const barByTaskId = /* @__PURE__ */ new Map();
+  flatRows.forEach((row, index) => {
+    const { task } = row.node;
+    const y = index * theme.rowHeight;
+    rows.push({
+      taskId: task.id,
+      y,
+      height: theme.rowHeight,
+      isGroup: !!task.isGroup,
+      collapsed: !!task.collapsed,
+      depth: row.depth,
+      hasChildren: row.node.children.length > 0
+    });
+    const start = row.node.computedStart;
+    const end = row.node.computedEnd;
+    if (!start || !end) return;
+    const x = dateToX(start, paddedStart, viewMode, columnWidth);
+    const width2 = Math.max(0, dateToX(end, paddedStart, viewMode, columnWidth) - x);
+    if (!Number.isFinite(x) || !Number.isFinite(width2)) return;
+    const progress = task.progress !== void 0 ? Math.min(100, Math.max(0, task.progress)) : autoRollupProgress ? row.node.computedProgress : 0;
+    const barHeight = theme.barHeight;
+    const barY = y + (theme.rowHeight - barHeight) / 2;
+    const color = task.color ?? (task.isGroup ? theme.groupBarColor : theme.barColor);
+    const progressColor = task.progressColor ?? theme.barProgressColor;
+    const bar = {
+      taskId: task.id,
+      x,
+      y: barY,
+      width: width2,
+      height: barHeight,
+      progressWidth: width2 * progress / 100,
+      color,
+      progressColor,
+      label: task.name,
+      isCritical: showCriticalPath && criticalTasks.has(task.id),
+      isMilestone: task.isMilestone ?? start.getTime() === end.getTime(),
+      isSelected: selectedTaskIds?.has(task.id) ?? false
+    };
+    if (task.segments && task.segments.length > 0) {
+      const validSegments = task.segments.filter(
+        (s) => isValidDate(s.start) && isValidDate(s.end) && s.end.getTime() > s.start.getTime()
+      );
+      if (validSegments.length > 0) {
+        bar.segments = validSegments.map((s) => {
+          const sx = dateToX(s.start, paddedStart, viewMode, columnWidth);
+          const sw = Math.max(0, dateToX(s.end, paddedStart, viewMode, columnWidth) - sx);
+          return { x: sx - x, width: sw, progressWidth: sw * progress / 100 };
+        });
+      }
+    }
+    if (showBaseline && isValidDate(task.baselineStart) && isValidDate(task.baselineEnd)) {
+      const bx = dateToX(task.baselineStart, paddedStart, viewMode, columnWidth);
+      const bw = Math.max(
+        0,
+        dateToX(task.baselineEnd, paddedStart, viewMode, columnWidth) - bx
+      );
+      if (Number.isFinite(bx) && Number.isFinite(bw)) {
+        bar.baseline = { x: bx, width: bw };
+      }
+    }
+    if (showBaseline && task.baselines && task.baselines.length > 0) {
+      bar.baselines = task.baselines.filter((b) => isValidDate(b.start) && isValidDate(b.end)).map((b) => {
+        const bx = dateToX(b.start, paddedStart, viewMode, columnWidth);
+        const bw = Math.max(0, dateToX(b.end, paddedStart, viewMode, columnWidth) - bx);
+        return { label: b.label, x: bx, width: bw };
+      }).filter((b) => Number.isFinite(b.x) && Number.isFinite(b.width));
+    }
+    if (showDeadlines && isValidDate(task.deadline)) {
+      const dx = dateToX(task.deadline, paddedStart, viewMode, columnWidth);
+      if (Number.isFinite(dx)) {
+        bar.deadlineX = dx;
+        bar.isOverdue = end.getTime() > task.deadline.getTime();
+      }
+    }
+    bars.push(bar);
+    barByTaskId.set(task.id, bar);
+  });
+  function nearestVisibleAncestorId(taskId) {
+    let currentId = taskId;
+    const guard = /* @__PURE__ */ new Set();
+    while (currentId !== null && !guard.has(currentId)) {
+      guard.add(currentId);
+      if (visibleIds.has(currentId)) return currentId;
+      const node = nodeById.get(currentId);
+      currentId = node?.task.parentId ?? null;
+    }
+    return null;
+  }
+  const links = [];
+  for (const dep of dependencies) {
+    if (!nodeById.has(dep.fromId) || !nodeById.has(dep.toId)) continue;
+    const fromVisibleId = nearestVisibleAncestorId(dep.fromId);
+    const toVisibleId = nearestVisibleAncestorId(dep.toId);
+    if (!fromVisibleId || !toVisibleId || fromVisibleId === toVisibleId) continue;
+    const fromBar = barByTaskId.get(fromVisibleId);
+    const toBar = barByTaskId.get(toVisibleId);
+    if (!fromBar || !toBar) continue;
+    const fromSide = dep.type === "SS" || dep.type === "SF" ? "start" : "end";
+    const toSide = dep.type === "FF" || dep.type === "SF" ? "end" : "start";
+    const from = anchorPoint(fromBar, fromSide);
+    const to = anchorPoint(toBar, toSide);
+    links.push({
+      fromId: dep.fromId,
+      toId: dep.toId,
+      type: dep.type,
+      path: linkPath(from, to),
+      isCritical: showCriticalPath && criticalLinks.has(`${dep.fromId}->${dep.toId}`)
+    });
+  }
+  const ticks = generateTicks(paddedStart, paddedEnd, viewMode, columnWidth, /* @__PURE__ */ new Date(), calendar).map(
+    (t) => ({
+      x: t.x,
+      label: t.label,
+      isWeekend: t.isWeekend,
+      isNonWorking: t.isNonWorking,
+      isToday: t.isToday,
+      isMajorBoundary: t.isMajorBoundary
+    })
+  );
+  const renderMarkers = markers.filter((m) => isValidDate(m.date)).map((m) => ({
+    x: dateToX(m.date, paddedStart, viewMode, columnWidth),
+    label: m.label ?? "",
+    color: m.color ?? theme.markerColor
+  })).filter((m) => Number.isFinite(m.x));
+  let width = 0;
+  for (const tick of ticks) width = Math.max(width, tick.x);
+  for (const bar of bars) width = Math.max(width, bar.x + bar.width);
+  width += columnWidth;
+  const height = rows.length * theme.rowHeight;
+  return {
+    width,
+    height,
+    rowHeight: theme.rowHeight,
+    headerHeight: theme.headerHeight,
+    rows,
+    bars,
+    links,
+    ticks,
+    columns,
+    theme,
+    markers: renderMarkers,
+    rangeStart: paddedStart
+  };
+}
+
+// src/history.ts
+var HistoryManager = class {
+  constructor(onChange) {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.onChange = onChange;
+  }
+  push(cmd) {
+    cmd.do();
+    this.undoStack.push(cmd);
+    this.redoStack = [];
+    this.notify();
+  }
+  undo() {
+    const cmd = this.undoStack.pop();
+    if (!cmd) return false;
+    cmd.undo();
+    this.redoStack.push(cmd);
+    this.notify();
+    return true;
+  }
+  redo() {
+    const cmd = this.redoStack.pop();
+    if (!cmd) return false;
+    cmd.do();
+    this.undoStack.push(cmd);
+    this.notify();
+    return true;
+  }
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.notify();
+  }
+  notify() {
+    this.onChange?.({ canUndo: this.canUndo, canRedo: this.canRedo });
+  }
+};
+
+// src/event-emitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.listeners = {};
+  }
+  on(event, listener) {
+    let set = this.listeners[event];
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners[event] = set;
+    }
+    set.add(listener);
+  }
+  off(event, listener) {
+    this.listeners[event]?.delete(listener);
+  }
+  once(event, listener) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      listener(payload);
+    };
+    this.on(event, wrapper);
+  }
+  emit(event, payload) {
+    const set = this.listeners[event];
+    if (!set) return;
+    for (const listener of Array.from(set)) {
+      listener(payload);
+    }
+  }
+  removeAllListeners() {
+    this.listeners = {};
+  }
+};
+
+// src/csv.ts
+var CSV_COLUMNS = ["id", "name", "start", "end", "progress", "parentId"];
+function escapeCsvField(value) {
+  if (/[",\n]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i] ?? "";
+    if (inQuotes) {
+      if (char === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      fields.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function tasksToCSV(tasks) {
+  const lines = [CSV_COLUMNS.join(",")];
+  for (const task of tasks) {
+    const row = [
+      task.id,
+      task.name,
+      task.start instanceof Date ? task.start.toISOString() : "",
+      task.end instanceof Date ? task.end.toISOString() : "",
+      task.progress !== void 0 ? String(task.progress) : "",
+      task.parentId ?? ""
+    ].map((v) => escapeCsvField(String(v)));
+    lines.push(row.join(","));
+  }
+  return lines.join("\n");
+}
+function tasksFromCSV(csv) {
+  const lines = csv.split(/\r?\n/).filter((l) => l.length > 0);
+  if (lines.length === 0) return [];
+  const header = parseCsvLine(lines[0] ?? "");
+  const colIndex = new Map(header.map((h, i) => [h.trim(), i]));
+  const tasks = [];
+  for (let i = 1; i < lines.length; i++) {
+    const fields = parseCsvLine(lines[i] ?? "");
+    const get = (col) => {
+      const idx = colIndex.get(col);
+      return idx === void 0 ? "" : fields[idx] ?? "";
+    };
+    const id = get("id");
+    if (!id) continue;
+    const progressRaw = get("progress");
+    const parentIdRaw = get("parentId");
+    tasks.push({
+      id,
+      name: get("name"),
+      start: new Date(get("start")),
+      end: new Date(get("end")),
+      progress: progressRaw ? Number(progressRaw) : void 0,
+      parentId: parentIdRaw || null
+    });
+  }
+  return tasks;
+}
+
+// src/renderer.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+function isSafeHref(url) {
+  try {
+    const base = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
+    const parsed = new URL(url, base);
+    return parsed.protocol === "http:" || parsed.protocol === "https:" || parsed.protocol === "mailto:";
+  } catch {
+    return false;
+  }
+}
+function el(tag, className) {
+  const e = document.createElement(tag);
+  if (className) e.className = className;
+  return e;
+}
+function svgEl(tag) {
+  return document.createElementNS(SVG_NS, tag);
+}
+function initials(name) {
+  const parts = name.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "?";
+  const first = parts[0]?.[0] ?? "";
+  const last = parts.length > 1 ? parts[parts.length - 1]?.[0] ?? "" : "";
+  return (first + last).toUpperCase();
+}
+var GanttRenderer = class {
+  constructor(container, options = {}) {
+    this.container = container;
+    this.options = options;
+    this.lastModel = null;
+    this.lastTasks = [];
+    this.lastColumns = [];
+    this.onGridDoubleClick = (evt) => {
+      if (!this.options.onRenameCommit) return;
+      const target = evt.target;
+      const cell = target.closest("[data-gantt-name-cell]");
+      if (!cell || cell.querySelector("input")) return;
+      const taskId = cell.dataset.ganttNameCell;
+      if (!taskId) return;
+      const currentText = cell.dataset.ganttNameValue ?? "";
+      cell.replaceChildren();
+      const input = document.createElement("input");
+      input.type = "text";
+      input.value = currentText;
+      input.className = "gantt-rename-input";
+      cell.appendChild(input);
+      input.focus();
+      input.select();
+      const commit = () => {
+        this.options.onRenameCommit?.(taskId, input.value);
+      };
+      const cancel = () => {
+        this.rerenderVisibleOnly();
+      };
+      input.addEventListener("keydown", (kEvt) => {
+        if (kEvt.key === "Enter") {
+          kEvt.preventDefault();
+          commit();
+        } else if (kEvt.key === "Escape") {
+          kEvt.preventDefault();
+          cancel();
+        }
+      });
+      input.addEventListener("blur", commit, { once: true });
+    };
+    this.markerDefsId = `gantt-arrow-${Math.random().toString(36).slice(2)}`;
+    this.root = el("div", "gantt-root");
+    this.gridPanel = el("div", "gantt-grid-panel");
+    this.timelineScroll = el("div", "gantt-timeline-scroll");
+    this.svg = svgEl("svg");
+    this.svg.classList.add("gantt-svg");
+    this.timelineScroll.appendChild(this.svg);
+    this.root.appendChild(this.gridPanel);
+    this.root.appendChild(this.timelineScroll);
+    this.container.appendChild(this.root);
+    if (options.virtualScroll !== false && typeof document !== "undefined") {
+      this.scrollListener = () => this.rerenderVisibleOnly();
+      this.timelineScroll.addEventListener("scroll", this.scrollListener);
+    }
+    this.gridPanel.addEventListener("dblclick", this.onGridDoubleClick);
+  }
+  render(model, tasks, columns, explicitTheme) {
+    this.lastModel = model;
+    this.lastTasks = tasks;
+    this.lastColumns = columns;
+    const cssVars = explicitThemeToCssVars(explicitTheme);
+    for (const key of Object.keys(cssVars)) {
+      this.root.style.setProperty(key, cssVars[key]);
+    }
+    this.renderGridPanel(model, tasks, columns);
+    this.renderTimeline(model, tasks);
+  }
+  getViewportRowRange(model) {
+    if (this.options.virtualScroll === false) {
+      return { startY: -Infinity, endY: Infinity };
+    }
+    const overscan = (this.options.overscan ?? 5) * model.rowHeight;
+    const scrollTop = this.timelineScroll.scrollTop || 0;
+    const viewportHeight = this.timelineScroll.clientHeight || model.height;
+    return {
+      startY: scrollTop - overscan,
+      endY: scrollTop + viewportHeight + overscan
+    };
+  }
+  rerenderVisibleOnly() {
+    if (!this.lastModel) return;
+    this.renderGridPanel(this.lastModel, this.lastTasks, this.lastColumns);
+    this.renderTimeline(this.lastModel, this.lastTasks);
+  }
+  renderGridPanel(model, tasks, columns) {
+    this.gridPanel.replaceChildren();
+    const taskById = new Map(tasks.map((t) => [t.id, t]));
+    const { startY, endY } = this.getViewportRowRange(model);
+    const header = el("div", "gantt-grid-header-row");
+    header.style.height = `${model.headerHeight}px`;
+    for (const col of columns) {
+      header.appendChild(this.renderHeaderCell(col, columns));
+    }
+    this.gridPanel.appendChild(header);
+    const body = el("div", "gantt-grid-body");
+    body.style.height = `${model.height}px`;
+    model.rows.forEach((row, index) => {
+      if (row.y + row.height < startY || row.y > endY) return;
+      const task = taskById.get(row.taskId);
+      if (!task) return;
+      body.appendChild(this.renderGridRow(row, task, columns, index));
+    });
+    this.gridPanel.appendChild(body);
+  }
+  renderHeaderCell(col, columns) {
+    const cell = el("div", "gantt-grid-header-cell");
+    cell.style.position = "relative";
+    if (col.width) cell.style.width = `${col.width}px`;
+    cell.textContent = col.title;
+    if (this.options.onColumnReorder) {
+      cell.draggable = true;
+      cell.style.cursor = "grab";
+      cell.addEventListener("dragstart", (evt) => {
+        evt.dataTransfer?.setData("text/plain", col.id);
+      });
+      cell.addEventListener("dragover", (evt) => evt.preventDefault());
+      cell.addEventListener("drop", (evt) => {
+        evt.preventDefault();
+        const draggedId = evt.dataTransfer?.getData("text/plain");
+        if (!draggedId || draggedId === col.id) return;
+        const order = columns.map((c) => c.id).filter((id) => id !== draggedId);
+        const targetIndex = order.indexOf(col.id);
+        order.splice(targetIndex, 0, draggedId);
+        this.options.onColumnReorder?.(order);
+      });
+    }
+    if (this.options.onColumnResize) {
+      const handle = el("div", "gantt-col-resize-handle");
+      handle.style.position = "absolute";
+      handle.style.right = "0";
+      handle.style.top = "0";
+      handle.style.bottom = "0";
+      handle.style.width = "6px";
+      handle.style.cursor = "col-resize";
+      handle.addEventListener("pointerdown", (evt) => {
+        evt.preventDefault();
+        evt.stopPropagation();
+        const startX = evt.clientX;
+        const startWidth = col.width ?? cell.getBoundingClientRect().width;
+        const onMove = (moveEvt) => {
+          const newWidth = Math.max(30, startWidth + (moveEvt.clientX - startX));
+          cell.style.width = `${newWidth}px`;
+        };
+        const onUp = (upEvt) => {
+          window.removeEventListener("pointermove", onMove);
+          window.removeEventListener("pointerup", onUp);
+          const newWidth = Math.max(30, startWidth + (upEvt.clientX - startX));
+          this.options.onColumnResize?.(col.id, newWidth);
+        };
+        window.addEventListener("pointermove", onMove);
+        window.addEventListener("pointerup", onUp);
+      });
+      cell.appendChild(handle);
+    }
+    return cell;
+  }
+  renderGridRow(row, task, columns, firstColumnIndex) {
+    const rowEl = el("div", "gantt-grid-row");
+    rowEl.style.position = "absolute";
+    rowEl.style.top = `${row.y}px`;
+    rowEl.style.height = `${row.height}px`;
+    rowEl.dataset.ganttRow = task.id;
+    if (this.options.keyboardAccessible) {
+      rowEl.setAttribute("role", "row");
+    }
+    if (this.options.onRowReorder) {
+      rowEl.draggable = true;
+      rowEl.style.cursor = "grab";
+      rowEl.addEventListener("dragstart", (evt) => {
+        evt.dataTransfer?.setData("text/plain", task.id);
+        evt.stopPropagation();
+      });
+      rowEl.addEventListener("dragover", (evt) => {
+        evt.preventDefault();
+        evt.stopPropagation();
+      });
+      rowEl.addEventListener("drop", (evt) => {
+        evt.preventDefault();
+        evt.stopPropagation();
+        const draggedId = evt.dataTransfer?.getData("text/plain");
+        if (!draggedId || draggedId === task.id) return;
+        const bounds = rowEl.getBoundingClientRect();
+        const fraction = (evt.clientY - bounds.top) / bounds.height;
+        const position = fraction < 0.25 ? "before" : fraction > 0.75 ? "after" : "inside";
+        this.options.onRowReorder?.(draggedId, task.id, position);
+      });
+    }
+    columns.forEach((col, colIndex) => {
+      const cell = el("div", "gantt-grid-cell");
+      if (col.width) cell.style.width = `${col.width}px`;
+      if (col.align) cell.style.textAlign = col.align;
+      const rawValue = col.accessor ? col.accessor(task) : colIndex === 0 ? task.name : "";
+      const textValue = rawValue === null || rawValue === void 0 ? "" : String(rawValue);
+      if (colIndex === 0) {
+        cell.dataset.ganttNameCell = task.id;
+        cell.dataset.ganttNameValue = textValue;
+        const indent = el("span", "gantt-indent");
+        indent.style.width = `${row.depth * 16}px`;
+        cell.appendChild(indent);
+        if (row.hasChildren) {
+          const toggle = el("button", "gantt-toggle");
+          toggle.type = "button";
+          toggle.dataset.ganttToggle = task.id;
+          toggle.setAttribute("aria-label", row.collapsed ? "Expand" : "Collapse");
+          toggle.textContent = row.collapsed ? "\u25B8" : "\u25BE";
+          cell.appendChild(toggle);
+        }
+      }
+      const rendered = col.render ? col.render(task) : void 0;
+      if (rendered instanceof HTMLElement) {
+        cell.appendChild(rendered);
+      } else if (typeof rendered === "string") {
+        cell.appendChild(document.createTextNode(rendered));
+      } else {
+        const href = col.getHref ? col.getHref(task) : null;
+        if (href && isSafeHref(href)) {
+          const anchor = document.createElement("a");
+          anchor.href = href;
+          anchor.target = col.linkTarget ?? "_blank";
+          anchor.rel = "noopener noreferrer";
+          anchor.textContent = textValue;
+          cell.appendChild(anchor);
+        } else {
+          const textNode = document.createTextNode(textValue);
+          cell.appendChild(textNode);
+        }
+      }
+      rowEl.appendChild(cell);
+    });
+    void firstColumnIndex;
+    return rowEl;
+  }
+  renderTimeline(model, tasks) {
+    this.svg.replaceChildren();
+    this.svg.setAttribute("width", String(model.width));
+    this.svg.setAttribute("height", String(model.headerHeight + model.height));
+    this.svg.setAttribute("viewBox", `0 0 ${model.width} ${model.headerHeight + model.height}`);
+    const defs = svgEl("defs");
+    const marker = svgEl("marker");
+    marker.setAttribute("id", this.markerDefsId);
+    marker.setAttribute("markerWidth", "8");
+    marker.setAttribute("markerHeight", "8");
+    marker.setAttribute("refX", "6");
+    marker.setAttribute("refY", "3");
+    marker.setAttribute("orient", "auto");
+    const arrowPath = svgEl("path");
+    arrowPath.setAttribute("d", "M0,0 L6,3 L0,6 Z");
+    arrowPath.style.fill = themedFill("linkColor", model.theme.linkColor);
+    marker.appendChild(arrowPath);
+    defs.appendChild(marker);
+    this.svg.appendChild(defs);
+    const { startY, endY } = this.getViewportRowRange(model);
+    const bodyGroup = svgEl("g");
+    bodyGroup.setAttribute("transform", `translate(0, ${model.headerHeight})`);
+    this.renderGridLines(bodyGroup, model);
+    this.renderRowBackgrounds(bodyGroup, model, startY, endY);
+    this.renderBars(bodyGroup, model, tasks, startY, endY);
+    this.renderLinks(bodyGroup, model, startY, endY);
+    this.renderMarkers(bodyGroup, model);
+    this.svg.appendChild(bodyGroup);
+    this.renderHeader(model);
+  }
+  renderGridLines(group, model) {
+    for (const tick of model.ticks) {
+      if (tick.isNonWorking) {
+        const rect = svgEl("rect");
+        rect.setAttribute("x", String(tick.x));
+        rect.setAttribute("y", "0");
+        rect.setAttribute("width", "1");
+        rect.setAttribute("height", String(model.height));
+        rect.style.fill = themedFill("weekendColor", model.theme.weekendColor);
+        group.appendChild(rect);
+      }
+      const line = svgEl("line");
+      line.setAttribute("x1", String(tick.x));
+      line.setAttribute("x2", String(tick.x));
+      line.setAttribute("y1", "0");
+      line.setAttribute("y2", String(model.height));
+      line.style.stroke = themedFill("gridColor", model.theme.gridColor);
+      line.setAttribute("stroke-width", tick.isMajorBoundary ? "1.5" : "1");
+      group.appendChild(line);
+      if (tick.isToday) {
+        const todayLine = svgEl("line");
+        todayLine.setAttribute("x1", String(tick.x));
+        todayLine.setAttribute("x2", String(tick.x));
+        todayLine.setAttribute("y1", "0");
+        todayLine.setAttribute("y2", String(model.height));
+        todayLine.style.stroke = themedFill("todayColor", model.theme.todayColor);
+        todayLine.setAttribute("stroke-width", "2");
+        group.appendChild(todayLine);
+      }
+    }
+  }
+  renderMarkers(group, model) {
+    for (const marker of model.markers) {
+      const line = svgEl("line");
+      line.setAttribute("x1", String(marker.x));
+      line.setAttribute("x2", String(marker.x));
+      line.setAttribute("y1", "0");
+      line.setAttribute("y2", String(model.height));
+      line.setAttribute("stroke", marker.color);
+      line.setAttribute("stroke-width", "1.5");
+      line.setAttribute("stroke-dasharray", "3 3");
+      line.dataset.ganttMarker = marker.label;
+      group.appendChild(line);
+      if (marker.label) {
+        const label = svgEl("text");
+        label.setAttribute("x", String(marker.x + 4));
+        label.setAttribute("y", "12");
+        label.setAttribute("fill", marker.color);
+        label.setAttribute("font-size", String(model.theme.fontSize));
+        label.setAttribute("font-family", model.theme.fontFamily);
+        label.textContent = marker.label;
+        group.appendChild(label);
+      }
+    }
+  }
+  renderHeader(model) {
+    let headerGroup = this.svg.querySelector(".gantt-header-group");
+    if (headerGroup) headerGroup.remove();
+    headerGroup = svgEl("g");
+    headerGroup.setAttribute("class", "gantt-header-group");
+    const bg = svgEl("rect");
+    bg.setAttribute("x", "0");
+    bg.setAttribute("y", "0");
+    bg.setAttribute("width", String(model.width));
+    bg.setAttribute("height", String(model.headerHeight));
+    bg.style.fill = themedFill("backgroundColor", model.theme.backgroundColor);
+    headerGroup.appendChild(bg);
+    for (const tick of model.ticks) {
+      const text = svgEl("text");
+      text.setAttribute("x", String(tick.x + 4));
+      text.setAttribute("y", String(model.headerHeight - 8));
+      text.style.fill = themedFill("textColor", model.theme.textColor);
+      text.setAttribute("font-size", String(model.theme.fontSize));
+      text.setAttribute("font-family", model.theme.fontFamily);
+      text.textContent = tick.label;
+      headerGroup.appendChild(text);
+    }
+    this.svg.appendChild(headerGroup);
+  }
+  /**
+   * Invisible full-width hit-test rects, one per row, behind the bars. Lets
+   * drag-to-create (InteractionController) find "which row / empty timeline
+   * space was this pointerdown on" without needing its own copy of the
+   * layout math - a bar drawn on top naturally wins the hit test where one exists.
+   */
+  renderRowBackgrounds(group, model, startY, endY) {
+    for (const row of model.rows) {
+      if (row.y + row.height < startY || row.y > endY) continue;
+      const rect = svgEl("rect");
+      rect.setAttribute("x", "0");
+      rect.setAttribute("y", String(row.y));
+      rect.setAttribute("width", String(model.width));
+      rect.setAttribute("height", String(row.height));
+      rect.setAttribute("fill", "transparent");
+      rect.style.pointerEvents = "all";
+      rect.dataset.ganttRowBg = row.taskId;
+      group.appendChild(rect);
+    }
+  }
+  renderBars(group, model, tasks, startY, endY) {
+    const taskById = new Map(tasks.map((t) => [t.id, t]));
+    for (const bar of model.bars) {
+      if (bar.y + bar.height < startY || bar.y > endY) continue;
+      const task = taskById.get(bar.taskId);
+      group.appendChild(this.renderBar(bar, task, model));
+    }
+  }
+  renderBar(bar, task, model) {
+    const g = svgEl("g");
+    g.setAttribute("class", "gantt-bar");
+    g.dataset.ganttBar = bar.taskId;
+    g.setAttribute("transform", `translate(${bar.x}, ${bar.y})`);
+    if (task?.notes) {
+      const title = svgEl("title");
+      title.textContent = task.notes;
+      g.appendChild(title);
+    }
+    if (this.options.keyboardAccessible) {
+      g.setAttribute("tabindex", "0");
+      g.setAttribute("role", "button");
+      if (task) {
+        const progress = Math.round(task.progress ?? 0);
+        const label2 = `${task.name}, ${task.start.toDateString()} to ${task.end.toDateString()}, ${progress}% complete`;
+        g.setAttribute("aria-label", label2);
+      }
+    }
+    if (bar.baseline) {
+      const baseline = svgEl("rect");
+      baseline.setAttribute("x", String(bar.baseline.x - bar.x));
+      baseline.setAttribute("y", "-2");
+      baseline.setAttribute("width", String(bar.baseline.width));
+      baseline.setAttribute("height", String(bar.height + 4));
+      baseline.style.fill = themedFill("baselineColor", model.theme.baselineColor);
+      baseline.setAttribute("opacity", "0.35");
+      baseline.setAttribute("rx", String(model.theme.borderRadius));
+      g.appendChild(baseline);
+    }
+    if (bar.baselines && bar.baselines.length > 0) {
+      bar.baselines.forEach((b, i) => {
+        const offset = (bar.baselines.length - i) * 2;
+        const rect = svgEl("rect");
+        rect.setAttribute("x", String(b.x - bar.x));
+        rect.setAttribute("y", String(-2 - offset));
+        rect.setAttribute("width", String(b.width));
+        rect.setAttribute("height", "3");
+        rect.style.fill = themedFill("baselineColor", model.theme.baselineColor);
+        rect.setAttribute("opacity", String(Math.max(0.15, 0.4 - i * 0.08)));
+        if (b.label) {
+          const title = svgEl("title");
+          title.textContent = b.label;
+          rect.appendChild(title);
+        }
+        g.appendChild(rect);
+      });
+    }
+    const isDefaultBarColor = bar.color === (task?.isGroup ? model.theme.groupBarColor : model.theme.barColor);
+    const isDefaultProgressColor = bar.progressColor === model.theme.barProgressColor;
+    const fillColor = bar.isCritical ? themedFill("criticalColor", model.theme.criticalColor) : isDefaultBarColor ? themedFill(task?.isGroup ? "groupBarColor" : "barColor", bar.color) : bar.color;
+    if (bar.isMilestone) {
+      const size = bar.height * 0.8;
+      const diamond = svgEl("rect");
+      diamond.setAttribute("x", String(-size / 2));
+      diamond.setAttribute("y", String((bar.height - size) / 2));
+      diamond.setAttribute("width", String(size));
+      diamond.setAttribute("height", String(size));
+      diamond.style.fill = fillColor;
+      diamond.setAttribute(
+        "transform",
+        `rotate(45, 0, ${bar.height / 2})`
+      );
+      g.appendChild(diamond);
+      const label2 = svgEl("text");
+      label2.setAttribute("x", String(size / 2 + 8));
+      label2.setAttribute("y", String(bar.height / 2 + 4));
+      label2.style.fill = themedFill("textColor", model.theme.textColor);
+      label2.setAttribute("font-size", String(model.theme.fontSize));
+      label2.setAttribute("font-family", model.theme.fontFamily);
+      label2.textContent = bar.label;
+      g.appendChild(label2);
+      return g;
+    }
+    if (bar.segments && bar.segments.length > 0) {
+      bar.segments.forEach((seg, i) => {
+        const segRect = svgEl("rect");
+        segRect.setAttribute("x", String(seg.x));
+        segRect.setAttribute("y", "0");
+        segRect.setAttribute("width", String(seg.width));
+        segRect.setAttribute("height", String(bar.height));
+        segRect.setAttribute("rx", String(model.theme.borderRadius));
+        segRect.style.fill = fillColor;
+        if (bar.isCritical) {
+          segRect.style.stroke = themedFill("criticalColor", model.theme.criticalColor);
+          segRect.setAttribute("stroke-width", "1.5");
+        }
+        g.appendChild(segRect);
+        if (seg.progressWidth > 0) {
+          const segProgress = svgEl("rect");
+          segProgress.setAttribute("x", String(seg.x));
+          segProgress.setAttribute("y", "0");
+          segProgress.setAttribute("width", String(seg.progressWidth));
+          segProgress.setAttribute("height", String(bar.height));
+          segProgress.setAttribute("rx", String(model.theme.borderRadius));
+          segProgress.style.fill = isDefaultProgressColor ? themedFill("barProgressColor", bar.progressColor) : bar.progressColor;
+          g.appendChild(segProgress);
+        }
+        const next = bar.segments[i + 1];
+        if (next) {
+          const connector2 = svgEl("line");
+          connector2.setAttribute("x1", String(seg.x + seg.width));
+          connector2.setAttribute("x2", String(next.x));
+          connector2.setAttribute("y1", String(bar.height / 2));
+          connector2.setAttribute("y2", String(bar.height / 2));
+          connector2.style.stroke = fillColor;
+          connector2.setAttribute("stroke-width", "1.5");
+          connector2.setAttribute("stroke-dasharray", "3 2");
+          g.appendChild(connector2);
+        }
+      });
+    } else {
+      const rect = svgEl("rect");
+      rect.setAttribute("x", "0");
+      rect.setAttribute("y", "0");
+      rect.setAttribute("width", String(bar.width));
+      rect.setAttribute("height", String(bar.height));
+      rect.setAttribute("rx", String(model.theme.borderRadius));
+      rect.style.fill = fillColor;
+      if (bar.isCritical) {
+        rect.style.stroke = themedFill("criticalColor", model.theme.criticalColor);
+        rect.setAttribute("stroke-width", "1.5");
+      }
+      g.appendChild(rect);
+      if (bar.progressWidth > 0) {
+        const progressRect = svgEl("rect");
+        progressRect.setAttribute("x", "0");
+        progressRect.setAttribute("y", "0");
+        progressRect.setAttribute("width", String(bar.progressWidth));
+        progressRect.setAttribute("height", String(bar.height));
+        progressRect.setAttribute("rx", String(model.theme.borderRadius));
+        progressRect.style.fill = isDefaultProgressColor ? themedFill("barProgressColor", bar.progressColor) : bar.progressColor;
+        g.appendChild(progressRect);
+      }
+    }
+    if (bar.isSelected) {
+      const selectionOutline = svgEl("rect");
+      selectionOutline.setAttribute("x", "-2");
+      selectionOutline.setAttribute("y", "-2");
+      selectionOutline.setAttribute("width", String(bar.width + 4));
+      selectionOutline.setAttribute("height", String(bar.height + 4));
+      selectionOutline.setAttribute("rx", String(model.theme.borderRadius + 2));
+      selectionOutline.setAttribute("fill", "none");
+      selectionOutline.style.stroke = themedFill("selectionColor", model.theme.selectionColor);
+      selectionOutline.setAttribute("stroke-width", "2");
+      g.appendChild(selectionOutline);
+    }
+    const handleWidth = 6;
+    const leftHandle = svgEl("rect");
+    leftHandle.setAttribute("x", "0");
+    leftHandle.setAttribute("y", "0");
+    leftHandle.setAttribute("width", String(handleWidth));
+    leftHandle.setAttribute("height", String(bar.height));
+    leftHandle.setAttribute("fill", "transparent");
+    leftHandle.dataset.ganttHandle = "left";
+    leftHandle.dataset.ganttHandleFor = bar.taskId;
+    leftHandle.style.cursor = "ew-resize";
+    g.appendChild(leftHandle);
+    const rightHandle = svgEl("rect");
+    rightHandle.setAttribute("x", String(Math.max(0, bar.width - handleWidth)));
+    rightHandle.setAttribute("y", "0");
+    rightHandle.setAttribute("width", String(handleWidth));
+    rightHandle.setAttribute("height", String(bar.height));
+    rightHandle.setAttribute("fill", "transparent");
+    rightHandle.dataset.ganttHandle = "right";
+    rightHandle.dataset.ganttHandleFor = bar.taskId;
+    rightHandle.style.cursor = "ew-resize";
+    g.appendChild(rightHandle);
+    const connector = svgEl("circle");
+    connector.setAttribute("cx", String(bar.width));
+    connector.setAttribute("cy", String(bar.height / 2));
+    connector.setAttribute("r", "4");
+    connector.style.fill = themedFill("linkColor", model.theme.linkColor);
+    connector.dataset.ganttConnector = bar.taskId;
+    connector.dataset.ganttConnectorSide = "right";
+    connector.style.cursor = "crosshair";
+    g.appendChild(connector);
+    const label = svgEl("text");
+    label.setAttribute("x", String(bar.width + 6));
+    label.setAttribute("y", String(bar.height / 2 + 4));
+    label.style.fill = themedFill("textColor", model.theme.textColor);
+    label.setAttribute("font-size", String(model.theme.fontSize));
+    label.setAttribute("font-family", model.theme.fontFamily);
+    label.textContent = bar.label;
+    g.appendChild(label);
+    if (bar.deadlineX !== void 0) {
+      const markerX = bar.deadlineX - bar.x;
+      const flag = svgEl("g");
+      flag.setAttribute("transform", `translate(${markerX}, -6)`);
+      const pole = svgEl("line");
+      pole.setAttribute("x1", "0");
+      pole.setAttribute("x2", "0");
+      pole.setAttribute("y1", "0");
+      pole.setAttribute("y2", String(bar.height + 6));
+      const deadlineColor = bar.isOverdue ? themedFill("criticalColor", model.theme.criticalColor) : themedFill("deadlineColor", model.theme.deadlineColor);
+      pole.style.stroke = deadlineColor;
+      pole.setAttribute("stroke-width", "1.5");
+      flag.appendChild(pole);
+      const pennant = svgEl("path");
+      pennant.setAttribute("d", "M0,0 L7,3 L0,6 Z");
+      pennant.style.fill = deadlineColor;
+      flag.appendChild(pennant);
+      g.appendChild(flag);
+    }
+    if (this.options.showAssigneeAvatars && task?.assignees?.length) {
+      let ax = -10;
+      for (const assignee of task.assignees.slice(0, 3)) {
+        const avatarGroup = svgEl("g");
+        avatarGroup.setAttribute("transform", `translate(${ax}, ${bar.height / 2})`);
+        if (assignee.avatarUrl) {
+          const image = svgEl("image");
+          image.setAttribute("href", assignee.avatarUrl);
+          image.setAttribute("x", "-8");
+          image.setAttribute("y", "-8");
+          image.setAttribute("width", "16");
+          image.setAttribute("height", "16");
+          image.setAttribute("clip-path", "circle(8px at 8px 8px)");
+          avatarGroup.appendChild(image);
+        } else {
+          const circle = svgEl("circle");
+          circle.setAttribute("r", "8");
+          circle.style.fill = assignee.color ?? themedFill("groupBarColor", model.theme.groupBarColor);
+          avatarGroup.appendChild(circle);
+          const text = svgEl("text");
+          text.setAttribute("text-anchor", "middle");
+          text.setAttribute("y", "3");
+          text.setAttribute("font-size", "8");
+          text.setAttribute("fill", "#fff");
+          text.textContent = initials(assignee.name);
+          avatarGroup.appendChild(text);
+        }
+        g.appendChild(avatarGroup);
+        ax -= 18;
+      }
+    }
+    return g;
+  }
+  renderLinks(group, model, startY, endY) {
+    const barByTaskId = new Map(model.bars.map((b) => [b.taskId, b]));
+    for (const link of model.links) {
+      const fromBar = barByTaskId.get(link.fromId);
+      const toBar = barByTaskId.get(link.toId);
+      const relevantY = toBar?.y ?? fromBar?.y ?? 0;
+      if (relevantY < startY || relevantY > endY) continue;
+      const path = svgEl("path");
+      path.setAttribute("d", link.path);
+      path.setAttribute("fill", "none");
+      path.style.stroke = link.isCritical ? themedFill("criticalColor", model.theme.criticalColor) : themedFill("linkColor", model.theme.linkColor);
+      path.setAttribute("stroke-width", link.isCritical ? "2" : "1.5");
+      path.setAttribute("marker-end", `url(#${this.markerDefsId})`);
+      path.dataset.ganttLink = `${link.fromId}->${link.toId}`;
+      group.appendChild(path);
+    }
+  }
+  toSVGString() {
+    return new XMLSerializer().serializeToString(this.svg);
+  }
+  destroy() {
+    if (this.scrollListener) {
+      this.timelineScroll.removeEventListener("scroll", this.scrollListener);
+    }
+    this.gridPanel.removeEventListener("dblclick", this.onGridDoubleClick);
+    this.root.remove();
+  }
+};
+
+// src/auto-color.ts
+var DEFAULT_PALETTE = [
+  "#3b82f6",
+  // blue
+  "#f59e0b",
+  // amber
+  "#10b981",
+  // emerald
+  "#ef4444",
+  // red
+  "#8b5cf6",
+  // violet
+  "#06b6d4",
+  // cyan
+  "#f97316",
+  // orange
+  "#84cc16",
+  // lime
+  "#ec4899",
+  // pink
+  "#64748b"
+  // slate
+];
+function colorByField(tasks, field, palette = DEFAULT_PALETTE) {
+  const colors = /* @__PURE__ */ new Map();
+  if (palette.length === 0) return colors;
+  for (const task of tasks) {
+    const value = field(task);
+    if (value === null || value === void 0 || colors.has(value)) continue;
+    colors.set(value, palette[colors.size % palette.length]);
+  }
+  return colors;
+}
+function applyColorByField(tasks, field, palette = DEFAULT_PALETTE) {
+  const colors = colorByField(tasks, field, palette);
+  return tasks.map((task) => {
+    if (task.color) return task;
+    const value = field(task);
+    const color = value === null || value === void 0 ? void 0 : colors.get(value);
+    return color ? { ...task, color } : task;
+  });
+}
+
+// src/constraints.ts
+function applyConstraint(range, constraintType, constraintDate) {
+  if (!constraintType || !constraintDate) return range;
+  const duration = range.end.getTime() - range.start.getTime();
+  const cd = constraintDate.getTime();
+  switch (constraintType) {
+    case "mso":
+      return { start: new Date(cd), end: new Date(cd + duration) };
+    case "mfo":
+      return { start: new Date(cd - duration), end: new Date(cd) };
+    case "snet":
+      if (range.start.getTime() >= cd) return range;
+      return { start: new Date(cd), end: new Date(cd + duration) };
+    case "snlt":
+      if (range.start.getTime() <= cd) return range;
+      return { start: new Date(cd), end: new Date(cd + duration) };
+    case "fnet":
+      if (range.end.getTime() >= cd) return range;
+      return { start: new Date(cd - duration), end: new Date(cd) };
+    case "fnlt":
+      if (range.end.getTime() <= cd) return range;
+      return { start: new Date(cd - duration), end: new Date(cd) };
+    case "asap":
+    case "alap":
+      return range;
+  }
+}
+
+// src/wbs.ts
+function computeWBSCodes(tasks) {
+  const ids = new Set(tasks.map((t) => t.id));
+  const effectiveParent = (task) => task.parentId && ids.has(task.parentId) ? task.parentId : null;
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const key = effectiveParent(task);
+    const list = childrenByParent.get(key) ?? [];
+    list.push(task);
+    childrenByParent.set(key, list);
+  }
+  const codes = /* @__PURE__ */ new Map();
+  function assign(parentId, prefix) {
+    const children = childrenByParent.get(parentId) ?? [];
+    children.forEach((task, index) => {
+      const code = prefix ? `${prefix}.${index + 1}` : `${index + 1}`;
+      codes.set(task.id, code);
+      assign(task.id, code);
+    });
+  }
+  assign(null, "");
+  return codes;
+}
+
+// src/resource-histogram.ts
+function startOfDay2(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function computeResourceHistogram(tasks, options = {}) {
+  const capacityHours = options.capacityHoursPerDay ?? 8;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (!task.assignees || task.assignees.length === 0) continue;
+    if (!(task.start instanceof Date) || !(task.end instanceof Date)) continue;
+    if (task.end.getTime() <= task.start.getTime()) continue;
+    let cursor = startOfDay2(task.start);
+    const end = task.end;
+    let guard = 0;
+    while (cursor.getTime() < end.getTime() && guard++ < 3660) {
+      if (isWorkingDay(cursor, options.calendar)) {
+        for (const assignee of task.assignees) {
+          const key = `${assignee.id}|${cursor.getTime()}`;
+          const existing = buckets.get(key);
+          if (existing) {
+            existing.allocatedHours += capacityHours;
+          } else {
+            buckets.set(key, {
+              assigneeId: assignee.id,
+              assigneeName: assignee.name,
+              date: new Date(cursor.getTime()),
+              allocatedHours: capacityHours,
+              capacityHours,
+              overallocated: false
+            });
+          }
+        }
+      }
+      cursor = new Date(cursor.getTime() + MS_PER_DAY);
+    }
+  }
+  const result = Array.from(buckets.values());
+  for (const bucket of result) {
+    bucket.overallocated = bucket.allocatedHours > bucket.capacityHours;
+  }
+  result.sort((a, b) => a.date.getTime() - b.date.getTime() || a.assigneeId.localeCompare(b.assigneeId));
+  return result;
+}
+function renderResourceHistogramSVG(buckets, options = {}) {
+  const barWidth = options.barWidth ?? 14;
+  const gap = 4;
+  const maxBarHeight = options.maxBarHeight ?? 120;
+  const barColor = options.barColor ?? "#3b82f6";
+  const overColor = options.overallocatedColor ?? "#dc2626";
+  const days = Array.from(new Set(buckets.map((b) => b.date.getTime()))).sort((a, b) => a - b);
+  const assigneesByDay = /* @__PURE__ */ new Map();
+  for (const b of buckets) {
+    const list = assigneesByDay.get(b.date.getTime()) ?? [];
+    list.push(b);
+    assigneesByDay.set(b.date.getTime(), list);
+  }
+  const maxHours = buckets.reduce((m, b) => Math.max(m, b.allocatedHours), 1);
+  const dayWidth = (assigneesByDay.get(days[0] ?? 0)?.length ?? 1) * (barWidth + gap) + gap;
+  const width = options.width ?? Math.max(dayWidth * days.length, 100);
+  const height = maxBarHeight + 24;
+  const parts = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`
+  ];
+  days.forEach((day, dayIndex) => {
+    const dayBuckets = assigneesByDay.get(day) ?? [];
+    dayBuckets.forEach((b, i) => {
+      const x = dayIndex * dayWidth + gap + i * (barWidth + gap);
+      const barHeight = Math.min(maxBarHeight, b.allocatedHours / maxHours * maxBarHeight);
+      const y = maxBarHeight - barHeight;
+      const fill = b.overallocated ? overColor : barColor;
+      parts.push(
+        `<rect x="${x}" y="${y}" width="${barWidth}" height="${barHeight}" fill="${fill}"><title>${escapeXml(
+          b.assigneeName
+        )}: ${b.allocatedHours}h</title></rect>`
+      );
+    });
+  });
+  parts.push(`</svg>`);
+  return parts.join("");
+}
+function escapeXml(text) {
+  return text.replace(/[&<>"']/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+}
+
+// src/filter.ts
+function filterTasks(tasks, predicate, options = {}) {
+  const includeAncestors = options.includeAncestors ?? true;
+  const includeDescendants = options.includeDescendants ?? true;
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const matchedIds = new Set(tasks.filter(predicate).map((t) => t.id));
+  const keep = new Set(matchedIds);
+  if (includeAncestors) {
+    for (const id of matchedIds) {
+      let current = byId.get(id);
+      while (current?.parentId) {
+        const parent = byId.get(current.parentId);
+        if (!parent || keep.has(parent.id)) break;
+        keep.add(parent.id);
+        current = parent;
+      }
+    }
+  }
+  if (includeDescendants) {
+    const childrenByParent = /* @__PURE__ */ new Map();
+    for (const t of tasks) {
+      if (!t.parentId) continue;
+      const list = childrenByParent.get(t.parentId) ?? [];
+      list.push(t);
+      childrenByParent.set(t.parentId, list);
+    }
+    const stack = Array.from(matchedIds);
+    while (stack.length > 0) {
+      const id = stack.pop();
+      if (id === void 0) continue;
+      for (const child of childrenByParent.get(id) ?? []) {
+        if (keep.has(child.id)) continue;
+        keep.add(child.id);
+        stack.push(child.id);
+      }
+    }
+  }
+  return { tasks: tasks.filter((t) => keep.has(t.id)), matchedIds };
+}
+
+// src/resource-leveling.ts
+function startOfDay3(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function workingDaySpan(start, end, calendar) {
+  const days = [];
+  let cursor = startOfDay3(start);
+  let guard = 0;
+  while (cursor.getTime() < end.getTime() && guard++ < 3660) {
+    if (isWorkingDay(cursor, calendar)) days.push(cursor.getTime());
+    cursor = new Date(cursor.getTime() + MS_PER_DAY);
+  }
+  return days;
+}
+function levelResources(tasks, dependencies, options = {}) {
+  const calendar = options.calendar;
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const fsPredecessors = /* @__PURE__ */ new Map();
+  const fsSuccessors = /* @__PURE__ */ new Map();
+  for (const dep of dependencies) {
+    if (dep.type !== "FS") continue;
+    if (!byId.has(dep.fromId) || !byId.has(dep.toId)) continue;
+    const preds = fsPredecessors.get(dep.toId) ?? [];
+    preds.push(dep.fromId);
+    fsPredecessors.set(dep.toId, preds);
+    const succs = fsSuccessors.get(dep.fromId) ?? [];
+    succs.push(dep.toId);
+    fsSuccessors.set(dep.fromId, succs);
+  }
+  const indegree = /* @__PURE__ */ new Map();
+  for (const t of tasks) indegree.set(t.id, (fsPredecessors.get(t.id) ?? []).length);
+  const queue = tasks.filter((t) => indegree.get(t.id) === 0);
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  let guard = 0;
+  while (queue.length > 0 && guard++ < tasks.length * 2 + 10) {
+    queue.sort((a, b) => a.start.getTime() - b.start.getTime());
+    const t = queue.shift();
+    if (!t || seen.has(t.id)) continue;
+    seen.add(t.id);
+    order.push(t);
+    for (const nextId of fsSuccessors.get(t.id) ?? []) {
+      const d = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, d);
+      if (d === 0) {
+        const nt = byId.get(nextId);
+        if (nt) queue.push(nt);
+      }
+    }
+  }
+  for (const t of tasks) if (!seen.has(t.id)) order.push(t);
+  const placedById = /* @__PURE__ */ new Map();
+  const occupiedDays = /* @__PURE__ */ new Map();
+  const shifted = [];
+  for (const task of order) {
+    const duration = task.end.getTime() - task.start.getTime();
+    let start = new Date(task.start.getTime());
+    for (const predId of fsPredecessors.get(task.id) ?? []) {
+      const placed = placedById.get(predId);
+      if (placed && placed.end.getTime() > start.getTime()) start = new Date(placed.end.getTime());
+    }
+    if (task.assignees && task.assignees.length > 0 && duration > 0) {
+      let levelGuard = 0;
+      while (levelGuard++ < 400) {
+        const end3 = new Date(start.getTime() + duration);
+        const days2 = workingDaySpan(start, end3, calendar);
+        const conflict = task.assignees.some((a) => {
+          const set = occupiedDays.get(a.id);
+          return set && days2.some((d) => set.has(d));
+        });
+        if (!conflict) break;
+        start = new Date(start.getTime() + MS_PER_DAY);
+        while (!isWorkingDay(start, calendar)) start = new Date(start.getTime() + MS_PER_DAY);
+      }
+      const end2 = new Date(start.getTime() + duration);
+      const days = workingDaySpan(start, end2, calendar);
+      for (const a of task.assignees) {
+        const set = occupiedDays.get(a.id) ?? /* @__PURE__ */ new Set();
+        for (const d of days) set.add(d);
+        occupiedDays.set(a.id, set);
+      }
+    }
+    const end = new Date(start.getTime() + duration);
+    placedById.set(task.id, { start, end });
+    const delayMs = start.getTime() - task.start.getTime();
+    if (delayMs !== 0) shifted.push({ taskId: task.id, delayMs });
+  }
+  const resultById = /* @__PURE__ */ new Map();
+  for (const task of order) {
+    const placed = placedById.get(task.id);
+    resultById.set(task.id, placed && placed.start.getTime() !== task.start.getTime() ? { ...task, ...placed } : task);
+  }
+  return { tasks: tasks.map((t) => resultById.get(t.id) ?? t), shifted };
+}
+
+// src/interactions.ts
+function snapDeltaMs(dxMs, snapToUnit) {
+  if (!snapToUnit) return dxMs;
+  const base = /* @__PURE__ */ new Date(0);
+  const unitMs = addUnit(base, snapToUnit, 1).getTime() - base.getTime();
+  if (unitMs <= 0) return dxMs;
+  return Math.round(dxMs / unitMs) * unitMs;
+}
+var InteractionController = class {
+  constructor(svg, gridPanel, callbacks, options) {
+    this.svg = svg;
+    this.gridPanel = gridPanel;
+    this.callbacks = callbacks;
+    this.options = options;
+    this.dragMode = null;
+    this.dragTaskId = null;
+    this.dragStartX = 0;
+    this.linkFromId = null;
+    this.linkFromAnchor = null;
+    this.tempLinkEl = null;
+    this.rafHandle = null;
+    this.pendingDxMs = 0;
+    this.pendingMode = null;
+    this.onGridClick = (evt) => {
+      const target = evt.target;
+      const toggleId = target.closest("[data-gantt-toggle]")?.dataset.ganttToggle;
+      if (toggleId) {
+        this.callbacks.onToggleCollapse(toggleId);
+      }
+    };
+    this.onContextMenu = (evt) => {
+      const pointerEvt = evt;
+      const target = pointerEvt.target;
+      const barGroup = target.closest("[data-gantt-bar]");
+      const taskId = barGroup?.dataset.ganttBar;
+      if (taskId && this.callbacks.onContextMenu) {
+        pointerEvt.preventDefault();
+        this.callbacks.onContextMenu(taskId, pointerEvt);
+      }
+    };
+    this.onSvgDoubleClick = (evt) => {
+      if (!this.callbacks.onLinkDblClick) return;
+      const target = evt.target;
+      const linkPath2 = target.closest("[data-gantt-link]");
+      const key = linkPath2?.dataset.ganttLink;
+      if (!key) return;
+      const [fromId, toId] = key.split("->");
+      if (fromId && toId) this.callbacks.onLinkDblClick(fromId, toId);
+    };
+    this.onPointerDown = (evt) => {
+      const target = evt.target;
+      const connector = target.closest("[data-gantt-connector]");
+      if (connector) {
+        const taskId = connector.dataset.ganttConnector;
+        const side = connector.dataset.ganttConnectorSide ?? "right";
+        if (taskId) this.startLinkDrag(evt, taskId, side);
+        return;
+      }
+      const handle = target.closest("[data-gantt-handle]");
+      if (handle) {
+        const taskId = handle.dataset.ganttHandleFor;
+        const edge = handle.dataset.ganttHandle;
+        if (taskId && !this.isReadonly(taskId)) this.startResize(evt, taskId, edge);
+        return;
+      }
+      const barGroup = target.closest("[data-gantt-bar]");
+      if (barGroup) {
+        const taskId = barGroup.dataset.ganttBar;
+        if (taskId) this.startMove(evt, taskId, barGroup);
+        return;
+      }
+      const rowBg = target.closest("[data-gantt-row-bg]");
+      if (rowBg && this.callbacks.onCreateTaskDrag && !this.options.readonly) {
+        const taskId = rowBg.dataset.ganttRowBg;
+        if (taskId) this.startCreateDrag(evt, taskId, rowBg);
+      }
+    };
+    /**
+     * Delegates to handleBarKeyDown when a focused bar dispatched the event
+     * (bars get tabindex="0" when keyboardAccessible, so native Tab/Shift+Tab
+     * traversal between them already works without any code here), and
+     * otherwise checks the chart-wide shortcuts (Ctrl/Cmd+A, Home, End).
+     */
+    this.onKeyDown = (evt) => {
+      if (!this.options.keyboardAccessible) return;
+      const target = evt.target;
+      const barGroup = target.closest?.("[data-gantt-bar]");
+      const taskId = barGroup?.getAttribute("data-gantt-bar");
+      if (taskId) {
+        this.handleBarKeyDown(taskId, evt);
+        return;
+      }
+      if ((evt.ctrlKey || evt.metaKey) && evt.key.toLowerCase() === "a") {
+        evt.preventDefault();
+        this.callbacks.onSelectAll?.();
+      } else if (evt.key === "Home") {
+        evt.preventDefault();
+        this.callbacks.onJumpToStart?.();
+      } else if (evt.key === "End") {
+        evt.preventDefault();
+        this.callbacks.onJumpToEnd?.();
+      }
+    };
+    this.attach();
+  }
+  isReadonly(taskId) {
+    if (this.options.readonly) return true;
+    return this.options.isTaskReadonly?.(taskId) ?? false;
+  }
+  attach() {
+    this.svg.addEventListener("pointerdown", this.onPointerDown);
+    this.gridPanel.addEventListener("click", this.onGridClick);
+    if (typeof document !== "undefined") {
+      this.svg.addEventListener("contextmenu", this.onContextMenu);
+      this.svg.addEventListener("dblclick", this.onSvgDoubleClick);
+      this.svg.addEventListener("keydown", this.onKeyDown);
+    }
+  }
+  destroy() {
+    this.svg.removeEventListener("pointerdown", this.onPointerDown);
+    this.gridPanel.removeEventListener("click", this.onGridClick);
+    this.svg.removeEventListener("contextmenu", this.onContextMenu);
+    this.svg.removeEventListener("dblclick", this.onSvgDoubleClick);
+    this.svg.removeEventListener("keydown", this.onKeyDown);
+    if (this.rafHandle !== null && typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.rafHandle);
+    }
+  }
+  startMove(evt, taskId, barGroup) {
+    if (this.isReadonly(taskId)) return;
+    this.dragMode = "move";
+    this.dragTaskId = taskId;
+    this.dragStartX = evt.clientX;
+    let moved = false;
+    barGroup.setPointerCapture(evt.pointerId);
+    const onMove = (moveEvt) => {
+      const dx = moveEvt.clientX - this.dragStartX;
+      if (Math.abs(dx) > 2) moved = true;
+      this.scheduleDeltaEmit(taskId, "move", dx);
+    };
+    const onUp = (upEvt) => {
+      barGroup.removeEventListener("pointermove", onMove);
+      barGroup.removeEventListener("pointerup", onUp);
+      this.flushPending();
+      this.dragMode = null;
+      this.dragTaskId = null;
+      if (!moved) {
+        this.callbacks.onBarClick(taskId, {
+          ctrlKey: upEvt.ctrlKey,
+          metaKey: upEvt.metaKey,
+          shiftKey: upEvt.shiftKey
+        });
+      }
+    };
+    barGroup.addEventListener("pointermove", onMove);
+    barGroup.addEventListener("pointerup", onUp);
+  }
+  startResize(evt, taskId, edge) {
+    this.dragMode = edge === "left" ? "resize-left" : "resize-right";
+    this.dragTaskId = taskId;
+    this.dragStartX = evt.clientX;
+    const target = evt.currentTarget;
+    const capture = target instanceof Element ? target : this.svg;
+    capture.setPointerCapture?.(evt.pointerId);
+    const onMove = (moveEvt) => {
+      const dx = moveEvt.clientX - this.dragStartX;
+      this.scheduleDeltaEmit(taskId, edge === "left" ? "resize-left" : "resize-right", dx);
+    };
+    const onUp = () => {
+      this.svg.removeEventListener("pointermove", onMove);
+      this.svg.removeEventListener("pointerup", onUp);
+      this.flushPending();
+      this.dragMode = null;
+      this.dragTaskId = null;
+    };
+    this.svg.addEventListener("pointermove", onMove);
+    this.svg.addEventListener("pointerup", onUp);
+  }
+  scheduleDeltaEmit(taskId, mode, dxPx) {
+    const pxPerMs2 = this.options.pxPerMs();
+    const dxMs = pxPerMs2 > 0 ? dxPx / pxPerMs2 : 0;
+    this.pendingDxMs = snapDeltaMs(dxMs, this.options.snapToUnit);
+    this.pendingMode = mode;
+    if (this.rafHandle !== null) return;
+    const raf = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => {
+      cb();
+      return 0;
+    };
+    this.rafHandle = raf(() => {
+      this.rafHandle = null;
+      if (!this.dragTaskId || !this.pendingMode) return;
+      if (this.pendingMode === "move") {
+        this.callbacks.onMove(taskId, this.pendingDxMs);
+      } else {
+        this.callbacks.onResize(
+          taskId,
+          this.pendingMode === "resize-left" ? "left" : "right",
+          this.pendingDxMs
+        );
+      }
+    });
+  }
+  flushPending() {
+    if (this.rafHandle !== null && typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.rafHandle);
+      this.rafHandle = null;
+    }
+  }
+  startLinkDrag(evt, taskId, anchor) {
+    this.dragMode = "link";
+    this.linkFromId = taskId;
+    this.linkFromAnchor = anchor;
+    this.callbacks.onLinkStart(taskId, anchor);
+    const svgPoint = (clientX, clientY) => {
+      const rect = this.svg.getBoundingClientRect();
+      return { x: clientX - rect.left + this.svg.scrollLeft, y: clientY - rect.top };
+    };
+    const startPos = svgPoint(evt.clientX, evt.clientY);
+    const line = document.createElementNS("http://www.w3.org/2000/svg", "line");
+    line.setAttribute("x1", String(startPos.x));
+    line.setAttribute("y1", String(startPos.y));
+    line.setAttribute("x2", String(startPos.x));
+    line.setAttribute("y2", String(startPos.y));
+    line.setAttribute("stroke", "#94a3b8");
+    line.setAttribute("stroke-dasharray", "4 3");
+    line.classList.add("gantt-temp-link");
+    this.svg.appendChild(line);
+    this.tempLinkEl = line;
+    const onMove = (moveEvt) => {
+      const pos = svgPoint(moveEvt.clientX, moveEvt.clientY);
+      line.setAttribute("x2", String(pos.x));
+      line.setAttribute("y2", String(pos.y));
+    };
+    const onUp = (upEvt) => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      this.tempLinkEl?.remove();
+      this.tempLinkEl = null;
+      const target = document.elementFromPoint(upEvt.clientX, upEvt.clientY);
+      const connector = target?.closest("[data-gantt-connector]");
+      const toId = connector?.dataset.ganttConnector;
+      if (toId && this.linkFromId && toId !== this.linkFromId) {
+        this.callbacks.onLinkComplete(this.linkFromId, toId);
+      } else {
+        this.callbacks.onLinkCancel();
+      }
+      this.dragMode = null;
+      this.linkFromId = null;
+      this.linkFromAnchor = null;
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+  }
+  startCreateDrag(evt, rowTaskId, rowBg) {
+    this.dragMode = "create";
+    const parent = rowBg.parentNode;
+    const rowY = Number(rowBg.getAttribute("y") ?? "0");
+    const rowHeight = Number(rowBg.getAttribute("height") ?? "0");
+    const svgX = (clientX) => {
+      const rect = this.svg.getBoundingClientRect();
+      return clientX - rect.left + this.svg.scrollLeft;
+    };
+    const startX = svgX(evt.clientX);
+    let moved = false;
+    const preview = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+    preview.setAttribute("y", String(rowY + 2));
+    preview.setAttribute("height", String(Math.max(0, rowHeight - 4)));
+    preview.setAttribute("x", String(startX));
+    preview.setAttribute("width", "0");
+    preview.setAttribute("fill", "currentColor");
+    preview.setAttribute("opacity", "0.25");
+    preview.classList.add("gantt-create-preview");
+    parent?.appendChild(preview);
+    const onMove = (moveEvt) => {
+      const currentX = svgX(moveEvt.clientX);
+      if (Math.abs(currentX - startX) > 2) moved = true;
+      const x1 = Math.min(startX, currentX);
+      const x2 = Math.max(startX, currentX);
+      preview.setAttribute("x", String(x1));
+      preview.setAttribute("width", String(x2 - x1));
+    };
+    const onUp = (upEvt) => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      preview.remove();
+      this.dragMode = null;
+      if (moved) {
+        const endX = svgX(upEvt.clientX);
+        this.callbacks.onCreateTaskDrag?.(rowTaskId, Math.min(startX, endX), Math.max(startX, endX));
+      }
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+  }
+  handleBarKeyDown(taskId, evt) {
+    if (!this.options.keyboardAccessible) return;
+    if (this.isReadonly(taskId)) return;
+    if (evt.key === "ArrowLeft") {
+      evt.preventDefault();
+      this.callbacks.onMove(taskId, -MS_PER_DAY);
+    } else if (evt.key === "ArrowRight") {
+      evt.preventDefault();
+      this.callbacks.onMove(taskId, MS_PER_DAY);
+    } else if (evt.key === "Enter") {
+      evt.preventDefault();
+      this.callbacks.onBarClick(taskId);
+    }
+  }
+};
+
+// src/index.ts
+var HAS_DOM = typeof document !== "undefined" && typeof window !== "undefined";
+var DEFAULT_COLUMNS = [{ id: "name", title: "Name" }];
+function cloneTask(task) {
+  return { ...task };
+}
+var _GanttChart = class _GanttChart {
+  constructor(container, tasks, dependencies = [], options = {}) {
+    this.container = container;
+    this.darkMediaQuery = null;
+    this.handleSchemeChange = () => {
+      if (this.colorScheme !== "auto") return;
+      this.theme = mergeTheme(this.explicitTheme, "auto");
+      this.scheduleRender();
+    };
+    this.emitter = new EventEmitter();
+    this.history = null;
+    this.renderer = null;
+    this.interactions = null;
+    this.renderModel = null;
+    this.rafHandle = null;
+    this.currentPage = 1;
+    this.selectedTaskIds = /* @__PURE__ */ new Set();
+    this.lastSelectedId = null;
+    this.tasks = tasks.map(cloneTask);
+    this.dependencies = dependencies.map((d) => ({ ...d }));
+    this.colorScheme = options.colorScheme ?? "auto";
+    this.explicitTheme = options.theme;
+    this.theme = mergeTheme(options.theme, this.colorScheme);
+    this.columns = options.columns ?? DEFAULT_COLUMNS;
+    this.columnWidth = options.columnWidth ?? 32;
+    this.currentPage = options.pagination?.page ?? 1;
+    this.options = {
+      viewMode: options.viewMode ?? "day",
+      readonly: options.readonly ?? false,
+      showProgress: options.showProgress ?? true,
+      showDependencies: options.showDependencies ?? true,
+      gridPanelWidth: options.gridPanelWidth ?? 260,
+      showCriticalPath: options.showCriticalPath ?? false,
+      showBaseline: options.showBaseline ?? false,
+      showDeadlines: options.showDeadlines ?? true,
+      showAssigneeAvatars: options.showAssigneeAvatars ?? false,
+      enableHistory: options.enableHistory ?? false,
+      keyboardAccessible: options.keyboardAccessible ?? false,
+      virtualScroll: options.virtualScroll ?? true,
+      autoSchedule: options.autoSchedule ?? false,
+      autoRollupProgress: options.autoRollupProgress ?? false,
+      selectable: options.selectable ?? false,
+      columnWidth: options.columnWidth,
+      theme: options.theme,
+      columns: options.columns,
+      calendar: options.calendar,
+      markers: options.markers,
+      pagination: options.pagination,
+      snapToUnit: options.snapToUnit,
+      onDateChange: options.onDateChange,
+      onProgressChange: options.onProgressChange,
+      onDependencyCreate: options.onDependencyCreate,
+      onDependencyRemove: options.onDependencyRemove,
+      onDependencyDblClick: options.onDependencyDblClick,
+      onTaskClick: options.onTaskClick,
+      onGroupToggle: options.onGroupToggle,
+      onContextMenu: options.onContextMenu,
+      onTaskCreate: options.onTaskCreate,
+      onColumnResize: options.onColumnResize,
+      onColumnReorder: options.onColumnReorder,
+      onTaskReorder: options.onTaskReorder,
+      onSelectionChange: options.onSelectionChange
+    };
+    if (this.options.enableHistory) {
+      this.history = new HistoryManager((state) => this.emitter.emit("history-change", state));
+    }
+    if (HAS_DOM) {
+      this.setupDom();
+    }
+    this.scheduleRender(true);
+  }
+  setupDom() {
+    this.container.style.setProperty("--gantt-grid-panel-width", `${this.options.gridPanelWidth}px`);
+    if (typeof window.matchMedia === "function") {
+      this.darkMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      this.darkMediaQuery.addEventListener?.("change", this.handleSchemeChange);
+    }
+    this.renderer = new GanttRenderer(this.container, {
+      keyboardAccessible: this.options.keyboardAccessible,
+      showAssigneeAvatars: this.options.showAssigneeAvatars,
+      virtualScroll: this.options.virtualScroll,
+      onRenameCommit: (taskId, name) => this.updateTask(taskId, { name }),
+      onColumnResize: this.options.onColumnResize ? (columnId, width) => this.handleColumnResize(columnId, width) : void 0,
+      onColumnReorder: this.options.onColumnReorder ? (order) => this.handleColumnReorder(order) : void 0,
+      onRowReorder: this.options.onTaskReorder ? (draggedId, targetId, position) => this.handleRowReorder(draggedId, targetId, position) : void 0
+    });
+    this.interactions = new InteractionController(
+      this.renderer.svg,
+      this.renderer.gridPanel,
+      {
+        onMove: (taskId, dxMs) => this.handleMove(taskId, dxMs),
+        onResize: (taskId, edge, dxMs) => this.handleResize(taskId, edge, dxMs),
+        onLinkStart: () => {
+        },
+        onLinkComplete: (fromId, toId) => this.handleLinkComplete(fromId, toId),
+        onLinkCancel: () => {
+        },
+        onToggleCollapse: (taskId) => this.toggleGroup(taskId),
+        onBarClick: (taskId, modifiers) => this.handleBarClick(taskId, modifiers),
+        onProgressDrag: (taskId, newProgress) => this.handleProgressDrag(taskId, newProgress),
+        // Only wired when the consumer opted in via onTaskCreate - like onContextMenu below,
+        // this keeps drag-to-create off by default instead of silently mutating task state.
+        onCreateTaskDrag: this.options.onTaskCreate ? (rowTaskId, startXPx, endXPx) => this.handleCreateTaskDrag(rowTaskId, startXPx, endXPx) : void 0,
+        onLinkDblClick: this.options.onDependencyDblClick ? (fromId, toId) => {
+          const dep = this.dependencies.find((d) => d.fromId === fromId && d.toId === toId);
+          if (dep) this.options.onDependencyDblClick?.(dep);
+        } : void 0,
+        onContextMenu: this.options.onContextMenu ? (taskId, evt) => {
+          const task = this.tasks.find((t) => t.id === taskId);
+          if (task) this.emitter.emit("context-menu", { task, evt });
+          this.options.onContextMenu?.(task ?? { id: taskId }, evt);
+        } : void 0,
+        onSelectAll: this.options.selectable ? () => this.selectAllVisible() : void 0,
+        onJumpToStart: () => this.scrollToRangeStart(),
+        onJumpToEnd: () => this.scrollToRangeEnd()
+      },
+      {
+        readonly: this.options.readonly,
+        isTaskReadonly: (taskId) => !!this.tasks.find((t) => t.id === taskId)?.readonly,
+        keyboardAccessible: this.options.keyboardAccessible,
+        snapToUnit: this.options.snapToUnit,
+        pxPerMs: () => pxPerMs(this.options.viewMode, this.columnWidth)
+      }
+    );
+  }
+  handleMove(taskId, dxMs) {
+    if (dxMs === 0) return;
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task || task.readonly || this.options.readonly) return;
+    const newStart = new Date(task.start.getTime() + dxMs);
+    const newEnd = new Date(task.end.getTime() + dxMs);
+    const newSegments = task.segments?.map((s) => ({
+      start: new Date(s.start.getTime() + dxMs),
+      end: new Date(s.end.getTime() + dxMs)
+    }));
+    this.applyDateChange(taskId, newStart, newEnd, newSegments);
+  }
+  handleResize(taskId, edge, dxMs) {
+    if (dxMs === 0) return;
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task || task.readonly || this.options.readonly) return;
+    const newStart = edge === "left" ? new Date(task.start.getTime() + dxMs) : task.start;
+    const newEnd = edge === "right" ? new Date(task.end.getTime() + dxMs) : task.end;
+    if (newEnd.getTime() <= newStart.getTime()) return;
+    let newSegments = task.segments?.map((s) => ({ ...s }));
+    if (newSegments && newSegments.length > 0) {
+      if (edge === "left") newSegments[0] = { ...newSegments[0], start: newStart };
+      else newSegments[newSegments.length - 1] = { ...newSegments[newSegments.length - 1], end: newEnd };
+    }
+    this.applyDateChange(taskId, newStart, newEnd, newSegments);
+  }
+  applyDateChange(taskId, newStart, newEnd, newSegments) {
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task) return;
+    const before = [
+      { id: taskId, start: task.start, end: task.end, segments: task.segments }
+    ];
+    const after = [
+      { id: taskId, start: newStart, end: newEnd, segments: newSegments }
+    ];
+    if (this.options.autoSchedule) {
+      const cascade = this.computeCascade(taskId, newStart, newEnd);
+      for (const c of cascade) {
+        before.push({ id: c.id, start: c.oldStart, end: c.oldEnd });
+        after.push({ id: c.id, start: c.newStart, end: c.newEnd });
+      }
+    }
+    const applyState = (state) => {
+      for (const s of state) {
+        const t = this.tasks.find((tt) => tt.id === s.id);
+        if (t) {
+          t.start = s.start;
+          t.end = s.end;
+          if (s.segments !== void 0) t.segments = s.segments;
+        }
+      }
+    };
+    const cmd = {
+      label: "move-or-resize",
+      do: () => {
+        applyState(after);
+        this.emitDateChangeEvents(after.map((a) => a.id));
+      },
+      undo: () => {
+        applyState(before);
+        this.emitDateChangeEvents(before.map((b) => b.id));
+      }
+    };
+    this.runCommand(cmd);
+  }
+  emitDateChangeEvents(ids) {
+    for (const id of ids) {
+      const t = this.tasks.find((tt) => tt.id === id);
+      if (!t) continue;
+      this.emitter.emit("date-change", { task: t, start: t.start, end: t.end });
+      this.options.onDateChange?.(t, t.start, t.end);
+    }
+    this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+    this.scheduleRender();
+  }
+  /** Shift successors that would violate their dependency constraint after `taskId` moves to [newStart, newEnd]. */
+  computeCascade(taskId, newStart, newEnd) {
+    const results = [];
+    const simulated = /* @__PURE__ */ new Map();
+    simulated.set(taskId, { start: newStart, end: newEnd });
+    const outgoing = /* @__PURE__ */ new Map();
+    for (const dep of this.dependencies) {
+      const list = outgoing.get(dep.fromId) ?? [];
+      list.push(dep);
+      outgoing.set(dep.fromId, list);
+    }
+    const queue = [taskId];
+    const visited = /* @__PURE__ */ new Set();
+    let ops = 0;
+    const maxOps = this.tasks.length * 2 + 5;
+    while (queue.length > 0 && ops++ < maxOps) {
+      const currentId = queue.shift();
+      if (currentId === void 0) break;
+      const currentState = simulated.get(currentId);
+      if (!currentState) continue;
+      for (const dep of outgoing.get(currentId) ?? []) {
+        if (visited.has(dep.toId) && !simulated.has(dep.toId)) continue;
+        const succTask = this.tasks.find((t) => t.id === dep.toId);
+        if (!succTask) continue;
+        const succState = simulated.get(dep.toId) ?? { start: succTask.start, end: succTask.end };
+        const lag = dep.lagMs ?? 0;
+        const duration = succState.end.getTime() - succState.start.getTime();
+        let requiredStart = null;
+        let requiredEnd = null;
+        if (dep.type === "FS") requiredStart = currentState.end.getTime() + lag;
+        else if (dep.type === "SS") requiredStart = currentState.start.getTime() + lag;
+        else if (dep.type === "FF") requiredEnd = currentState.end.getTime() + lag;
+        else if (dep.type === "SF") requiredEnd = currentState.start.getTime() + lag;
+        let newSuccStart = succState.start.getTime();
+        let newSuccEnd = succState.end.getTime();
+        let violated = false;
+        if (requiredStart !== null && succState.start.getTime() < requiredStart) {
+          newSuccStart = requiredStart;
+          newSuccEnd = requiredStart + duration;
+          violated = true;
+        } else if (requiredEnd !== null && succState.end.getTime() < requiredEnd) {
+          newSuccEnd = requiredEnd;
+          newSuccStart = requiredEnd - duration;
+          violated = true;
+        }
+        if (violated && !visited.has(dep.toId)) {
+          visited.add(dep.toId);
+          let newState = { start: new Date(newSuccStart), end: new Date(newSuccEnd) };
+          newState = applyConstraint(newState, succTask.constraintType, succTask.constraintDate);
+          if (this.options.calendar) {
+            const shiftedStart = this.options.calendar.workingHours ? shiftToWorkingTime(newState.start, this.options.calendar, 1) : shiftToWorkingDay(newState.start, this.options.calendar, 1);
+            if (shiftedStart.getTime() !== newState.start.getTime()) {
+              const dur = newState.end.getTime() - newState.start.getTime();
+              newState = { start: shiftedStart, end: new Date(shiftedStart.getTime() + dur) };
+            }
+          }
+          simulated.set(dep.toId, newState);
+          results.push({
+            id: dep.toId,
+            oldStart: succTask.start,
+            oldEnd: succTask.end,
+            newStart: newState.start,
+            newEnd: newState.end
+          });
+          queue.push(dep.toId);
+        }
+      }
+    }
+    return results;
+  }
+  handleLinkComplete(fromId, toId) {
+    const dep = { fromId, toId, type: "FS" };
+    const cmd = {
+      label: "link-create",
+      do: () => {
+        this.dependencies.push(dep);
+        this.emitter.emit("dependency-create", dep);
+        this.options.onDependencyCreate?.(dep);
+        this.scheduleRender();
+      },
+      undo: () => {
+        this.dependencies = this.dependencies.filter((d) => d !== dep);
+        this.emitter.emit("dependency-remove", dep);
+        this.options.onDependencyRemove?.(dep);
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  removeDependency(fromId, toId) {
+    const dep = this.dependencies.find((d) => d.fromId === fromId && d.toId === toId);
+    if (!dep) return;
+    const cmd = {
+      label: "link-remove",
+      do: () => {
+        this.dependencies = this.dependencies.filter((d) => d !== dep);
+        this.emitter.emit("dependency-remove", dep);
+        this.options.onDependencyRemove?.(dep);
+        this.scheduleRender();
+      },
+      undo: () => {
+        this.dependencies.push(dep);
+        this.emitter.emit("dependency-create", dep);
+        this.options.onDependencyCreate?.(dep);
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  /** Update a dependency's type/lag in place (e.g. from your own "edit this link" UI opened via onDependencyDblClick). Undoable. */
+  updateDependency(fromId, toId, partial) {
+    const dep = this.dependencies.find((d) => d.fromId === fromId && d.toId === toId);
+    if (!dep) return;
+    const before = { ...dep };
+    const after = { ...dep, ...partial, fromId: dep.fromId, toId: dep.toId };
+    const cmd = {
+      label: "link-update",
+      do: () => {
+        Object.assign(dep, after);
+        this.emitter.emit("dependency-create", dep);
+        this.options.onDependencyCreate?.(dep);
+        this.scheduleRender();
+      },
+      undo: () => {
+        Object.assign(dep, before);
+        this.emitter.emit("dependency-create", dep);
+        this.options.onDependencyCreate?.(dep);
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  handleProgressDrag(taskId, newProgress) {
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task || task.readonly || this.options.readonly) return;
+    const oldProgress = task.progress ?? 0;
+    const clamped = Math.min(100, Math.max(0, newProgress));
+    const cmd = {
+      label: "progress-change",
+      do: () => {
+        task.progress = clamped;
+        this.emitter.emit("progress-change", { task, progress: clamped });
+        this.options.onProgressChange?.(task, clamped);
+        this.scheduleRender();
+      },
+      undo: () => {
+        task.progress = oldProgress;
+        this.emitter.emit("progress-change", { task, progress: oldProgress });
+        this.options.onProgressChange?.(task, oldProgress);
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  handleCreateTaskDrag(rowTaskId, startXPx, endXPx) {
+    if (!this.renderModel) return;
+    const scale = pxPerMs(this.options.viewMode, this.columnWidth);
+    if (scale <= 0) return;
+    const rangeStartMs = this.renderModel.rangeStart.getTime();
+    let start = new Date(rangeStartMs + startXPx / scale);
+    let end = new Date(rangeStartMs + endXPx / scale);
+    if (this.options.snapToUnit) {
+      start = snapToGrid(start, this.options.snapToUnit);
+      end = snapToGrid(end, this.options.snapToUnit);
+    }
+    if (end.getTime() <= start.getTime()) end = new Date(start.getTime() + MS_PER_DAY);
+    const rowTask = this.tasks.find((t) => t.id === rowTaskId);
+    const newTask = {
+      id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+      name: "New task",
+      start,
+      end,
+      parentId: rowTask?.parentId ?? null
+    };
+    const cmd = {
+      label: "task-create",
+      do: () => {
+        const index = this.tasks.findIndex((t) => t.id === rowTaskId);
+        if (index >= 0) this.tasks.splice(index + 1, 0, newTask);
+        else this.tasks.push(newTask);
+        this.emitter.emit("task-create", { task: newTask });
+        this.options.onTaskCreate?.(newTask);
+        this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+        this.scheduleRender();
+      },
+      undo: () => {
+        this.tasks = this.tasks.filter((t) => t.id !== newTask.id);
+        this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  handleBarClick(taskId, modifiers) {
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task) return;
+    if (this.options.selectable) {
+      if (modifiers?.shiftKey && this.lastSelectedId && this.renderModel) {
+        const ids = this.renderModel.rows.map((r) => r.taskId);
+        const i1 = ids.indexOf(this.lastSelectedId);
+        const i2 = ids.indexOf(taskId);
+        if (i1 >= 0 && i2 >= 0) {
+          const [lo, hi] = i1 < i2 ? [i1, i2] : [i2, i1];
+          this.selectedTaskIds = new Set(ids.slice(lo, hi + 1));
+        }
+      } else if (modifiers?.ctrlKey || modifiers?.metaKey) {
+        if (this.selectedTaskIds.has(taskId)) this.selectedTaskIds.delete(taskId);
+        else this.selectedTaskIds.add(taskId);
+        this.lastSelectedId = taskId;
+      } else {
+        this.selectedTaskIds = /* @__PURE__ */ new Set([taskId]);
+        this.lastSelectedId = taskId;
+      }
+      this.emitter.emit("selection-change", { taskIds: this.getSelectedTaskIds() });
+      this.options.onSelectionChange?.(this.getSelectedTaskIds());
+      this.scheduleRender();
+    }
+    this.emitter.emit("task-click", { task });
+    this.options.onTaskClick?.(task);
+  }
+  /** Replace (default) or add to (`additive: true`) the current selection. Requires `selectable`. */
+  selectTask(id, options = {}) {
+    if (!options.additive) this.selectedTaskIds.clear();
+    this.selectedTaskIds.add(id);
+    this.lastSelectedId = id;
+    this.emitter.emit("selection-change", { taskIds: this.getSelectedTaskIds() });
+    this.options.onSelectionChange?.(this.getSelectedTaskIds());
+    this.scheduleRender();
+  }
+  clearSelection() {
+    this.selectedTaskIds.clear();
+    this.lastSelectedId = null;
+    this.emitter.emit("selection-change", { taskIds: [] });
+    this.options.onSelectionChange?.([]);
+    this.scheduleRender();
+  }
+  getSelectedTaskIds() {
+    return Array.from(this.selectedTaskIds);
+  }
+  /** Shift every selected task's start/end by `deltaMs`. Single undoable step. */
+  bulkShiftDates(deltaMs) {
+    if (deltaMs === 0 || this.selectedTaskIds.size === 0) return;
+    const ids = Array.from(this.selectedTaskIds);
+    const before = ids.map((id) => this.tasks.find((t) => t.id === id)).filter((t) => !!t).map((t) => ({ id: t.id, start: t.start, end: t.end }));
+    const after = before.map((b) => ({
+      id: b.id,
+      start: new Date(b.start.getTime() + deltaMs),
+      end: new Date(b.end.getTime() + deltaMs)
+    }));
+    const applyState = (state) => {
+      for (const s of state) {
+        const t = this.tasks.find((tt) => tt.id === s.id);
+        if (t) {
+          t.start = s.start;
+          t.end = s.end;
+        }
+      }
+    };
+    const cmd = {
+      label: "bulk-shift",
+      do: () => {
+        applyState(after);
+        this.emitDateChangeEvents(after.map((a) => a.id));
+      },
+      undo: () => {
+        applyState(before);
+        this.emitDateChangeEvents(before.map((b) => b.id));
+      }
+    };
+    this.runCommand(cmd);
+  }
+  /** Delete every selected task (and any dependency touching one). Single undoable step. */
+  bulkDelete() {
+    if (this.selectedTaskIds.size === 0) return;
+    const ids = Array.from(this.selectedTaskIds);
+    const idSet = new Set(ids);
+    const removedTasks = this.tasks.filter((t) => idSet.has(t.id));
+    const removedIndices = removedTasks.map((t) => this.tasks.indexOf(t));
+    const removedDeps = this.dependencies.filter((d) => idSet.has(d.fromId) || idSet.has(d.toId));
+    const cmd = {
+      label: "bulk-delete",
+      do: () => {
+        this.tasks = this.tasks.filter((t) => !idSet.has(t.id));
+        this.dependencies = this.dependencies.filter((d) => !idSet.has(d.fromId) && !idSet.has(d.toId));
+        this.selectedTaskIds.clear();
+        this.emitter.emit("selection-change", { taskIds: [] });
+        this.options.onSelectionChange?.([]);
+        this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+        this.scheduleRender();
+      },
+      undo: () => {
+        const combined = [...this.tasks];
+        removedTasks.forEach((t, i) => {
+          const at = Math.min(removedIndices[i] ?? combined.length, combined.length);
+          combined.splice(at, 0, t);
+        });
+        this.tasks = combined;
+        this.dependencies.push(...removedDeps);
+        this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+        this.scheduleRender();
+      }
+    };
+    this.runCommand(cmd);
+  }
+  runCommand(cmd) {
+    if (this.history) {
+      this.history.push(cmd);
+    } else {
+      cmd.do();
+    }
+  }
+  handleColumnResize(columnId, width) {
+    const col = this.columns.find((c) => c.id === columnId);
+    if (!col) return;
+    col.width = width;
+    this.emitter.emit("column-resize", { columnId, width });
+    this.options.onColumnResize?.(columnId, width);
+    this.scheduleRender();
+  }
+  handleColumnReorder(order) {
+    const byId = new Map(this.columns.map((c) => [c.id, c]));
+    const reordered = order.map((id) => byId.get(id)).filter((c) => !!c);
+    if (reordered.length !== this.columns.length) return;
+    this.columns = reordered;
+    this.emitter.emit("column-reorder", { order });
+    this.options.onColumnReorder?.(order);
+    this.scheduleRender();
+  }
+  handleRowReorder(draggedId, targetId, position) {
+    const draggedIndex = this.tasks.findIndex((t) => t.id === draggedId);
+    const targetIndex = this.tasks.findIndex((t) => t.id === targetId);
+    if (draggedIndex < 0 || targetIndex < 0) return;
+    const dragged = this.tasks[draggedIndex];
+    const target = this.tasks[targetIndex];
+    if (!dragged || !target) return;
+    let cursor = target;
+    while (cursor) {
+      if (cursor.id === draggedId) return;
+      cursor = cursor.parentId ? this.tasks.find((t) => t.id === cursor.parentId) : void 0;
+    }
+    this.tasks.splice(draggedIndex, 1);
+    const newTargetIndex = this.tasks.findIndex((t) => t.id === targetId);
+    if (position === "inside") {
+      dragged.parentId = target.id;
+      this.tasks.splice(newTargetIndex + 1, 0, dragged);
+    } else {
+      dragged.parentId = target.parentId ?? null;
+      this.tasks.splice(position === "before" ? newTargetIndex : newTargetIndex + 1, 0, dragged);
+    }
+    this.emitter.emit("task-reorder", { draggedTaskId: draggedId, targetTaskId: targetId, position });
+    this.options.onTaskReorder?.(draggedId, targetId, position);
+    this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+    this.scheduleRender();
+  }
+  toggleGroup(taskId) {
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task) return;
+    task.collapsed = !task.collapsed;
+    this.emitter.emit("group-toggle", { task, collapsed: !!task.collapsed });
+    this.options.onGroupToggle?.(task, !!task.collapsed);
+    this.scheduleRender();
+  }
+  expandAll() {
+    for (const t of this.tasks) t.collapsed = false;
+    this.scheduleRender();
+  }
+  collapseAll() {
+    for (const t of this.tasks) if (t.isGroup) t.collapsed = true;
+    this.scheduleRender();
+  }
+  setTasks(tasks) {
+    this.tasks = tasks.map(cloneTask);
+    this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+    this.scheduleRender();
+  }
+  getTasks() {
+    return this.tasks.map(cloneTask);
+  }
+  setDependencies(deps) {
+    this.dependencies = deps.map((d) => ({ ...d }));
+    this.scheduleRender();
+  }
+  updateTask(id, partial) {
+    const task = this.tasks.find((t) => t.id === id);
+    if (!task) return;
+    Object.assign(task, partial);
+    this.emitter.emit("tasks-change", { tasks: this.getTasks() });
+    this.scheduleRender();
+  }
+  setViewMode(mode) {
+    this.options.viewMode = mode;
+    this.scheduleRender();
+  }
+  setOptions(partial) {
+    if (partial.colorScheme !== void 0) this.colorScheme = partial.colorScheme;
+    if (partial.theme !== void 0) this.explicitTheme = partial.theme;
+    if (partial.theme !== void 0 || partial.colorScheme !== void 0) {
+      this.theme = mergeTheme(this.explicitTheme, this.colorScheme);
+    }
+    if (partial.columns) this.columns = partial.columns;
+    if (partial.columnWidth !== void 0) this.columnWidth = partial.columnWidth;
+    Object.assign(this.options, partial);
+    this.scheduleRender();
+  }
+  /** Scroll the timeline so "today" is centered in the viewport. No-op without a DOM / today column visible. */
+  scrollToToday() {
+    if (!HAS_DOM || !this.renderer || !this.renderModel) return;
+    const todayTick = this.renderModel.ticks.find((t) => t.isToday);
+    if (!todayTick) return;
+    const scrollEl = this.renderer.timelineScroll;
+    const viewportWidth = scrollEl.clientWidth || 0;
+    scrollEl.scrollLeft = Math.max(0, todayTick.x - viewportWidth / 2);
+  }
+  /** Scroll the timeline to the very start of the project's date range. Also the Home-key shortcut when keyboardAccessible. */
+  scrollToRangeStart() {
+    if (!HAS_DOM || !this.renderer) return;
+    this.renderer.timelineScroll.scrollLeft = 0;
+  }
+  /** Scroll the timeline to the very end of the project's date range. Also the End-key shortcut when keyboardAccessible. */
+  scrollToRangeEnd() {
+    if (!HAS_DOM || !this.renderer || !this.renderModel) return;
+    this.renderer.timelineScroll.scrollLeft = this.renderModel.width;
+  }
+  /** Select every currently visible task. Also the Ctrl/Cmd+A shortcut when both `selectable` and `keyboardAccessible` are on. */
+  selectAllVisible() {
+    if (!this.options.selectable || !this.renderModel) return;
+    this.selectedTaskIds = new Set(this.renderModel.rows.map((r) => r.taskId));
+    this.emitter.emit("selection-change", { taskIds: this.getSelectedTaskIds() });
+    this.options.onSelectionChange?.(this.getSelectedTaskIds());
+    this.scheduleRender();
+  }
+  fitToViewport(containerWidthPx) {
+    let min = null;
+    let max = null;
+    for (const t of this.tasks) {
+      if (!isValidDate(t.start) || !isValidDate(t.end)) continue;
+      min = min === null ? t.start.getTime() : Math.min(min, t.start.getTime());
+      max = max === null ? t.end.getTime() : Math.max(max, t.end.getTime());
+    }
+    if (min === null || max === null || max <= min) return;
+    const rangeMs = max - min;
+    const unitMs = approxUnitMs(this.options.viewMode);
+    const newColumnWidth = Math.max(4, containerWidthPx * unitMs / rangeMs);
+    this.columnWidth = newColumnWidth;
+    this.scheduleRender();
+  }
+  /** Zoom in by `factor` (default 1.25x), clamped to a sane minimum column width. */
+  zoomIn(factor = 1.25) {
+    this.columnWidth = Math.min(_GanttChart.MAX_COLUMN_WIDTH, this.columnWidth * factor);
+    this.scheduleRender();
+  }
+  /** Zoom out by `factor` (default 1.25x), clamped to a sane maximum column width. */
+  zoomOut(factor = 1.25) {
+    this.columnWidth = Math.max(_GanttChart.MIN_COLUMN_WIDTH, this.columnWidth / factor);
+    this.scheduleRender();
+  }
+  /** Current zoom level, expressed as px per grid-unit column (same unit as the `columnWidth` option). */
+  getZoomLevel() {
+    return this.columnWidth;
+  }
+  /** Per-assignee daily workload, computed from the current tasks. See computeResourceHistogram. */
+  getResourceHistogram(options = {}) {
+    return computeResourceHistogram(this.tasks, { calendar: this.options.calendar, ...options });
+  }
+  /** Resolve resource overallocation by delaying tasks. Doesn't mutate state - call setTasks(result.tasks) to apply it. See levelResources. */
+  getLeveledTasks(options = {}) {
+    return levelResources(this.tasks, this.dependencies, { calendar: this.options.calendar, ...options });
+  }
+  getPageCount() {
+    const pageSize = this.options.pagination?.pageSize;
+    if (!pageSize || pageSize <= 0) return 1;
+    const rootCount = this.tasks.filter((t) => !t.parentId).length;
+    return Math.max(1, Math.ceil(rootCount / pageSize));
+  }
+  setPage(page) {
+    const pageCount = this.getPageCount();
+    const clamped = Math.min(Math.max(1, page), pageCount);
+    this.currentPage = clamped;
+    if (this.options.pagination) this.options.pagination.page = clamped;
+    this.emitter.emit("page-change", { page: clamped, pageCount });
+    this.scheduleRender();
+  }
+  getRenderModel() {
+    if (!this.renderModel) this.renderModel = this.computeModel();
+    return this.renderModel;
+  }
+  computeModel() {
+    const pagination = this.options.pagination ? { pageSize: this.options.pagination.pageSize, page: this.currentPage } : void 0;
+    return computeLayout({
+      tasks: this.tasks,
+      dependencies: this.dependencies,
+      viewMode: this.options.viewMode,
+      columnWidth: this.columnWidth,
+      theme: this.theme,
+      columns: this.columns,
+      showCriticalPath: this.options.showCriticalPath,
+      showBaseline: this.options.showBaseline,
+      showDeadlines: this.options.showDeadlines,
+      showAssigneeAvatars: this.options.showAssigneeAvatars,
+      calendar: this.options.calendar,
+      markers: this.options.markers,
+      autoRollupProgress: this.options.autoRollupProgress,
+      selectedTaskIds: this.options.selectable ? this.selectedTaskIds : void 0,
+      pagination
+    });
+  }
+  scheduleRender(immediate = false) {
+    if (immediate || !HAS_DOM) {
+      this.doRender();
+      return;
+    }
+    if (this.rafHandle !== null) return;
+    this.rafHandle = requestAnimationFrame(() => {
+      this.rafHandle = null;
+      this.doRender();
+    });
+  }
+  doRender() {
+    this.renderModel = this.computeModel();
+    this.renderer?.render(this.renderModel, this.tasks, this.columns, this.explicitTheme);
+    if (this.renderer && this.colorScheme !== "auto") {
+      this.renderer.root.setAttribute("data-gantt-theme", this.colorScheme);
+    } else {
+      this.renderer?.root.removeAttribute("data-gantt-theme");
+    }
+  }
+  undo() {
+    this.history?.undo();
+  }
+  redo() {
+    this.history?.redo();
+  }
+  get canUndo() {
+    return this.history?.canUndo ?? false;
+  }
+  get canRedo() {
+    return this.history?.canRedo ?? false;
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  toSVGString() {
+    return this.renderer?.toSVGString() ?? "";
+  }
+  async rasterizeSVG(svgString, width, height) {
+    const svgBlob = new Blob([svgString], { type: "image/svg+xml;charset=utf-8" });
+    const url = URL.createObjectURL(svgBlob);
+    try {
+      return await new Promise((resolve, reject) => {
+        const image = new Image();
+        image.onload = () => {
+          const canvas = document.createElement("canvas");
+          canvas.width = image.width || width || 800;
+          canvas.height = image.height || height || 600;
+          const ctx = canvas.getContext("2d");
+          if (!ctx) {
+            reject(new Error("2D canvas context unavailable"));
+            return;
+          }
+          ctx.drawImage(image, 0, 0);
+          resolve(canvas.toDataURL("image/png"));
+        };
+        image.onerror = () => reject(new Error("Failed to rasterize SVG"));
+        image.src = url;
+      });
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+  async toPNGDataURL() {
+    if (!HAS_DOM || !this.renderer) {
+      throw new Error("toPNGDataURL requires a browser DOM environment");
+    }
+    const svgString = this.renderer.toSVGString();
+    return this.rasterizeSVG(svgString, this.renderer.svg.clientWidth, this.renderer.svg.clientHeight);
+  }
+  /**
+   * Like toPNGDataURL, but tiles a chart larger than `pageWidthPx`/`pageHeightPx`
+   * into multiple images (row-major order) instead of one oversized raster -
+   * useful for charts too big to comfortably rasterize/view as a single PNG.
+   * Reuses the full rendered SVG (so every page renders at full fidelity);
+   * defaults to the chart's actual size, i.e. a single image, when omitted.
+   */
+  async toPNGDataURLs(options = {}) {
+    if (!HAS_DOM || !this.renderer || !this.renderModel) {
+      throw new Error("toPNGDataURLs requires a browser DOM environment");
+    }
+    const svgString = this.renderer.toSVGString();
+    const totalWidth = this.renderModel.width;
+    const totalHeight = this.renderModel.headerHeight + this.renderModel.height;
+    const pageWidth = Math.max(1, options.pageWidthPx ?? totalWidth);
+    const pageHeight = Math.max(1, options.pageHeightPx ?? totalHeight);
+    const cols = Math.max(1, Math.ceil(totalWidth / pageWidth));
+    const rows = Math.max(1, Math.ceil(totalHeight / pageHeight));
+    const results = [];
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const tx = c * pageWidth;
+        const ty = r * pageHeight;
+        const tw = Math.min(pageWidth, totalWidth - tx);
+        const th = Math.min(pageHeight, totalHeight - ty);
+        const tileSvg = svgString.replace(/<svg([^>]*)>/, (_match, attrs) => {
+          const cleaned = attrs.replace(/\swidth="[^"]*"/, "").replace(/\sheight="[^"]*"/, "").replace(/\sviewBox="[^"]*"/, "");
+          return `<svg${cleaned} width="${tw}" height="${th}" viewBox="${tx} ${ty} ${tw} ${th}">`;
+        });
+        results.push(await this.rasterizeSVG(tileSvg, tw, th));
+      }
+    }
+    return results;
+  }
+  destroy() {
+    if (this.rafHandle !== null && typeof cancelAnimationFrame !== "undefined") {
+      cancelAnimationFrame(this.rafHandle);
+    }
+    this.darkMediaQuery?.removeEventListener?.("change", this.handleSchemeChange);
+    this.emitter.removeAllListeners();
+    this.interactions?.destroy();
+    this.renderer?.destroy();
+  }
+};
+_GanttChart.MIN_COLUMN_WIDTH = 4;
+_GanttChart.MAX_COLUMN_WIDTH = 400;
+var GanttChart = _GanttChart;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PALETTE,
+  DEFAULT_THEME,
+  DENSITY_PRESETS,
+  EventEmitter,
+  GanttChart,
+  HistoryManager,
+  applyColorByField,
+  applyConstraint,
+  colorByField,
+  computeCriticalPath,
+  computeLayout,
+  computeResourceHistogram,
+  computeWBSCodes,
+  dateUtils,
+  filterTasks,
+  isHoliday,
+  isSafeHref,
+  isWithinWorkingHours,
+  isWorkingDay,
+  isWorkingTime,
+  levelResources,
+  mergeTheme,
+  nextWorkingDay,
+  previousWorkingDay,
+  renderResourceHistogramSVG,
+  shiftToWorkingDay,
+  shiftToWorkingTime,
+  tasksFromCSV,
+  tasksToCSV,
+  themeToCssVars
+});
+//# sourceMappingURL=index.cjs.map