@jaeungkim/gantt-chart 0.3.1 → 1.0.0

package/dist/index.js

@@ -0,0 +1,4749 @@
+import { jsx as P, jsxs as J, Fragment as we } from "react/jsx-runtime";
+import Ft, { createContext as Vn, useContext as Zn, useMemo as j, useCallback as z, useEffect as it, useId as gn, useRef as Z, useLayoutEffect as Rt, useState as ut, Fragment as Jn, useSyncExternalStore as Qn, forwardRef as tr, useImperativeHandle as er } from "react";
+const Fe = (t) => {
+  let n;
+  const r = /* @__PURE__ */ new Set(), o = (u, l) => {
+    const f = typeof u == "function" ? u(n) : u;
+    if (!Object.is(f, n)) {
+      const h = n;
+      n = l ?? (typeof f != "object" || f === null) ? f : Object.assign({}, n, f), r.forEach((w) => w(n, h));
+    }
+  }, s = () => n, i = { setState: o, getState: s, getInitialState: () => c, subscribe: (u) => (r.add(u), () => r.delete(u)) }, c = n = t(o, s, i);
+  return i;
+}, nr = ((t) => t ? Fe(t) : Fe), rr = (t) => t;
+function or(t, n = rr) {
+  const r = Ft.useSyncExternalStore(
+    t.subscribe,
+    Ft.useCallback(() => n(t.getState()), [t, n]),
+    Ft.useCallback(() => n(t.getInitialState()), [t, n])
+  );
+  return Ft.useDebugValue(r), r;
+}
+const $n = Vn(null);
+function yt() {
+  const t = Zn($n);
+  if (!t)
+    throw new Error(
+      "Gantt store is missing. Render this component inside <ReactGanttChart>."
+    );
+  return t;
+}
+function Q(t) {
+  return or(yt(), t);
+}
+function sr(t) {
+  const n = [];
+  for (const r of t) {
+    const o = n[n.length - 1];
+    o && o.label === r.label ? o.widthPx += r.widthPx : n.push({ ...r });
+  }
+  return n;
+}
+function Dn(t) {
+  const n = [0];
+  let r = 0;
+  for (const o of t)
+    r += o.widthPx, n.push(r);
+  return n;
+}
+function se(t, n) {
+  if (t.length < 2) return null;
+  let r = 0, o = t.length - 2;
+  for (; r < o; ) {
+    const s = Math.ceil((r + o) / 2);
+    t[s] <= n ? r = s : o = s - 1;
+  }
+  return {
+    index: r,
+    left: t[r],
+    width: t[r + 1] - t[r]
+  };
+}
+function wn(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var ee = { exports: {} }, ar = ee.exports, Ue;
+function ir() {
+  return Ue || (Ue = 1, (function(t, n) {
+    (function(r, o) {
+      t.exports = o();
+    })(ar, (function() {
+      var r = 1e3, o = 6e4, s = 36e5, e = "millisecond", a = "second", i = "minute", c = "hour", u = "day", l = "week", f = "month", h = "quarter", w = "year", p = "date", d = "Invalid Date", m = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, D = /\[([^\]]+)]|YYYY|YY|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, b = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(T) {
+        var M = ["th", "st", "nd", "rd"], I = T % 100;
+        return "[" + T + (M[(I - 20) % 10] || M[I] || M[0]) + "]";
+      } }, S = function(T, M, I) {
+        var y = String(T);
+        return !y || y.length >= M ? T : "" + Array(M + 1 - y.length).join(I) + T;
+      }, L = { s: S, z: function(T) {
+        var M = -T.utcOffset(), I = Math.abs(M), y = Math.floor(I / 60), $ = I % 60;
+        return (M <= 0 ? "+" : "-") + S(y, 2, "0") + ":" + S($, 2, "0");
+      }, m: function T(M, I) {
+        if (M.date() < I.date()) return -T(I, M);
+        var y = 12 * (I.year() - M.year()) + (I.month() - M.month()), $ = M.clone().add(y, f), k = I - $ < 0, E = M.clone().add(y + (k ? -1 : 1), f);
+        return +(-(y + (I - $) / (k ? $ - E : E - $)) || 0);
+      }, a: function(T) {
+        return T < 0 ? Math.ceil(T) || 0 : Math.floor(T);
+      }, p: function(T) {
+        return { M: f, y: w, w: l, d: u, D: p, h: c, m: i, s: a, ms: e, Q: h }[T] || String(T || "").toLowerCase().replace(/s$/, "");
+      }, u: function(T) {
+        return T === void 0;
+      } }, N = "en", x = {};
+      x[N] = b;
+      var _ = "$isDayjsObject", A = function(T) {
+        return T instanceof F || !(!T || !T[_]);
+      }, v = function T(M, I, y) {
+        var $;
+        if (!M) return N;
+        if (typeof M == "string") {
+          var k = M.toLowerCase();
+          x[k] && ($ = k), I && (x[k] = I, $ = k);
+          var E = M.split("-");
+          if (!$ && E.length > 1) return T(E[0]);
+        } else {
+          var C = M.name;
+          x[C] = M, $ = C;
+        }
+        return !y && $ && (N = $), $ || !y && N;
+      }, g = function(T, M) {
+        if (A(T)) return T.clone();
+        var I = typeof M == "object" ? M : {};
+        return I.date = T, I.args = arguments, new F(I);
+      }, R = L;
+      R.l = v, R.i = A, R.w = function(T, M) {
+        return g(T, { locale: M.$L, utc: M.$u, x: M.$x, $offset: M.$offset });
+      };
+      var F = (function() {
+        function T(I) {
+          this.$L = v(I.locale, null, !0), this.parse(I), this.$x = this.$x || I.x || {}, this[_] = !0;
+        }
+        var M = T.prototype;
+        return M.parse = function(I) {
+          this.$d = (function(y) {
+            var $ = y.date, k = y.utc;
+            if ($ === null) return /* @__PURE__ */ new Date(NaN);
+            if (R.u($)) return /* @__PURE__ */ new Date();
+            if ($ instanceof Date) return new Date($);
+            if (typeof $ == "string" && !/Z$/i.test($)) {
+              var E = $.match(m);
+              if (E) {
+                var C = E[2] - 1 || 0, X = (E[7] || "0").substring(0, 3);
+                return k ? new Date(Date.UTC(E[1], C, E[3] || 1, E[4] || 0, E[5] || 0, E[6] || 0, X)) : new Date(E[1], C, E[3] || 1, E[4] || 0, E[5] || 0, E[6] || 0, X);
+              }
+            }
+            return new Date($);
+          })(I), this.init();
+        }, M.init = function() {
+          var I = this.$d;
+          this.$y = I.getFullYear(), this.$M = I.getMonth(), this.$D = I.getDate(), this.$W = I.getDay(), this.$H = I.getHours(), this.$m = I.getMinutes(), this.$s = I.getSeconds(), this.$ms = I.getMilliseconds();
+        }, M.$utils = function() {
+          return R;
+        }, M.isValid = function() {
+          return this.$d.toString() !== d;
+        }, M.isSame = function(I, y) {
+          var $ = g(I);
+          return this.startOf(y) <= $ && $ <= this.endOf(y);
+        }, M.isAfter = function(I, y) {
+          return g(I) < this.startOf(y);
+        }, M.isBefore = function(I, y) {
+          return this.endOf(y) < g(I);
+        }, M.$g = function(I, y, $) {
+          return R.u(I) ? this[y] : this.set($, I);
+        }, M.unix = function() {
+          return Math.floor(this.valueOf() / 1e3);
+        }, M.valueOf = function() {
+          return this.$d.getTime();
+        }, M.startOf = function(I, y) {
+          var $ = this, k = !!R.u(y) || y, E = R.p(I), C = function(O, G) {
+            var B = R.w($.$u ? Date.UTC($.$y, G, O) : new Date($.$y, G, O), $);
+            return k ? B : B.endOf(u);
+          }, X = function(O, G) {
+            return R.w($.toDate()[O].apply($.toDate("s"), (k ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(G)), $);
+          }, q = this.$W, tt = this.$M, rt = this.$D, wt = "set" + (this.$u ? "UTC" : "");
+          switch (E) {
+            case w:
+              return k ? C(1, 0) : C(31, 11);
+            case f:
+              return k ? C(1, tt) : C(0, tt + 1);
+            case l:
+              var ot = this.$locale().weekStart || 0, gt = (q < ot ? q + 7 : q) - ot;
+              return C(k ? rt - gt : rt + (6 - gt), tt);
+            case u:
+            case p:
+              return X(wt + "Hours", 0);
+            case c:
+              return X(wt + "Minutes", 1);
+            case i:
+              return X(wt + "Seconds", 2);
+            case a:
+              return X(wt + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, M.endOf = function(I) {
+          return this.startOf(I, !1);
+        }, M.$set = function(I, y) {
+          var $, k = R.p(I), E = "set" + (this.$u ? "UTC" : ""), C = ($ = {}, $[u] = E + "Date", $[p] = E + "Date", $[f] = E + "Month", $[w] = E + "FullYear", $[c] = E + "Hours", $[i] = E + "Minutes", $[a] = E + "Seconds", $[e] = E + "Milliseconds", $)[k], X = k === u ? this.$D + (y - this.$W) : y;
+          if (k === f || k === w) {
+            var q = this.clone().set(p, 1);
+            q.$d[C](X), q.init(), this.$d = q.set(p, Math.min(this.$D, q.daysInMonth())).$d;
+          } else C && this.$d[C](X);
+          return this.init(), this;
+        }, M.set = function(I, y) {
+          return this.clone().$set(I, y);
+        }, M.get = function(I) {
+          return this[R.p(I)]();
+        }, M.add = function(I, y) {
+          var $, k = this;
+          I = Number(I);
+          var E = R.p(y), C = function(tt) {
+            var rt = g(k);
+            return R.w(rt.date(rt.date() + Math.round(tt * I)), k);
+          };
+          if (E === f) return this.set(f, this.$M + I);
+          if (E === w) return this.set(w, this.$y + I);
+          if (E === u) return C(1);
+          if (E === l) return C(7);
+          var X = ($ = {}, $[i] = o, $[c] = s, $[a] = r, $)[E] || 1, q = this.$d.getTime() + I * X;
+          return R.w(q, this);
+        }, M.subtract = function(I, y) {
+          return this.add(-1 * I, y);
+        }, M.format = function(I) {
+          var y = this, $ = this.$locale();
+          if (!this.isValid()) return $.invalidDate || d;
+          var k = I || "YYYY-MM-DDTHH:mm:ssZ", E = R.z(this), C = this.$H, X = this.$m, q = this.$M, tt = $.weekdays, rt = $.months, wt = $.meridiem, ot = function(G, B, ct, st) {
+            return G && (G[B] || G(y, k)) || ct[B].slice(0, st);
+          }, gt = function(G) {
+            return R.s(C % 12 || 12, G, "0");
+          }, O = wt || function(G, B, ct) {
+            var st = G < 12 ? "AM" : "PM";
+            return ct ? st.toLowerCase() : st;
+          };
+          return k.replace(D, (function(G, B) {
+            return B || (function(ct) {
+              switch (ct) {
+                case "YY":
+                  return String(y.$y).slice(-2);
+                case "YYYY":
+                  return R.s(y.$y, 4, "0");
+                case "M":
+                  return q + 1;
+                case "MM":
+                  return R.s(q + 1, 2, "0");
+                case "MMM":
+                  return ot($.monthsShort, q, rt, 3);
+                case "MMMM":
+                  return ot(rt, q);
+                case "D":
+                  return y.$D;
+                case "DD":
+                  return R.s(y.$D, 2, "0");
+                case "d":
+                  return String(y.$W);
+                case "dd":
+                  return ot($.weekdaysMin, y.$W, tt, 2);
+                case "ddd":
+                  return ot($.weekdaysShort, y.$W, tt, 3);
+                case "dddd":
+                  return tt[y.$W];
+                case "H":
+                  return String(C);
+                case "HH":
+                  return R.s(C, 2, "0");
+                case "h":
+                  return gt(1);
+                case "hh":
+                  return gt(2);
+                case "a":
+                  return O(C, X, !0);
+                case "A":
+                  return O(C, X, !1);
+                case "m":
+                  return String(X);
+                case "mm":
+                  return R.s(X, 2, "0");
+                case "s":
+                  return String(y.$s);
+                case "ss":
+                  return R.s(y.$s, 2, "0");
+                case "SSS":
+                  return R.s(y.$ms, 3, "0");
+                case "Z":
+                  return E;
+              }
+              return null;
+            })(G) || E.replace(":", "");
+          }));
+        }, M.utcOffset = function() {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, M.diff = function(I, y, $) {
+          var k, E = this, C = R.p(y), X = g(I), q = (X.utcOffset() - this.utcOffset()) * o, tt = this - X, rt = function() {
+            return R.m(E, X);
+          };
+          switch (C) {
+            case w:
+              k = rt() / 12;
+              break;
+            case f:
+              k = rt();
+              break;
+            case h:
+              k = rt() / 3;
+              break;
+            case l:
+              k = (tt - q) / 6048e5;
+              break;
+            case u:
+              k = (tt - q) / 864e5;
+              break;
+            case c:
+              k = tt / s;
+              break;
+            case i:
+              k = tt / o;
+              break;
+            case a:
+              k = tt / r;
+              break;
+            default:
+              k = tt;
+          }
+          return $ ? k : R.a(k);
+        }, M.daysInMonth = function() {
+          return this.endOf(f).$D;
+        }, M.$locale = function() {
+          return x[this.$L];
+        }, M.locale = function(I, y) {
+          if (!I) return this.$L;
+          var $ = this.clone(), k = v(I, y, !0);
+          return k && ($.$L = k), $;
+        }, M.clone = function() {
+          return R.w(this.$d, this);
+        }, M.toDate = function() {
+          return new Date(this.valueOf());
+        }, M.toJSON = function() {
+          return this.isValid() ? this.toISOString() : null;
+        }, M.toISOString = function() {
+          return this.$d.toISOString();
+        }, M.toString = function() {
+          return this.$d.toUTCString();
+        }, T;
+      })(), U = F.prototype;
+      return g.prototype = U, [["$ms", e], ["$s", a], ["$m", i], ["$H", c], ["$W", u], ["$M", f], ["$y", w], ["$D", p]].forEach((function(T) {
+        U[T[1]] = function(M) {
+          return this.$g(M, T[0], T[1]);
+        };
+      })), g.extend = function(T, M) {
+        return T.$i || (T(M, F, g), T.$i = !0), g;
+      }, g.locale = v, g.isDayjs = A, g.unix = function(T) {
+        return g(1e3 * T);
+      }, g.en = x[N], g.Ls = x, g.p = {}, g;
+    }));
+  })(ee)), ee.exports;
+}
+var cr = ir();
+const ae = /* @__PURE__ */ wn(cr);
+var ne = { exports: {} }, lr = ne.exports, We;
+function ur() {
+  return We || (We = 1, (function(t, n) {
+    (function(r, o) {
+      t.exports = o();
+    })(lr, (function() {
+      var r = "minute", o = /[+-]\d\d(?::?\d\d)?/g, s = /([+-]|\d\d)/g;
+      return function(e, a, i) {
+        var c = a.prototype;
+        i.utc = function(d) {
+          var m = { date: d, utc: !0, args: arguments };
+          return new a(m);
+        }, c.utc = function(d) {
+          var m = i(this.toDate(), { locale: this.$L, utc: !0 });
+          return d ? m.add(this.utcOffset(), r) : m;
+        }, c.local = function() {
+          return i(this.toDate(), { locale: this.$L, utc: !1 });
+        };
+        var u = c.parse;
+        c.parse = function(d) {
+          d.utc && (this.$u = !0), this.$utils().u(d.$offset) || (this.$offset = d.$offset), u.call(this, d);
+        };
+        var l = c.init;
+        c.init = function() {
+          if (this.$u) {
+            var d = this.$d;
+            this.$y = d.getUTCFullYear(), this.$M = d.getUTCMonth(), this.$D = d.getUTCDate(), this.$W = d.getUTCDay(), this.$H = d.getUTCHours(), this.$m = d.getUTCMinutes(), this.$s = d.getUTCSeconds(), this.$ms = d.getUTCMilliseconds();
+          } else l.call(this);
+        };
+        var f = c.utcOffset;
+        c.utcOffset = function(d, m) {
+          var D = this.$utils().u;
+          if (D(d)) return this.$u ? 0 : D(this.$offset) ? f.call(this) : this.$offset;
+          if (typeof d == "string" && (d = (function(N) {
+            N === void 0 && (N = "");
+            var x = N.match(o);
+            if (!x) return null;
+            var _ = ("" + x[0]).match(s) || ["-", 0, 0], A = _[0], v = 60 * +_[1] + +_[2];
+            return v === 0 ? 0 : A === "+" ? v : -v;
+          })(d), d === null)) return this;
+          var b = Math.abs(d) <= 16 ? 60 * d : d;
+          if (b === 0) return this.utc(m);
+          var S = this.clone();
+          if (m) return S.$offset = b, S.$u = !1, S;
+          var L = this.$u ? this.toDate().getTimezoneOffset() : -1 * this.utcOffset();
+          return (S = this.local().add(b + L, r)).$offset = b, S.$x.$localOffset = L, S;
+        };
+        var h = c.format;
+        c.format = function(d) {
+          var m = d || (this.$u ? "YYYY-MM-DDTHH:mm:ss[Z]" : "");
+          return h.call(this, m);
+        }, c.valueOf = function() {
+          var d = this.$utils().u(this.$offset) ? 0 : this.$offset + (this.$x.$localOffset || this.$d.getTimezoneOffset());
+          return this.$d.valueOf() - 6e4 * d;
+        }, c.isUTC = function() {
+          return !!this.$u;
+        }, c.toISOString = function() {
+          return this.toDate().toISOString();
+        }, c.toString = function() {
+          return this.toDate().toUTCString();
+        };
+        var w = c.toDate;
+        c.toDate = function(d) {
+          return d === "s" && this.$offset ? i(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate() : w.call(this);
+        };
+        var p = c.diff;
+        c.diff = function(d, m, D) {
+          if (d && this.$u === d.$u) return p.call(this, d, m, D);
+          var b = this.local(), S = i(d).local();
+          return p.call(b, S, m, D);
+        };
+      };
+    }));
+  })(ne)), ne.exports;
+}
+var dr = ur();
+const fr = /* @__PURE__ */ wn(dr);
+ae.extend(fr);
+const H = ae.utc;
+function vn(t) {
+  return Math.floor(t.month() / 3) + 1;
+}
+function hr(t) {
+  return t.startOf("month").month(Math.floor(t.month() / 3) * 3);
+}
+function mr(t, n = 0) {
+  const r = (t.day() - n + 7) % 7;
+  return t.startOf("day").subtract(r, "day");
+}
+const xt = 38, ve = 28, pr = 18, gr = 73, Ge = 120, Xe = 800, Be = 16, $r = 220, Dr = 5, wr = 56, Wt = 8, ze = Wt + 5, yn = 44, ke = Wt * 3, vr = yn * 3, yr = ke, br = 24, je = 4, Sr = 450, Mr = {
+  day: "MMM D, YYYY HH:mm [UTC]",
+  week: "MMM D, YYYY",
+  month: "MMM D, YYYY",
+  quarter: "MMM YYYY",
+  year: "MMM YYYY"
+}, xr = {
+  day: "HH:mm [UTC]",
+  week: "MMM D",
+  month: "MMM D",
+  quarter: "MMM YYYY",
+  year: "MMM YYYY"
+}, Ir = 44, dt = {
+  day: {
+    // Quarter-day cells - the only scale that draws a task shorter than a day at its true length
+    labelUnit: "day",
+    tickUnit: "hour",
+    unitPerTick: 6,
+    tickAlign: "day",
+    dragStepUnit: "hour",
+    dragStepAmount: 1,
+    basePxPerDragStep: 12,
+    // 24-hour: there is no AM/PM marker here, so a 12-hour label would appear twice a day
+    formatTickLabel: (t) => t.format("HH"),
+    formatHeaderLabel: (t) => t.format("MMM D, YYYY")
+  },
+  week: {
+    labelUnit: "month",
+    tickUnit: "day",
+    unitPerTick: 1,
+    dragStepUnit: "hour",
+    dragStepAmount: 6,
+    basePxPerDragStep: 18,
+    formatTickLabel: (t) => t.format("D"),
+    formatHeaderLabel: (t) => t.format("MMM YYYY")
+  },
+  month: {
+    // Week cells - a day cell would be 18px here, too narrow for a date or an edge grab
+    labelUnit: "month",
+    tickUnit: "day",
+    unitPerTick: 7,
+    tickAlign: "week",
+    dragStepUnit: "day",
+    dragStepAmount: 1,
+    basePxPerDragStep: 18,
+    formatTickLabel: (t) => t.format("MMM D"),
+    formatHeaderLabel: (t) => t.format("MMM YYYY")
+  },
+  quarter: {
+    labelUnit: "quarter",
+    tickUnit: "month",
+    unitPerTick: 1,
+    dragStepUnit: "day",
+    dragStepAmount: 7,
+    basePxPerDragStep: 28,
+    formatTickLabel: (t) => t.format("MMM"),
+    formatHeaderLabel: (t) => `Q${vn(t)} ${t.format("YYYY")}`
+  },
+  year: {
+    // Quarter cells under a year header - the coarsest zoom; 4-week drag steps keep the weekday
+    labelUnit: "year",
+    tickUnit: "month",
+    unitPerTick: 3,
+    tickAlign: "quarter",
+    dragStepUnit: "day",
+    dragStepAmount: 28,
+    basePxPerDragStep: 28,
+    formatTickLabel: (t) => t.format("MMM"),
+    formatHeaderLabel: (t) => t.format("YYYY")
+  }
+}, re = {
+  year: "numeric",
+  month: "short",
+  day: "numeric"
+}, _t = { year: "numeric", month: "short" }, ye = { year: "numeric" }, bn = {
+  hour: "2-digit",
+  minute: "2-digit",
+  hourCycle: "h23"
+}, Or = {
+  day: { hour: "2-digit", hourCycle: "h23" },
+  week: { day: "numeric" },
+  // Week columns - the day number alone would not say which month the week is in
+  month: { month: "short", day: "numeric" },
+  quarter: { month: "short" },
+  year: { month: "short" }
+}, kr = {
+  day: re,
+  week: _t,
+  month: _t,
+  quarter: ye,
+  year: ye
+}, Pr = {
+  day: { ...re, ...bn, timeZoneName: "short" },
+  week: re,
+  month: re,
+  quarter: _t,
+  year: _t
+}, qe = {
+  day: { ...bn, timeZoneName: "short" },
+  week: { month: "short", day: "numeric" },
+  month: { month: "short", day: "numeric" },
+  quarter: _t,
+  year: _t
+}, Tr = " – ", Ke = /* @__PURE__ */ new Set();
+function Ut(t, n) {
+  const r = new Intl.DateTimeFormat(t, { timeZone: "UTC", ...n });
+  return (o) => r.format(o.toDate());
+}
+function Er(t) {
+  return (n, r) => {
+    try {
+      return t.formatRange(n.toDate(), r.toDate());
+    } catch {
+      return Sn(t.format(n.toDate()), t.format(r.toDate()));
+    }
+  };
+}
+function Sn(t, n) {
+  return t === n ? t : `${t}${Tr}${n}`;
+}
+function Lr(t) {
+  const n = Ut(t, ye);
+  return (r) => {
+    const o = n(r), s = `Q${vn(r)}`;
+    return /\d$/.test(o) ? `${s} ${o}` : `${o} ${s}`;
+  };
+}
+function Mn(t, n) {
+  return t === "week" && (n == null ? void 0 : n.firstDayOfWeek) !== void 0 ? "week" : dt[t].labelUnit;
+}
+function Yt(t, n) {
+  var l;
+  const r = (l = n == null ? void 0 : n.formats) == null ? void 0 : l[t], o = Mn(t, n) === "week" ? "day" : t, s = dt[t], e = dt[o], a = n != null && n.locale ? Ar(n.locale, t, o) : null, i = r == null ? void 0 : r.tooltip, c = i ?? (a == null ? void 0 : a.edge) ?? ((f) => f.format(xr[t])), u = !i && (a != null && a.range) ? a.range : (f, h) => Sn(c(f), c(h));
+  return {
+    edge: c,
+    range: u,
+    tick: (r == null ? void 0 : r.tick) ?? (a == null ? void 0 : a.tick) ?? ((f) => {
+      var h;
+      return ((h = s.formatTickLabel) == null ? void 0 : h.call(s, f)) ?? "";
+    }),
+    header: (r == null ? void 0 : r.header) ?? (a == null ? void 0 : a.header) ?? ((f) => {
+      var h;
+      return ((h = e.formatHeaderLabel) == null ? void 0 : h.call(e, f)) ?? f.format();
+    }),
+    tooltip: (r == null ? void 0 : r.tooltip) ?? (a == null ? void 0 : a.tooltip) ?? ((f) => f.format(Mr[t]))
+  };
+}
+function Ar(t, n, r) {
+  try {
+    return {
+      tick: Ut(t, Or[n]),
+      header: r === "quarter" ? Lr(t) : Ut(t, kr[r]),
+      tooltip: Ut(t, Pr[n]),
+      edge: Ut(t, qe[n]),
+      range: Er(
+        new Intl.DateTimeFormat(t, {
+          timeZone: "UTC",
+          ...qe[n]
+        })
+      )
+    };
+  } catch {
+    return Ke.has(t) || (Ke.add(t), console.warn(
+      `[gantt-chart] Unusable locale "${t}" - falling back to the built-in labels.`
+    )), null;
+  }
+}
+function xn(t) {
+  const n = Math.max(0, Math.round(t / 36e5));
+  return n < 24 ? `${n}h` : `${Math.round(n / 24)}d`;
+}
+const At = Object.keys(dt), Nr = {
+  minute: 6e4,
+  hour: 36e5,
+  day: 864e5,
+  week: 6048e5
+};
+function Rr(t) {
+  const { basePxPerDragStep: n, dragStepUnit: r, dragStepAmount: o } = dt[t];
+  return n / (o * Nr[r]);
+}
+function In(t, n) {
+  const r = At.indexOf(t);
+  if (r === -1) return t;
+  const o = Math.min(
+    At.length - 1,
+    Math.max(0, r + n)
+  );
+  return At[o];
+}
+function _r(t, n) {
+  for (const r of At)
+    if (t * Rr(r) <= n) return r;
+  return At[At.length - 1];
+}
+const Yr = 24, Hr = 120, Cr = {
+  delta: 0,
+  lastEventAt: 0,
+  locked: !1
+};
+function Fr(t, n, r) {
+  const o = r - t.lastEventAt >= Hr;
+  if (!o && t.locked)
+    return { state: { delta: 0, lastEventAt: r, locked: !0 }, step: 0 };
+  const s = (o ? 0 : t.delta) + n;
+  return Math.abs(s) < Yr ? { state: { delta: s, lastEventAt: r, locked: !1 }, step: 0 } : {
+    state: { delta: 0, lastEventAt: r, locked: !0 },
+    step: Math.sign(s)
+  };
+}
+const Ur = 48, Ve = 22;
+function be(t, n, r) {
+  const o = r - n;
+  if (o <= 0) return 0;
+  const s = Math.min(Ur, o / 2);
+  return s <= 0 ? 0 : t < n + s ? -Ve * Math.min(1, (n + s - t) / s) : t > r - s ? Ve * Math.min(1, (t - (r - s)) / s) : 0;
+}
+const Se = { before: 0, after: 0 }, Qt = 2e3;
+function Wr({
+  current: t,
+  scrollLeft: n,
+  viewportPx: r,
+  totalPx: o,
+  pxPerTick: s,
+  canExtend: e
+}) {
+  if (s <= 0 || r <= 0) return null;
+  const a = Math.max(1, Math.ceil(r / s)), i = r / 2;
+  return (e == null ? void 0 : e.before) !== !1 && n <= i && t.before < Qt ? {
+    ...t,
+    before: Math.min(Qt, t.before + a)
+  } : (e == null ? void 0 : e.after) !== !1 && o - (n + r) <= i && t.after < Qt ? {
+    ...t,
+    after: Math.min(Qt, t.after + a)
+  } : null;
+}
+function Gt(t) {
+  return typeof t != "number" || Number.isNaN(t) ? null : Math.min(100, Math.max(0, t));
+}
+function Xt(t) {
+  const n = new Map(t.map((i) => [i.id, i])), r = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), e = [], a = (i) => {
+    const c = i.parentId;
+    if (!c || c === i.id || !n.has(c)) return null;
+    const u = /* @__PURE__ */ new Set([i.id]);
+    let l = n.get(c);
+    for (; l; ) {
+      if (u.has(l.id)) return null;
+      if (u.add(l.id), !l.parentId) break;
+      l = n.get(l.parentId);
+    }
+    return c;
+  };
+  for (const i of t)
+    r.set(i.id, a(i));
+  for (const i of t) {
+    const c = r.get(i.id);
+    if (!c) {
+      e.push(i.id);
+      continue;
+    }
+    const u = o.get(c);
+    u ? u.push(i.id) : o.set(c, [i.id]);
+  }
+  for (const i of t) {
+    let c = 0, u = r.get(i.id) ?? null;
+    for (; u; )
+      c++, u = r.get(u) ?? null;
+    s.set(i.id, c);
+  }
+  return { childIds: o, parentOf: r, depthOf: s, rootIds: e };
+}
+function ie(t, n, r = Xt(t)) {
+  if (!r.parentOf.has(n)) return [];
+  const o = [n];
+  for (let s = 0; s < o.length; s++) {
+    const e = r.childIds.get(o[s]);
+    e && o.push(...e);
+  }
+  return o;
+}
+function Gr(t, n, r = Xt(t)) {
+  const o = n instanceof Set ? n : new Set(n);
+  if (!o.size) return t;
+  const s = (e) => {
+    let a = r.parentOf.get(e) ?? null;
+    for (; a; ) {
+      if (o.has(a)) return !0;
+      a = r.parentOf.get(a) ?? null;
+    }
+    return !1;
+  };
+  return t.filter((e) => !s(e.id));
+}
+function Xr(t) {
+  let n = 0, r = 0, o = 0, s = !1;
+  for (const a of t) {
+    const i = Gt(a.progress);
+    i !== null && (s = !0);
+    const c = i ?? 0, u = Math.max(
+      0,
+      H(a.endDate).valueOf() - H(a.startDate).valueOf()
+    );
+    n += c * u, r += u, o += c;
+  }
+  if (!s) return;
+  const e = r > 0 ? n / r : o / t.length;
+  return Math.round(e);
+}
+function Br(t, n = Xt(t)) {
+  if (!n.childIds.size) return t;
+  const r = new Map(t.map((a) => [a.id, a])), o = [...n.childIds.keys()].filter((a) => r.has(a)).sort((a, i) => (n.depthOf.get(i) ?? 0) - (n.depthOf.get(a) ?? 0)), s = /* @__PURE__ */ new Map(), e = (a) => s.get(a) ?? r.get(a);
+  for (const a of o) {
+    const i = r.get(a);
+    if (!i) continue;
+    const c = (n.childIds.get(a) ?? []).map(e).filter((f) => f !== void 0);
+    if (!c.length) continue;
+    let u = 1 / 0, l = -1 / 0;
+    for (const f of c) {
+      const h = H(f.startDate).valueOf(), w = H(f.endDate).valueOf();
+      Number.isNaN(h) || (u = Math.min(u, h)), Number.isNaN(w) || (l = Math.max(l, w));
+    }
+    !Number.isFinite(u) || !Number.isFinite(l) || s.set(a, {
+      ...i,
+      startDate: H(u).toISOString(),
+      endDate: H(l).toISOString(),
+      progress: i.progress ?? Xr(c)
+    });
+  }
+  return s.size ? t.map((a) => s.get(a.id) ?? a) : t;
+}
+function Ze(t) {
+  return t.split(".").map(Number);
+}
+function ce(t) {
+  return [...t].sort((n, r) => {
+    const o = Ze(n.sequence), s = Ze(r.sequence), e = Math.max(o.length, s.length);
+    for (let a = 0; a < e; a++) {
+      const i = o[a] || 0, c = s[a] || 0;
+      if (i !== c) return i - c;
+    }
+    return 0;
+  });
+}
+const Nt = "";
+function Pe(t, n) {
+  const r = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  if (n) {
+    const s = new Map(t.map((e) => [e.id, e]));
+    for (const e of t) {
+      const a = e.parentId;
+      let i = null;
+      if (a && a !== e.id && s.has(a)) {
+        const c = /* @__PURE__ */ new Set([e.id]);
+        let u = s.get(a);
+        for (i = a; u; ) {
+          if (c.has(u.id)) {
+            i = null;
+            break;
+          }
+          if (c.add(u.id), !u.parentId) break;
+          u = s.get(u.parentId);
+        }
+      }
+      r.set(e.id, i);
+    }
+  } else {
+    const s = /* @__PURE__ */ new Map();
+    for (const e of t)
+      s.has(e.sequence) || s.set(e.sequence, e.id);
+    for (const e of t) {
+      const a = e.sequence.lastIndexOf("."), i = a === -1 ? null : e.sequence.slice(0, a), c = i ? s.get(i) ?? null : null;
+      r.set(e.id, c === e.id ? null : c);
+    }
+  }
+  for (const s of t) {
+    const e = r.get(s.id) ?? Nt, a = o.get(e);
+    a ? a.push(s.id) : o.set(e, [s.id]);
+  }
+  return { children: o, parentOf: r };
+}
+const zr = [];
+function oe(t, n) {
+  const { children: r, parentOf: o } = Pe(
+    ce(t),
+    n
+  );
+  return {
+    parentOf: o,
+    childrenOf: (s) => r.get(s ?? Nt) ?? zr
+  };
+}
+function jr(t, n, r, o) {
+  const s = o === "child" ? r : t.parentOf.get(r) ?? null, e = t.childrenOf(s), a = o === "child" ? e.length : e.indexOf(r) + (o === "after" ? 1 : 0), i = e.indexOf(n);
+  return {
+    taskId: n,
+    toParentId: s,
+    toIndex: i !== -1 && i < a ? a - 1 : a
+  };
+}
+function On(t, n, r) {
+  const o = new Map(t.map((h) => [h.id, h])), s = o.get(n.taskId);
+  if (!s) return "unknown-task";
+  const e = n.toParentId ? o.get(n.toParentId) : null;
+  if (n.toParentId && !e) return "unknown-parent";
+  if (r.canReorder && !r.canReorder(s)) return "read-only";
+  const a = ce(t), { children: i, parentOf: c } = Pe(a, r.hierarchy), u = c.get(s.id) ?? null;
+  if (!r.hierarchy && n.toParentId !== u)
+    return "reparent-disabled";
+  if (n.toParentId && new Set(ie(a, s.id)).has(n.toParentId))
+    return "cycle";
+  const f = (i.get(u ?? Nt) ?? []).indexOf(s.id);
+  return n.toParentId === u && n.toIndex === f ? "no-op" : null;
+}
+function qr(t, n, r) {
+  if (On(t, n, r)) return null;
+  const o = ce(t), { children: s, parentOf: e } = Pe(o, r.hierarchy), a = e.get(n.taskId) ?? null, i = a ?? Nt, c = n.toParentId ?? Nt, u = [...s.get(i) ?? []], l = u.indexOf(n.taskId);
+  u.splice(l, 1), s.set(i, u);
+  const f = c === i ? u : [...s.get(c) ?? []], h = Math.min(Math.max(n.toIndex, 0), f.length);
+  f.splice(h, 0, n.taskId), s.set(c, f);
+  const w = /* @__PURE__ */ new Map(), p = (m, D) => {
+    (s.get(m) ?? []).forEach((S, L) => {
+      const N = D ? `${D}.${L + 1}` : `${L + 1}`;
+      w.set(S, N), p(S, N);
+    });
+  };
+  return p(Nt, ""), {
+    tasks: t.map((m) => {
+      const D = w.get(m.id) ?? m.sequence, b = r.hierarchy && m.id === n.taskId ? n.toParentId : m.parentId;
+      return D === m.sequence && b === m.parentId ? m : { ...m, sequence: D, parentId: b };
+    }),
+    change: {
+      taskId: n.taskId,
+      fromParentId: a,
+      fromIndex: l,
+      toParentId: n.toParentId,
+      toIndex: h,
+      afterId: f[h - 1] ?? null,
+      beforeId: f[h + 1] ?? null
+    }
+  };
+}
+function Kr(t) {
+  return t.split(".").length - 1;
+}
+function Vr(t, n, r, o) {
+  return ce(t).map((e, a) => {
+    var h;
+    const i = o ? o.depthOf.get(e.id) ?? 0 : Kr(e.sequence), c = (((h = o == null ? void 0 : o.childIds.get(e.id)) == null ? void 0 : h.length) ?? 0) > 0, u = a + 1, { barMarginLeftAmount: l, barWidthSize: f } = to(
+      H(e.startDate),
+      H(e.endDate),
+      n,
+      r
+    );
+    return {
+      ...e,
+      barLeft: l,
+      barWidth: f,
+      depth: i,
+      isSummary: c,
+      order: u,
+      originalOrder: u
+    };
+  });
+}
+const Zr = "off";
+function Jr(t, n, r) {
+  if (!t.length || !n.length) return 0;
+  const o = t[0].startDate, s = n[0].startDate, e = o.valueOf() - s.valueOf();
+  return e === 0 ? 0 : e > 0 ? Lt(o, n, r) ?? 0 : -(Lt(s, t, r) ?? 0);
+}
+function Qr(t, n, r) {
+  const { tickUnit: o, unitPerTick: s } = dt[n];
+  if (o !== "day" && o !== "hour") return [];
+  const e = o === "day" ? s : 1, a = [];
+  let i = 0, c = null;
+  for (const u of t) {
+    const l = u.widthPx / e;
+    for (let f = 0; f < e; f++) {
+      const h = r(u.startDate.add(f, "day"));
+      h && (h.key === c ? a[a.length - 1].width += l : a.push({
+        left: i + f * l,
+        width: l,
+        ...h.label !== void 0 && { label: h.label },
+        ...h.color !== void 0 && { color: h.color }
+      })), c = (h == null ? void 0 : h.key) ?? null;
+    }
+    i += u.widthPx;
+  }
+  return a;
+}
+function Et(t, n, r) {
+  const { dragStepUnit: o, dragStepAmount: s } = dt[r];
+  return t.add(n * s, o);
+}
+function pe(t, n, r) {
+  const { dragStepUnit: o, dragStepAmount: s, basePxPerDragStep: e } = dt[r];
+  return n.diff(t, o, !0) / s * e;
+}
+function Te(t, n, r, o, s) {
+  const { min: e, max: a } = o;
+  if (!e && !a) return { startDate: n, endDate: r };
+  if (t === "bar") {
+    let u = n, l = r;
+    if (a && l.valueOf() > a.valueOf()) {
+      const f = l.valueOf() - a.valueOf();
+      u = u.subtract(f, "millisecond"), l = a;
+    }
+    if (e && u.valueOf() < e.valueOf()) {
+      const f = e.valueOf() - u.valueOf();
+      u = e, l = l.add(f, "millisecond");
+    }
+    return { startDate: u, endDate: l };
+  }
+  if (t === "left") {
+    let u = n;
+    e && u.valueOf() < e.valueOf() && (u = e), a && u.valueOf() > a.valueOf() && (u = a);
+    const l = Et(r, -1, s);
+    return u.valueOf() > l.valueOf() && (u = l), { startDate: u, endDate: r };
+  }
+  let i = r;
+  a && i.valueOf() > a.valueOf() && (i = a), e && i.valueOf() < e.valueOf() && (i = e);
+  const c = Et(n, 1, s);
+  return i.valueOf() < c.valueOf() && (i = c), { startDate: n, endDate: i };
+}
+function kn(t, n, r) {
+  const o = Math.min(0, n), s = Math.max(0, n);
+  let e = n;
+  for (const a of t) {
+    const { startDate: i } = Te(
+      "bar",
+      a.start.add(n, "millisecond"),
+      a.end.add(n, "millisecond"),
+      a.bounds,
+      r
+    ), c = Math.min(
+      s,
+      Math.max(o, i.valueOf() - a.start.valueOf())
+    );
+    Math.abs(c) < Math.abs(e) && (e = c);
+  }
+  return e;
+}
+function to(t, n, r, o) {
+  if (!r.length)
+    return { barMarginLeftAmount: 0, barWidthSize: 0 };
+  const s = dt[o], { tickUnit: e, unitPerTick: a } = s;
+  let i = 0, c = 0, u = !1;
+  const l = t.valueOf(), f = n.valueOf();
+  for (const h of r) {
+    const w = h.startDate, p = w.add(a, e), d = h.widthPx, m = w.valueOf(), D = p.valueOf();
+    if (D <= l) {
+      i += d;
+      continue;
+    }
+    if (m >= f)
+      break;
+    const b = l > m ? t : w, S = f < D ? n : p, L = D - m, x = (S.valueOf() - b.valueOf()) / L;
+    if (!u && b.valueOf() > m) {
+      const _ = (b.valueOf() - m) / L;
+      i += _ * d;
+    }
+    c += x * d, u = !0;
+  }
+  return {
+    barMarginLeftAmount: i,
+    barWidthSize: Math.max(c, 1)
+  };
+}
+function Lt(t, n, r) {
+  if (!n.length) return null;
+  const { tickUnit: o, unitPerTick: s } = dt[r], e = t.valueOf();
+  if (e < n[0].startDate.valueOf()) return null;
+  let a = 0;
+  for (const i of n) {
+    const c = i.startDate.valueOf(), u = i.startDate.add(s, o).valueOf();
+    if (e < u)
+      return a + (e - c) / (u - c) * i.widthPx;
+    a += i.widthPx;
+  }
+  return null;
+}
+function Pn(t, n, r) {
+  if (!n.length || t < 0) return null;
+  const { tickUnit: o, unitPerTick: s } = dt[r];
+  let e = 0;
+  for (const a of n) {
+    if (t < e + a.widthPx) {
+      const i = a.startDate.valueOf(), c = a.startDate.add(s, o).valueOf() - i, u = a.widthPx > 0 ? (t - e) / a.widthPx : 0;
+      return H(i + u * c);
+    }
+    e += a.widthPx;
+  }
+  return null;
+}
+function eo(t, n) {
+  if (!t.length) return null;
+  const { tickUnit: r, unitPerTick: o } = dt[n], s = t[t.length - 1];
+  return {
+    start: t[0].startDate,
+    end: s.startDate.add(o, r)
+  };
+}
+function Je(t, n) {
+  if (t <= 0) return 0;
+  let r = 0;
+  for (let o = 0; o < n.length; o++)
+    if (r += n[o].widthPx, t < r) return o;
+  return n.length - 1;
+}
+function Tn(t, n, r, o) {
+  if (!r.length) return null;
+  const { tickUnit: s, unitPerTick: e } = dt[o], a = Je(Math.min(t, n), r), i = Je(Math.max(t, n), r);
+  let c = 0;
+  for (let l = 0; l < a; l++)
+    c += r[l].widthPx;
+  let u = 0;
+  for (let l = a; l <= i; l++)
+    u += r[l].widthPx;
+  return {
+    startDate: r[a].startDate,
+    endDate: r[i].startDate.add(e, s),
+    leftPx: c,
+    widthPx: u
+  };
+}
+function no(t) {
+  let n = 1 / 0, r = -1 / 0;
+  for (const o of t) {
+    const s = o.startDate ? H(o.startDate).valueOf() : NaN;
+    Number.isNaN(s) || (n = Math.min(n, s));
+    const e = o.endDate ? H(o.endDate).valueOf() : NaN;
+    Number.isNaN(e) || (r = Math.max(r, e));
+  }
+  return {
+    minDate: H(n),
+    maxDate: H(r)
+  };
+}
+function ro(t, n, r, o) {
+  const s = dt[r], { tickUnit: e, unitPerTick: a } = s, i = Dr * a;
+  return {
+    paddedMinDate: t.subtract(
+      i + o.before * a,
+      e
+    ),
+    paddedMaxDate: n.add(
+      i + o.after * a,
+      e
+    )
+  };
+}
+function oo(t, n, r) {
+  const o = dt[r], {
+    tickUnit: s,
+    unitPerTick: e,
+    basePxPerDragStep: a,
+    dragStepUnit: i,
+    dragStepAmount: c
+  } = o, u = [];
+  let l = o.tickAlign ? En(t, o.tickAlign) : t.startOf(s);
+  const f = n.valueOf(), h = a / c;
+  for (; l.valueOf() < f; ) {
+    const w = l.add(e, s), d = w.diff(l, i) * h;
+    u.push({
+      startDate: l,
+      widthPx: d
+    }), l = w;
+  }
+  return u;
+}
+function En(t, n, r) {
+  return n === "quarter" ? hr(t) : n === "week" ? mr(t, r) : t.startOf(n);
+}
+function so(t, n, r) {
+  const o = Mn(n, r), { header: s } = Yt(n, r);
+  if (t.length === 0) return [];
+  const e = [];
+  let a = null;
+  for (const i of t) {
+    const c = En(
+      i.startDate,
+      o,
+      r == null ? void 0 : r.firstDayOfWeek
+    ), u = c.valueOf(), l = s(c);
+    a && a.startDate.valueOf() === u ? a.widthPx += i.widthPx : (a && e.push(a), a = {
+      label: l,
+      widthPx: i.widthPx,
+      startDate: c
+    });
+  }
+  return a && e.push(a), e;
+}
+function ao(t, n, r, o = !1, s = Se) {
+  const e = r == null ? void 0 : r.start, a = r == null ? void 0 : r.end;
+  if (!t.length && !(e && a))
+    return { bottomCells: [], transformedTasks: [] };
+  const i = o ? Xt(t) : void 0, c = i ? Br(t, i) : t;
+  let u = e, l = a;
+  if (!u || !l) {
+    const { minDate: w, maxDate: p } = no(c), { paddedMinDate: d, paddedMaxDate: m } = ro(
+      w,
+      p,
+      n,
+      s
+    );
+    u = u ?? d, l = l ?? m;
+  }
+  const f = oo(
+    u,
+    l,
+    n
+  ), h = Vr(
+    c,
+    f,
+    n,
+    i
+  );
+  return { bottomCells: f, transformedTasks: h };
+}
+function io({
+  bottomRowCells: t,
+  selectedScale: n,
+  width: r,
+  virtual: o
+}) {
+  const s = Q((u) => u.localeOptions), e = j(
+    () => Yt(n, s),
+    [n, s]
+  ), { virtualCells: a, leadingCellPx: i } = o, c = j(
+    () => sr(
+      so(t, n, s)
+    ),
+    [t, n, s]
+  );
+  return /* @__PURE__ */ P("header", { className: "gantt-header", style: { width: `${r}px` }, children: /* @__PURE__ */ J("div", { className: "gantt-header-content", children: [
+    /* @__PURE__ */ P("div", { className: "gantt-top-header", children: /* @__PURE__ */ P("div", { className: "gantt-top-groups", children: c.map((u, l) => /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-top-group",
+        style: { width: `${u.widthPx}px` },
+        children: /* @__PURE__ */ P("p", { className: "gantt-top-group-label", children: u.label })
+      },
+      `${u.label}-${l}`
+    )) }) }),
+    /* @__PURE__ */ J("div", { className: "gantt-bottom-row", children: [
+      /* @__PURE__ */ P("div", { style: { width: `${i}px` }, "aria-hidden": "true" }),
+      a.map((u) => {
+        const l = t[u.index];
+        return l ? /* @__PURE__ */ P(
+          "div",
+          {
+            className: "gantt-bottom-cell",
+            style: { width: `${u.size}px` },
+            children: e.tick(l.startDate)
+          },
+          `bottom-${u.index}`
+        ) : null;
+      })
+    ] })
+  ] }) });
+}
+const Ln = {};
+function Dt(t, n = Ln) {
+  const r = (e, a) => e !== void 0 ? e : t.readOnly !== void 0 ? !t.readOnly : a !== void 0 ? a : !n.readOnly, o = t.allowReorder ?? (t.readOnly === !0 ? !1 : n.allowReorder ?? !1), s = t.isSummary === !0;
+  return {
+    canMove: r(t.allowMove, n.allowMove),
+    canResize: !s && r(t.allowResize, n.allowResize),
+    canChangeProgress: !s && r(t.allowProgressChange, n.allowProgressChange),
+    canCreateLink: r(t.allowLinkCreate, n.allowLinkCreate),
+    canDeleteLink: r(t.allowLinkDelete, n.allowLinkDelete),
+    canReorder: o,
+    minDate: t.minDate ?? n.minDate,
+    maxDate: t.maxDate ?? n.maxDate
+  };
+}
+function co(t = Ln) {
+  return t.allowTaskCreate ?? !t.readOnly;
+}
+function lo(t) {
+  const n = t == null ? void 0 : t.trim();
+  return n ? {
+    "--gantt-bar-color": n,
+    "--gantt-bar-color-hover": `color-mix(in srgb, ${n} 86%, #000)`,
+    "--gantt-progress-color": `color-mix(in srgb, ${n} 62%, #000)`,
+    // Black or white, whichever the bar color can carry: `l` is the color's own lightness, and
+    // dividing by the threshold then multiplying by -infinity clamps to one end or the other.
+    // 0.5637 is cbrt(0.1791), the OKLab lightness of the relative luminance where black and white
+    // tie on WCAG contrast. Anything higher (MUI ships 0.7 for its own palette) picks white on
+    // mid-tone colors that read better in black; measured, 0.7 gets 8 of 18 sample colors wrong.
+    // Done in CSS, not here, because `var(--brand)` is a legal color and JS cannot read its lightness.
+    "--gantt-bar-text-color": `oklch(from ${n} clamp(0, (l / 0.5637 - 1) * -infinity, 1) 0 h)`
+  } : {};
+}
+const Me = { offsetX: 0, offsetWidth: 0 };
+function Qe(t, n, r, o, s) {
+  if (r < 0 || s < 0)
+    return `M ${n} ${r} h ${(o - n) / 2}`;
+  const e = 7, a = 11, i = 25, c = 20, u = `M ${n} ${r}`, l = o - n, f = s - r, h = Math.abs(l), w = Math.abs(f), p = s <= r, d = s >= r, m = o >= n, D = o <= n, b = h > c, S = Math.abs(l / 2), L = Math.abs(f / 2);
+  function N() {
+    function v() {
+      return (m || D) && d && !b ? "downSmallHorizontal" : (m || D) && p && !b ? "upSmallHorizontal" : d && D ? "downLeft" : d && m ? "downRight" : p && D ? "upLeft" : p && m ? "upRight" : "";
+    }
+    let g = u;
+    switch (v()) {
+      case "downRight": {
+        g += ` h ${S - e}`, g += ` a ${e} ${e} 0 0 1 ${e} ${e}`, g += ` v ${f - e * 2}`, g += ` a ${e} ${e} 0 0 0 ${e} ${e}`, g += ` h ${S - e}`;
+        break;
+      }
+      case "upRight": {
+        g += ` h ${S - e}`, g += ` a ${e} ${e} 0 0 0 ${e} -${e}`, g += ` v -${w - e * 2}`, g += ` a ${e} ${e} 0 0 1 ${e} -${e}`, g += ` h ${S - e}`;
+        break;
+      }
+      case "downLeft":
+      case "downSmallHorizontal": {
+        const F = r + f / 2;
+        g += ` h ${a}`, g += ` a ${e} ${e} 0 0 1 ${e} ${e}`, g += ` v ${F - r - e * 2}`, g += ` a ${e} ${e} 0 0 1 -${e} ${e}`, g += ` h ${l - 2 * a}`, g += ` a ${e} ${e} 0 0 0 -${e} ${e}`, g += ` v ${F - r - e * 2}`, g += ` a ${e} ${e} 0 0 0 ${e} ${e}`, g += ` h ${a}`;
+        break;
+      }
+      case "upLeft":
+      case "upSmallHorizontal": {
+        const F = r + f / 2;
+        g += ` h ${a}`, g += ` a ${e} ${e} 0 0 0 ${e} -${e}`, g += ` v -${r - F - e * 2}`, g += ` a ${e} ${e} 0 0 0 -${e} -${e}`, g += ` h ${l - 2 * a}`, g += ` a ${e} ${e} 0 0 1 -${e} -${e}`, g += ` v -${r - F - e * 2}`, g += ` a ${e} ${e} 0 0 1 ${e} -${e}`, g += ` h ${a}`;
+        break;
+      }
+      default:
+        return g;
+    }
+    return g;
+  }
+  function x() {
+    let v = u;
+    return d && D ? (v += ` h ${i - a}`, v += ` a ${e} ${e} 0 0 1 ${e} ${e}`, v += ` v ${f - e * 2}`, v += ` a ${e} ${e} 0 0 1 -${e} ${e}`, v += ` h ${l - e * 2}`) : d && m ? (v += ` h ${l + i - a}`, v += ` a ${e} ${e} 0 0 1 ${e} ${e}`, v += ` v ${f - e * 2}`, v += ` a ${e} ${e} 0 0 1 -${e} ${e}`, v += ` h -${i - a}`) : p && D ? (v += ` h ${i - a}`, v += ` a ${e} ${e} 0 0 0 ${e} -${e}`, v += ` v ${f + e * 2}`, v += ` a ${e} ${e} 0 0 0 -${e} -${e}`, v += ` h ${l - i + a}`) : p && m && (v += ` h ${l + i - a}`, v += ` a ${e} ${e} 0 0 0 ${e} -${e}`, v += ` v ${f + e * 2}`, v += ` a ${e} ${e} 0 0 0 -${e} -${e}`, v += ` h -${i - a}`), v;
+  }
+  function _() {
+    function v() {
+      return (m || D) && d && !b ? "downSmallHorizontal" : (m || D) && p && !b ? "upSmallHorizontal" : d && D ? "downLeft" : d && m ? "downRight" : p && D ? "upLeft" : p && m ? "upRight" : "";
+    }
+    let g = u;
+    switch (v()) {
+      case "downRight":
+      case "downSmallHorizontal": {
+        g += ` h ${-a}`, g += ` a ${e} ${e} 0 0 0 -${e} ${e}`, g += ` v ${L - e * 2}`, g += ` a ${e} ${e} 0 0 0 ${e} ${e}`, g += ` h ${a * 2 + l}`, g += ` a ${e} ${e} 0 0 1 ${e} ${e}`, g += ` v ${L - e * 2}`, g += ` a ${e} ${e} 0 0 1 -${e} ${e}`, g += ` h ${-a}`;
+        break;
+      }
+      case "upRight":
+      case "upSmallHorizontal": {
+        g += ` h ${-a}`, g += ` a ${e} ${e} 0 0 1 -${e} -${e}`, g += ` v ${-(L - e * 2)}`, g += ` a ${e} ${e} 0 0 1 ${e} -${e}`, g += ` h ${a * 2 + l}`, g += ` a ${e} ${e} 0 0 0 ${e} -${e}`, g += ` v ${-(L - e * 2)}`, g += ` a ${e} ${e} 0 0 0 -${e} -${e}`, g += ` h ${-a}`;
+        break;
+      }
+      case "downLeft": {
+        g += ` h ${-S + e}`, g += ` a ${e} ${e} 0 0 0 -${e} ${e}`, g += ` v ${w - e * 2}`, g += ` a ${e} ${e} 0 0 1 -${e} ${e}`, g += ` h ${-S + e}`;
+        break;
+      }
+      case "upLeft": {
+        g += ` h ${-(S - e)}`, g += ` a ${e} ${e} 0 0 1 -${e} -${e}`, g += ` v ${-(w - e * 2)}`, g += ` a ${e} ${e} 0 0 0 -${e} -${e}`, g += ` h ${-S + e}`;
+        break;
+      }
+      default:
+        return g;
+    }
+    return g;
+  }
+  function A() {
+    let v = u;
+    return d && D ? (v += ` h ${l - i}`, v += ` a ${e} ${e} 0 0 0 -${e} ${e}`, v += ` v ${f - e * 2}`, v += ` a ${e} ${e} 0 0 0 ${e} ${e}`, v += ` h ${i}`) : d && m ? (v += ` h ${-i}`, v += ` a ${e} ${e} 0 0 0 -${e} ${e}`, v += ` v ${f - e * 2}`, v += ` a ${e} ${e} 0 0 0 ${e} ${e}`, v += ` h ${l + i}`) : p && D ? (v += ` h ${l - i}`, v += ` a ${e} ${e} 0 0 1 -${e} -${e}`, v += ` v ${f + e * 2}`, v += ` a ${e} ${e} 0 0 1 ${e} -${e}`, v += ` h ${i}`) : p && m && (v += ` h ${-i}`, v += ` a ${e} ${e} 0 0 1 -${e} -${e}`, v += ` v ${f + e * 2}`, v += ` a ${e} ${e} 0 0 1 ${e} -${e}`, v += ` h ${l + i}`), v;
+  }
+  switch (t) {
+    case "FS":
+      return N();
+    case "FF":
+      return x();
+    case "SF":
+      return _();
+    case "SS":
+      return A();
+    default:
+      return `${u} L ${o} ${s}`;
+  }
+}
+function xe(t, n) {
+  const r = t.barLeft + n.offsetX;
+  return {
+    startX: r,
+    endX: r + t.barWidth + n.offsetWidth
+  };
+}
+function tn(t, n, r = Me) {
+  const { startX: o, endX: s } = xe(t, r);
+  return {
+    x: n === "start" ? o : s,
+    y: (t.order - 1) * xt + xt / 2
+  };
+}
+function uo(t, n, r, o, s) {
+  const e = xt, a = t.order - 1, i = n.order - 1, c = e / 2, u = i * e + c, l = a * e + c, f = xe(n, o), h = xe(t, r), p = {
+    FS: [f.endX, h.startX],
+    SS: [f.startX, h.startX],
+    FF: [f.endX, h.endX],
+    SF: [f.startX, h.endX]
+  }[s];
+  if (!p)
+    return null;
+  const [d, m] = p;
+  return { fromX: d, fromY: u, toX: m, toY: l };
+}
+function fo(t) {
+  return new Map(t.map((n) => [n.id, n]));
+}
+const te = 32;
+function ho(t, n) {
+  const r = Math.min(t.fromY, t.toY) - te;
+  if (Math.max(t.fromY, t.toY) + te < n.topPx || r > n.bottomPx) return !1;
+  const s = Math.min(t.fromX, t.toX) - te, e = Math.max(t.fromX, t.toX) + te;
+  return n.isBarVisible(s, e - s);
+}
+function mo(t, n) {
+  const r = [];
+  for (const o of t.values()) {
+    const s = n[o.id] ?? Me;
+    for (const e of o.dependencies ?? []) {
+      const a = t.get(e.targetId);
+      if (!a) continue;
+      const i = uo(
+        o,
+        a,
+        s,
+        n[a.id] ?? Me,
+        e.type
+      );
+      i && r.push({
+        ...e,
+        sourceId: o.id,
+        ...i
+      });
+    }
+  }
+  return r;
+}
+function An(t, n) {
+  const r = (o) => o === "end" ? "F" : "S";
+  return `${r(t)}${r(n)}`;
+}
+function po(t, n, r, o, s) {
+  const e = Math.floor(r / o);
+  if (e < 0) return null;
+  let a = null, i = 1 / 0;
+  for (const f of t) {
+    if (f.order - 1 !== e) continue;
+    const h = f.barLeft ?? 0, w = h + (f.barWidth ?? 0), p = n < h ? h - n : Math.max(0, n - w);
+    p < i && (i = p, a = f);
+  }
+  if (!a) return null;
+  const c = a.barLeft ?? 0, u = a.barWidth ?? 0, l = Math.min(s, u / 3);
+  return { task: a, anchor: n > c + u - l ? "end" : "start" };
+}
+function go(t, n, r) {
+  var i;
+  if (n === r) return "self";
+  const o = new Map(t.map((c) => [c.id, c])), s = (i = o.get(r)) == null ? void 0 : i.dependencies;
+  if (s != null && s.some((c) => c.targetId === n))
+    return "duplicate";
+  const e = /* @__PURE__ */ new Set([n]), a = [n];
+  for (; a.length; ) {
+    const c = o.get(a.pop());
+    for (const u of (c == null ? void 0 : c.dependencies) ?? []) {
+      if (u.targetId === r) return "cycle";
+      e.has(u.targetId) || (e.add(u.targetId), a.push(u.targetId));
+    }
+  }
+  return null;
+}
+const $o = {
+  self: "Cannot link a task to itself",
+  duplicate: "These tasks are already linked",
+  cycle: "That would create a circular dependency"
+};
+function Do(t, n, r, o) {
+  let s = !1;
+  const e = t.map((a) => a.id !== r ? a : (s = !0, {
+    ...a,
+    dependencies: [
+      ...a.dependencies ?? [],
+      { targetId: n, type: o }
+    ]
+  }));
+  return s ? e : t;
+}
+function wo(t, n, r) {
+  let o = !1;
+  const s = t.map((e) => {
+    if (e.id !== r || !e.dependencies) return e;
+    const a = e.dependencies.filter(
+      (i) => i.targetId !== n
+    );
+    return a.length === e.dependencies.length ? e : (o = !0, { ...e, dependencies: a });
+  });
+  return o ? s : t;
+}
+const vo = 8, yo = 14, bo = 220;
+function So(t) {
+  const n = t;
+  return n ? n.isContentEditable || n.tagName === "INPUT" || n.tagName === "TEXTAREA" || n.tagName === "SELECT" : !1;
+}
+function Mo({
+  transformedTasks: t,
+  rowCount: n,
+  virtual: r,
+  interaction: o,
+  onTasksChange: s,
+  onDependencyDelete: e
+}) {
+  const a = yt(), i = Q((x) => x.dragOffsets), c = Q((x) => x.linkDraft), u = Q((x) => x.getTotalWidth()), l = Q((x) => x.selectedDependency), f = Q((x) => x.selectedTaskId), h = Q((x) => x.hoveredTaskId), w = j(
+    () => fo(t),
+    [t]
+  ), p = {
+    topPx: r.rowStartPx,
+    bottomPx: r.rowEndPx,
+    isBarVisible: r.isBarVisible
+  }, d = mo(w, i).filter(
+    (x) => ho(x, p)
+  ), m = (x) => (l == null ? void 0 : l.sourceId) === x.sourceId && (l == null ? void 0 : l.targetId) === x.targetId, D = (x) => h !== null && (x.sourceId === h || x.targetId === h) || f !== null && (x.sourceId === f || x.targetId === f), b = z(() => {
+    var I;
+    const { rawTasks: x, selectedDependency: _, setRawTasks: A, setSelectedDependency: v } = a.getState();
+    if (!_) return;
+    const { sourceId: g, targetId: R } = _, F = x.find((y) => y.id === g), U = (I = F == null ? void 0 : F.dependencies) == null ? void 0 : I.find(
+      (y) => y.targetId === R
+    );
+    if (!F || !U || !Dt(F, o).canDeleteLink) return;
+    const T = {
+      predecessorId: R,
+      successorId: g,
+      type: U.type
+    };
+    if ((e == null ? void 0 : e(T)) === !1) return;
+    v(null);
+    const M = wo(x, R, g);
+    A(M), s == null || s(M);
+  }, [a, o, e, s]);
+  it(() => {
+    if (!l) return;
+    const x = (A) => {
+      So(A.target) || (A.key === "Delete" || A.key === "Backspace" ? (A.preventDefault(), b()) : A.key === "Escape" && a.getState().setSelectedDependency(null));
+    }, _ = () => {
+      a.getState().setSelectedDependency(null);
+    };
+    return document.addEventListener("keydown", x), document.addEventListener("pointerdown", _), () => {
+      document.removeEventListener("keydown", x), document.removeEventListener("pointerdown", _);
+    };
+  }, [l, b, a]);
+  const S = j(() => {
+    if (!c) return null;
+    const x = w.get(c.fromTaskId);
+    if (!x) return null;
+    const _ = tn(
+      x,
+      c.fromAnchor,
+      i[x.id]
+    ), A = c.hoverTaskId ? w.get(c.hoverTaskId) : void 0, v = c.hoverAnchor && An(c.fromAnchor, c.hoverAnchor), g = !c.rejection && A !== void 0 && c.hoverAnchor !== null, R = g && A && c.hoverAnchor ? tn(
+      A,
+      c.hoverAnchor,
+      i[A.id]
+    ) : { x: c.toX, y: c.toY }, F = R.x > u - bo;
+    return {
+      from: _,
+      d: g && v ? Qe(v, _.x, _.y, R.x, R.y) : `M ${_.x} ${_.y} L ${R.x} ${R.y}`,
+      armed: g,
+      type: v,
+      rejection: c.rejection,
+      label: {
+        x: F ? R.x - 12 : R.x + 12,
+        y: Math.max(yo, R.y - 8),
+        anchor: F ? "end" : "start"
+      }
+    };
+  }, [c, w, i, u]), N = `gantt-arrowhead-${gn().replace(/[^a-zA-Z0-9]/g, "")}`;
+  return /* @__PURE__ */ J(
+    "svg",
+    {
+      className: `gantt-dependency-arrows${c ? " linking" : ""}`,
+      style: {
+        height: `${n * xt}px`
+      },
+      children: [
+        /* @__PURE__ */ P("defs", { children: /* @__PURE__ */ P(
+          "marker",
+          {
+            id: N,
+            markerWidth: "5",
+            markerHeight: "5",
+            refX: "4.5",
+            refY: "2.5",
+            orient: "auto",
+            children: /* @__PURE__ */ P(
+              "polygon",
+              {
+                className: "gantt-dependency-arrow-head",
+                points: "0 0, 5 2.5, 0 5"
+              }
+            )
+          }
+        ) }),
+        d.map((x, _) => {
+          const A = Qe(
+            x.type,
+            x.fromX,
+            x.fromY,
+            x.toX,
+            x.toY
+          ), v = m(x), g = w.get(x.sourceId), R = g !== void 0 && Dt(g, o).canDeleteLink;
+          return /* @__PURE__ */ J("g", { children: [
+            R && /* @__PURE__ */ P(
+              "path",
+              {
+                className: "gantt-dependency-hit",
+                d: A,
+                fill: "none",
+                onPointerDown: (F) => {
+                  F.stopPropagation(), a.getState().setSelectedDependency({
+                    sourceId: x.sourceId,
+                    targetId: x.targetId
+                  });
+                }
+              }
+            ),
+            /* @__PURE__ */ P(
+              "path",
+              {
+                className: `gantt-dependency-arrow${v ? " selected" : ""}${D(x) ? " related" : ""}`,
+                d: A,
+                markerEnd: `url(#${N})`,
+                fill: "none"
+              }
+            ),
+            v && /* @__PURE__ */ J(
+              "g",
+              {
+                className: "gantt-dependency-delete",
+                transform: `translate(${(x.fromX + x.toX) / 2} ${(x.fromY + x.toY) / 2})`,
+                role: "button",
+                "aria-label": `Delete ${x.type} dependency`,
+                onPointerDown: (F) => {
+                  F.stopPropagation(), b();
+                },
+                children: [
+                  /* @__PURE__ */ P("circle", { r: vo }),
+                  /* @__PURE__ */ P("path", { d: "M -3 -3 L 3 3 M 3 -3 L -3 3" })
+                ]
+              }
+            )
+          ] }, `arrow-${_}`);
+        }),
+        S && /* @__PURE__ */ J("g", { className: "gantt-link-preview", children: [
+          /* @__PURE__ */ P(
+            "path",
+            {
+              className: `gantt-link-preview-line${S.rejection ? " invalid" : ""}${S.armed ? " armed" : ""}`,
+              d: S.d,
+              fill: "none",
+              markerEnd: S.rejection ? void 0 : `url(#${N})`
+            }
+          ),
+          /* @__PURE__ */ P(
+            "circle",
+            {
+              className: "gantt-link-preview-origin",
+              cx: S.from.x,
+              cy: S.from.y,
+              r: "3"
+            }
+          ),
+          S.armed && S.type && /* @__PURE__ */ P(
+            "text",
+            {
+              className: "gantt-link-preview-type",
+              x: S.label.x,
+              y: S.label.y,
+              textAnchor: S.label.anchor,
+              children: S.type
+            }
+          ),
+          S.rejection && /* @__PURE__ */ P(
+            "text",
+            {
+              className: "gantt-link-preview-reason",
+              x: S.label.x,
+              y: S.label.y,
+              textAnchor: S.label.anchor,
+              children: $o[S.rejection]
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function xo() {
+  const t = Q((d) => d.currentTask), n = Q((d) => d.dragOffsets), r = Q((d) => d.dragMode), o = Q((d) => d.selectedScale), s = Q((d) => d.localeOptions), e = Q((d) => d.bottomRowCells), { edge: a, range: i } = j(
+    () => Yt(o, s),
+    [o, s]
+  ), c = j(
+    () => Dn(e),
+    [e]
+  ), u = t ? n[t.id] : void 0;
+  if (!t || !u) return null;
+  const l = t.barLeft + u.offsetX, f = l + t.barWidth + u.offsetWidth, h = se(c, l), w = se(c, f);
+  if (!h || !w) return null;
+  const p = r === "left" ? [{ cell: h, label: a(u.offsetStartDate) }] : r === "right" ? [{ cell: w, label: a(u.offsetEndDate) }] : h.index === w.index ? [
+    {
+      cell: h,
+      label: i(u.offsetStartDate, u.offsetEndDate)
+    }
+  ] : [
+    { cell: h, label: a(u.offsetStartDate) },
+    { cell: w, label: a(u.offsetEndDate) }
+  ];
+  return /* @__PURE__ */ J("div", { className: "gantt-drag-guides", "aria-hidden": "true", children: [
+    p.map(({ cell: d, label: m }) => /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-drag-cell",
+        style: { left: `${d.left}px`, width: `${d.width}px` },
+        children: /* @__PURE__ */ P("span", { children: m })
+      },
+      d.index
+    )),
+    /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-drag-footprint",
+        style: {
+          left: `${l}px`,
+          width: `${Math.max(f - l, 2)}px`
+        }
+      }
+    )
+  ] });
+}
+function Io({
+  width: t,
+  onWidthChange: n
+}) {
+  const r = (a) => Math.min(Xe, Math.max(Ge, a)), o = (a) => {
+    if (!a.isPrimary || a.button !== 0) return;
+    const i = a.clientX, c = t;
+    a.currentTarget.setPointerCapture(a.pointerId);
+    const u = (f) => {
+      f.pointerId === a.pointerId && n(r(c + f.clientX - i));
+    }, l = (f) => {
+      f.pointerId === a.pointerId && (document.removeEventListener("pointermove", u), document.removeEventListener("pointerup", l), document.removeEventListener("pointercancel", l));
+    };
+    document.addEventListener("pointermove", u), document.addEventListener("pointerup", l), document.addEventListener("pointercancel", l);
+  }, s = (a) => {
+    var h, w;
+    const i = (h = a.parentElement) == null ? void 0 : h.querySelectorAll(
+      ".gantt-grid-cell-text"
+    );
+    if (!(i != null && i.length)) return;
+    const c = (w = a.parentElement) == null ? void 0 : w.querySelector(".gantt-grid");
+    if (!c) return;
+    const u = c.getBoundingClientRect().width / c.offsetWidth || 1, l = document.createRange();
+    let f = 0;
+    i.forEach((p) => {
+      const d = p.closest(".gantt-grid-row");
+      if (!d) return;
+      l.selectNodeContents(p);
+      const m = l.getBoundingClientRect().width;
+      let b = p.getBoundingClientRect().left - d.getBoundingClientRect().left + m;
+      for (let S = p.nextElementSibling; S; S = S.nextElementSibling)
+        b += S.getBoundingClientRect().width;
+      f = Math.max(f, b);
+    }), n(r(Math.ceil(f / u + 10) + 1));
+  }, e = (a) => {
+    if (a.key === "Enter") {
+      a.preventDefault(), s(a.currentTarget);
+      return;
+    }
+    a.key !== "ArrowLeft" && a.key !== "ArrowRight" || (a.preventDefault(), n(r(t + (a.key === "ArrowLeft" ? -16 : 16))));
+  };
+  return /* @__PURE__ */ P(
+    "div",
+    {
+      className: "gantt-grid-splitter",
+      style: { left: `${t - 2}px` },
+      onPointerDown: o,
+      onDoubleClick: (a) => s(a.currentTarget),
+      onKeyDown: e,
+      role: "separator",
+      "aria-orientation": "vertical",
+      "aria-label": "Resize task list",
+      "aria-valuenow": t,
+      "aria-valuemin": Ge,
+      "aria-valuemax": Xe,
+      tabIndex: 0
+    }
+  );
+}
+function Oo({
+  width: t,
+  onAdd: n
+}) {
+  return /* @__PURE__ */ P("div", { className: "gantt-grid-footer", style: { width: `${t}px` }, children: /* @__PURE__ */ J("button", { type: "button", className: "gantt-grid-add", onClick: n, children: [
+    /* @__PURE__ */ P("svg", { viewBox: "0 0 12 12", "aria-hidden": "true", children: /* @__PURE__ */ P("path", { d: "M6 2.5 V9.5 M2.5 6 H9.5" }) }),
+    "Add task"
+  ] }) });
+}
+function ko({ leftPx: t }) {
+  return t === null ? null : /* @__PURE__ */ P(
+    "div",
+    {
+      className: "gantt-today-marker",
+      style: { left: `${t}px` },
+      "aria-hidden": "true"
+    }
+  );
+}
+function Po({ leftPx: t }) {
+  return t === null ? null : /* @__PURE__ */ P(
+    "div",
+    {
+      className: "gantt-today-dot",
+      style: { left: `${t}px` },
+      "aria-hidden": "true"
+    }
+  );
+}
+function ht(t) {
+  const n = Z(t);
+  return Rt(() => {
+    n.current = t;
+  }), n;
+}
+const To = 400, Eo = 10;
+function le(t, n, r = document) {
+  if (t.pointerType === "mouse")
+    return n(t.clientX, t.clientY), null;
+  let o = t.clientX, s = t.clientY, e;
+  const a = () => {
+    e !== void 0 && clearTimeout(e), e = void 0, r.removeEventListener("pointermove", i), r.removeEventListener("pointerup", c), r.removeEventListener("pointercancel", c);
+  };
+  function i(u) {
+    const l = u;
+    if (l.pointerId !== t.pointerId) return;
+    if (Math.abs(l.clientX - t.clientX) + Math.abs(l.clientY - t.clientY) > Eo) {
+      a();
+      return;
+    }
+    o = l.clientX, s = l.clientY;
+  }
+  function c(u) {
+    u.pointerId === t.pointerId && a();
+  }
+  return r.addEventListener("pointermove", i), r.addEventListener("pointerup", c), r.addEventListener("pointercancel", c), e = setTimeout(() => {
+    a(), n(o, s);
+  }, To), a;
+}
+function ue() {
+  const t = (n) => n.preventDefault();
+  return document.addEventListener("touchmove", t, { passive: !1 }), () => document.removeEventListener("touchmove", t);
+}
+const en = 0.25;
+function Lo({
+  rows: t,
+  virtualItems: n,
+  bodyRef: r,
+  hierarchy: o,
+  move: s
+}) {
+  const e = yt(), a = Q((p) => p.reorderDraft), i = ht(t), c = ht(n), u = ht(s), l = Z(null), f = Z(null);
+  it(
+    () => () => {
+      var p, d;
+      (p = l.current) == null || p.call(l), (d = f.current) == null || d.call(f);
+    },
+    []
+  );
+  const h = (p, d, m, D) => {
+    const b = oe(e.getState().rawTasks, o);
+    try {
+      D.setPointerCapture(d);
+    } catch {
+    }
+    const S = m === "mouse" ? null : ue(), L = document.body.style.cursor;
+    document.body.style.cursor = "grabbing";
+    const N = (U) => {
+      const T = r.current;
+      if (!T) return null;
+      const M = U - T.getBoundingClientRect().top, I = c.current.find(
+        (X) => M >= X.start && M < X.start + X.size
+      );
+      if (!I) return null;
+      const y = i.current[I.index], $ = y == null ? void 0 : y.tasks[0];
+      if (!y || !$ || y.tasks.length > 1) return null;
+      const k = (M - I.start) / I.size, E = k < en ? "before" : k > 1 - en ? "after" : "child", C = jr(b, p, $.id, E);
+      return {
+        taskId: p,
+        rowIndex: I.index,
+        mode: E,
+        depth: E === "child" ? y.depth + 1 : y.depth,
+        move: C,
+        rejection: u.current.validate(C)
+      };
+    };
+    let x = null;
+    const _ = (U) => {
+      U.pointerId === d && (x = U.clientY, e.getState().setReorderDraft(N(U.clientY)));
+    }, A = () => {
+      S == null || S(), document.body.style.cursor = L, document.removeEventListener("pointermove", _), document.removeEventListener("pointerup", F), document.removeEventListener("pointercancel", g), document.removeEventListener("keydown", R);
+      try {
+        D.releasePointerCapture(d);
+      } catch {
+      }
+    }, v = () => {
+      A(), f.current = null, e.getState().setReorderDraft(null);
+    }, g = (U) => {
+      U.pointerId === d && v();
+    };
+    function R(U) {
+      U.key === "Escape" && v();
+    }
+    function F(U) {
+      if (U.pointerId !== d) return;
+      const T = x === null ? null : N(x) ?? e.getState().reorderDraft;
+      v(), T != null && T.move && !T.rejection && u.current.apply(T.move);
+    }
+    f.current = v, document.addEventListener("pointermove", _), document.addEventListener("pointerup", F), document.addEventListener("pointercancel", g), document.addEventListener("keydown", R);
+  };
+  return { onGripPointerDown: (p, d) => {
+    var L, N;
+    if (!d.isPrimary || d.button !== 0 || f.current) return;
+    (L = l.current) == null || L.call(l), l.current = null;
+    const m = (N = i.current[p]) == null ? void 0 : N.tasks[0];
+    if (!m) return;
+    const D = d.currentTarget, { pointerId: b, pointerType: S } = d;
+    l.current = le(
+      { pointerType: S, pointerId: b, clientX: d.clientX, clientY: d.clientY },
+      () => {
+        l.current = null, h(m.id, b, S, D);
+      }
+    );
+  }, draft: a };
+}
+const nn = 5, ge = (t, n) => Math.min(Math.max(t, 0), Math.max(n, 0));
+function Ao(t, n, r) {
+  var c;
+  const o = r[n.row];
+  if (!o) return null;
+  const s = r.length - 1, e = ge(n.col, o.cells - 1), a = t.key === "ArrowRight" ? 1 : -1, i = t.key === "ArrowLeft" || t.key === "ArrowRight";
+  if (i && (t.altKey || t.shiftKey)) {
+    const u = t.altKey ? t.shiftKey ? "left" : "bar" : "right";
+    return { kind: "nudge", row: n.row, col: e, mode: u, steps: a };
+  }
+  if (t.altKey && (t.key === "ArrowUp" || t.key === "ArrowDown"))
+    return {
+      kind: "reorder",
+      row: n.row,
+      col: e,
+      delta: t.key === "ArrowDown" ? 1 : -1
+    };
+  if (i && (t.ctrlKey || t.metaKey))
+    return { kind: "reparent", row: n.row, col: e, direction: a };
+  if ((t.ctrlKey || t.metaKey) && (t.key === "ArrowUp" || t.key === "ArrowDown"))
+    return { kind: "zoom", direction: t.key === "ArrowUp" ? -1 : 1 };
+  switch (t.key) {
+    case "ArrowDown":
+      return {
+        kind: "focus",
+        focus: { row: Math.min(n.row + 1, s), col: e }
+      };
+    case "ArrowUp":
+      return {
+        kind: "focus",
+        focus: { row: Math.max(n.row - 1, 0), col: e }
+      };
+    case "ArrowRight":
+      return e === 0 && o.expandable && !o.expanded ? { kind: "toggle", row: n.row, col: e } : {
+        kind: "focus",
+        focus: { row: n.row, col: ge(e + 1, o.cells - 1) }
+      };
+    case "ArrowLeft":
+      return e === 0 && o.expandable && o.expanded ? { kind: "toggle", row: n.row, col: e } : {
+        kind: "focus",
+        focus: { row: n.row, col: ge(e - 1, o.cells - 1) }
+      };
+    case "Home":
+      return t.ctrlKey || t.metaKey ? { kind: "focus", focus: { row: 0, col: 0 } } : { kind: "focus", focus: { row: n.row, col: 0 } };
+    case "End": {
+      const u = t.ctrlKey || t.metaKey ? s : n.row;
+      return {
+        kind: "focus",
+        focus: { row: u, col: Math.max((((c = r[u]) == null ? void 0 : c.cells) ?? 1) - 1, 0) }
+      };
+    }
+    case "Enter":
+    case " ":
+      return o.expandable ? { kind: "toggle", row: n.row, col: e } : { kind: "activate", row: n.row, col: e };
+    case "Delete":
+    case "Backspace":
+      return { kind: "delete", row: n.row, col: e };
+    case "+":
+    case "=":
+      return { kind: "progress", row: n.row, col: e, delta: nn };
+    case "-":
+    case "_":
+      return { kind: "progress", row: n.row, col: e, delta: -nn };
+    default:
+      return null;
+  }
+}
+function No(t, n, r) {
+  if (!(!t || !t.tasks.length))
+    return t.tasks[Math.max(0, n - r)] ?? t.tasks[0];
+}
+function Nn(t, n, r = null) {
+  const o = [t.name];
+  return t.isSummary && o.push("summary"), o.push(
+    `${n(H(t.startDate))} to ${n(H(t.endDate))}`
+  ), r !== null && o.push(`${r}% complete`), o.join(", ");
+}
+function Ro(t, n, r, o) {
+  const s = o ? `under ${o}` : "at the top level";
+  return `${t} moved to ${n} of ${r} ${s}`;
+}
+function Rn(t, n, r) {
+  var o;
+  return {
+    role: "row",
+    "aria-level": t.level,
+    "aria-posinset": t.posinset,
+    "aria-setsize": t.setsize,
+    "aria-rowindex": n + 1 + r.headerOffset,
+    ...r.expandable ? { "aria-expanded": r.expanded } : null,
+    ...(o = r.ownedIds) != null && o.length ? { "aria-owns": r.ownedIds.join(" ") } : null
+  };
+}
+function rn(t, n) {
+  return !t && !n ? null : { min: t ? H(t) : void 0, max: n ? H(n) : void 0 };
+}
+function _o(t, n, r, o, s, e) {
+  const { canMove: a, canResize: i, minDate: c, maxDate: u } = Dt(
+    n,
+    e
+  );
+  if ((r === "bar" ? !a : !i) || !o) return null;
+  const l = new Set(
+    n.isSummary && r === "bar" ? ie(t, n.id) : [n.id]
+  ), f = rn(c, u), h = H(n.startDate), w = H(n.endDate);
+  let p = r === "right" ? h : Et(h, o, s), d = r === "left" ? w : Et(w, o, s), m = null;
+  if (r === "bar") {
+    const b = [];
+    for (const S of t) {
+      if (!l.has(S.id)) continue;
+      const L = Dt(S, e), N = S.id === n.id ? f : rn(L.minDate, L.maxDate);
+      N && b.push({
+        start: S.id === n.id ? h : H(S.startDate),
+        end: S.id === n.id ? w : H(S.endDate),
+        bounds: N
+      });
+    }
+    if (b.length) {
+      if (m = kn(
+        b,
+        p.valueOf() - h.valueOf(),
+        s
+      ), m === 0) return null;
+      p = h.add(m, "millisecond"), d = w.add(m, "millisecond");
+    }
+  } else if (f) {
+    const b = Te(r, p, d, f, s);
+    p = b.startDate, d = b.endDate;
+  }
+  if (r !== "bar" && !d.isAfter(p) || r === "left" && p.valueOf() === h.valueOf() || r === "right" && d.valueOf() === w.valueOf())
+    return null;
+  const D = (b) => m !== null ? H(b).add(m, "millisecond").toISOString() : Et(H(b), o, s).toISOString();
+  return t.map((b) => {
+    if (!l.has(b.id)) return b;
+    switch (r) {
+      case "bar":
+        return {
+          ...b,
+          startDate: D(b.startDate),
+          endDate: D(b.endDate)
+        };
+      case "left":
+        return { ...b, startDate: p.toISOString() };
+      default:
+        return { ...b, endDate: d.toISOString() };
+    }
+  });
+}
+function Yo(t, n, r, o) {
+  if (!Dt(n, o).canChangeProgress) return null;
+  const s = Gt(n.progress);
+  if (s === null) return null;
+  const e = Math.min(100, Math.max(0, s + r));
+  return e === s ? null : t.map(
+    (a) => a.id === n.id ? { ...a, progress: e } : a
+  );
+}
+function Ho(t, n, r) {
+  if (!Dt(n, r).canMove) return null;
+  const o = new Set(ie(t, n.id));
+  if (!o.size) return null;
+  const s = t.filter((e) => !o.has(e.id));
+  return s.length === t.length ? null : s;
+}
+function Ee(t, n) {
+  var r;
+  return n && !!((r = t.tasks[0]) != null && r.isSummary);
+}
+function on(t) {
+  return H(t.endDate).valueOf();
+}
+function Co(t) {
+  if (t.length < 2) return t.length ? [[...t]] : [];
+  const n = t.map((s, e) => ({ task: s, index: e })).sort((s, e) => {
+    const a = H(s.task.startDate).valueOf() - H(e.task.startDate).valueOf();
+    return a !== 0 ? a : s.index - e.index;
+  }), r = [], o = [];
+  for (const { task: s } of n) {
+    const e = H(s.startDate).valueOf(), a = o.findIndex((i) => i <= e);
+    a === -1 ? (r.push([s]), o.push(on(s))) : (r[a].push(s), o[a] = Math.max(o[a], on(s)));
+  }
+  return r;
+}
+function Fo(t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const s of t) {
+    if (!s.lane) continue;
+    const e = n.get(s.lane);
+    e ? e.push(s) : n.set(s.lane, [s]);
+  }
+  if (!n.size) return t.map((s) => [s]);
+  const r = [], o = /* @__PURE__ */ new Set();
+  for (const s of t) {
+    if (!s.lane) {
+      r.push([s]);
+      continue;
+    }
+    o.has(s.lane) || (o.add(s.lane), r.push(...Co(n.get(s.lane) ?? [])));
+  }
+  return r;
+}
+function Uo(t) {
+  const n = Fo(t), r = n.map((i) => i.map((c) => c.id).join("+")), o = [], s = /* @__PURE__ */ new Map(), e = [];
+  n.forEach((i, c) => {
+    const u = i[0].depth, l = u === 0 ? "" : e[u - 1] ?? "";
+    o.push(l), s.set(l, (s.get(l) ?? 0) + 1), e[u] = r[c], e.length = u + 1;
+  });
+  const a = /* @__PURE__ */ new Map();
+  return n.map((i, c) => {
+    const u = o[c], l = (a.get(u) ?? 0) + 1;
+    a.set(u, l);
+    const f = i[0].depth, h = c + 1;
+    return {
+      id: r[c],
+      // Only rewrapped when the row number moved, so unchanged tasks keep identity
+      tasks: i.map((w) => w.order === h ? w : { ...w, order: h }),
+      depth: f,
+      level: f + 1,
+      posinset: l,
+      setsize: s.get(u) ?? 1
+    };
+  });
+}
+function Wo({
+  rows: t,
+  virtualItems: n,
+  totalHeight: r,
+  width: o,
+  showRowNumbers: s,
+  hierarchy: e,
+  collapsedIds: a,
+  onToggleCollapse: i,
+  focus: c,
+  reorderEnabled: u,
+  interaction: l,
+  move: f,
+  selectedTaskId: h,
+  onRowClick: w,
+  onRowDoubleClick: p
+}) {
+  const d = Z(null), { onGripPointerDown: m, draft: D } = Lo({
+    rows: t,
+    virtualItems: n,
+    bodyRef: d,
+    hierarchy: e,
+    move: f
+  }), b = D ? n.find((S) => S.index === D.rowIndex) : void 0;
+  return /* @__PURE__ */ J(
+    "div",
+    {
+      className: "gantt-grid",
+      style: { width: `${o}px` },
+      role: "presentation",
+      children: [
+        /* @__PURE__ */ J(
+          "div",
+          {
+            className: "gantt-grid-header",
+            style: { height: `${gr}px` },
+            role: "row",
+            "aria-rowindex": 1,
+            children: [
+              /* @__PURE__ */ P("div", { className: "gantt-grid-header-cell", role: "columnheader", children: /* @__PURE__ */ P("span", { className: "gantt-sr-only", children: "Task name" }) }),
+              /* @__PURE__ */ P("span", { className: "gantt-sr-only", role: "columnheader", children: "Timeline" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ J(
+          "div",
+          {
+            ref: d,
+            className: "gantt-grid-body",
+            style: { height: `${r}px` },
+            role: "rowgroup",
+            children: [
+              n.map((S) => {
+                const L = t[S.index];
+                if (!L) return null;
+                const N = L.tasks[0], x = Ee(L, e), _ = a.has(L.id), A = c.row === S.index, v = Rn(L, S.index, {
+                  headerOffset: 1,
+                  expandable: x,
+                  expanded: !_,
+                  ownedIds: L.tasks.map((F) => `task-${F.id}`)
+                }), g = {
+                  height: `${S.size}px`,
+                  transform: `translateY(${S.start}px)`
+                };
+                if (!N) return null;
+                const R = u && L.tasks.length === 1 && Dt(N, l).canReorder;
+                return /* @__PURE__ */ P(
+                  "div",
+                  {
+                    "data-row-id": L.id,
+                    className: [
+                      "gantt-grid-row",
+                      N.isSummary ? "summary" : "",
+                      N.id === h ? "selected" : "",
+                      N.id === (D == null ? void 0 : D.taskId) ? "dragging" : "",
+                      N.className ?? ""
+                    ].filter(Boolean).join(" "),
+                    style: g,
+                    onClick: w && ((F) => w(N, F)),
+                    onDoubleClick: p && ((F) => p(N, F)),
+                    ...v,
+                    children: /* @__PURE__ */ J(
+                      "div",
+                      {
+                        className: "gantt-grid-cell",
+                        title: N.name,
+                        role: "gridcell",
+                        tabIndex: A && c.col === 0 ? 0 : -1,
+                        "data-gantt-cell": `${S.index}:0`,
+                        children: [
+                          u && (R ? /* @__PURE__ */ P(
+                            "button",
+                            {
+                              type: "button",
+                              className: "gantt-grid-grip",
+                              onPointerDown: (F) => {
+                                F.stopPropagation(), m(S.index, F);
+                              },
+                              tabIndex: -1,
+                              "aria-hidden": "true",
+                              children: /* @__PURE__ */ J("svg", { viewBox: "0 0 12 12", "aria-hidden": "true", children: [
+                                /* @__PURE__ */ P("circle", { cx: "4.5", cy: "2.5", r: "1.1" }),
+                                /* @__PURE__ */ P("circle", { cx: "7.5", cy: "2.5", r: "1.1" }),
+                                /* @__PURE__ */ P("circle", { cx: "4.5", cy: "6", r: "1.1" }),
+                                /* @__PURE__ */ P("circle", { cx: "7.5", cy: "6", r: "1.1" }),
+                                /* @__PURE__ */ P("circle", { cx: "4.5", cy: "9.5", r: "1.1" }),
+                                /* @__PURE__ */ P("circle", { cx: "7.5", cy: "9.5", r: "1.1" })
+                              ] })
+                            }
+                          ) : (
+                            // Holds the space so the row's text does not jog
+                            /* @__PURE__ */ P("span", { className: "gantt-grid-grip-spacer" })
+                          )),
+                          s && /* @__PURE__ */ P("span", { className: "gantt-grid-no", children: N.sequence }),
+                          /* @__PURE__ */ P(
+                            "span",
+                            {
+                              className: "gantt-grid-indent",
+                              style: { width: `${L.depth * Be}px` }
+                            }
+                          ),
+                          x ? /* @__PURE__ */ P(
+                            "button",
+                            {
+                              type: "button",
+                              className: `gantt-grid-expander${_ ? "" : " open"}`,
+                              onClick: (F) => {
+                                F.stopPropagation(), i(L.id);
+                              },
+                              tabIndex: -1,
+                              "aria-hidden": "true",
+                              children: /* @__PURE__ */ P("svg", { viewBox: "0 0 12 12", "aria-hidden": "true", children: /* @__PURE__ */ P("path", { d: "M4 2.5 L8 6 L4 9.5" }) })
+                            }
+                          ) : (
+                            // Holds the space so untoggled rows start their text in the same place
+                            /* @__PURE__ */ P("span", { className: "gantt-grid-expander-spacer" })
+                          ),
+                          /* @__PURE__ */ P("span", { className: "gantt-grid-cell-text", children: N.name }),
+                          L.tasks.length > 1 && /* @__PURE__ */ J("span", { className: "gantt-grid-lane-count", children: [
+                            "+",
+                            L.tasks.length - 1
+                          ] })
+                        ]
+                      }
+                    )
+                  },
+                  `grid-row-${L.id}`
+                );
+              }),
+              D && b && /* @__PURE__ */ P(
+                "div",
+                {
+                  className: [
+                    "gantt-grid-drop",
+                    D.mode === "child" ? "child" : "",
+                    D.rejection ? "blocked" : ""
+                  ].filter(Boolean).join(" "),
+                  style: D.mode === "child" ? { top: `${b.start}px`, height: `${b.size}px` } : {
+                    top: `${b.start + (D.mode === "after" ? b.size : 0)}px`,
+                    marginLeft: `${D.depth * Be}px`
+                  },
+                  "aria-hidden": "true"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function sn(t, n) {
+  return !t && !n ? null : {
+    min: t ? H(t) : void 0,
+    max: n ? H(n) : void 0
+  };
+}
+function Go(t, n = {}, r, o) {
+  const s = yt(), e = Z(null), a = Z(null), i = Z(!1), c = Z(null), u = Z(n);
+  u.current = n, it(() => () => {
+    var L;
+    return (L = c.current) == null ? void 0 : L.call(c);
+  }, []);
+  const l = Q((L) => L.selectedScale), { basePxPerDragStep: f } = dt[l], { canMove: h, canResize: w, minDate: p, maxDate: d } = Dt(
+    t,
+    r
+  ), m = (L) => {
+    const N = L.currentTarget.getBoundingClientRect(), x = L.pointerType !== "mouse", _ = x ? yn : Wt, A = x ? vr : ke;
+    if (w && N.width >= A) {
+      const v = L.clientX - N.left;
+      if (v <= _) return "left";
+      if (v >= N.width - _) return "right";
+    }
+    return h ? "bar" : null;
+  }, D = (L) => {
+    var v;
+    if (!L.isPrimary || L.button !== 0 || e.current) return;
+    (v = c.current) == null || v.call(c), c.current = null;
+    const N = m(L);
+    if (!N) return;
+    const x = L.currentTarget, { pointerId: _, pointerType: A } = L;
+    c.current = le(
+      { pointerType: A, pointerId: _, clientX: L.clientX, clientY: L.clientY },
+      (g) => {
+        c.current = null, b(N, _, A, g, x);
+      }
+    );
+  }, b = (L, N, x, _, A) => {
+    a.current = L, i.current = !1;
+    const v = A.closest(
+      ".gantt-scroll-container"
+    ), g = s.getState().rawTasks, R = t.isSummary ? ie(g, t.id) : [t.id], F = new Set(R), U = new Map(
+      g.filter((O) => F.has(O.id)).map((O) => [
+        O.id,
+        { start: H(O.startDate), end: H(O.endDate) }
+      ])
+    );
+    U.set(t.id, {
+      start: H(t.startDate),
+      end: H(t.endDate)
+    });
+    const T = sn(p, d), M = [];
+    for (const O of g) {
+      if (!F.has(O.id)) continue;
+      const G = U.get(O.id);
+      if (!G) continue;
+      const B = Dt(O, r), ct = O.id === t.id ? T : sn(B.minDate, B.maxDate);
+      ct && M.push({
+        start: G.start,
+        end: G.end,
+        bounds: ct
+      });
+    }
+    e.current = {
+      mode: L,
+      pointerId: N,
+      initialClientX: _,
+      initialStartDate: H(t.startDate),
+      initialEndDate: H(t.endDate),
+      initialBarWidth: t.barWidth,
+      dragSteps: 0,
+      basePxPerDragStep: f,
+      lastClientX: _,
+      autoScrollPx: 0,
+      scaleKey: l,
+      taskId: t.id,
+      taskIds: R,
+      initialDates: U,
+      snapDays: 0,
+      bounds: T,
+      boundedMembers: M,
+      moveDeltaMs: null,
+      clamped: null
+    }, s.getState().setCurrentTask(t), s.getState().setDragMode(L), A.focus({ preventScroll: !0 });
+    try {
+      A.setPointerCapture(N);
+    } catch {
+    }
+    const I = x === "mouse" ? null : ue(), y = () => {
+      const O = e.current;
+      if (!O) return;
+      const G = O.lastClientX - O.initialClientX + O.autoScrollPx, B = Math.round(G / O.basePxPerDragStep), ct = Math.floor(
+        (O.initialBarWidth - O.basePxPerDragStep) / O.basePxPerDragStep
+      );
+      let st = B;
+      if (O.mode === "left" && (st = Math.min(B, ct)), O.mode === "right" && (st = Math.max(B, -ct)), st === O.dragSteps) return;
+      O.dragSteps = st, i.current = !0;
+      const bt = st * O.basePxPerDragStep, at = (W) => Et(W, st, O.scaleKey);
+      let nt, K, V = 0, $t = 0;
+      switch (O.mode) {
+        case "bar":
+          nt = at(O.initialStartDate), K = at(O.initialEndDate), V = bt, $t = 0;
+          break;
+        case "left":
+          nt = at(O.initialStartDate), K = O.initialEndDate, V = bt, $t = -bt;
+          break;
+        case "right":
+          nt = O.initialStartDate, K = at(O.initialEndDate), V = 0, $t = bt;
+          break;
+      }
+      let lt = 0;
+      if (o != null && o.skipsNonWorkingDays) {
+        const W = O.mode === "right" ? K : nt, et = o.snapForward(W);
+        lt = et.diff(W, "day"), O.mode === "left" && et.valueOf() >= K.valueOf() && (lt = 0);
+      }
+      O.snapDays = lt;
+      const St = lt ? pe(
+        nt,
+        nt.add(lt, "day"),
+        O.scaleKey
+      ) : 0;
+      if (lt && (O.mode !== "right" && (nt = nt.add(lt, "day"), V += St), O.mode !== "left" && (K = K.add(lt, "day")), O.mode === "left" && ($t -= St), O.mode === "right" && ($t += St)), O.mode === "bar") {
+        if (O.boundedMembers.length) {
+          const W = nt.valueOf() - O.initialStartDate.valueOf(), et = kn(
+            O.boundedMembers,
+            W,
+            O.scaleKey
+          );
+          O.moveDeltaMs = et, nt = O.initialStartDate.add(et, "millisecond"), K = O.initialEndDate.add(et, "millisecond");
+        }
+      } else if (O.bounds) {
+        const W = Te(
+          O.mode,
+          nt,
+          K,
+          O.bounds,
+          O.scaleKey
+        );
+        O.clamped = W, nt = W.startDate, K = W.endDate;
+      }
+      if (O.moveDeltaMs !== null || O.clamped) {
+        const W = pe(
+          O.initialStartDate,
+          nt,
+          O.scaleKey
+        ), et = pe(
+          O.initialEndDate,
+          K,
+          O.scaleKey
+        );
+        V = W, $t = et - W;
+      }
+      const Mt = O.moveDeltaMs !== null ? (W) => W.add(O.moveDeltaMs, "millisecond") : (W) => at(W).add(lt, "day"), Ot = O.moveDeltaMs !== null ? V : bt + St, Y = {};
+      for (const W of O.taskIds) {
+        const et = O.initialDates.get(W), mt = W === O.taskId || !et, ft = mt ? nt : Mt(et.start), Bt = mt ? K : Mt(et.end);
+        Y[W] = {
+          offsetX: mt ? V : Ot,
+          offsetWidth: mt ? $t : 0,
+          offsetStartDate: ft,
+          offsetEndDate: Bt
+        };
+      }
+      s.getState().setDragOffsets(Y);
+    };
+    let $ = null, k = 0;
+    const E = () => {
+      $ !== null && cancelAnimationFrame($), $ = null, k = 0;
+    }, C = (O) => {
+      !v || !O.autoScrollPx || (v.scrollBy({ left: -O.autoScrollPx, behavior: "smooth" }), O.autoScrollPx = 0);
+    }, X = () => {
+      $ = null;
+      const O = e.current;
+      if (!O || !v || k === 0) return;
+      const G = v.scrollLeft;
+      v.scrollLeft = G + k;
+      const B = v.scrollLeft - G;
+      B !== 0 && (O.autoScrollPx += B, y()), $ = requestAnimationFrame(X);
+    }, q = (O) => {
+      if (u.current.autoScroll === !1 || !v) return;
+      const G = v.getBoundingClientRect(), B = v.querySelector(".gantt-grid");
+      k = be(
+        O,
+        G.left + ((B == null ? void 0 : B.offsetWidth) ?? 0),
+        G.right
+      ), k === 0 ? E() : $ === null && ($ = requestAnimationFrame(X));
+    }, tt = (O) => {
+      const G = e.current;
+      !G || O.pointerId !== G.pointerId || (G.lastClientX = O.clientX, q(O.clientX), y());
+    }, rt = () => {
+      E(), document.removeEventListener("pointermove", tt), document.removeEventListener("pointerup", gt), document.removeEventListener("pointercancel", ot), I == null || I();
+    }, wt = (O) => {
+      C(O), e.current = null, a.current = null, s.getState().setCurrentTask(null), s.getState().setDragMode(null), s.getState().clearDragOffsets(O.taskIds);
+    }, ot = (O) => {
+      const G = e.current;
+      G && O.pointerId !== G.pointerId || (rt(), G && wt(G));
+    }, gt = (O) => {
+      var lt, St, Mt, Ot;
+      const G = e.current;
+      if (G && O.pointerId !== G.pointerId) return;
+      rt();
+      const B = G;
+      if (!B)
+        return;
+      if (B.dragSteps === 0) {
+        wt(B);
+        return;
+      }
+      const ct = s.getState().rawTasks, st = (Y) => B.moveDeltaMs !== null ? H(Y).add(B.moveDeltaMs, "millisecond").toISOString() : Et(H(Y), B.dragSteps, B.scaleKey).add(B.snapDays, "day").toISOString(), bt = (lt = B.clamped) == null ? void 0 : lt.startDate.toISOString(), at = (St = B.clamped) == null ? void 0 : St.endDate.toISOString(), nt = new Set(B.taskIds), K = ct.map((Y) => {
+        if (!nt.has(Y.id)) return Y;
+        switch (B.mode) {
+          case "bar":
+            return {
+              ...Y,
+              startDate: st(Y.startDate),
+              endDate: st(Y.endDate)
+            };
+          case "left":
+            return {
+              ...Y,
+              startDate: bt ?? st(Y.startDate)
+            };
+          case "right":
+            return {
+              ...Y,
+              endDate: at ?? st(Y.endDate)
+            };
+        }
+      });
+      e.current = null, a.current = null, s.getState().setCurrentTask(null), s.getState().setDragMode(null);
+      const V = new Map(
+        K.filter((Y) => nt.has(Y.id)).map((Y) => [Y.id, Y])
+      ), $t = s.getState().rawTasks.map((Y) => V.get(Y.id) ?? Y);
+      s.getState().setRawTasks($t), (Ot = (Mt = u.current).onTasksChange) == null || Ot.call(Mt, $t);
+    };
+    document.addEventListener("pointermove", tt), document.addEventListener("pointerup", gt), document.addEventListener("pointercancel", ot);
+  }, S = () => i.current ? (i.current = !1, !0) : !1;
+  return {
+    onPointerDown: D,
+    dragMode: a.current,
+    consumeDragClick: S
+  };
+}
+const $e = {
+  hoverTaskId: null,
+  hoverAnchor: null,
+  rejection: null
+};
+function Xo({
+  task: t,
+  interaction: n,
+  onTasksChange: r,
+  onDependencyCreate: o
+}) {
+  const s = yt(), e = Z(null), a = Z(null);
+  return it(() => () => {
+    var c;
+    return (c = a.current) == null ? void 0 : c.call(a);
+  }, []), { startLink: (c) => (u) => {
+    if (!u.isPrimary || u.button !== 0 || e.current !== null) return;
+    u.stopPropagation(), u.preventDefault();
+    const l = u.currentTarget, f = l.closest(".gantt-content"), h = l.closest(".gantt-scroll-container");
+    if (!f) return;
+    const w = u.pointerId;
+    e.current = w;
+    try {
+      l.setPointerCapture(w);
+    } catch {
+    }
+    const p = u.clientX, d = u.clientY;
+    let m = !1, D = p, b = d;
+    const S = document.body.style.cursor, L = ($, k) => {
+      const E = f.getBoundingClientRect(), C = po(
+        s.getState().rowTasks,
+        $ - E.left,
+        k - E.top,
+        xt,
+        br
+      );
+      if (!C) return $e;
+      const X = s.getState().rawTasks, q = X.find((rt) => rt.id === C.task.id);
+      return C.task.id === t.id || q !== void 0 && Dt(q, n).canCreateLink ? {
+        hoverTaskId: C.task.id,
+        hoverAnchor: C.anchor,
+        rejection: go(X, t.id, C.task.id)
+      } : $e;
+    }, N = ($, k) => {
+      const E = f.getBoundingClientRect();
+      s.getState().setLinkDraft({
+        fromTaskId: t.id,
+        fromAnchor: c,
+        toX: $ - E.left,
+        toY: k - E.top,
+        ...L($, k)
+      });
+    };
+    let x = null, _ = 0, A = 0;
+    const v = () => {
+      x !== null && cancelAnimationFrame(x), x = null, _ = 0, A = 0;
+    }, g = () => {
+      if (x = null, !h || _ === 0 && A === 0) return;
+      const $ = h.scrollLeft, k = h.scrollTop;
+      if (h.scrollLeft = $ + _, h.scrollTop = k + A, h.scrollLeft === $ && h.scrollTop === k) {
+        v();
+        return;
+      }
+      N(D, b), x = requestAnimationFrame(g);
+    }, R = ($, k) => {
+      if (!h) return;
+      const E = h.getBoundingClientRect(), C = h.querySelector(".gantt-grid");
+      _ = be(
+        $,
+        E.left + ((C == null ? void 0 : C.offsetWidth) ?? 0),
+        E.right
+      ), A = be(k, E.top, E.bottom), _ === 0 && A === 0 ? v() : x === null && (x = requestAnimationFrame(g));
+    }, F = ($) => {
+      if ($.pointerId === w) {
+        if (D = $.clientX, b = $.clientY, !m) {
+          if (Math.abs(D - p) < je && Math.abs(b - d) < je)
+            return;
+          m = !0, s.getState().setSelectedDependency(null), document.body.style.cursor = "crosshair";
+        }
+        R(D, b), N(D, b);
+      }
+    }, U = () => {
+      v(), document.body.style.cursor = S, document.removeEventListener("pointermove", F), document.removeEventListener("pointerup", y), document.removeEventListener("pointercancel", M), document.removeEventListener("keydown", I);
+      try {
+        l.releasePointerCapture(w);
+      } catch {
+      }
+    }, T = () => {
+      U(), a.current = null, e.current = null, s.getState().setLinkDraft(null);
+    }, M = ($) => {
+      $.pointerId === w && T();
+    };
+    function I($) {
+      $.key === "Escape" && T();
+    }
+    function y($) {
+      if ($.pointerId !== w) return;
+      const E = m ? L($.clientX, $.clientY) : $e;
+      if (T(), !E.hoverTaskId || !E.hoverAnchor || E.rejection) return;
+      const C = {
+        predecessorId: t.id,
+        successorId: E.hoverTaskId,
+        type: An(c, E.hoverAnchor)
+      };
+      if ((o == null ? void 0 : o(C)) === !1) return;
+      const X = Do(
+        s.getState().rawTasks,
+        C.predecessorId,
+        C.successorId,
+        C.type
+      );
+      s.getState().setRawTasks(X), r == null || r(X);
+    }
+    a.current = T, document.addEventListener("pointermove", F), document.addEventListener("pointerup", y), document.addEventListener("pointercancel", M), document.addEventListener("keydown", I);
+  } };
+}
+function Bo(t, n, r = {}) {
+  const o = yt(), [s, e] = ut(null), a = Z(null), i = Z(null);
+  it(() => () => {
+    var h;
+    return (h = i.current) == null ? void 0 : h.call(i);
+  }, []);
+  const c = (h) => {
+    const w = n.current;
+    if (!w) return null;
+    const p = w.getBoundingClientRect();
+    if (p.width === 0) return null;
+    const d = (h - p.left) / p.width;
+    return Math.round(Math.min(1, Math.max(0, d)) * 100);
+  }, { onTasksChange: u } = r, l = (h) => {
+    var p;
+    h.stopPropagation(), h.preventDefault(), (p = i.current) == null || p.call(i), i.current = null;
+    const { pointerType: w } = h;
+    i.current = le(
+      {
+        pointerType: w,
+        pointerId: h.pointerId,
+        clientX: h.clientX,
+        clientY: h.clientY
+      },
+      () => {
+        i.current = null, f(w);
+      }
+    );
+  }, f = (h) => {
+    const w = h === "mouse" ? null : ue(), p = (m) => {
+      const D = c(m.clientX);
+      D !== null && (a.current = D, e(D));
+    }, d = () => {
+      document.removeEventListener("pointermove", p), document.removeEventListener("pointerup", d), document.removeEventListener("pointercancel", d), w == null || w();
+      const m = a.current;
+      if (a.current = null, m === null) {
+        e(null);
+        return;
+      }
+      const D = o.getState().rawTasks.map(
+        (b) => b.id === t.id ? { ...b, progress: m } : b
+      );
+      o.getState().setRawTasks(D), e(null), u == null || u(D);
+    };
+    document.addEventListener("pointermove", p), document.addEventListener("pointerup", d), document.addEventListener("pointercancel", d);
+  };
+  return {
+    onProgressPointerDown: l,
+    progress: s ?? Gt(t.progress),
+    isDraggingProgress: s !== null
+  };
+}
+function zo({
+  currentTask: t,
+  options: n,
+  interaction: r,
+  tabIndex: o,
+  cellCoord: s,
+  calendar: e,
+  autoScrollOnDrag: a,
+  onDependencyCreate: i
+}) {
+  const {
+    onTasksChange: c,
+    onTaskClick: u,
+    onTaskDoubleClick: l,
+    showTooltip: f = !0
+  } = n, h = Z(null), { onPointerDown: w, dragMode: p, consumeDragClick: d } = Go(
+    t,
+    { onTasksChange: c, autoScroll: a },
+    r,
+    e
+  ), { canMove: m, canResize: D, canChangeProgress: b, canCreateLink: S } = Dt(t, r), [L, N] = ut(!1), [x, _] = ut(!1), A = yt(), v = Q((Y) => Y.setHoveredTaskId), g = Z(null), R = z(() => {
+    g.current !== null && (clearTimeout(g.current), g.current = null);
+  }, []);
+  it(() => {
+    const Y = t.id;
+    return () => {
+      R(), A.getState().hoveredTaskId === Y && A.getState().setHoveredTaskId(null);
+    };
+  }, [t.id, R, A]);
+  const { startLink: F } = Xo({
+    task: t,
+    interaction: r,
+    onTasksChange: c,
+    onDependencyCreate: i
+  }), U = Q((Y) => {
+    const W = Y.linkDraft;
+    return W ? W.hoverTaskId === t.id ? ` link-${W.rejection ? "invalid" : "valid"} link-at-${W.hoverAnchor}` : W.fromTaskId === t.id ? ` link-source link-at-${W.fromAnchor}` : "" : "";
+  }), T = S && /* @__PURE__ */ P(we, { children: ["start", "end"].map((Y) => /* @__PURE__ */ P(
+    "span",
+    {
+      className: `gantt-link-handle ${Y}`,
+      onPointerDown: F(Y),
+      role: "button",
+      tabIndex: -1,
+      "aria-label": `Link from the ${Y} of ${t.name}`
+    },
+    Y
+  )) }), M = Q((Y) => Y.dragOffsets[t.id]), I = Q((Y) => {
+    var W;
+    return ((W = Y.currentTask) == null ? void 0 : W.id) === t.id;
+  }), y = Q((Y) => Y.selectedScale), $ = Q((Y) => Y.localeOptions), k = Q(
+    (Y) => Y.selectedTaskId === t.id
+  ), E = (M == null ? void 0 : M.offsetX) ?? 0, C = (M == null ? void 0 : M.offsetWidth) ?? 0, X = t.barLeft + E, q = t.barWidth + C, tt = Math.max(q, yr), rt = tt < wr, { onProgressPointerDown: wt, progress: ot, isDraggingProgress: gt } = Bo(t, h, {
+    onTasksChange: c
+  }), O = ot !== null, G = z(
+    (Y) => {
+      const W = h.current;
+      if (!W) return;
+      const et = W.getBoundingClientRect();
+      if (et.width < ke) {
+        N(!1);
+        return;
+      }
+      const mt = Y.clientX - et.left;
+      N(
+        mt <= Wt || mt >= et.width - Wt
+      );
+    },
+    []
+  ), B = (Y) => {
+    d() || u == null || u(t, Y);
+  }, ct = (Y) => {
+    l == null || l(t, Y);
+  }, st = m ? "grab" : "default", bt = I ? m || D ? "grabbing" : st : L && D ? "ew-resize" : st, { tooltip: at } = j(
+    () => Yt(y, $),
+    [y, $]
+  ), nt = Nn(
+    t,
+    at,
+    O ? ot : null
+  ), K = (Y) => {
+    if (!M) return "";
+    const W = at(M.offsetStartDate), et = at(M.offsetEndDate);
+    switch (Y) {
+      case "left":
+        return `Start: ${W}`;
+      case "right":
+        return `End: ${et}`;
+      case "bar":
+      default:
+        return `${W} → ${et}`;
+    }
+  }, V = f ? gt ? "progress" : I && M ? p === "left" || p === "right" ? "resize" : "move" : x ? "hover" : null : null;
+  it(() => {
+    if (!x) return;
+    const Y = (W) => {
+      W.key === "Escape" && _(!1);
+    };
+    return document.addEventListener("keydown", Y), () => document.removeEventListener("keydown", Y);
+  }, [x]);
+  const $t = () => {
+    if (!V) return null;
+    const Y = V !== "hover", W = Y && M ? M.offsetStartDate : H(t.startDate), et = Y && M ? M.offsetEndDate : H(t.endDate);
+    return V === "progress" ? /* @__PURE__ */ J("div", { className: "gantt-bar-tooltip", role: "status", "aria-live": "polite", children: [
+      ot,
+      "%"
+    ] }) : Y ? /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-bar-tooltip gantt-sr-only",
+        role: "status",
+        "aria-live": "polite",
+        children: K(p)
+      }
+    ) : /* @__PURE__ */ J("div", { className: "gantt-bar-tooltip gantt-bar-tooltip-detail", role: "tooltip", children: [
+      /* @__PURE__ */ P("span", { className: "gantt-tooltip-name", children: t.name }),
+      /* @__PURE__ */ P("span", { className: "gantt-tooltip-meta", children: `${at(W)} → ${at(et)}` }),
+      /* @__PURE__ */ J("span", { className: "gantt-tooltip-meta", children: [
+        xn(et.valueOf() - W.valueOf()),
+        ot !== null ? ` · ${ot}%` : ""
+      ] })
+    ] });
+  }, lt = lo(t.color), St = {
+    transform: `translateX(${X}px)`,
+    width: tt,
+    height: t.isSummary ? pr : ve,
+    cursor: bt,
+    ...lt
+  }, Mt = [
+    k ? "selected" : "",
+    t.className ?? ""
+  ].filter(Boolean).join(" "), Ot = Mt ? ` ${Mt}` : "";
+  return /* @__PURE__ */ J(
+    "div",
+    {
+      ref: h,
+      id: `task-${t.id}`,
+      "data-task-id": t.id,
+      className: `gantt-task-bar${I ? " dragging" : ""}${V ? " has-tooltip" : ""}${rt ? " compact" : ""}${t.isSummary ? " summary" : ""}${D ? "" : " no-resize"}${U}${Ot}`,
+      onPointerDown: w,
+      onClick: B,
+      onDoubleClick: ct,
+      onMouseMove: G,
+      onPointerEnter: (Y) => {
+        Y.pointerType === "mouse" && (v(t.id), R(), g.current = setTimeout(
+          () => _(!0),
+          Sr
+        ));
+      },
+      onMouseLeave: () => {
+        N(!1), v(null), R(), _(!1);
+      },
+      style: St,
+      role: "gridcell",
+      tabIndex: o,
+      "data-gantt-cell": s,
+      "aria-label": nt,
+      children: [
+        O && /* @__PURE__ */ J(we, { children: [
+          /* @__PURE__ */ P(
+            "div",
+            {
+              className: "gantt-progress-fill",
+              style: { width: `${ot}%` }
+            }
+          ),
+          b && /* @__PURE__ */ P(
+            "div",
+            {
+              className: `gantt-progress-handle${gt ? " dragging" : ""}`,
+              style: {
+                left: `clamp(${ze}px, ${ot}%, calc(100% - ${ze}px))`
+              },
+              onPointerDown: wt,
+              role: "slider",
+              tabIndex: -1,
+              "aria-label": `${t.name} progress`,
+              "aria-valuemin": 0,
+              "aria-valuemax": 100,
+              "aria-valuenow": ot
+            }
+          )
+        ] }),
+        /* @__PURE__ */ P(
+          "span",
+          {
+            className: `gantt-task-name${rt ? " outside" : ""}`,
+            children: t.name
+          }
+        ),
+        T,
+        $t()
+      ]
+    }
+  );
+}
+function jo({
+  rows: t,
+  virtualItems: n,
+  gridColumnCount: r,
+  focus: o,
+  isBarVisible: s,
+  options: e,
+  interaction: a,
+  calendar: i,
+  autoScrollOnDrag: c,
+  onDependencyCreate: u
+}) {
+  return n.flatMap((l) => {
+    const f = t[l.index];
+    return f ? f.tasks.map((h, w) => {
+      if (!s(h.barLeft, h.barWidth)) return null;
+      const p = r + w;
+      return (
+        // styles.css lifts this wrapper's z-index while its bar has a tooltip or is being
+        // dragged; any opaque stacking context here would trap the subtree (test-guarded).
+        /* @__PURE__ */ P(
+          "div",
+          {
+            className: "gantt-bar-wrap",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              height: `${l.size - 1}px`,
+              transform: `translateY(${l.start}px)`,
+              display: "flex",
+              alignItems: "center"
+            },
+            children: /* @__PURE__ */ P(
+              zo,
+              {
+                currentTask: h,
+                options: e,
+                interaction: a,
+                calendar: i,
+                autoScrollOnDrag: c,
+                onDependencyCreate: u,
+                tabIndex: o.row === l.index && o.col === p ? 0 : -1,
+                cellCoord: `${l.index}:${p}`
+              }
+            )
+          },
+          h.id
+        )
+      );
+    }) : [];
+  });
+}
+function qo({
+  ranges: t
+}) {
+  const n = Q((s) => s.bottomRowCells), r = j(
+    () => Dn(n),
+    [n]
+  ), o = j(() => {
+    const s = /* @__PURE__ */ new Set();
+    return t.flatMap((e) => {
+      if (!e.label) return [];
+      const a = se(r, e.left), i = se(r, e.left + e.width - 1);
+      if (!a || !i) return [];
+      const c = e.width >= Ir && !s.has(a.index);
+      return c && s.add(a.index), [
+        {
+          label: e.label,
+          shown: c,
+          left: e.left,
+          width: e.width,
+          // Relative to the band, which is what the hover target is positioned at
+          cellLeft: a.left - e.left,
+          cellWidth: i.left + i.width - a.left
+        }
+      ];
+    });
+  }, [t, r]);
+  return o.length ? /* @__PURE__ */ P("div", { className: "gantt-holiday-labels", children: o.map((s) => /* @__PURE__ */ P(
+    "div",
+    {
+      className: "gantt-holiday-band",
+      style: { left: `${s.left}px`, width: `${s.width}px` },
+      children: /* @__PURE__ */ P(
+        "div",
+        {
+          className: `gantt-holiday-cell${s.shown ? " shown" : ""}`,
+          style: {
+            left: `${s.cellLeft}px`,
+            width: `${s.cellWidth}px`
+          },
+          children: /* @__PURE__ */ P("span", { children: s.label })
+        }
+      )
+    },
+    s.left
+  )) }) : null;
+}
+function Ko({
+  ranges: t
+}) {
+  return t.length ? /* @__PURE__ */ P("div", { className: "gantt-non-working-layer", "aria-hidden": "true", children: t.map((n) => /* @__PURE__ */ P(
+    "div",
+    {
+      className: "gantt-non-working-range",
+      style: {
+        left: `${n.left}px`,
+        width: `${n.width}px`,
+        ...n.color && {
+          background: `color-mix(in srgb, ${n.color} 14%, transparent)`
+        }
+      }
+    },
+    n.left
+  )) }) : null;
+}
+function Vo({
+  rows: t,
+  virtualItems: n,
+  ownedByTaskList: r,
+  hierarchy: o,
+  collapsedIds: s
+}) {
+  return /* @__PURE__ */ P("div", { className: "gantt-rows", role: "presentation", children: n.map((e) => {
+    const a = t[e.index];
+    if (!a) return null;
+    const i = {
+      // border-box, so the 1px border sits inside the height
+      height: `${e.size}px`,
+      transform: `translateY(${e.start}px)`
+    };
+    return r ? /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-task-row",
+        style: i,
+        "aria-hidden": "true"
+      },
+      `row-${a.id}`
+    ) : /* @__PURE__ */ P(
+      "div",
+      {
+        className: "gantt-task-row",
+        style: i,
+        ...Rn(a, e.index, {
+          headerOffset: 0,
+          expandable: Ee(a, o),
+          expanded: !s.has(a.id),
+          ownedIds: a.tasks.map((c) => `task-${c.id}`)
+        })
+      },
+      `row-${a.id}`
+    );
+  }) });
+}
+const Zo = [];
+function Jo({
+  collapsedIds: t,
+  defaultCollapsedIds: n,
+  onCollapsedChange: r
+}) {
+  const [o, s] = ut(
+    () => n ?? Zo
+  ), e = t ?? o, a = j(() => new Set(e), [e]), i = z(
+    (l) => {
+      t === void 0 && s(l), r == null || r(l);
+    },
+    [t, r]
+  ), c = z(
+    (l) => {
+      i(
+        e.includes(l) ? e.filter((f) => f !== l) : [...e, l]
+      );
+    },
+    [e, i]
+  ), u = z(
+    (l) => {
+      e.includes(l) && i(e.filter((f) => f !== l));
+    },
+    [e, i]
+  );
+  return { collapsedIds: a, toggle: c, expand: u };
+}
+const an = 4;
+function Qo(t, n, r) {
+  const o = Lt(t, n, r) ?? 0, s = Tn(o, o, n, r);
+  return s ? {
+    startDate: s.startDate.toISOString(),
+    endDate: s.endDate.toISOString()
+  } : null;
+}
+function ts(t, n) {
+  const r = n * xt;
+  return t < r ? null : r;
+}
+function es({
+  enabled: t,
+  rowCount: n,
+  onTaskCreate: r
+}) {
+  const o = yt(), [s, e] = ut(null), a = Z(null), i = Z(null), c = (l) => {
+    var w;
+    if (!t || !l.isPrimary || l.button !== 0 || a.current !== null || l.target !== l.currentTarget) return;
+    (w = i.current) == null || w.call(i), i.current = null;
+    const f = l.currentTarget, h = l.pointerId;
+    i.current = le(
+      { pointerType: l.pointerType, pointerId: h, clientX: l.clientX, clientY: l.clientY },
+      (p, d) => {
+        i.current = null, u(f, h, l.pointerType, p, d);
+      }
+    );
+  }, u = (l, f, h, w, p) => {
+    const d = l.getBoundingClientRect(), m = w - d.left, D = ts(p - d.top, n);
+    if (D === null) return;
+    a.current = f;
+    const b = h === "mouse" ? null : ue(), S = (g) => {
+      const { bottomRowCells: R, selectedScale: F } = o.getState(), U = l.getBoundingClientRect();
+      return Tn(
+        m,
+        g - U.left,
+        R,
+        F
+      );
+    }, L = (g) => {
+      if (g.pointerId !== f) return;
+      const R = l.getBoundingClientRect();
+      if (Math.abs(g.clientX - R.left - m) < an) {
+        e(null);
+        return;
+      }
+      const F = S(g.clientX);
+      e(
+        F && {
+          leftPx: F.leftPx,
+          widthPx: F.widthPx,
+          topPx: D
+        }
+      );
+    }, N = () => {
+      document.removeEventListener("pointermove", L), document.removeEventListener("pointerup", v), document.removeEventListener("pointercancel", _), document.removeEventListener("keydown", A);
+    }, x = () => {
+      N(), b == null || b(), a.current = null, e(null);
+    }, _ = (g) => {
+      g.pointerId === f && x();
+    }, A = (g) => {
+      g.key === "Escape" && x();
+    }, v = (g) => {
+      if (g.pointerId !== f) return;
+      const R = l.getBoundingClientRect(), U = Math.abs(g.clientX - R.left - m) >= an ? S(g.clientX) : null;
+      x(), U && (r == null || r({
+        startDate: U.startDate.toISOString(),
+        endDate: U.endDate.toISOString()
+      }));
+    };
+    document.addEventListener("pointermove", L), document.addEventListener("pointerup", v), document.addEventListener("pointercancel", _), document.addEventListener("keydown", A);
+  };
+  return { onDrawPointerDown: c, ghost: s };
+}
+function ns({
+  readOnly: t,
+  allowMove: n,
+  allowResize: r,
+  allowProgressChange: o,
+  allowLinkCreate: s,
+  allowLinkDelete: e,
+  allowTaskCreate: a,
+  allowReorder: i,
+  minDate: c,
+  maxDate: u
+}) {
+  return j(
+    () => ({
+      readOnly: t,
+      allowMove: n,
+      allowResize: r,
+      allowProgressChange: o,
+      allowLinkCreate: s,
+      allowLinkDelete: e,
+      allowTaskCreate: a,
+      allowReorder: i,
+      minDate: c,
+      maxDate: u
+    }),
+    [
+      t,
+      n,
+      r,
+      o,
+      s,
+      e,
+      a,
+      i,
+      c,
+      u
+    ]
+  );
+}
+const rs = 3;
+function os({
+  rows: t,
+  rawTasks: n,
+  gridColumnCount: r,
+  hierarchy: o,
+  collapsedIds: s,
+  selectedScale: e,
+  localeOptions: a,
+  interaction: i,
+  onActivate: c,
+  onToggleCollapse: u,
+  onTasksChange: l,
+  move: f,
+  scrollToRow: h,
+  scrollApi: w,
+  bodyRef: p
+}) {
+  const d = yt(), [m, D] = ut({ row: 0, col: 0 }), [b, S] = ut(0), [L, N] = ut(""), x = j(
+    () => ({
+      row: Math.min(m.row, Math.max(t.length - 1, 0)),
+      col: m.col
+    }),
+    [m, t.length]
+  ), _ = j(
+    () => t.map((U) => ({
+      cells: Math.max(r + U.tasks.length, 1),
+      firstBarCell: r,
+      expandable: Ee(U, o),
+      expanded: !s.has(U.id)
+    })),
+    [t, r, o, s]
+  ), { tooltip: A } = j(
+    () => Yt(e, a),
+    [e, a]
+  ), v = z(
+    (U) => {
+      d.getState().setRawTasks(U), l == null || l(U);
+    },
+    [d, l]
+  ), g = z(
+    (U) => {
+      const T = d.getState().rawTasks, M = oe(T, o), I = M.parentOf.get(U.id) ?? null, y = M.childrenOf(I), $ = T.find((k) => k.id === I);
+      N(
+        Ro(
+          U.name,
+          y.indexOf(U.id) + 1,
+          y.length,
+          ($ == null ? void 0 : $.name) ?? null
+        )
+      ), S((k) => k + 1);
+    },
+    [d, o]
+  ), R = z(
+    (U) => {
+      const T = Ao(U, x, _);
+      if (!T) return;
+      if (U.preventDefault(), T.kind === "zoom") {
+        const $ = In(e, T.direction);
+        $ !== e && (w.setScale($), N(`${$} scale`));
+        return;
+      }
+      const M = t[T.kind === "focus" ? x.row : T.row], I = _[x.row], y = T.kind === "focus" ? void 0 : No(M, T.col, (I == null ? void 0 : I.firstBarCell) ?? 0);
+      switch (T.kind) {
+        case "focus":
+          D(T.focus), S(($) => $ + 1);
+          break;
+        case "toggle":
+          M && u(M.id);
+          break;
+        case "activate":
+          y && (c == null || c(y.id), N(Nn(y, A, null)));
+          break;
+        case "delete": {
+          if (!y) return;
+          const $ = Ho(n, y, i);
+          if (!$) {
+            N(`${y.name} cannot be deleted`);
+            break;
+          }
+          v($), N(`${y.name} deleted`);
+          break;
+        }
+        case "nudge": {
+          if (!y) return;
+          const $ = _o(
+            n,
+            y,
+            T.mode,
+            T.steps,
+            e,
+            i
+          );
+          if (!$) {
+            N(`${y.name} cannot be changed`);
+            break;
+          }
+          v($);
+          const k = $.find((E) => E.id === y.id);
+          k && N(
+            `${y.name}, ${A(H(k.startDate))} to ${A(H(k.endDate))}`
+          ), S((E) => E + 1);
+          break;
+        }
+        case "progress": {
+          if (!y) return;
+          const $ = Yo(
+            n,
+            y,
+            T.delta,
+            i
+          );
+          if (!$) {
+            N(`${y.name} progress cannot be changed`);
+            break;
+          }
+          v($);
+          const k = $.find((E) => E.id === y.id);
+          N(`${y.name}, ${(k == null ? void 0 : k.progress) ?? 0}% complete`), S((E) => E + 1);
+          break;
+        }
+        case "reorder": {
+          if (!y) return;
+          const $ = oe(n, o), k = $.parentOf.get(y.id) ?? null, E = $.childrenOf(k), C = E.indexOf(y.id) + T.delta;
+          if (C < 0 || C >= E.length) break;
+          f.apply({ taskId: y.id, toParentId: k, toIndex: C }) && g(y);
+          break;
+        }
+        case "reparent": {
+          if (!y || !o) return;
+          const $ = oe(n, o), k = $.parentOf.get(y.id) ?? null, E = $.childrenOf(k);
+          if (T.direction > 0) {
+            const q = E[E.indexOf(y.id) - 1];
+            if (!q) break;
+            f.apply({
+              taskId: y.id,
+              toParentId: q,
+              toIndex: $.childrenOf(q).length
+            }) && g(y);
+            break;
+          }
+          if (!k) break;
+          const C = $.parentOf.get(k) ?? null, X = $.childrenOf(C);
+          f.apply({
+            taskId: y.id,
+            toParentId: C,
+            toIndex: X.indexOf(k) + 1
+          }) && g(y);
+          break;
+        }
+      }
+    },
+    [
+      x,
+      _,
+      t,
+      c,
+      u,
+      n,
+      i,
+      e,
+      w,
+      v,
+      A,
+      o,
+      f,
+      g
+    ]
+  ), F = z(
+    (U) => {
+      var y, $, k;
+      const T = (k = ($ = (y = U.target).closest) == null ? void 0 : $.call(y, "[data-gantt-cell]")) == null ? void 0 : k.getAttribute("data-gantt-cell");
+      if (!T) return;
+      const [M, I] = T.split(":").map(Number);
+      D(
+        (E) => E.row === M && E.col === I ? E : { row: M, col: I }
+      );
+    },
+    []
+  );
+  return it(() => {
+    if (!b) return;
+    let U = rs, T = 0;
+    const M = () => {
+      var $, k;
+      const I = ($ = p.current) == null ? void 0 : $.querySelector(
+        `[data-gantt-cell="${x.row}:${x.col}"]`
+      );
+      if (I) {
+        I.focus({ preventScroll: !0 }), I.scrollIntoView({ block: "nearest", inline: "nearest" });
+        return;
+      }
+      if (--U <= 0) return;
+      h(x.row, "auto");
+      const y = (k = t[x.row]) == null ? void 0 : k.tasks[0];
+      y && w.scrollToTask(y.id, { smooth: !1 }), T = requestAnimationFrame(M);
+    };
+    return M(), () => cancelAnimationFrame(T);
+  }, [b]), { focus: x, announcement: L, onKeyDown: R, onFocusCapture: F };
+}
+function ss({
+  rawTasks: t,
+  tasks: n,
+  hierarchy: r,
+  collapsedIds: o
+}) {
+  const s = j(
+    () => r ? Xt(t) : void 0,
+    [r, t]
+  ), e = j(() => !r || !o.size ? n : Gr(n, o, s), [r, o, n, s]), a = j(() => Uo(e), [e]), i = j(() => a.flatMap((c) => c.tasks), [a]);
+  return { rows: a, tasks: i };
+}
+const cn = (t) => Symbol.iterator in t, ln = (t) => (
+  // HACK: avoid checking entries type
+  "entries" in t
+), un = (t, n) => {
+  const r = t instanceof Map ? t : new Map(t.entries()), o = n instanceof Map ? n : new Map(n.entries());
+  if (r.size !== o.size)
+    return !1;
+  for (const [s, e] of r)
+    if (!o.has(s) || !Object.is(e, o.get(s)))
+      return !1;
+  return !0;
+}, as = (t, n) => {
+  const r = t[Symbol.iterator](), o = n[Symbol.iterator]();
+  let s = r.next(), e = o.next();
+  for (; !s.done && !e.done; ) {
+    if (!Object.is(s.value, e.value))
+      return !1;
+    s = r.next(), e = o.next();
+  }
+  return !!s.done && !!e.done;
+};
+function is(t, n) {
+  return Object.is(t, n) ? !0 : typeof t != "object" || t === null || typeof n != "object" || n === null || Object.getPrototypeOf(t) !== Object.getPrototypeOf(n) ? !1 : cn(t) && cn(n) ? ln(t) && ln(n) ? un(t, n) : as(t, n) : un(
+    { entries: () => Object.entries(t) },
+    { entries: () => Object.entries(n) }
+  );
+}
+function cs(t) {
+  const n = Ft.useRef(void 0);
+  return (r) => {
+    const o = t(r);
+    return is(n.current, o) ? n.current : n.current = o;
+  };
+}
+function ls() {
+  return Q(
+    cs((t) => ({
+      rawTasks: t.rawTasks,
+      transformedTasks: t.transformedTasks,
+      bottomRowCells: t.bottomRowCells,
+      selectedScale: t.selectedScale,
+      selectedTaskId: t.selectedTaskId,
+      syncTasksFromProps: t.syncTasksFromProps,
+      setSelectedScale: t.setSelectedScale,
+      setLocaleOptions: t.setLocaleOptions,
+      getTotalWidth: t.getTotalWidth
+    }))
+  );
+}
+function us({
+  selectable: t,
+  onTaskSelect: n,
+  onTaskClick: r
+}) {
+  const o = yt(), s = t ?? n !== void 0, e = z(
+    (i) => {
+      if (!s) return;
+      const c = (i == null ? void 0 : i.id) ?? null;
+      o.getState().selectedTaskId !== c && (o.getState().setSelectedTaskId(c), n == null || n(i));
+    },
+    [s, n, o]
+  ), a = z(
+    (i, c) => {
+      r == null || r(i, c), e(i);
+    },
+    [r, e]
+  );
+  return {
+    select: e,
+    onTaskClick: a
+  };
+}
+function ds(t, n) {
+  const { canResize: r, canChangeProgress: o } = Dt(t, n);
+  return {
+    name: !(t.readOnly ?? (n == null ? void 0 : n.readOnly) ?? !1),
+    dates: r,
+    progress: o
+  };
+}
+function fs(t, n) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(n)) return null;
+  const r = H(`${n}T${H(t).format("HH:mm:ss.SSS")}`);
+  return r.isValid() ? r : null;
+}
+const hs = (t, n, r) => n && t.isBefore(H(n)) ? H(n) : r && t.isAfter(H(r)) ? H(r) : t;
+function ms(t, n, r, o) {
+  switch (n) {
+    case "name":
+      return r.trim() === "" ? null : { name: r };
+    case "progress": {
+      const s = r.trim() === "" ? null : Gt(Number(r));
+      return s === null ? null : { progress: s };
+    }
+    default: {
+      const { minDate: s, maxDate: e } = Dt(t, o), a = fs(t[n], r);
+      if (a === null) return null;
+      const i = hs(a, s, e), c = n === "startDate" ? i : H(t.startDate);
+      return (n === "endDate" ? i : H(t.endDate)).isAfter(c) ? { [n]: i.toISOString() } : null;
+    }
+  }
+}
+function ps(t, n, r) {
+  return t.map(
+    (o) => o.id === n ? { ...o, ...r } : o
+  );
+}
+function gs(t, n, r, o) {
+  const { rawTasks: s, setRawTasks: e } = t.getState(), a = ps(s, n, r);
+  e(a), o == null || o(a);
+}
+function De({ value: t, commit: n, ...r }) {
+  const [o, s] = ut(t), [e, a] = ut(t);
+  e !== t && (a(t), s(t));
+  const i = () => {
+    o !== t && n(o), s(t);
+  };
+  return /* @__PURE__ */ P(
+    "input",
+    {
+      className: "gantt-detail-input",
+      ...r,
+      value: o,
+      onChange: (c) => s(c.target.value),
+      onBlur: i,
+      onKeyDown: (c) => {
+        c.key === "Enter" && i(), c.key === "Escape" && (c.stopPropagation(), s(t));
+      }
+    }
+  );
+}
+function $s({
+  task: t,
+  tasks: n,
+  scale: r,
+  localeOptions: o,
+  interaction: s,
+  onClose: e,
+  onTasksChange: a,
+  render: i,
+  open: c,
+  onTransitionEnd: u
+}) {
+  const l = Z(null), f = yt(), h = gn(), w = Z(null);
+  it(() => {
+    const A = l.current;
+    return w.current = document.activeElement, () => {
+      const v = document.activeElement;
+      if (!(v === null || v === document.body || ((A == null ? void 0 : A.contains(v)) ?? !1))) return;
+      const R = w.current;
+      R instanceof HTMLElement && R.isConnected && R.focus({ preventScroll: !0 });
+    };
+  }, []), it(() => {
+    const A = (v) => {
+      v.key === "Escape" && e();
+    };
+    return document.addEventListener("keydown", A), () => document.removeEventListener("keydown", A);
+  }, [e]);
+  const { tooltip: p } = j(
+    () => Yt(r, o),
+    [r, o]
+  ), d = z(
+    (A) => gs(f, t.id, A, a),
+    [f, t.id, a]
+  ), m = z(
+    (A, v) => {
+      const g = ms(t, A, v, s);
+      g && d(g);
+    },
+    [t, s, d]
+  ), D = ds(t, s), b = Gt(t.progress), S = H(t.startDate), L = H(t.endDate), N = (t.dependencies ?? []).map(
+    (A) => {
+      var v;
+      return ((v = n.find((g) => g.id === A.targetId)) == null ? void 0 : v.name) ?? A.targetId;
+    }
+  ), x = (A, v) => /* @__PURE__ */ P(
+    De,
+    {
+      id: `${h}-${A}`,
+      type: "date",
+      value: H(v).format("YYYY-MM-DD"),
+      commit: (g) => m(A, g)
+    }
+  ), _ = [
+    D.dates ? {
+      caption: "Start",
+      inputId: `${h}-startDate`,
+      value: x("startDate", t.startDate)
+    } : { caption: "Start", value: p(S) },
+    D.dates ? {
+      caption: "End",
+      inputId: `${h}-endDate`,
+      value: x("endDate", t.endDate)
+    } : { caption: "End", value: p(L) },
+    { caption: "Duration", value: xn(L.valueOf() - S.valueOf()) }
+  ];
+  return b !== null && _.push(
+    D.progress ? {
+      caption: "Progress",
+      inputId: `${h}-progress`,
+      value: /* @__PURE__ */ P(
+        De,
+        {
+          id: `${h}-progress`,
+          type: "number",
+          min: 0,
+          max: 100,
+          step: 1,
+          value: String(b),
+          commit: (A) => m("progress", A)
+        }
+      )
+    } : { caption: "Progress", value: `${b}%` }
+  ), N.length > 0 && _.push({ caption: "Depends on", value: N.join(", ") }), /* @__PURE__ */ P(
+    "aside",
+    {
+      ref: l,
+      className: c ? "gantt-detail gantt-detail-open" : "gantt-detail",
+      role: "complementary",
+      "aria-label": "Task details",
+      onTransitionEnd: u,
+      children: i ? i({ task: t, close: e, scale: r, update: d }) : /* @__PURE__ */ J(we, { children: [
+        /* @__PURE__ */ J("div", { className: "gantt-detail-header", children: [
+          D.name ? /* @__PURE__ */ P(
+            De,
+            {
+              type: "text",
+              "aria-label": "Task name",
+              value: t.name,
+              commit: (A) => m("name", A)
+            }
+          ) : /* @__PURE__ */ P("h2", { className: "gantt-detail-title", children: t.name }),
+          /* @__PURE__ */ P(
+            "button",
+            {
+              type: "button",
+              className: "gantt-detail-close",
+              onClick: e,
+              "aria-label": "Close task details",
+              children: "✕"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ P("dl", { className: "gantt-detail-fields", children: _.map(({ caption: A, value: v, inputId: g }) => /* @__PURE__ */ J(Jn, { children: [
+          /* @__PURE__ */ P("dt", { children: g ? /* @__PURE__ */ P("label", { htmlFor: g, children: A }) : A }),
+          /* @__PURE__ */ P("dd", { children: v })
+        ] }, A)) })
+      ] })
+    }
+  );
+}
+function Ds({
+  enabled: t,
+  detailTaskId: n,
+  uncontrolled: r,
+  tasks: o
+}) {
+  if (!t) return { openId: null, task: null, stale: !1 };
+  const s = n !== void 0 ? n : r;
+  if (s === null) return { openId: null, task: null, stale: !1 };
+  const e = o.find((a) => a.id === s) ?? null;
+  return { openId: s, task: e, stale: e === null };
+}
+function ws({
+  enabled: t,
+  tasks: n,
+  detailTaskId: r,
+  onDetailChange: o,
+  onTaskClick: s
+}) {
+  const [e, a] = ut(null), i = r !== void 0, { openId: c, task: u } = j(
+    () => Ds({ enabled: t, detailTaskId: r, uncontrolled: e, tasks: n }),
+    [t, r, e, n]
+  ), l = z(
+    (p) => {
+      t && p !== c && (i || a(p), o == null || o(
+        p ? n.find((d) => d.id === p) ?? null : null
+      ));
+    },
+    [t, c, i, o, n]
+  ), f = z(
+    (p) => {
+      n.some((d) => d.id === p) && l(p);
+    },
+    [l, n]
+  ), h = z(() => l(null), [l]), w = z(
+    (p, d) => {
+      s == null || s(p, d), l(p.id);
+    },
+    [s, l]
+  );
+  return { task: u, open: f, close: h, onTaskClick: w };
+}
+const vs = 400;
+function ys(t) {
+  const [n, r] = ut(t), [o, s] = ut(!1);
+  t !== null && t !== n && r(t);
+  const e = t !== null;
+  it(() => {
+    let i = requestAnimationFrame(() => {
+      if (!e) {
+        s(!1);
+        return;
+      }
+      i = requestAnimationFrame(() => s(!0));
+    });
+    return () => cancelAnimationFrame(i);
+  }, [e]), it(() => {
+    if (e || n === null) return;
+    const i = setTimeout(() => r(null), vs);
+    return () => clearTimeout(i);
+  }, [e, n]);
+  const a = z(
+    (i) => {
+      i.target === i.currentTarget && i.propertyName === "flex-basis" && (e || r(null));
+    },
+    [e]
+  );
+  return { task: n, open: o, onTransitionEnd: a };
+}
+function bs({
+  scrollRef: t,
+  bottomRowCells: n,
+  transformedTasks: r,
+  selectedScale: o,
+  rowHeight: s,
+  viewportInsetPx: e = 0,
+  zoomTo: a,
+  setSelectedScale: i
+}) {
+  const c = z(
+    (p, d) => {
+      const m = t.current;
+      if (!m) return;
+      const D = (d == null ? void 0 : d.align) === "start" ? p : p - (m.clientWidth - e) / 2;
+      m.scrollTo({
+        left: Math.max(0, D),
+        behavior: (d == null ? void 0 : d.smooth) === !1 ? "auto" : "smooth"
+      });
+    },
+    [t, e]
+  ), u = z(
+    (p, d) => {
+      const m = Lt(H(p), n, o);
+      m !== null && c(m, d);
+    },
+    [n, o, c]
+  ), l = z(
+    (p) => u(H(), p),
+    [u]
+  ), f = z(
+    (p, d) => {
+      const m = r.findIndex((N) => N.id === p);
+      if (m === -1) return;
+      const D = r[m], b = t.current;
+      if (!b) return;
+      const S = (D.order - 1) * s, L = S < b.scrollTop || S + s > b.scrollTop + b.clientHeight;
+      b.scrollTo({
+        top: L ? Math.max(0, S - b.clientHeight / 2 + s / 2) : b.scrollTop,
+        left: Math.max(
+          0,
+          (d == null ? void 0 : d.align) === "start" ? D.barLeft : D.barLeft + D.barWidth / 2 - (b.clientWidth - e) / 2
+        ),
+        behavior: (d == null ? void 0 : d.smooth) === !1 ? "auto" : "smooth"
+      });
+    },
+    [r, s, t, e]
+  ), h = z(
+    (p) => {
+      if (!(p in dt)) return;
+      const d = t.current, m = d ? Math.max(0, d.clientWidth - e) / 2 : 0, D = d ? Pn(d.scrollLeft + m, n, o) : null;
+      if (!D) {
+        i(p);
+        return;
+      }
+      a(p, { date: D, viewportX: m });
+    },
+    [
+      t,
+      e,
+      n,
+      o,
+      i,
+      a
+    ]
+  ), w = z(() => {
+    const p = t.current;
+    if (!p || !r.length) return;
+    let d = 1 / 0, m = -1 / 0;
+    for (const D of r)
+      d = Math.min(d, H(D.startDate).valueOf()), m = Math.max(m, H(D.endDate).valueOf());
+    !Number.isFinite(d) || !Number.isFinite(m) || a(_r(m - d, p.clientWidth - e), {
+      date: H(d),
+      viewportX: 0
+    });
+  }, [r, t, e, a]);
+  return j(
+    () => ({
+      scrollToDate: u,
+      scrollToToday: l,
+      scrollToTask: f,
+      setScale: h,
+      zoomToFit: w,
+      getScrollElement: () => t.current
+    }),
+    [u, l, f, h, w, t]
+  );
+}
+function Ss({
+  showTaskList: t
+}) {
+  const n = t ?? !1, [r, o] = ut($r);
+  return {
+    width: r,
+    setWidth: o,
+    visible: n,
+    inset: n ? r : 0
+  };
+}
+function Ms({
+  hierarchy: t,
+  interaction: n,
+  collapsedIds: r,
+  onTasksChange: o,
+  onTaskMove: s,
+  onExpand: e
+}) {
+  const a = yt(), i = j(
+    () => ({
+      hierarchy: t,
+      canReorder: (l) => Dt(l, n).canReorder
+    }),
+    [t, n]
+  ), c = z(
+    (l) => On(a.getState().rawTasks, l, i),
+    [a, i]
+  ), u = z(
+    (l) => {
+      const f = qr(a.getState().rawTasks, l, i);
+      return !f || (s == null ? void 0 : s(f.change)) === !1 ? !1 : (a.getState().setRawTasks(f.tasks), o == null || o(f.tasks), l.toParentId && r.has(l.toParentId) && (e == null || e(l.toParentId)), !0);
+    },
+    [a, i, s, o, r, e]
+  );
+  return { validate: c, apply: u };
+}
+function _n(t, n) {
+  const r = Math.max(1, n);
+  return {
+    count: t,
+    total: t * r,
+    sizeAt: () => r,
+    offsetAt: (o) => Ie(o, 0, t) * r,
+    indexAt: (o) => Ie(Math.floor(o / r), 0, t - 1)
+  };
+}
+function xs(t, n) {
+  const r = new Float64Array(t + 1);
+  for (let o = 0; o < t; o += 1)
+    r[o + 1] = r[o] + Math.max(0, n(o));
+  return {
+    count: t,
+    total: r[t],
+    sizeAt: (o) => o >= 0 && o < t ? r[o + 1] - r[o] : 0,
+    offsetAt: (o) => r[Ie(o, 0, t)],
+    indexAt: (o) => {
+      if (t === 0) return 0;
+      let s = 0, e = t - 1;
+      for (; s < e; ) {
+        const a = s + e >> 1;
+        r[a + 1] <= o ? s = a + 1 : e = a;
+      }
+      return s;
+    }
+  };
+}
+function Is(t, n, r = 0) {
+  return typeof n == "number" ? _n(t, n) : xs(t, (o) => n[o] ?? r);
+}
+function Ie(t, n, r) {
+  return t < n ? n : t > r ? r : t;
+}
+const Os = 24;
+function Oe(t) {
+  return {
+    start: 0,
+    end: t - 1,
+    padStart: 0,
+    padEnd: 0,
+    virtualized: !1
+  };
+}
+function dn(t, n, r, o = 5, s = 0) {
+  if (t.count === 0 || t.count <= Os || r <= 0 || t.total <= r)
+    return Oe(t.count);
+  const e = o + (s < 0 ? o : 0), a = o + (s > 0 ? o : 0), i = Math.max(0, n), c = Math.max(0, t.indexAt(i) - e), u = Math.min(t.count - 1, t.indexAt(i + r) + a);
+  return {
+    start: c,
+    end: u,
+    padStart: t.offsetAt(c),
+    padEnd: Math.max(0, t.total - t.offsetAt(u + 1)),
+    virtualized: !0
+  };
+}
+function fn(t, n) {
+  const r = [];
+  for (let o = n.start; o <= n.end; o += 1) {
+    const s = t.offsetAt(o), e = t.sizeAt(o);
+    r.push({ index: o, key: o, start: s, end: s + e, size: e });
+  }
+  return r;
+}
+function ks(t, n) {
+  return n.end < n.start ? { startPx: 0, endPx: 0 } : {
+    startPx: t.offsetAt(n.start),
+    endPx: t.offsetAt(n.end + 1)
+  };
+}
+function hn(t, n) {
+  return t.start === n.start && t.end === n.end && t.virtualized === n.virtualized && t.padStart === n.padStart && t.padEnd === n.padEnd;
+}
+function Ps({
+  scrollRef: t,
+  row: n,
+  col: r
+}) {
+  const [o, s] = ut(() => ({
+    row: Oe(n.count),
+    col: Oe(r.count)
+  })), e = Z({ top: 0, left: 0 }), a = Z(0), i = z(() => {
+    const l = t.current;
+    if (!l) return;
+    const { scrollTop: f, scrollLeft: h, clientHeight: w, clientWidth: p } = l, d = mn(f, e.current.top), m = mn(h, e.current.left);
+    e.current = { top: f, left: h };
+    const D = {
+      row: dn(n, f, w, 5, d),
+      col: dn(r, h, p, 5, m)
+    };
+    s(
+      (b) => hn(b.row, D.row) && hn(b.col, D.col) ? b : D
+    );
+  }, [t, n, r]), c = z(() => {
+    a.current === 0 && (a.current = requestAnimationFrame(() => {
+      a.current = 0, i();
+    }));
+  }, [i]);
+  Rt(() => {
+    const l = t.current;
+    if (!l) return;
+    i(), l.addEventListener("scroll", c, { passive: !0 });
+    const f = new ResizeObserver(i);
+    return f.observe(l), () => {
+      l.removeEventListener("scroll", c), f.disconnect();
+    };
+  }, [t, c, i]), it(
+    () => () => {
+      a.current !== 0 && cancelAnimationFrame(a.current);
+    },
+    []
+  );
+  const u = z(
+    (l, f = "start") => {
+      const h = t.current;
+      if (!h || l < 0 || l >= n.count) return;
+      const w = h.clientHeight, p = n.offsetAt(l), d = n.sizeAt(l), m = h.scrollTop;
+      let D = p;
+      if (f === "center") D = p - (w - d) / 2;
+      else if (f === "end") D = p - w + d;
+      else if (f === "auto") {
+        if (p >= m && p + d <= m + w) return;
+        D = p < m ? p : p - w + d;
+      }
+      h.scrollTo({ top: Math.max(0, D) });
+    },
+    [t, n]
+  );
+  return { row: o.row, col: o.col, scrollToRow: u };
+}
+function mn(t, n) {
+  return t > n ? 1 : t < n ? -1 : 0;
+}
+function Ts({
+  rowCount: t,
+  bottomRowCells: n,
+  scrollRef: r
+}) {
+  var w;
+  const o = j(() => _n(t, xt), [t]), s = j(() => {
+    const p = n.map((d) => d.widthPx);
+    return Is(p.length, p);
+  }, [n]), { row: e, col: a, scrollToRow: i } = Ps({
+    scrollRef: r,
+    row: o,
+    col: s
+  }), c = j(
+    () => fn(o, e),
+    [o, e]
+  ), u = j(
+    () => fn(s, a),
+    [s, a]
+  ), { startPx: l, endPx: f } = ks(s, a), h = z(
+    (p, d) => p + d >= l && p <= f,
+    [l, f]
+  );
+  return {
+    virtualRows: c,
+    totalHeight: o.total,
+    virtualCells: u,
+    leadingCellPx: ((w = u[0]) == null ? void 0 : w.start) ?? 0,
+    rowStartPx: e.padStart,
+    rowEndPx: o.offsetAt(e.end + 1),
+    isBarVisible: h,
+    scrollToRow: i
+  };
+}
+function Es({
+  enabled: t,
+  scrollRef: n,
+  selectedScale: r,
+  bottomRowCells: o,
+  totalWidth: s,
+  viewportInsetPx: e,
+  pinnedStart: a,
+  pinnedEnd: i
+}) {
+  const [c, u] = ut({ scale: r, value: Se }), l = c.scale === r ? c.value : Se, f = ht(r), h = ht(o), w = ht(s), p = ht(e), d = ht(l);
+  return it(() => {
+    if (!t) return;
+    const m = n.current;
+    if (!m) return;
+    const D = () => {
+      const b = h.current, S = w.current;
+      if (!b.length || S <= 0) return;
+      const L = Wr({
+        current: d.current,
+        scrollLeft: m.scrollLeft,
+        viewportPx: m.clientWidth - p.current,
+        totalPx: S,
+        pxPerTick: S / b.length,
+        canExtend: { before: !a, after: !i }
+      });
+      L && (d.current = L, u({ scale: f.current, value: L }));
+    };
+    return D(), m.addEventListener("scroll", D, { passive: !0 }), () => m.removeEventListener("scroll", D);
+  }, [
+    t,
+    o,
+    a,
+    i,
+    n,
+    h,
+    w,
+    d,
+    p,
+    f
+  ]), l;
+}
+function Ls({
+  rawTasks: t,
+  selectedScale: n,
+  visibleRange: r,
+  hierarchy: o,
+  extension: s,
+  scrollRef: e,
+  bottomRowCells: a
+}) {
+  const i = ht(n), c = ht(a), u = Q((m) => m.setBottomRowCells), l = Q((m) => m.setTransformedTasks), f = Q((m) => m.clearAllDragOffsets), h = Q((m) => m.setSelectedScale), w = Z([]), p = Z(0), d = Z(null);
+  return Rt(() => {
+    const { bottomCells: m, transformedTasks: D } = ao(
+      t,
+      n,
+      r,
+      o,
+      s
+    ), b = w.current;
+    b.length && m.length && (p.current += Jr(
+      b,
+      m,
+      n
+    )), w.current = m, u(m), l(D), f();
+  }, [
+    t,
+    n,
+    r,
+    o,
+    s,
+    u,
+    l,
+    f
+  ]), Rt(() => {
+    const m = e.current, D = d.current;
+    if (D) {
+      d.current = null, p.current = 0;
+      const S = Lt(
+        D.date,
+        a,
+        i.current
+      );
+      if (m && S !== null) {
+        m.scrollLeft = Math.max(0, S - D.viewportX);
+        return;
+      }
+    }
+    const b = p.current;
+    b && (p.current = 0, m && (m.scrollLeft += b));
+  }, [a, e, i]), z(
+    (m, D) => {
+      if (m === i.current) {
+        const b = e.current, S = Lt(D.date, c.current, m);
+        b && S !== null && (b.scrollLeft = Math.max(0, S - D.viewportX));
+        return;
+      }
+      d.current = D, h(m);
+    },
+    [h, e, i, c]
+  );
+}
+function As({
+  enabled: t,
+  scrollRef: n,
+  selectedScale: r,
+  bottomRowCells: o,
+  viewportInsetPx: s,
+  zoomTo: e
+}) {
+  const a = ht(r), i = ht(o), c = ht(s);
+  it(() => {
+    if (!t) return;
+    const u = n.current;
+    if (!u) return;
+    const l = { ...Cr }, f = (h) => {
+      if (!h.ctrlKey && !h.metaKey) return;
+      h.preventDefault();
+      const { state: w, step: p } = Fr(
+        l,
+        h.deltaY,
+        h.timeStamp
+      );
+      if (Object.assign(l, w), !p) return;
+      const d = In(a.current, p);
+      if (d === a.current) return;
+      const m = u.getBoundingClientRect(), D = c.current, b = Math.min(
+        Math.max(h.clientX - m.left, D),
+        u.clientWidth
+      ) - D, S = Pn(
+        u.scrollLeft + b,
+        i.current,
+        a.current
+      );
+      S && e(d, { date: S, viewportX: b });
+    };
+    return u.addEventListener("wheel", f, { passive: !1 }), () => u.removeEventListener("wheel", f);
+  }, [t, e, n, a, i, c]);
+}
+function Ns(t, n) {
+  const r = ht(n), o = Z(t);
+  it(() => {
+    var s;
+    t !== o.current && (o.current = t, (s = r.current) == null || s.call(r, t));
+  }, [t, r]);
+}
+function Rs(t, n, r) {
+  const o = ht(n), s = ht(r), e = Z("");
+  it(() => {
+    const a = s.current;
+    if (!a) return;
+    const i = eo(t, o.current);
+    if (!i) return;
+    const c = `${i.start.valueOf()}:${i.end.valueOf()}`;
+    c !== e.current && (e.current = c, a(i));
+  }, [t, o, s]);
+}
+function _s(t, n, r) {
+  const o = Z(!1);
+  it(() => {
+    if (o.current || !t || !n.length) return;
+    o.current = !0;
+    const s = t === "today" ? H() : t;
+    r.scrollToDate(s, { smooth: !1 });
+  }, [t, n, r]);
+}
+const Yn = "(prefers-color-scheme: dark)", Hn = () => typeof window < "u" && typeof window.matchMedia == "function", Cn = () => Hn() && window.matchMedia(Yn).matches, Ys = () => {
+  if (typeof document > "u") return "light";
+  const t = getComputedStyle(document.documentElement).colorScheme, n = t.includes("light"), r = t.includes("dark");
+  return n && r ? Cn() ? "dark" : "light" : r ? "dark" : "light";
+}, Hs = (t) => {
+  if (typeof window > "u") return () => {
+  };
+  const n = Hn() ? window.matchMedia(Yn) : null;
+  n == null || n.addEventListener("change", t);
+  const r = new MutationObserver(t);
+  return r.observe(document.documentElement, {
+    attributes: !0,
+    attributeFilter: ["class", "style", "data-theme"]
+  }), () => {
+    n == null || n.removeEventListener("change", t), r.disconnect();
+  };
+}, Cs = () => "light";
+function Fs(t) {
+  const n = Qn(
+    Hs,
+    t === "system" ? () => Cn() ? "dark" : "light" : Ys,
+    Cs
+  );
+  return t === "light" || t === "dark" ? t : n;
+}
+function Us(t = "month") {
+  return nr()((n, r) => ({
+    rawTasks: [],
+    transformedTasks: [],
+    rowTasks: [],
+    bottomRowCells: [],
+    selectedScale: t,
+    currentTask: null,
+    dragMode: null,
+    dragOffsets: {},
+    localeOptions: void 0,
+    linkDraft: null,
+    reorderDraft: null,
+    selectedDependency: null,
+    selectedTaskId: null,
+    hoveredTaskId: null,
+    setCurrentTask: (o) => n({ currentTask: o }),
+    setDragMode: (o) => {
+      r().dragMode !== o && n({ dragMode: o });
+    },
+    setLinkDraft: (o) => n({ linkDraft: o }),
+    setReorderDraft: (o) => n({ reorderDraft: o }),
+    setSelectedDependency: (o) => n(
+      (s) => {
+        var e, a;
+        return ((e = s.selectedDependency) == null ? void 0 : e.sourceId) === (o == null ? void 0 : o.sourceId) && ((a = s.selectedDependency) == null ? void 0 : a.targetId) === (o == null ? void 0 : o.targetId) ? s : { selectedDependency: o };
+      }
+    ),
+    setLocaleOptions: (o) => n({ localeOptions: o }),
+    setSelectedTaskId: (o) => {
+      r().selectedTaskId !== o && n({ selectedTaskId: o });
+    },
+    // Guarded: without it a pointer moving inside one bar re-renders the arrow layer every event
+    setHoveredTaskId: (o) => {
+      r().hoveredTaskId !== o && n({ hoveredTaskId: o });
+    },
+    setSelectedScale: (o) => {
+      r().selectedScale !== o && n({ selectedScale: o });
+    },
+    setRawTasks: (o) => n({ rawTasks: o }),
+    syncTasksFromProps: (o) => n(
+      (s) => JSON.stringify(s.rawTasks) === JSON.stringify(o) ? s : { rawTasks: o }
+    ),
+    setBottomRowCells: (o) => n({ bottomRowCells: o }),
+    setTransformedTasks: (o) => n({ transformedTasks: o }),
+    setRowTasks: (o) => n({ rowTasks: o }),
+    // Runs every drag frame - one store update even when a whole subtree moves
+    setDragOffsets: (o) => n((s) => ({
+      dragOffsets: { ...s.dragOffsets, ...o }
+    })),
+    clearDragOffsets: (o) => n((s) => {
+      const e = { ...s.dragOffsets };
+      let a = !1;
+      for (const i of o)
+        i in e && (delete e[i], a = !0);
+      return a ? { dragOffsets: e } : s;
+    }),
+    // Keeps an in-progress drag's offset, so a drag started right after a drop is not swept away.
+    clearAllDragOffsets: () => n((o) => {
+      var a;
+      const s = (a = o.currentTask) == null ? void 0 : a.id, e = Object.keys(o.dragOffsets);
+      return e.length ? !s || !o.dragOffsets[s] ? { dragOffsets: {} } : e.length === 1 ? o : { dragOffsets: { [s]: o.dragOffsets[s] } } : o;
+    }),
+    getTotalWidth: () => r().bottomRowCells.reduce((s, e) => s + e.widthPx, 0)
+  }));
+}
+const Tt = "day", pn = 366, Ws = 18263, Gs = "YYYY-MM-DD", Xs = [1, 2, 3, 4, 5];
+function Fn(t) {
+  const n = t ? (s) => !t(s) : () => !0, r = (s, e) => {
+    if (!e || !t) return s.add(e, Tt);
+    const a = e > 0 ? 1 : -1;
+    let i = Math.abs(e), c = s, u = Math.abs(e) + pn * Math.abs(e);
+    for (; i > 0; )
+      if (c = c.add(a, Tt), n(c) && i--, u-- <= 0) return s.add(e, Tt);
+    return c;
+  }, o = (s, e) => {
+    const a = s.startOf(Tt), i = e.startOf(Tt), c = i.diff(a, Tt);
+    if (!t || c === 0 || Math.abs(c) > Ws) return c;
+    const u = c > 0 ? 1 : -1;
+    let l = u > 0 ? a : i;
+    const f = u > 0 ? i : a;
+    let h = 0;
+    for (; l.valueOf() < f.valueOf(); )
+      l = l.add(1, Tt), n(l) && h++;
+    return h === 0 ? 0 : h * u;
+  };
+  return {
+    skipsNonWorkingDays: t !== null,
+    isWorkingDay: n,
+    addDays: r,
+    daysBetween: o,
+    // daysBetween is day-granular, so correct by whole steps once time of day is counted.
+    daysUntil(s, e) {
+      let a = o(s, e);
+      const i = e.valueOf();
+      for (let c = 0; c < 2 && r(s, a).valueOf() < i; c++) a++;
+      for (let c = 0; c < 2 && r(s, a - 1).valueOf() >= i; c++) a--;
+      return a;
+    },
+    daysUpTo(s, e) {
+      let a = o(s, e);
+      const i = e.valueOf();
+      for (let c = 0; c < 2 && r(s, a).valueOf() > i; c++) a--;
+      for (let c = 0; c < 2 && r(s, a + 1).valueOf() <= i; c++) a++;
+      return a;
+    },
+    snapForward(s) {
+      if (!t || n(s)) return s;
+      let e = s;
+      for (let a = 0; a < pn; a++)
+        if (e = e.add(1, Tt), n(e)) return e;
+      return s;
+    }
+  };
+}
+const Bs = Fn(null);
+function zs(t = {}) {
+  const n = new Set(t.workingWeekdays ?? Xs), r = new Set(t.holidays ?? []);
+  return Fn(
+    (o) => !n.has(o.day()) || r.has(o.format(Gs))
+  );
+}
+const js = "YYYY-MM-DD", qs = 366, Ks = { byDate: /* @__PURE__ */ new Map(), dates: [] };
+function Vs(t) {
+  if (!(t != null && t.length)) return Ks;
+  const n = /* @__PURE__ */ new Map();
+  for (const r of t) {
+    const o = typeof r == "string" ? { date: r } : r, s = ae(o.date);
+    if (!s.isValid()) continue;
+    const e = o.endDate ? ae(o.endDate) : s, a = e.isValid() && !e.isBefore(s, "day") ? Math.min(e.diff(s, "day"), qs - 1) : 0;
+    for (let i = 0; i <= a; i++) {
+      const c = s.add(i, "day").format(js);
+      n.has(c) || n.set(c, o);
+    }
+  }
+  return { byDate: n, dates: [...n.keys()] };
+}
+const Zs = 600, Js = "100%", Qs = [], ra = tr(function(n, r) {
+  const [o] = ut(() => Us(n.defaultScale));
+  return /* @__PURE__ */ P($n.Provider, { value: o, children: /* @__PURE__ */ P(ta, { ...n, forwardedRef: r }) });
+});
+function ta({
+  tasks: t = Qs,
+  onTasksChange: n,
+  height: r = Zs,
+  width: o = Js,
+  theme: s,
+  className: e,
+  showNonWorkingDays: a = !0,
+  workingWeekdays: i,
+  holidays: c,
+  initialScrollTo: u,
+  readOnly: l,
+  allowMove: f,
+  allowResize: h,
+  allowProgressChange: w,
+  minDate: p,
+  maxDate: d,
+  visibleStart: m,
+  visibleEnd: D,
+  locale: b,
+  formats: S,
+  firstDayOfWeek: L,
+  showTaskList: N,
+  showRowNumbers: x = !1,
+  hierarchy: _ = !1,
+  collapsedIds: A,
+  defaultCollapsedIds: v,
+  onCollapsedChange: g,
+  workingCalendar: R = !1,
+  allowLinkCreate: F,
+  allowLinkDelete: U,
+  allowTaskCreate: T,
+  allowReorder: M,
+  onTaskMove: I,
+  onDependencyCreate: y,
+  onDependencyDelete: $,
+  onTaskCreate: k,
+  onTaskClick: E,
+  onTaskDoubleClick: C,
+  onTaskSelect: X,
+  selectable: q,
+  renderDetail: tt,
+  showDetail: rt,
+  detailTaskId: wt,
+  onDetailChange: ot,
+  showTooltip: gt,
+  zoomOnWheel: O = !1,
+  infiniteScroll: G = !1,
+  onRangeChange: B,
+  onScaleChange: ct,
+  autoScrollOnDrag: st = !0,
+  forwardedRef: bt
+}) {
+  const {
+    rawTasks: at,
+    transformedTasks: nt,
+    bottomRowCells: K,
+    selectedScale: V,
+    selectedTaskId: $t,
+    syncTasksFromProps: lt,
+    setSelectedScale: St,
+    setLocaleOptions: Mt,
+    getTotalWidth: Ot
+  } = ls(), Y = j(
+    () => b === void 0 && S === void 0 && L === void 0 ? void 0 : { locale: b, formats: S, firstDayOfWeek: L },
+    [b, S, L]
+  );
+  Rt(() => {
+    Mt(Y);
+  }, [Y, Mt]);
+  const W = Z(null), et = Z(null), mt = ns({
+    readOnly: l,
+    allowMove: f,
+    allowResize: h,
+    allowProgressChange: w,
+    allowLinkCreate: F,
+    allowLinkDelete: U,
+    allowTaskCreate: T,
+    allowReorder: M,
+    minDate: p,
+    maxDate: d
+  }), ft = Ss({ showTaskList: N }), Bt = ft.visible ? 1 : 0, zt = Ot(), Un = Es({
+    enabled: G,
+    scrollRef: W,
+    selectedScale: V,
+    bottomRowCells: K,
+    totalWidth: zt,
+    viewportInsetPx: ft.inset,
+    pinnedStart: !!m,
+    pinnedEnd: !!D
+  }), kt = Jo({
+    collapsedIds: A,
+    defaultCollapsedIds: v,
+    onCollapsedChange: g
+  }), Le = Ms({
+    hierarchy: _,
+    interaction: mt,
+    collapsedIds: kt.collapsedIds,
+    onTasksChange: n,
+    onTaskMove: I,
+    onExpand: kt.expand
+  }), Wn = j(
+    () => M === !0 || at.some((pt) => pt.allowReorder === !0),
+    [M, at]
+  ), jt = j(() => Vs(c), [c]), de = j(
+    () => zs({
+      workingWeekdays: i,
+      holidays: jt.dates
+    }),
+    [i, jt]
+  ), Ae = z(
+    (pt) => {
+      if (de.isWorkingDay(pt)) return null;
+      const Jt = jt.byDate.get(pt.format("YYYY-MM-DD"));
+      return Jt ? { key: Jt.date, label: Jt.label, color: Jt.color } : { key: Zr };
+    },
+    [de, jt]
+  ), Gn = R ? de : Bs, fe = rt ?? tt !== void 0, he = us({
+    // The panel turns selection on unless the host has said otherwise
+    selectable: q ?? (fe ? !0 : void 0),
+    onTaskSelect: X,
+    onTaskClick: E
+  }), vt = ws({
+    enabled: fe,
+    tasks: nt,
+    detailTaskId: wt,
+    onDetailChange: ot,
+    onTaskClick: he.onTaskClick
+  }), qt = ys(vt.task), Xn = j(
+    () => ({
+      onTasksChange: n,
+      onTaskClick: vt.onTaskClick,
+      onTaskDoubleClick: C,
+      showTooltip: gt
+    }),
+    [n, vt.onTaskClick, C, gt]
+  ), { rows: Pt, tasks: Kt } = ss({
+    rawTasks: at,
+    tasks: nt,
+    hierarchy: _,
+    collapsedIds: kt.collapsedIds
+  }), Ne = Q((pt) => pt.setRowTasks);
+  Rt(() => {
+    Ne(Kt);
+  }, [Kt, Ne]);
+  const Ht = k !== void 0 && co(mt), { onDrawPointerDown: Bn, ghost: Vt } = es({
+    enabled: Ht,
+    rowCount: Pt.length,
+    onTaskCreate: k
+  }), me = z(() => {
+    if (!Ht) return;
+    const pt = Qo(H(), K, V);
+    pt && (k == null || k(pt));
+  }, [Ht, K, V, k]), It = Ts({
+    rowCount: Pt.length,
+    bottomRowCells: K,
+    scrollRef: W
+  }), zn = Fs(s), Re = Z(null);
+  it(() => {
+    const pt = JSON.stringify(t);
+    pt !== Re.current && (Re.current = pt, lt(t));
+  }, [t, lt]);
+  const jn = j(
+    () => m || D ? {
+      start: m ? H(m) : void 0,
+      end: D ? H(D) : void 0
+    } : void 0,
+    [m, D]
+  ), _e = Ls({
+    rawTasks: at,
+    selectedScale: V,
+    visibleRange: jn,
+    hierarchy: _,
+    extension: Un,
+    scrollRef: W,
+    bottomRowCells: K
+  });
+  As({
+    enabled: O,
+    scrollRef: W,
+    selectedScale: V,
+    bottomRowCells: K,
+    viewportInsetPx: ft.inset,
+    zoomTo: _e
+  }), Rs(K, V, B), Ns(V, ct);
+  const Ye = j(
+    () => Lt(H(), K, V),
+    [K, V]
+  ), He = j(() => a ? Qr(
+    K,
+    V,
+    Ae
+  ) : [], [a, Ae, K, V]), Zt = bs({
+    scrollRef: W,
+    bottomRowCells: K,
+    transformedTasks: Kt,
+    selectedScale: V,
+    rowHeight: xt,
+    viewportInsetPx: ft.inset,
+    zoomTo: _e,
+    setSelectedScale: St
+  });
+  er(
+    bt,
+    () => ({
+      ...Zt,
+      openDetail: vt.open,
+      closeDetail: vt.close,
+      addTask: me
+    }),
+    [Zt, vt.open, vt.close, me]
+  );
+  const Ct = os({
+    // Enter opens the panel, the way a click does
+    onActivate: fe ? vt.open : void 0,
+    rows: Pt,
+    rawTasks: at,
+    gridColumnCount: Bt,
+    hierarchy: _,
+    collapsedIds: kt.collapsedIds,
+    selectedScale: V,
+    localeOptions: Y,
+    interaction: mt,
+    onToggleCollapse: kt.toggle,
+    onTasksChange: n,
+    move: Le,
+    scrollToRow: It.scrollToRow,
+    scrollApi: Zt,
+    bodyRef: et
+  });
+  _s(u, K, Zt);
+  const qn = z(
+    (pt) => {
+      pt.target === pt.currentTarget && (he.select(null), vt.close());
+    },
+    [he, vt]
+  ), Kn = {
+    height: typeof r == "number" ? `${r}px` : r,
+    width: typeof o == "number" ? `${o}px` : o,
+    // How far the pinned task list reaches in; left-pinned timeline content offsets by this
+    "--gantt-pane-inset": `${ft.inset}px`,
+    // Row height as a token, so CSS keeps the row pitch without a second copy of the number
+    "--gantt-row-height": `${xt}px`
+  }, Ce = { width: `${zt}px` };
+  return /* @__PURE__ */ J(
+    "section",
+    {
+      className: e ? `gantt-container ${e}` : "gantt-container",
+      "data-theme": zn,
+      style: Kn,
+      children: [
+        /* @__PURE__ */ P("div", { className: "gantt-sr-only", role: "status", "aria-live": "polite", children: Ct.announcement }),
+        /* @__PURE__ */ J("div", { className: "gantt-layout", children: [
+          /* @__PURE__ */ J("div", { className: "gantt-main", children: [
+            /* @__PURE__ */ P("div", { ref: W, className: "gantt-scroll-container", children: /* @__PURE__ */ J(
+              "div",
+              {
+                ref: et,
+                className: "gantt-body",
+                role: "treegrid",
+                "aria-label": "Gantt chart",
+                "aria-rowcount": Pt.length + (ft.visible ? 1 : 0),
+                onKeyDown: Ct.onKeyDown,
+                onFocusCapture: Ct.onFocusCapture,
+                children: [
+                  ft.visible && /* @__PURE__ */ P(
+                    Wo,
+                    {
+                      rows: Pt,
+                      virtualItems: It.virtualRows,
+                      totalHeight: It.totalHeight,
+                      width: ft.width,
+                      showRowNumbers: x,
+                      hierarchy: _,
+                      collapsedIds: kt.collapsedIds,
+                      onToggleCollapse: kt.toggle,
+                      focus: Ct.focus,
+                      selectedTaskId: $t,
+                      onRowClick: vt.onTaskClick,
+                      onRowDoubleClick: C,
+                      reorderEnabled: Wn,
+                      interaction: mt,
+                      move: Le
+                    }
+                  ),
+                  /* @__PURE__ */ J(
+                    "div",
+                    {
+                      className: "gantt-timeline",
+                      style: Ce,
+                      role: "presentation",
+                      children: [
+                        /* @__PURE__ */ J("div", { className: "gantt-header-wrapper", style: Ce, children: [
+                          /* @__PURE__ */ P(
+                            io,
+                            {
+                              bottomRowCells: K,
+                              selectedScale: V,
+                              width: zt,
+                              virtual: It
+                            }
+                          ),
+                          /* @__PURE__ */ P(qo, { ranges: He }),
+                          /* @__PURE__ */ P(xo, {}),
+                          /* @__PURE__ */ P(Po, { leftPx: Ye })
+                        ] }),
+                        /* @__PURE__ */ J(
+                          "div",
+                          {
+                            className: `gantt-content${Ht ? " drawable" : ""}`,
+                            style: {
+                              height: `${It.totalHeight}px`,
+                              width: `${zt}px`
+                            },
+                            role: "presentation",
+                            onPointerDown: Bn,
+                            onClick: qn,
+                            children: [
+                              /* @__PURE__ */ P(Ko, { ranges: He }),
+                              /* @__PURE__ */ P(
+                                Vo,
+                                {
+                                  rows: Pt,
+                                  virtualItems: It.virtualRows,
+                                  ownedByTaskList: ft.visible,
+                                  hierarchy: _,
+                                  collapsedIds: kt.collapsedIds
+                                }
+                              ),
+                              /* @__PURE__ */ P(ko, { leftPx: Ye }),
+                              Vt && /* @__PURE__ */ P(
+                                "div",
+                                {
+                                  className: "gantt-draw-ghost",
+                                  style: {
+                                    left: `${Vt.leftPx}px`,
+                                    width: `${Vt.widthPx}px`,
+                                    // Same geometry as the bar this becomes, centred in the row
+                                    height: `${ve}px`,
+                                    marginTop: `${(xt - ve) / 2}px`,
+                                    transform: `translateY(${Vt.topPx}px)`
+                                  },
+                                  "aria-hidden": "true"
+                                }
+                              ),
+                              /* @__PURE__ */ P(
+                                Mo,
+                                {
+                                  transformedTasks: Kt,
+                                  rowCount: Pt.length,
+                                  virtual: It,
+                                  interaction: mt,
+                                  onTasksChange: n,
+                                  onDependencyDelete: $
+                                }
+                              ),
+                              /* @__PURE__ */ P(
+                                jo,
+                                {
+                                  rows: Pt,
+                                  virtualItems: It.virtualRows,
+                                  gridColumnCount: Bt,
+                                  focus: Ct.focus,
+                                  isBarVisible: It.isBarVisible,
+                                  options: Xn,
+                                  interaction: mt,
+                                  calendar: Gn,
+                                  autoScrollOnDrag: st,
+                                  onDependencyCreate: y
+                                }
+                              )
+                            ]
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              }
+            ) }),
+            ft.visible && /* @__PURE__ */ P(
+              Io,
+              {
+                width: ft.width,
+                onWidthChange: ft.setWidth
+              }
+            ),
+            ft.visible && Ht && /* @__PURE__ */ P(Oo, { width: ft.width, onAdd: me })
+          ] }),
+          qt.task && /* @__PURE__ */ P(
+            $s,
+            {
+              task: qt.task,
+              tasks: nt,
+              scale: V,
+              localeOptions: Y,
+              interaction: mt,
+              onClose: vt.close,
+              onTasksChange: n,
+              render: tt,
+              open: qt.open,
+              onTransitionEnd: qt.onTransitionEnd
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+export {
+  Bs as CALENDAR_DAYS,
+  ra as ReactGanttChart,
+  Xt as buildTaskTree,
+  ie as collectSubtreeIds,
+  zs as createWorkingCalendar,
+  qr as moveTask,
+  Br as rollUpTasks,
+  ce as sortTasksBySequence,
+  On as validateMove
+};