@umriss-ui/schedule 0.34.0 → 0.35.0

package/dist/schedule.js

@@ -1,456 +1,478 @@
 "use client";
 import "./schedule.css";
-var ds = Object.defineProperty;
-var hs = (n, t, e) => t in n ? ds(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
-var f = (n, t, e) => hs(n, typeof t != "symbol" ? t + "" : t, e);
-import { localOffset as Bt, toWorkingTimeClamped as H, DAY as X, calendarFrom as pt, toWallClock as xt, MINUTE as q, timeStep as cs, workingTimeTicks as us, HOUR as Gt, LinearScale as fs, resolveColours as ms, removedIntervals as ps, subscribeTheme as gs } from "@umriss-ui/charts";
-import { createContext as Ne, useContext as Re, useRef as V, useEffect as z, forwardRef as Pe, useId as ks, useState as ot, useLayoutEffect as ut, useImperativeHandle as ys, useSyncExternalStore as $e, useMemo as W, createElement as vs } from "react";
-import { jsxs as G, Fragment as it, jsx as g } from "react/jsx-runtime";
-import { useFormats as Ht, useWording as gt, AngleGlyph as ws, VisuallyHidden as fe } from "@umriss-ui/core";
-function et(n) {
-  return { from: n.from - (n.leadIn ?? 0), to: n.to + (n.leadOut ?? 0) };
-}
-function Yt(n, t) {
-  return (n.leaves ?? "leadOut") === "main" ? t.to : t.to + (t.leadOut ?? 0);
-}
-function Kt(n, t) {
-  return (n.arrives ?? "leadIn") === "main" ? t.from : t.from - (t.leadIn ?? 0);
-}
-function me(n, t) {
-  if (t.kind === "place" || t.subtask !== n.id) return n;
+import { localOffset as Bt, toWorkingTimeClamped as R, calendarFrom as ft, toWallClock as Nt, MINUTE as X, DAY as z, timeStep as is, workingTimeTicks as os, HOUR as xt, LinearScale as rs, resolveColours as as, removedIntervals as ls, subscribeTheme as ds } from "@umriss-ui/charts";
+import { useContext as _e, createContext as Fe, useRef as Y, useEffect as W, useId as hs, useState as nt, useLayoutEffect as ht, useImperativeHandle as us, useSyncExternalStore as Oe, useMemo as K, createElement as cs } from "react";
+import { jsxs as x, Fragment as it, jsx as m } from "react/jsx-runtime";
+import { useFormats as Rt, useWording as mt, AngleGlyph as fs, VisuallyHidden as de } from "@umriss-ui/core";
+function et(s) {
+  return { from: s.from - (s.leadIn ?? 0), to: s.to + (s.leadOut ?? 0) };
+}
+function $t(s, t) {
+  return (s.leaves ?? "leadOut") === "main" ? t.to : t.to + (t.leadOut ?? 0);
+}
+function Gt(s, t) {
+  return (s.arrives ?? "leadIn") === "main" ? t.from : t.from - (t.leadIn ?? 0);
+}
+function he(s, t) {
+  if (t.kind === "place" || t.subtask !== s.id) return s;
   switch (t.kind) {
     case "move":
     case "stretch":
-      return { ...n, from: t.from, to: t.to };
+      return { ...s, from: t.from, to: t.to };
     case "leadIn":
-      return { ...n, leadIn: t.leadIn };
+      return { ...s, leadIn: t.leadIn };
     case "leadOut":
-      return { ...n, leadOut: t.leadOut };
+      return { ...s, leadOut: t.leadOut };
     case "lane":
-      return { ...n, lane: t.lane };
+      return { ...s, lane: t.lane };
   }
 }
-function yo(n, t) {
+function hi(s, t) {
   return {
     id: t,
-    task: n.task,
-    lane: n.lane,
-    from: n.from,
-    to: n.to,
-    ...n.leadIn === void 0 ? {} : { leadIn: n.leadIn },
-    ...n.leadOut === void 0 ? {} : { leadOut: n.leadOut }
+    task: s.task,
+    lane: s.lane,
+    from: s.from,
+    to: s.to,
+    ...s.leadIn === void 0 ? {} : { leadIn: s.leadIn },
+    ...s.leadOut === void 0 ? {} : { leadOut: s.leadOut }
   };
 }
-function Vt(n) {
+function Ht(s) {
   const t = [], e = /* @__PURE__ */ new Map();
-  n.forEach((s, o) => {
-    const { from: i, to: r } = et(s);
-    if (!(i < r)) return;
-    const a = e.get(s.lane) ?? [];
-    a.push({ subtask: s, index: o, from: i, to: r }), e.set(s.lane, a);
+  s.forEach((n, i) => {
+    const { from: o, to: r } = et(n);
+    if (!(o < r)) return;
+    const a = e.get(n.lane) ?? [];
+    a.push({ subtask: n, index: i, from: o, to: r }), e.set(n.lane, a);
   });
-  for (const [s, o] of e) {
-    o.sort((i, r) => i.from - r.from || i.index - r.index);
-    for (let i = 0; i < o.length; i++) {
-      const r = o[i];
-      for (let a = i + 1; a < o.length; a++) {
-        const l = o[a];
+  for (const [n, i] of e) {
+    i.sort((o, r) => o.from - r.from || o.index - r.index);
+    for (let o = 0; o < i.length; o++) {
+      const r = i[o];
+      for (let a = o + 1; a < i.length; a++) {
+        const l = i[a];
         if (l.from >= r.to) break;
-        t.push({ lane: s, first: r.subtask.id, second: l.subtask.id, from: l.from, to: Math.min(r.to, l.to) });
+        t.push({ lane: n, first: r.subtask.id, second: l.subtask.id, from: l.from, to: Math.min(r.to, l.to) });
       }
     }
   }
   return t;
 }
-function bs(n) {
+function ms(s) {
   const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
-  for (const s of n) {
-    const o = et(s), i = e.get(s.lane) ?? [];
+  for (const n of s) {
+    const i = et(n), o = e.get(n.lane) ?? [];
     let r = 0;
-    if (o.from < o.to) {
-      for (const a of i) o.from < a.to && a.from < o.to && r++;
-      i.push(o);
+    if (i.from < i.to) {
+      for (const a of o) i.from < a.to && a.from < i.to && r++;
+      o.push(i);
     }
-    e.set(s.lane, i), t.set(s.id, r);
+    e.set(n.lane, o), t.set(n.id, r);
   }
   return t;
 }
-function Wt(n, t) {
-  const e = new Map(n.map((o) => [o.id, o])), s = [];
-  for (const o of t) {
-    const i = e.get(o.from), r = e.get(o.to);
-    if (i === void 0 || r === void 0) continue;
-    const a = Yt(o, i), l = Kt(o, r), h = a + o.lag - l;
-    h > 0 && s.push({ dependency: o.id, departure: a, arrival: l, shortBy: h });
+function Yt(s, t) {
+  const e = new Map(s.map((i) => [i.id, i])), n = [];
+  for (const i of t) {
+    const o = e.get(i.from), r = e.get(i.to);
+    if (o === void 0 || r === void 0) continue;
+    const a = $t(i, o), l = Gt(i, r), d = a + i.lag - l;
+    d > 0 && n.push({ dependency: i.id, departure: a, arrival: l, shortBy: d });
   }
-  return s;
+  return n;
 }
-function Be(n, t) {
+function Ee(s, t) {
   const e = [];
-  for (const s of n) {
-    const o = et(s);
-    for (const i of t)
-      i.lane !== s.lane || !(o.from < i.to && i.from < o.to) || e.push({ subtask: s.id, blocked: i.id, lane: i.lane, from: Math.max(o.from, i.from), to: Math.min(o.to, i.to) });
+  for (const n of s) {
+    const i = et(n);
+    for (const o of t)
+      o.lane !== n.lane || !(i.from < o.to && o.from < i.to) || e.push({ subtask: n.id, blocked: o.id, lane: o.lane, from: Math.max(i.from, o.from), to: Math.min(i.to, o.to) });
   }
   return e;
 }
-function vo(n, t, e = []) {
+function ui(s, t, e = []) {
   return {
-    overlaps: Vt(n),
-    violatedDependencies: Wt(n, t),
-    inBlockedTime: Be(n, e)
+    overlaps: Ht(s),
+    violatedDependencies: Yt(s, t),
+    inBlockedTime: Ee(s, e)
   };
 }
-function wo(n, t, e) {
+function ci(s, t, e) {
   if (e.kind === "place") return [];
-  const s = new Map(n.map((l) => [l.id, me(l, e)])), o = /* @__PURE__ */ new Map();
+  const n = new Map(s.map((l) => [l.id, he(l, e)])), i = /* @__PURE__ */ new Map();
   for (const l of t) {
-    const h = o.get(l.from) ?? [];
-    h.push(l), o.set(l.from, h);
+    const d = i.get(l.from) ?? [];
+    d.push(l), i.set(l.from, d);
   }
-  const i = /* @__PURE__ */ new Map(), r = [e.subtask];
-  let a = (n.length + 1) * (t.length + 1);
+  const o = /* @__PURE__ */ new Map(), r = [e.subtask];
+  let a = (s.length + 1) * (t.length + 1);
   for (; r.length > 0 && a-- > 0; ) {
-    const l = r.shift(), h = s.get(l);
-    if (h !== void 0)
-      for (const d of o.get(l) ?? []) {
-        if (d.to === e.subtask) continue;
-        const u = s.get(d.to);
-        if (u === void 0) continue;
-        const m = Yt(d, h) + d.lag - Kt(d, u);
-        if (!(m > 0)) continue;
-        const p = { kind: "move", subtask: u.id, from: u.from + m, to: u.to + m };
-        s.set(u.id, me(u, p)), i.set(u.id, p), r.push(u.id);
+    const l = r.shift(), d = n.get(l);
+    if (d !== void 0)
+      for (const h of i.get(l) ?? []) {
+        if (h.to === e.subtask) continue;
+        const c = n.get(h.to);
+        if (c === void 0) continue;
+        const f = $t(h, d) + h.lag - Gt(h, c);
+        if (!(f > 0)) continue;
+        const g = { kind: "move", subtask: c.id, from: c.from + f, to: c.to + f };
+        n.set(c.id, he(c, g)), o.set(c.id, g), r.push(c.id);
       }
   }
-  return [...i.values()];
+  return [...o.values()];
 }
-function Ms(n, t) {
-  const { step: e, offset: s } = typeof t == "number" ? { step: t, offset: 0 } : t;
-  if (!(e > 0) || !Number.isFinite(n)) return n;
-  const o = Bt(n) + s;
-  return o + Math.round((n - o) / e) * e;
+function ps(s, t) {
+  const { step: e, offset: n } = typeof t == "number" ? { step: t, offset: 0 } : t;
+  if (!(e > 0) || !Number.isFinite(s)) return s;
+  const i = Bt(s) + n;
+  return i + Math.round((s - i) / e) * e;
 }
-function bo(n, t, e) {
-  return e === 0 || !Number.isFinite(e) ? [] : n.filter((s) => s.task === t).map((s) => ({ kind: "move", subtask: s.id, from: s.from + e, to: s.to + e }));
+function fi(s, t, e) {
+  return e === 0 || !Number.isFinite(e) ? [] : s.filter((n) => n.task === t).map((n) => ({ kind: "move", subtask: n.id, from: n.from + e, to: n.to + e }));
 }
-function kt(n) {
-  let t = !1, e = !1, s = !1, o = !1;
-  for (const i of n ?? [])
-    i === "provisional" ? (t = !0, e = !1) : i === "fixed" ? (e = !0, t = !1) : i === "muted" ? s = !0 : i === "open" && (o = !0);
-  return { dashed: t, hatched: e, muted: s, open: o };
+function pt(s) {
+  let t = !1, e = !1, n = !1, i = !1;
+  for (const o of s ?? [])
+    o === "provisional" ? (t = !0, e = !1) : o === "fixed" ? (e = !0, t = !1) : o === "muted" ? n = !0 : o === "open" && (i = !0);
+  return { dashed: t, hatched: e, muted: n, open: i };
 }
-const xe = Ne(null), Ge = Ne(null);
-function He() {
-  return Re(Ge);
+const Pe = /* @__PURE__ */ Fe(null), Be = /* @__PURE__ */ Fe(null);
+function Ne() {
+  return _e(Be);
 }
-function Ts(n) {
-  const t = Re(xe);
+function gs(s) {
+  const t = _e(Pe);
   if (t === null)
-    throw new Error(`@umriss-ui/schedule: <${n}> must be used inside a <Schedule>.`);
+    throw new Error(`@umriss-ui/schedule: <${s}> must be used inside a <Schedule>.`);
   return t;
 }
-function Ut(n, t, e, s, o) {
-  const i = Ts(n), r = V(null);
-  z(() => (r.current = e(i, t), () => {
-    r.current !== null && o(i, r.current), r.current = null;
-  }), [i]), z(() => {
-    r.current !== null && s(i, r.current, t);
+function Kt(s, t, e, n, i) {
+  const o = gs(s), r = Y(null);
+  W(() => (r.current = e(o, t), () => {
+    r.current !== null && i(o, r.current), r.current = null;
+  }), [o]), W(() => {
+    r.current !== null && n(o, r.current, t);
   });
 }
-function Is(n) {
-  Ut("Lane", n, (t, e) => t.registerLane(e), (t, e, s) => t.updateLane(e, s), (t, e) => t.unregisterLane(e));
-}
-function Ss(n) {
-  Ut("LaneGroup", n, (t, e) => t.registerGroup(e), (t, e, s) => t.updateGroup(e, s), (t, e) => t.unregisterGroup(e));
-}
-function yt(n, t) {
-  Ut(n, t, (e, s) => e.registerLayer(s), (e, s, o) => e.updateLayer(s, o), (e, s) => e.unregisterLayer(s));
-}
-const Ls = 24, As = 4, Cs = 3, At = 4;
-function pe(n) {
-  const { lanes: t, groups: e, collapsed: s, laneHeight: o } = n, i = new Map(e.map((k) => [k.id, k])), r = (k) => k !== void 0 && i.has(k) ? k : void 0, a = /* @__PURE__ */ new Map(), l = (k) => {
-    const T = [];
-    let S = r(k.parent);
-    const E = /* @__PURE__ */ new Set();
-    for (; S !== void 0 && !E.has(S); )
-      E.add(S), T.unshift(S), S = r(i.get(S).parent);
-    return T;
-  }, h = /* @__PURE__ */ new Map();
-  for (const k of t) {
-    const T = l(k);
-    h.set(k.id, T);
-    for (const S of T) {
-      const E = a.get(S) ?? [];
-      E.push(k.id), a.set(S, E);
+function ks(s) {
+  Kt("Lane", s, (t, e) => t.registerLane(e), (t, e, n) => t.updateLane(e, n), (t, e) => t.unregisterLane(e));
+}
+function vs(s) {
+  Kt("LaneGroup", s, (t, e) => t.registerGroup(e), (t, e, n) => t.updateGroup(e, n), (t, e) => t.unregisterGroup(e));
+}
+function gt(s, t) {
+  Kt(s, t, (e, n) => e.registerLayer(n), (e, n, i) => e.updateLayer(n, i), (e, n) => e.unregisterLayer(n));
+}
+const ys = 24, ws = 4, bs = 3, It = 4;
+function ue(s) {
+  const { lanes: t, groups: e, collapsed: n, laneHeight: i } = s, o = new Map(e.map((p) => [p.id, p])), r = (p) => p !== void 0 && o.has(p) ? p : void 0, a = /* @__PURE__ */ new Map(), l = (p) => {
+    const M = [];
+    let T = r(p.parent);
+    const F = /* @__PURE__ */ new Set();
+    for (; T !== void 0 && !F.has(T); )
+      F.add(T), M.unshift(T), T = r(o.get(T).parent);
+    return M;
+  }, d = /* @__PURE__ */ new Map();
+  for (const p of t) {
+    const M = l(p);
+    d.set(p.id, M);
+    for (const T of M) {
+      const F = a.get(T) ?? [];
+      F.push(p.id), a.set(T, F);
     }
   }
-  const d = [], u = /* @__PURE__ */ new Map();
-  let m = [], p = null, y = 0;
-  const I = (k) => (d.push({ ...k, top: y }), y += k.height, d.length - 1), A = (k) => k.find((T) => s.has(T)), C = () => {
-    if (p === null) return;
-    const { row: k, lanes: T } = p, S = d[k], E = Math.max(S.height, T.length * As + 2 * At);
-    d[k] = { ...S, height: E }, y += E - S.height;
-    const _ = E - 2 * At, P = Math.max(Cs, Math.floor(_ / T.length));
-    T.forEach((st, vt) => {
-      const ht = h.get(st) ?? [];
-      u.set(st, {
-        top: S.top + At + vt * P,
-        height: P,
+  const h = [], c = /* @__PURE__ */ new Map();
+  let f = [], g = null, v = 0;
+  const A = (p) => (h.push({ ...p, top: v }), v += p.height, h.length - 1), C = (p) => p.find((M) => n.has(M)), S = () => {
+    if (g === null) return;
+    const { row: p, lanes: M } = g, T = h[p], F = Math.max(T.height, M.length * ws + 2 * It);
+    h[p] = { ...T, height: F }, v += F - T.height;
+    const D = F - 2 * It, $ = Math.max(bs, Math.floor(D / M.length));
+    M.forEach((dt, kt) => {
+      const j = d.get(dt) ?? [];
+      c.set(dt, {
+        top: T.top + It + kt * $,
+        height: $,
         miniature: !0,
-        group: ht[ht.length - 1]
+        group: j[j.length - 1]
       });
-    }), p = null;
+    }), g = null;
   };
-  for (const k of t) {
-    const T = (h.get(k.id) ?? []).filter((_) => (a.get(_) ?? []).length > 0), S = A(T);
-    if (p !== null && S === p.group) {
-      p.lanes.push(k.id);
+  for (const p of t) {
+    const M = (d.get(p.id) ?? []).filter((D) => (a.get(D) ?? []).length > 0), T = C(M);
+    if (g !== null && T === g.group) {
+      g.lanes.push(p.id);
       continue;
     }
-    C();
-    const E = T.filter((_, P) => m[P] === _).length;
-    m = m.slice(0, E);
-    for (const _ of T.slice(E)) {
-      if (m.push(_), _ === S) break;
-      I({
+    S();
+    const F = M.filter((D, $) => f[$] === D).length;
+    f = f.slice(0, F);
+    for (const D of M.slice(F)) {
+      if (f.push(D), D === T) break;
+      A({
         kind: "groupHead",
         lane: void 0,
-        group: _,
-        depth: m.length - 1,
-        within: [...m],
-        lanes: (a.get(_) ?? []).length,
-        height: Ls
+        group: D,
+        depth: f.length - 1,
+        within: [...f],
+        lanes: (a.get(D) ?? []).length,
+        height: ys
       });
     }
-    if (S !== void 0) {
-      const _ = T.indexOf(S), P = I({
+    if (T !== void 0) {
+      const D = M.indexOf(T), $ = A({
         kind: "miniature",
         lane: void 0,
-        group: S,
-        depth: _,
-        within: T.slice(0, _ + 1),
-        lanes: (a.get(S) ?? []).length,
-        height: o
+        group: T,
+        depth: D,
+        within: M.slice(0, D + 1),
+        lanes: (a.get(T) ?? []).length,
+        height: i
       });
-      p = { group: S, row: P, lanes: [k.id] };
+      g = { group: T, row: $, lanes: [p.id] };
       continue;
     }
-    I({ kind: "lane", lane: k.id, group: T[T.length - 1], depth: T.length, within: T, lanes: 1, height: o }), u.set(k.id, {
-      top: d[d.length - 1].top,
-      height: o,
+    A({ kind: "lane", lane: p.id, group: M[M.length - 1], depth: M.length, within: M, lanes: 1, height: i }), c.set(p.id, {
+      top: h[h.length - 1].top,
+      height: i,
       miniature: !1,
-      group: T[T.length - 1]
+      group: M[M.length - 1]
     });
   }
-  return C(), { rows: d, slots: u, height: y };
+  return S(), { rows: h, slots: c, height: v };
 }
-function Ds(n, t) {
-  if (t.size === 0) return n;
+function Ms(s, t) {
+  if (t.size === 0) return s;
   const e = /* @__PURE__ */ new Set();
-  for (const s of n) t.has(s) || e.add(s);
+  for (const n of s) t.has(n) || e.add(n);
   return e;
 }
-function tt(n, t) {
-  if (t < 0 || t >= n.height) return null;
-  let e = 0, s = n.rows.length - 1;
-  for (; e <= s; ) {
-    const o = e + s >> 1, i = n.rows[o];
-    if (t < i.top) s = o - 1;
-    else if (t >= i.top + i.height) e = o + 1;
-    else return i;
+function tt(s, t) {
+  if (t < 0 || t >= s.height) return null;
+  let e = 0, n = s.rows.length - 1;
+  for (; e <= n; ) {
+    const i = e + n >> 1, o = s.rows[i];
+    if (t < o.top) n = i - 1;
+    else if (t >= o.top + o.height) e = i + 1;
+    else return o;
   }
   return null;
 }
-function zt(n, t) {
-  return n.slots.get(t) ?? null;
+function Vt(s, t) {
+  return s.slots.get(t) ?? null;
 }
-function _s(n, t) {
-  const e = tt(n, t);
+function Ts(s, t) {
+  const e = tt(s, t);
   if (e === null) return null;
   if (e.kind === "lane") return e.lane ?? null;
   if (e.kind === "groupHead") return null;
-  for (const [s, o] of n.slots)
-    if (o.miniature && t >= o.top && t < o.top + o.height) return s;
+  for (const [n, i] of s.slots)
+    if (i.miniature && t >= i.top && t < i.top + i.height) return n;
   return null;
 }
-const Fs = 6, Ye = 3, nt = 2, ge = 3, ke = 3;
-function R(n, t) {
-  return Math.round(n.scale.toPx(H(t, n.calendar)));
+const Is = 6, xe = 3, st = 2, ce = 3, fe = 3;
+function P(s, t) {
+  return Math.round(s.scale.toPx(R(t, s.calendar)));
 }
-function j(n, t) {
-  const e = zt(n.rows, t);
-  return e === null ? null : { ...e, top: e.top - n.scrollY };
+function q(s, t) {
+  const e = Vt(s.rows, t);
+  return e === null ? null : { ...e, top: e.top - s.scrollY };
 }
-function Xt(n, t) {
-  const e = j(n, t.lane);
-  return e === null ? null : { x: R(n, t.at), y: e.top + e.height / 2, half: Math.max(2, Math.min(7, e.height * 0.3)) };
+function Wt(s, t) {
+  const e = q(s, t.lane);
+  return e === null ? null : { x: P(s, t.at), y: e.top + e.height / 2, half: Math.max(2, Math.min(7, e.height * 0.3)) };
 }
-function ye(n, t) {
-  return _s(n.rows, t + n.scrollY);
+function me(s, t) {
+  return Ts(s.rows, t + s.scrollY);
 }
-function Ke(n, t, e, s) {
-  const o = e.miniature ? 0 : Fs, i = e.miniature ? 0 : ke * ge, r = Math.max(e.miniature ? 1 : 4, e.height - 2 * o - i), a = e.top - n.scrollY + Math.floor((e.height - r) / 2), l = et(t);
+function Re(s, t, e, n) {
+  const i = e.miniature ? 0 : Is, o = e.miniature ? 0 : fe * ce, r = Math.max(e.miniature ? 1 : 4, e.height - 2 * i - o), a = e.top - s.scrollY + Math.floor((e.height - r) / 2), l = et(t);
   return {
     subtask: t,
     miniature: e.miniature,
-    depth: s,
-    y: a + (e.miniature ? 0 : Math.min(s, ke) * ge),
+    depth: n,
+    y: a + (e.miniature ? 0 : Math.min(n, fe) * ce),
     height: r,
-    outerFrom: R(n, l.from),
-    mainFrom: R(n, t.from),
-    mainTo: R(n, t.to),
-    outerTo: R(n, l.to)
+    outerFrom: P(s, l.from),
+    mainFrom: P(s, t.from),
+    mainTo: P(s, t.to),
+    outerTo: P(s, l.to)
   };
 }
-function Ve(n, t, e) {
-  if (e < n.y || e > n.y + n.height) return null;
-  const s = Math.max(0, (6 - (n.outerTo - n.outerFrom)) / 2);
-  return t < n.outerFrom - s || t > n.outerTo + s ? null : t < n.mainFrom ? "leadIn" : t > n.mainTo ? "leadOut" : "main";
-}
-function Os(n, t, e, s = 5) {
-  if (e < n.y || e > n.y + n.height) return null;
-  const o = Math.abs(t - n.mainFrom), i = Math.abs(t - n.mainTo);
-  return Math.min(o, i) > s ? null : o <= i ? "from" : "to";
-}
-function Ot(n, t, e) {
-  return n.outerTo >= 0 && n.outerFrom <= t && n.y + n.height >= 0 && n.y <= e;
-}
-const Es = 64;
-function Ns(n, t) {
-  if (n.miniature) return null;
-  const e = kt(n.subtask.appearance).hatched ? nt + Ye + 1 : 0, s = Math.max(n.mainFrom + e, 0), o = Math.min(n.mainTo - e, t) - s;
-  return o < Es ? null : { x: s, width: o, y: n.y, height: n.height };
-}
-const Rs = 10;
-function ve(n, t, e) {
-  const s = Math.round(t.y + t.height / 2);
-  return n === "centre" || e.y === t.y ? s : Math.round(e.y > t.y ? t.y + t.height - 1 : t.y + 1);
-}
-function Et(n, t, e, s, o) {
-  const i = t.route ?? o.route, r = t.attach ?? o.attach, a = t.ends ?? o.ends, l = R(n, Yt(t, e.subtask)), h = R(n, Kt(t, s.subtask)), d = ve(r, e, s), u = ve(r, s, e);
-  if (i === "straight")
-    return { dependency: t, kind: i, ends: a, x1: l, y1: d, x2: h, y2: u, c1x: l, c2x: h, points: [l, d, h, u] };
-  if (i === "orthogonal") {
-    const A = l + Rs, C = d === u ? A : Math.round((A + h) / 2);
-    return { dependency: t, kind: i, ends: a, x1: l, y1: d, x2: h, y2: u, c1x: l, c2x: h, points: d === u ? [l, d, h, u] : [l, d, C, d, C, u, h, u] };
-  }
-  const m = Math.max(14, Math.abs(h - l) / 2), p = l + m, y = h - m, I = [];
-  for (let A = 0; A <= 16; A++) {
-    const C = A / 16, k = 1 - C;
-    I.push(
-      k * k * k * l + 3 * k * k * C * p + 3 * k * C * C * y + C * C * C * h,
-      k * k * k * d + 3 * k * k * C * d + 3 * k * C * C * u + C * C * C * u
+function $e(s, t, e) {
+  if (e < s.y || e > s.y + s.height) return null;
+  const n = Math.max(0, (6 - (s.outerTo - s.outerFrom)) / 2);
+  return t < s.outerFrom - n || t > s.outerTo + n ? null : t < s.mainFrom ? "leadIn" : t > s.mainTo ? "leadOut" : "main";
+}
+function Ss(s, t, e, n = 5) {
+  if (e < s.y || e > s.y + s.height) return null;
+  const i = Math.abs(t - s.mainFrom), o = Math.abs(t - s.mainTo);
+  return Math.min(i, o) > n ? null : i <= o ? "from" : "to";
+}
+function Dt(s, t, e) {
+  return s.outerTo >= 0 && s.outerFrom <= t && s.y + s.height >= 0 && s.y <= e;
+}
+function Ls(s, t, e) {
+  let i = Math.min(s.x1, s.x2, s.c1x, s.c2x), o = Math.max(s.x1, s.x2, s.c1x, s.c2x), r = Math.min(s.y1, s.y2), a = Math.max(s.y1, s.y2);
+  for (let l = 0; l + 1 < s.points.length; l += 2)
+    i = Math.min(i, s.points[l]), o = Math.max(o, s.points[l]), r = Math.min(r, s.points[l + 1]), a = Math.max(a, s.points[l + 1]);
+  return o >= -8 && i <= t + 8 && a >= -8 && r <= e + 8;
+}
+const As = 64;
+function Cs(s, t) {
+  if (s.miniature) return null;
+  const e = pt(s.subtask.appearance).hatched ? st + xe + 1 : 0, n = Math.max(s.mainFrom + e, 0), i = Math.min(s.mainTo - e, t) - n;
+  return i < As ? null : { x: n, width: i, y: s.y, height: s.height };
+}
+const Ds = 10;
+function pe(s, t, e) {
+  const n = Math.round(t.y + t.height / 2);
+  return s === "centre" || e.y === t.y ? n : Math.round(e.y > t.y ? t.y + t.height - 1 : t.y + 1);
+}
+function _t(s, t, e, n, i) {
+  const o = t.route ?? i.route, r = t.attach ?? i.attach, a = t.ends ?? i.ends, l = P(s, $t(t, e.subtask)), d = P(s, Gt(t, n.subtask)), h = pe(r, e, n), c = pe(r, n, e);
+  if (o === "straight")
+    return { dependency: t, kind: o, ends: a, x1: l, y1: h, x2: d, y2: c, c1x: l, c2x: d, points: [l, h, d, c] };
+  if (o === "orthogonal") {
+    const C = l + Ds, S = h === c ? C : Math.round((C + d) / 2);
+    return { dependency: t, kind: o, ends: a, x1: l, y1: h, x2: d, y2: c, c1x: l, c2x: d, points: h === c ? [l, h, d, c] : [l, h, S, h, S, c, d, c] };
+  }
+  const f = Math.max(14, Math.abs(d - l) / 2), g = l + f, v = d - f, A = [];
+  for (let C = 0; C <= 16; C++) {
+    const S = C / 16, p = 1 - S;
+    A.push(
+      p * p * p * l + 3 * p * p * S * g + 3 * p * S * S * v + S * S * S * d,
+      p * p * p * h + 3 * p * p * S * h + 3 * p * S * S * c + S * S * S * c
     );
   }
-  return { dependency: t, kind: "curve", ends: a, x1: l, y1: d, x2: h, y2: u, c1x: p, c2x: y, points: I };
+  return { dependency: t, kind: "curve", ends: a, x1: l, y1: h, x2: d, y2: c, c1x: g, c2x: v, points: A };
 }
-function Ps(n, t, e) {
-  let s = 1 / 0;
-  const o = n.points;
-  for (let i = 0; i + 3 < o.length; i += 2) {
-    const r = o[i], a = o[i + 1], l = o[i + 2], h = o[i + 3], d = l - r, u = h - a, m = d * d + u * u, p = m === 0 ? 0 : Math.max(0, Math.min(1, ((t - r) * d + (e - a) * u) / m));
-    s = Math.min(s, Math.hypot(t - (r + p * d), e - (a + p * u)));
+function _s(s, t, e) {
+  let n = 1 / 0;
+  const i = s.points;
+  for (let o = 0; o + 3 < i.length; o += 2) {
+    const r = i[o], a = i[o + 1], l = i[o + 2], d = i[o + 3], h = l - r, c = d - a, f = h * h + c * c, g = f === 0 ? 0 : Math.max(0, Math.min(1, ((t - r) * h + (e - a) * c) / f));
+    n = Math.min(n, Math.hypot(t - (r + g * h), e - (a + g * c)));
   }
-  return s;
+  return n;
 }
-const We = [], $s = 56;
-function Bs(n, t = $s) {
-  return n > 0 ? Math.min(X, Math.max(15 * q, cs(n * t, 1))) : 15 * q;
+const Ge = [], Fs = 56;
+function Os(s, t = Fs) {
+  return s > 0 ? Math.min(z, Math.max(15 * X, is(s * t, 1))) : 15 * X;
 }
-function xs(n, t, e = We) {
-  const [s, o] = Ue(n, e);
-  return us(e, s, o, t, Bt(s)).filter(
-    (i) => i.workingTime >= n[0] && i.workingTime <= n[1]
+function Es(s, t, e = Ge) {
+  const [n, i] = He(s, e);
+  return os(e, n, i, t, Bt(n)).filter(
+    (o) => o.workingTime >= s[0] && o.workingTime <= s[1]
   );
 }
-function Gs(n, t = We) {
-  const [e, s] = Ue(n, t), o = [], i = new Date(e);
-  for (i.setHours(0, 0, 0, 0); i.getTime() < s && o.length < 400; ) {
-    const r = i.getTime();
-    i.setDate(i.getDate() + 1);
-    const a = i.getTime();
-    o.push({
+function Ps(s, t = Ge) {
+  const [e, n] = He(s, t), i = [], o = new Date(e);
+  for (o.setHours(0, 0, 0, 0); o.getTime() < n && i.length < 400; ) {
+    const r = o.getTime();
+    o.setDate(o.getDate() + 1);
+    const a = o.getTime();
+    i.push({
       start: r,
-      from: H(r, t),
-      to: H(a, t)
+      from: R(r, t),
+      to: R(a, t)
     });
   }
-  return o;
+  return i;
 }
-const Ct = [1, 2, 7, 14, 28];
-function Hs(n, t) {
-  return Ct.find((e) => e * n >= t) ?? Ct[Ct.length - 1];
+const St = [1, 2, 7, 14, 28];
+function Bs(s, t) {
+  return St.find((e) => e * s >= t) ?? St[St.length - 1];
 }
-function Dt(n, t) {
-  return ((Math.round((n - Bt(n)) / X) - 4) % t + t) % t === 0;
+function Lt(s, t) {
+  return ((Math.round((s - Bt(s)) / z) - 4) % t + t) % t === 0;
 }
-function Ys(n, t, e, s) {
-  const o = n[1] - n[0];
-  if (!(o > 0)) return [n[0], n[1]];
-  const i = Math.min(s.max, Math.max(s.min, o * e)), r = (t - n[0]) / o, a = t - r * i;
-  return [a, a + i];
+function Ns(s, t, e, n) {
+  const i = s[1] - s[0];
+  if (!(i > 0)) return [s[0], s[1]];
+  const o = Math.min(n.max, Math.max(n.min, i * e)), r = (t - s[0]) / i, a = t - r * o;
+  return [a, a + o];
 }
-function Ks(n, t) {
-  return [n[0] + t, n[1] + t];
+function xs(s, t) {
+  return [s[0] + t, s[1] + t];
 }
-function at(n, t) {
-  const e = pt(t);
-  return e.intervals.length === 0 ? n : xt(Math.max(0, Math.min(e.total, n)), e);
+function rt(s, t) {
+  const e = ft(t);
+  return e.intervals.length === 0 ? s : Nt(Math.max(0, Math.min(e.total, s)), e);
 }
-function Ue(n, t) {
-  return [at(n[0], t), at(n[1], t)];
+function He(s, t) {
+  return [rt(s[0], t), rt(s[1], t)];
 }
-const Nt = 44;
-class Vs {
+const Ft = 44;
+class Rs {
   constructor(t) {
-    f(this, "options", {
-      laneHeight: Nt,
-      calendar: [],
-      zoomLimits: { min: Gt, max: 28 * X },
-      snap: "ticks",
-      intents: [],
-      now: null,
-      route: "curve",
-      attach: "centre",
-      ends: "dot"
-    });
-    f(this, "domain", [0, X]);
-    f(this, "scrollY", 0);
-    f(this, "width", 0);
-    f(this, "height", 0);
-    /* What is laid out from top to bottom (`rows.ts`). It is derived here and
-       not in the data, because a row's height comes from a view option; every y
-       in the package reads it. */
-    f(this, "rows", pe({ lanes: [], groups: [], collapsed: /* @__PURE__ */ new Set(), laneHeight: Nt }));
-    /** The folded groups, as the scene holds them. */
-    f(this, "collapsed", /* @__PURE__ */ new Set());
-    /** The groups a gesture in flight holds open. Dropped when it ends; the
-        caller's list never learns of it. */
-    f(this, "openForGesture", /* @__PURE__ */ new Set());
-    f(this, "boxes", []);
-    f(this, "boxById", /* @__PURE__ */ new Map());
-    f(this, "paths", []);
     this.data = t;
   }
+  options = {
+    laneHeight: Ft,
+    calendar: [],
+    zoomLimits: { min: xt, max: 28 * z },
+    snap: "ticks",
+    intents: [],
+    now: null,
+    route: "curve",
+    attach: "centre",
+    ends: "dot"
+  };
+  domain = [0, z];
+  scrollY = 0;
+  width = 0;
+  height = 0;
+  /* What is laid out from top to bottom (`rows.ts`). It is derived here and
+     not in the data, because a row's height comes from a view option; every y
+     in the package reads it. */
+  rows = ue({ lanes: [], groups: [], collapsed: /* @__PURE__ */ new Set(), laneHeight: Ft });
+  /** The folded groups, as the scene holds them. */
+  collapsed = /* @__PURE__ */ new Set();
+  /** The groups a gesture in flight holds open. Dropped when it ends; the
+      caller's list never learns of it. */
+  openForGesture = /* @__PURE__ */ new Set();
+  laidBoxes = [];
+  laidBoxById = /* @__PURE__ */ new Map();
+  laidPaths = [];
+  /** Whether the domain or the scroll moved since the layout; the layout is
+      then made when it is read and not once per event. */
+  moved = !1;
+  get boxes() {
+    return this.current(), this.laidBoxes;
+  }
+  get boxById() {
+    return this.current(), this.laidBoxById;
+  }
+  get paths() {
+    return this.current(), this.laidPaths;
+  }
+  /** Says the domain or the scroll moved: the next read of the layout makes it. */
+  invalidate() {
+    this.moved = !0;
+  }
+  current() {
+    this.moved && this.layout();
+  }
   /** Takes new options; a new calendar keeps the wall-clock span in view. */
   setOptions(t) {
-    const e = t.calendar !== this.options.calendar, s = this.options.calendar;
+    const e = t.calendar !== this.options.calendar, n = this.options.calendar;
     if (this.options = t, e) {
-      const o = pt(s), i = (r) => {
-        const a = o.intervals.length === 0 ? r : Math.max(0, Math.min(o.total, r));
-        return H(xt(a, o), t.calendar) + (r - a);
+      const i = ft(n), o = (r) => {
+        const a = i.intervals.length === 0 ? r : Math.max(0, Math.min(i.total, r));
+        return R(Nt(a, i), t.calendar) + (r - a);
       };
-      this.domain = [i(this.domain[0]), i(this.domain[1])];
+      this.domain = [o(this.domain[0]), o(this.domain[1])];
     }
   }
   /** Puts a span of two wall-clock instants in view. */
   showWall(t) {
-    this.domain = [H(t[0], this.options.calendar), H(t[1], this.options.calendar)];
+    this.domain = [R(t[0], this.options.calendar), R(t[1], this.options.calendar)];
   }
   viewport() {
     return {
-      scale: new fs(this.domain, [0, this.width]),
+      scale: new rs(this.domain, [0, this.width]),
       calendar: this.options.calendar,
       scrollY: this.scrollY,
       rows: this.rows
@@ -466,41 +488,41 @@ class Vs {
   /** The fine band's step at the current zoom. */
   step() {
     const t = this.domain[1] - this.domain[0];
-    return Bs(this.width > 0 ? t / this.width : t);
+    return Os(this.width > 0 ? t / this.width : t);
   }
   /** Lays the rows out, clamps the scroll, and lays the data out anew. */
   layout() {
-    this.rows = pe({
+    this.moved = !1, this.rows = ue({
       lanes: this.data.lanes,
       groups: this.data.groups,
-      collapsed: Ds(this.collapsed, this.openForGesture),
+      collapsed: Ms(this.collapsed, this.openForGesture),
       laneHeight: this.options.laneHeight
     }), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY));
     const t = this.viewport();
-    this.boxes = [], this.boxById = /* @__PURE__ */ new Map();
+    this.laidBoxes = [], this.laidBoxById = /* @__PURE__ */ new Map();
     for (const e of this.data.subtasks) {
-      const s = zt(this.rows, e.lane);
-      if (s === null) continue;
-      const o = Ke(t, e, s, this.data.depth.get(e.id) ?? 0);
-      this.boxes.push(o), this.boxById.set(e.id, o);
+      const n = Vt(this.rows, e.lane);
+      if (n === null) continue;
+      const i = Re(t, e, n, this.data.depth.get(e.id) ?? 0);
+      this.laidBoxes.push(i), this.laidBoxById.set(e.id, i);
     }
-    this.paths = [];
+    this.laidPaths = [];
     for (const e of this.data.dependencies) {
-      const s = this.boxById.get(e.from), o = this.boxById.get(e.to);
-      s === void 0 || o === void 0 || this.paths.push(Et(t, e, s, o, this.options));
+      const n = this.boxById.get(e.from), i = this.boxById.get(e.to);
+      n === void 0 || i === void 0 || this.laidPaths.push(_t(t, e, n, i, this.options));
     }
   }
   /** The days of the coarse band and the ticks of the fine band, in pixels. */
   bands() {
     const t = this.step();
     if (this.width <= 0) return { days: [], ticks: [], step: t };
-    const e = this.viewport().scale, s = this.options.calendar;
+    const e = this.viewport().scale, n = this.options.calendar;
     return {
-      days: Gs(this.domain, s).map((o) => {
-        const i = Math.round(e.toPx(o.from));
-        return { start: o.start, x: i, width: Math.round(e.toPx(o.to)) - i };
+      days: Ps(this.domain, n).map((i) => {
+        const o = Math.round(e.toPx(i.from));
+        return { start: i.start, x: o, width: Math.round(e.toPx(i.to)) - o };
       }),
-      ticks: xs(this.domain, t, s).map((o) => ({ wallClock: o.wallClock, x: Math.round(e.toPx(o.workingTime)) })),
+      ticks: Es(this.domain, t, n).map((i) => ({ wallClock: i.wallClock, x: Math.round(e.toPx(i.workingTime)) })),
       step: t
     };
   }
@@ -508,32 +530,32 @@ class Vs {
   nowX() {
     const t = this.options.now;
     if (t === null || this.width <= 0) return null;
-    const e = Math.round(this.viewport().scale.toPx(H(t, this.options.calendar)));
+    const e = Math.round(this.viewport().scale.toPx(R(t, this.options.calendar)));
     return e >= 0 && e <= this.width ? e : null;
   }
   hitAt(t, e) {
-    const s = this.viewport();
+    const n = this.viewport();
     for (let a = this.data.milestones.length - 1; a >= 0; a--) {
-      const l = this.data.milestones[a], h = Xt(s, l);
-      if (h !== null && Math.abs(t - h.x) + Math.abs(e - h.y) <= h.half + 2) return { kind: "milestone", milestone: l };
+      const l = this.data.milestones[a], d = Wt(n, l);
+      if (d !== null && Math.abs(t - d.x) + Math.abs(e - d.y) <= d.half + 2) return { kind: "milestone", milestone: l };
     }
     for (let a = this.boxes.length - 1; a >= 0; a--) {
-      const l = this.boxes[a], h = Ve(l, t, e);
-      if (h !== null) return { kind: "subtask", subtask: l.subtask, part: h };
+      const l = this.boxes[a], d = $e(l, t, e);
+      if (d !== null) return { kind: "subtask", subtask: l.subtask, part: d };
     }
-    let o = null, i = 4;
+    let i = null, o = 4;
     for (const a of this.paths) {
-      const l = Ps(a, t, e);
-      l <= i && (i = l, o = a);
+      const l = _s(a, t, e);
+      l <= o && (o = l, i = a);
     }
-    if (o !== null) return { kind: "dependency", dependency: o.dependency };
-    const r = ye(this.viewport(), e);
+    if (i !== null) return { kind: "dependency", dependency: i.dependency };
+    const r = me(this.viewport(), e);
     return r !== null ? { kind: "lane", lane: r } : { kind: "nothing" };
   }
   /** The wall-clock time at a plot x; within the calendar's extent. */
   timeAt(t) {
     const e = this.viewport().scale.fromPx(t);
-    return at(e, this.options.calendar);
+    return rt(e, this.options.calendar);
   }
   /** The lane at a y, strips included: what the pointer is ON.
   
@@ -542,7 +564,7 @@ class Vs {
         `foldedGroupAt` - and a caller that reached through `viewport()` for it
         would be depending on the layout rather than asking the view. */
   laneIdAt(t) {
-    return ye(this.viewport(), t);
+    return me(this.viewport(), t);
   }
   /** The lane a DROP at this y would land on.
   
@@ -563,471 +585,469 @@ class Vs {
   /** Pans by pixels. Says what moved: the span through time, the lanes, or
       neither - a scroll through the lanes is no news about the time. */
   pan(t, e) {
-    const s = this.domain[0], o = this.scrollY, i = this.domain[1] - s;
-    this.width > 0 && t !== 0 && (this.domain = Ks(this.domain, t / this.width * i)), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY + e));
-    const r = this.domain[0] !== s;
-    return { moved: r || this.scrollY !== o, time: r };
+    const n = this.domain[0], i = this.scrollY, o = this.domain[1] - n;
+    this.width > 0 && t !== 0 && (this.domain = xs(this.domain, t / this.width * o)), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY + e));
+    const r = this.domain[0] !== n;
+    return { moved: r || this.scrollY !== i, time: r };
   }
   /** Zooms around a plot x; says whether the span changed. */
   zoomAt(t, e) {
     if (this.width <= 0 || !Number.isFinite(e)) return !1;
-    const s = this.domain, o = this.viewport().scale.fromPx(t);
-    return this.domain = Ys(this.domain, o, e, this.options.zoomLimits), s[0] !== this.domain[0] || s[1] !== this.domain[1];
-  }
-}
-const Ws = "_root_1g7hg_4 _text_18806_22", Us = "_corner_1g7hg_19", zs = "_dayBand_1g7hg_23", Xs = "_tickBand_1g7hg_24", qs = "_day_1g7hg_23", js = "_dayLabel_1g7hg_50", Js = "_tick_1g7hg_24", Zs = "_tickLabel_1g7hg_71", Qs = "_headers_1g7hg_79", tn = "_header_1g7hg_79", en = "_headerLabel_1g7hg_97", sn = "_headerCount_1g7hg_133", nn = "_chevron_1g7hg_142", on = "_plot_1g7hg_197", rn = "_focusRing_1g7hg_204", an = "_layer_1g7hg_222", ln = "_grip_1g7hg_231", dn = "_ghostLabel_1g7hg_241", hn = "_finding_1g7hg_254", cn = "_refusal_1g7hg_262", un = "_tooltip_1g7hg_266", fn = "_tooltipHead_1g7hg_285", mn = "_tooltipTimes_1g7hg_290", pn = "_now_1g7hg_299", gn = "_barLabel_1g7hg_313", kn = "_barLabelText_1g7hg_326", v = {
-  root: Ws,
-  corner: Us,
-  dayBand: zs,
-  tickBand: Xs,
-  day: qs,
-  dayLabel: js,
-  tick: Js,
-  tickLabel: Zs,
-  headers: Qs,
-  header: tn,
-  headerLabel: en,
-  headerCount: sn,
-  chevron: nn,
-  plot: on,
-  focusRing: rn,
-  layer: an,
-  grip: ln,
-  ghostLabel: dn,
-  finding: hn,
-  refusal: cn,
-  tooltip: un,
-  tooltipHead: fn,
-  tooltipTimes: mn,
-  now: pn,
-  barLabel: gn,
-  barLabelText: kn
+    const n = this.domain, i = this.viewport().scale.fromPx(t);
+    return this.domain = Ns(this.domain, i, e, this.options.zoomLimits), n[0] !== this.domain[0] || n[1] !== this.domain[1];
+  }
+}
+const $s = "_root_1g7hg_4 _text_18806_22", Gs = "_corner_1g7hg_19", Hs = "_dayBand_1g7hg_23", Ys = "_tickBand_1g7hg_24", Ks = "_day_1g7hg_23", Vs = "_dayLabel_1g7hg_50", Ws = "_tick_1g7hg_24", zs = "_tickLabel_1g7hg_71", Us = "_headers_1g7hg_79", Xs = "_header_1g7hg_79", qs = "_headerLabel_1g7hg_97", js = "_headerCount_1g7hg_133", Js = "_chevron_1g7hg_142", Zs = "_plot_1g7hg_197", Qs = "_focusRing_1g7hg_204", tn = "_layer_1g7hg_222", en = "_grip_1g7hg_231", sn = "_ghostLabel_1g7hg_241", nn = "_finding_1g7hg_254", on = "_refusal_1g7hg_262", rn = "_tooltip_1g7hg_266", an = "_tooltipHead_1g7hg_285", ln = "_tooltipTimes_1g7hg_290", dn = "_now_1g7hg_299", hn = "_barLabel_1g7hg_313", un = "_barLabelText_1g7hg_326", k = {
+  root: $s,
+  corner: Gs,
+  dayBand: Hs,
+  tickBand: Ys,
+  day: Ks,
+  dayLabel: Vs,
+  tick: Ws,
+  tickLabel: zs,
+  headers: Us,
+  header: Xs,
+  headerLabel: qs,
+  headerCount: js,
+  chevron: Js,
+  plot: Zs,
+  focusRing: Qs,
+  layer: tn,
+  grip: en,
+  ghostLabel: sn,
+  finding: nn,
+  refusal: on,
+  tooltip: rn,
+  tooltipHead: an,
+  tooltipTimes: ln,
+  now: dn,
+  barLabel: hn,
+  barLabelText: un
 };
-function ze() {
-  const n = gt();
+function Ye() {
+  const s = mt();
   return (t) => {
-    const e = Math.round(t / q), s = Math.floor(e / 60), o = e % 60;
-    return [s > 0 ? n.hoursShort(s) : "", o > 0 || s === 0 ? n.minutesShort(o) : ""].filter(Boolean).join(" ");
+    const e = Math.round(t / X), n = Math.floor(e / 60), i = e % 60;
+    return [n > 0 ? s.hoursShort(n) : "", i > 0 || n === 0 ? s.minutesShort(i) : ""].filter(Boolean).join(" ");
   };
 }
-function yn({ target: n, lane: t }) {
-  const e = Ht(), s = gt(), o = ze(), i = (u) => e.time(new Date(u), !1);
-  if (n.kind === "subtask") {
-    const { subtask: u, task: m } = n, p = [
-      (m == null ? void 0 : m.name) ?? u.task,
-      u.name ?? u.id,
-      `${e.dateShort(new Date(u.from))} ${s.scheduleGhostTimes(i(u.from), i(u.to))}`,
-      ...n.overlapping.map((y) => s.scheduleOverlapWith(y.name ?? y.id)),
-      ...n.violatedDependencies.map((y) => s.scheduleViolatedBy(o(y.shortBy))),
-      ...n.blocked.map((y) => s.scheduleInBlockedTime(y.label))
+function cn({ target: s, lane: t }) {
+  const e = Rt(), n = mt(), i = Ye(), o = (c) => e.time(new Date(c), !1);
+  if (s.kind === "subtask") {
+    const { subtask: c, task: f } = s, g = [
+      f?.name ?? c.task,
+      c.name ?? c.id,
+      `${e.dateShort(new Date(c.from))} ${n.scheduleGhostTimes(o(c.from), o(c.to))}`,
+      ...s.overlapping.map((v) => n.scheduleOverlapWith(v.name ?? v.id)),
+      ...s.violatedDependencies.map((v) => n.scheduleViolatedBy(i(v.shortBy))),
+      ...s.blocked.map((v) => n.scheduleInBlockedTime(v.label))
     ];
-    return /* @__PURE__ */ G(it, { children: [
+    return /* @__PURE__ */ x(it, { children: [
       t,
-      `, ${p.join(", ")}`
+      `, ${g.join(", ")}`
     ] });
   }
-  if (n.kind === "milestone") {
-    const { milestone: u } = n;
-    return /* @__PURE__ */ G(it, { children: [
+  if (s.kind === "milestone") {
+    const { milestone: c } = s;
+    return /* @__PURE__ */ x(it, { children: [
       t,
-      `, ${s.scheduleMilestone(u.label ?? u.id)}, ${e.dateShort(new Date(u.at))} ${i(u.at)}`
+      `, ${n.scheduleMilestone(c.label ?? c.id)}, ${e.dateShort(new Date(c.at))} ${o(c.at)}`
     ] });
   }
-  const { dependency: r, task: a, from: l, to: h, violated: d } = n;
+  const { dependency: r, task: a, from: l, to: d, violated: h } = s;
   return [
-    (a == null ? void 0 : a.name) ?? (a == null ? void 0 : a.id) ?? r.id,
-    `${s.scheduleDependency} ${o(r.lag)}`,
-    s.scheduleRoute((l == null ? void 0 : l.name) ?? r.from, (h == null ? void 0 : h.name) ?? r.to),
-    ...d === void 0 ? [] : [s.scheduleViolatedBy(o(d.shortBy))]
+    a?.name ?? a?.id ?? r.id,
+    `${n.scheduleDependency} ${i(r.lag)}`,
+    n.scheduleRoute(l?.name ?? r.from, d?.name ?? r.to),
+    ...h === void 0 ? [] : [n.scheduleViolatedBy(i(h.shortBy))]
   ].join(", ");
 }
-function vn({ target: n }) {
-  const t = Ht(), e = gt(), s = (d) => t.time(new Date(d), !1), o = ze();
-  if (n.kind === "subtask") {
-    const { subtask: d, task: u } = n;
-    return /* @__PURE__ */ G(it, { children: [
-      /* @__PURE__ */ g("span", { className: v.tooltipHead, children: (u == null ? void 0 : u.name) ?? d.task }),
-      /* @__PURE__ */ g("span", { children: d.name ?? d.id }),
-      /* @__PURE__ */ g("span", { className: v.tooltipTimes, children: e.scheduleGhostTimes(s(d.from), s(d.to)) }),
-      (d.leadIn ?? 0) > 0 && /* @__PURE__ */ g("span", { children: `${e.scheduleLeadIn} ${o(d.leadIn)}` }),
-      (d.leadOut ?? 0) > 0 && /* @__PURE__ */ g("span", { children: `${e.scheduleLeadOut} ${o(d.leadOut)}` }),
-      n.overlapping.map((m) => /* @__PURE__ */ g("span", { className: v.finding, children: e.scheduleOverlapWith(m.name ?? m.id) }, m.id)),
-      n.violatedDependencies.map((m) => /* @__PURE__ */ g("span", { className: v.finding, children: e.scheduleViolatedBy(o(m.shortBy)) }, m.dependency)),
-      n.blocked.map((m) => /* @__PURE__ */ g("span", { className: v.finding, children: e.scheduleInBlockedTime(m.label) }, m.id))
+function fn({ target: s }) {
+  const t = Rt(), e = mt(), n = (h) => t.time(new Date(h), !1), i = Ye();
+  if (s.kind === "subtask") {
+    const { subtask: h, task: c } = s;
+    return /* @__PURE__ */ x(it, { children: [
+      /* @__PURE__ */ m("span", { className: k.tooltipHead, children: c?.name ?? h.task }),
+      /* @__PURE__ */ m("span", { children: h.name ?? h.id }),
+      /* @__PURE__ */ m("span", { className: k.tooltipTimes, children: e.scheduleGhostTimes(n(h.from), n(h.to)) }),
+      (h.leadIn ?? 0) > 0 && /* @__PURE__ */ m("span", { children: `${e.scheduleLeadIn} ${i(h.leadIn)}` }),
+      (h.leadOut ?? 0) > 0 && /* @__PURE__ */ m("span", { children: `${e.scheduleLeadOut} ${i(h.leadOut)}` }),
+      s.overlapping.map((f) => /* @__PURE__ */ m("span", { className: k.finding, children: e.scheduleOverlapWith(f.name ?? f.id) }, f.id)),
+      s.violatedDependencies.map((f) => /* @__PURE__ */ m("span", { className: k.finding, children: e.scheduleViolatedBy(i(f.shortBy)) }, f.dependency)),
+      s.blocked.map((f) => /* @__PURE__ */ m("span", { className: k.finding, children: e.scheduleInBlockedTime(f.label) }, f.id))
     ] });
   }
-  if (n.kind === "milestone") {
-    const { milestone: d } = n;
-    return /* @__PURE__ */ G(it, { children: [
-      /* @__PURE__ */ g("span", { className: v.tooltipHead, children: e.scheduleMilestone(d.label ?? d.id) }),
-      /* @__PURE__ */ g("span", { className: v.tooltipTimes, children: `${t.dateShort(new Date(d.at))} ${s(d.at)}` })
+  if (s.kind === "milestone") {
+    const { milestone: h } = s;
+    return /* @__PURE__ */ x(it, { children: [
+      /* @__PURE__ */ m("span", { className: k.tooltipHead, children: e.scheduleMilestone(h.label ?? h.id) }),
+      /* @__PURE__ */ m("span", { className: k.tooltipTimes, children: `${t.dateShort(new Date(h.at))} ${n(h.at)}` })
     ] });
   }
-  const { dependency: i, task: r, from: a, to: l, violated: h } = n;
-  return /* @__PURE__ */ G(it, { children: [
-    /* @__PURE__ */ g("span", { className: v.tooltipHead, children: (r == null ? void 0 : r.name) ?? (r == null ? void 0 : r.id) ?? i.id }),
-    /* @__PURE__ */ g("span", { children: e.scheduleRoute((a == null ? void 0 : a.name) ?? i.from, (l == null ? void 0 : l.name) ?? i.to) }),
-    /* @__PURE__ */ g("span", { children: `${e.scheduleDependency} ${o(i.lag)}` }),
-    h !== void 0 && /* @__PURE__ */ g("span", { className: v.finding, children: e.scheduleViolatedBy(o(h.shortBy)) })
+  const { dependency: o, task: r, from: a, to: l, violated: d } = s;
+  return /* @__PURE__ */ x(it, { children: [
+    /* @__PURE__ */ m("span", { className: k.tooltipHead, children: r?.name ?? r?.id ?? o.id }),
+    /* @__PURE__ */ m("span", { children: e.scheduleRoute(a?.name ?? o.from, l?.name ?? o.to) }),
+    /* @__PURE__ */ m("span", { children: `${e.scheduleDependency} ${i(o.lag)}` }),
+    d !== void 0 && /* @__PURE__ */ m("span", { className: k.finding, children: e.scheduleViolatedBy(i(d.shortBy)) })
   ] });
 }
-const wn = [], we = { min: Gt, max: 28 * X }, bn = [], be = 20, _t = 44, Mn = Pe(function(t, e) {
-  var ue;
+const mn = [], ge = { min: xt, max: 28 * z }, pn = [], ke = 20, At = 44;
+function gn(s) {
   const {
-    scene: s,
-    ariaLabel: o,
+    ref: t,
+    scene: e,
+    ariaLabel: n,
     height: i = 400,
-    laneHeight: r = Nt,
-    headerWidth: a = 160,
-    calendar: l = bn,
-    zoomLimits: h,
+    laneHeight: o = Ft,
+    headerWidth: r = 160,
+    calendar: a = pn,
+    zoomLimits: l,
     snap: d = "ticks",
-    intents: u = wn,
-    onIntent: m,
-    canMoveTo: p,
-    onInteraction: y,
-    selectedTask: I,
+    intents: h = mn,
+    onIntent: c,
+    canMoveTo: f,
+    onInteraction: g,
+    selectedTask: v,
     onSelectedTaskChange: A,
     placing: C,
-    route: k = "curve",
-    attach: T = "centre",
-    ends: S = "dot",
-    label: E,
-    tooltip: _,
-    now: P,
-    className: st,
-    style: vt,
-    children: ht
-  } = t, wt = ks(), jt = `${wt}-summary`, Jt = V(null), Zt = V(null), Qt = V(null), te = V(null), Y = Ht(), B = gt(), ee = (h == null ? void 0 : h.min) ?? we.min, se = (h == null ? void 0 : h.max) ?? we.max, ne = typeof d == "object" ? d.step : null, oe = typeof d == "object" ? d.offset : null, ie = typeof d == "object" ? null : d, [es, ss] = ot(() => Date.now());
-  z(() => {
-    if (P !== !0) return;
-    const c = setInterval(() => ss(Date.now()), q);
-    return () => clearInterval(c);
-  }, [P]);
-  const re = P === !0 ? es : typeof P == "number" ? P : null;
-  ut(() => {
-    const c = ie ?? { step: ne ?? 0, offset: oe ?? 0 };
-    s.setOptions({ laneHeight: r, calendar: l, zoomLimits: { min: ee, max: se }, snap: c, intents: u, now: re, route: k, attach: T, ends: S });
-  }, [s, r, l, ee, se, ie, ne, oe, u, re, k, T, S]), z(() => {
-    s.setHandlers({ onIntent: m, canMoveTo: p, onInteraction: y, onSelectedTaskChange: A });
-  }, [s, m, p, y, A]), ys(
-    e,
+    route: S = "curve",
+    attach: p = "centre",
+    ends: M = "dot",
+    label: T,
+    tooltip: F,
+    now: D,
+    className: $,
+    style: dt,
+    children: kt
+  } = s, j = hs(), Ut = `${j}-summary`, Xt = Y(null), qt = Y(null), jt = Y(null), Jt = Y(null), G = Rt(), B = mt(), Zt = l?.min ?? ge.min, Qt = l?.max ?? ge.max, te = typeof d == "object" ? d.step : null, ee = typeof d == "object" ? d.offset : null, se = typeof d == "object" ? null : d, [je, Je] = nt(() => Date.now());
+  W(() => {
+    if (D !== !0) return;
+    const u = setInterval(() => Je(Date.now()), X);
+    return () => clearInterval(u);
+  }, [D]);
+  const ne = D === !0 ? je : typeof D == "number" ? D : null;
+  ht(() => {
+    const u = se ?? { step: te ?? 0, offset: ee ?? 0 };
+    e.setOptions({ laneHeight: o, calendar: a, zoomLimits: { min: Zt, max: Qt }, snap: u, intents: h, now: ne, route: S, attach: p, ends: M });
+  }, [e, o, a, Zt, Qt, se, te, ee, h, ne, S, p, M]), W(() => {
+    e.setHandlers({ onIntent: c, canMoveTo: f, onInteraction: g, onSelectedTaskChange: A });
+  }, [e, c, f, g, A]), us(
+    t,
     () => ({
-      positionAt: (c, w) => s.positionAt(c, w),
-      clientPointOf: (c, w) => s.clientPointOf(c, w),
-      visibleDomain: () => s.visibleDomain()
+      positionAt: (u, y) => e.positionAt(u, y),
+      clientPointOf: (u, y) => e.clientPointOf(u, y),
+      visibleDomain: () => e.visibleDomain()
     }),
-    [s]
-  ), z(() => {
-    s.setControlledTask(I);
-  }, [s, I]), z(() => {
-    s.setPlacing(C ?? null);
-  }, [s, C]), z(() => {
-    const c = Jt.current, w = Zt.current, L = Qt.current, N = te.current;
-    if (!c || !w || !L || !N) return;
-    s.bind(c, w, L, N);
-    const D = w.getBoundingClientRect();
-    s.resize(D.width, D.height);
-    const F = new ResizeObserver((O) => {
-      var ct;
-      const x = (ct = O[O.length - 1]) == null ? void 0 : ct.contentRect;
-      x !== void 0 && s.resize(x.width, x.height);
+    [e]
+  ), W(() => {
+    e.setControlledTask(v);
+  }, [e, v]), W(() => {
+    e.setPlacing(C ?? null);
+  }, [e, C]), W(() => {
+    const u = Xt.current, y = qt.current, I = jt.current, E = Jt.current;
+    if (!u || !y || !I || !E) return;
+    e.bind(u, y, I, E);
+    const L = y.getBoundingClientRect();
+    e.resize(L.width, L.height);
+    const _ = new ResizeObserver((O) => {
+      const U = O[O.length - 1]?.contentRect;
+      U !== void 0 && e.resize(U.width, U.height);
     });
-    F.observe(w);
-    const $ = (O) => s.wheel(O);
-    c.addEventListener("wheel", $, { passive: !1 });
-    const K = (O) => {
-      O.key === "Escape" && s.cancelEdit() && O.preventDefault();
+    _.observe(y);
+    const H = (O) => e.wheel(O);
+    u.addEventListener("wheel", H, { passive: !1 });
+    const N = (O) => {
+      O.key === "Escape" && e.cancelEdit() && O.preventDefault();
     };
-    return window.addEventListener("keydown", K), () => {
-      window.removeEventListener("keydown", K), c.removeEventListener("wheel", $), F.disconnect(), s.unbind();
+    return window.addEventListener("keydown", N), () => {
+      window.removeEventListener("keydown", N), u.removeEventListener("wheel", H), _.disconnect(), e.unbind();
     };
-  }, [s]);
-  const b = $e(s.subscribe, s.getSnapshot, s.getServerSnapshot), ns = (c, w) => {
-    const L = new Date(c);
-    return w >= 200 ? Y.dateLong(L) : w >= 84 ? Y.date(L) : w >= _t ? Y.dateShort(L) : "";
-  }, os = b.days.reduce((c, w) => Math.max(c, w.width), 0), J = Hs(os, _t), ae = b.step >= X ? J : 1, M = b.ghost, Z = b.spoken, bt = b.summary, le = (c) => `${Y.dateShort(new Date(c))} ${Y.time(new Date(c), !1)}`, Mt = (c) => `${wt}-row-${encodeURIComponent(c.key)}`, is = W(() => {
-    const c = /* @__PURE__ */ new Map();
-    for (const w of b.headers)
-      for (const L of w.within)
-        w.kind === "groupHead" && L === w.group || c.set(L, [...c.get(L) ?? [], Mt(w)]);
-    return c;
-  }, [b.headers, wt]), de = V(null);
-  ut(() => {
-    var F;
-    const c = de.current;
-    if (c === null) return;
-    let w = !0;
-    const L = () => {
-      if (!w) return;
-      const $ = [...c.querySelectorAll("[data-lane-count]")];
-      for (const O of $) O.hidden = !1;
-      const K = $.some((O) => {
-        const x = O.previousElementSibling;
-        if (!(x instanceof HTMLElement)) return !1;
-        const ct = parseFloat(getComputedStyle(x).lineHeight);
-        return x.scrollWidth > x.clientWidth || x.clientHeight > ct * 1.5;
+  }, [e]);
+  const w = Oe(e.subscribe, e.getSnapshot, e.getServerSnapshot), Ze = (u, y) => {
+    const I = new Date(u);
+    return y >= 200 ? G.dateLong(I) : y >= 84 ? G.date(I) : y >= At ? G.dateShort(I) : "";
+  }, Qe = w.days.reduce((u, y) => Math.max(u, y.width), 0), J = Bs(Qe, At), ie = w.step >= z ? J : 1, b = w.ghost, Z = w.spoken, vt = w.summary, oe = (u) => `${G.dateShort(new Date(u))} ${G.time(new Date(u), !1)}`, yt = (u) => `${j}-row-${encodeURIComponent(u.key)}`, ts = K(() => {
+    const u = /* @__PURE__ */ new Map();
+    for (const y of w.headers)
+      for (const I of y.within)
+        y.kind === "groupHead" && I === y.group || u.set(I, [...u.get(I) ?? [], yt(y)]);
+    return u;
+  }, [w.headers, j]), re = Y(null);
+  ht(() => {
+    const u = re.current;
+    if (u === null) return;
+    let y = !0;
+    const I = () => {
+      if (!y) return;
+      const _ = [...u.querySelectorAll("[data-lane-count]")];
+      for (const N of _) N.hidden = !1;
+      const H = _.some((N) => {
+        const O = N.previousElementSibling;
+        if (!(O instanceof HTMLElement)) return !1;
+        const U = parseFloat(getComputedStyle(O).lineHeight);
+        return O.scrollWidth > O.clientWidth || O.clientHeight > U * 1.5;
       });
-      for (const O of $) O.hidden = K;
+      for (const N of _) N.hidden = H;
     };
-    L(), (F = document.fonts) == null || F.ready.then(L);
-    const N = new ResizeObserver(L);
-    N.observe(c);
-    const D = new MutationObserver(L);
-    return D.observe(c, { childList: !0, characterData: !0, subtree: !0 }), () => {
-      w = !1, N.disconnect(), D.disconnect();
+    I(), document.fonts?.ready.then(I);
+    const E = new ResizeObserver(I);
+    E.observe(u);
+    const L = new MutationObserver(I);
+    return L.observe(u, { childList: !0, characterData: !0, subtree: !0 }), () => {
+      y = !1, E.disconnect(), L.disconnect();
     };
   }, []);
-  const rs = W(() => new Set((M == null ? void 0 : M.refusedLanes) ?? []), [M == null ? void 0 : M.refusedLanes]), he = V(null), [Tt, as] = ot({ x: 0, y: 0, at: "" }), It = M === null ? "" : `${M.x}:${M.y}:${M.from}:${M.to}:${M.overlap}:${M.violated}:${M.refused}:${M.blocked}`;
-  ut(() => {
-    const c = he.current;
-    if (M === null || c === null) return;
-    const w = 4, L = M.y - c.offsetHeight - w, N = M.y + M.height + w, D = {
-      x: Math.max(2, Math.min(M.x, b.width - c.offsetWidth - 2)),
-      y: L >= 2 ? L : Math.min(N, b.height - c.offsetHeight - 2),
-      at: It
+  const es = K(() => new Set(b?.refusedLanes ?? []), [b?.refusedLanes]), ae = Y(null), [wt, ss] = nt({ x: 0, y: 0, at: "" }), bt = b === null ? "" : `${b.x}:${b.y}:${b.from}:${b.to}:${b.overlap}:${b.violated}:${b.refused}:${b.blocked}`;
+  ht(() => {
+    const u = ae.current;
+    if (b === null || u === null) return;
+    const y = 4, I = b.y - u.offsetHeight - y, E = b.y + b.height + y, L = {
+      x: Math.max(2, Math.min(b.x, w.width - u.offsetWidth - 2)),
+      y: I >= 2 ? I : Math.min(E, w.height - u.offsetHeight - 2),
+      at: bt
     };
-    as((F) => F.x === D.x && F.y === D.y && F.at === D.at ? F : D);
-  }, [M, It, b.width, b.height]);
-  const ce = V(null), [St, ls] = ot({ x: 0, y: 0, at: "" }), U = b.tooltip, Lt = U === null ? "" : `${U.x}:${U.y}:${U.target.kind}`;
-  return ut(() => {
-    const c = ce.current;
-    if (U === null || c === null) return;
-    const w = 12, L = (D, F, $) => {
-      const K = D + w, O = D - w - F, x = K + F <= $ - 4 || O < 4 ? K : O;
-      return Math.max(4, Math.min(x, $ - F - 4));
-    }, N = {
-      x: L(U.x, c.offsetWidth, b.width),
-      y: L(U.y, c.offsetHeight, b.height),
-      at: Lt
+    ss((_) => _.x === L.x && _.y === L.y && _.at === L.at ? _ : L);
+  }, [b, bt, w.width, w.height]);
+  const le = Y(null), [Mt, ns] = nt({ x: 0, y: 0, at: "" }), V = w.tooltip, Tt = V === null ? "" : `${V.x}:${V.y}:${V.target.kind}`;
+  return ht(() => {
+    const u = le.current;
+    if (V === null || u === null) return;
+    const y = 12, I = (L, _, H) => {
+      const N = L + y, O = L - y - _, U = N + _ <= H - 4 || O < 4 ? N : O;
+      return Math.max(4, Math.min(U, H - _ - 4));
+    }, E = {
+      x: I(V.x, u.offsetWidth, w.width),
+      y: I(V.y, u.offsetHeight, w.height),
+      at: Tt
     };
-    ls((D) => D.x === N.x && D.y === N.y && D.at === N.at ? D : N);
-  }, [U, Lt, b.width, b.height]), /* @__PURE__ */ G(xe.Provider, { value: s, children: [
-    /* @__PURE__ */ G(
+    ns((L) => L.x === E.x && L.y === E.y && L.at === E.at ? L : E);
+  }, [V, Tt, w.width, w.height]), /* @__PURE__ */ x(Pe, { value: e, children: [
+    /* @__PURE__ */ x(
       "div",
       {
-        ref: Jt,
+        ref: Xt,
         role: "figure",
-        "aria-label": o,
-        className: st ? `${v.root} ${st}` : v.root,
-        style: { height: `${i}px`, gridTemplateColumns: `min(${a}px, 40%) minmax(0, 1fr)`, ...vt },
+        "aria-label": n,
+        className: $ ? `${k.root} ${$}` : k.root,
+        style: { height: `${i}px`, gridTemplateColumns: `min(${r}px, 40%) minmax(0, 1fr)`, ...dt },
         children: [
-          /* @__PURE__ */ g("div", { className: v.corner }),
-          /* @__PURE__ */ g("div", { className: v.dayBand, "aria-hidden": "true", "data-schedule-days": "", "data-schedule-clip": "day band", children: b.days.map((c, w) => {
-            var $;
-            const L = J === 1 || w === 0 || Dt(c.start, J), N = J === 1 ? c.x + c.width : (($ = b.days.slice(w + 1).find((K) => Dt(K.start, J))) == null ? void 0 : $.x) ?? b.width, D = Math.max(0, -c.x), F = Math.min(N, b.width) - Math.max(c.x, 0);
-            return /* @__PURE__ */ g("span", { className: v.day, style: { left: `${c.x}px`, width: `${L ? N - c.x : c.width}px` }, children: /* @__PURE__ */ g("span", { className: v.dayLabel, "data-schedule-overlay": "day label", style: { marginLeft: `${D}px` }, children: L ? ns(c.start, J === 1 ? F : Math.min(F, _t)) : "" }) }, c.start);
+          /* @__PURE__ */ m("div", { className: k.corner }),
+          /* @__PURE__ */ m("div", { className: k.dayBand, "aria-hidden": "true", "data-schedule-days": "", "data-schedule-clip": "day band", children: w.days.map((u, y) => {
+            const I = J === 1 || y === 0 || Lt(u.start, J), E = J === 1 ? u.x + u.width : w.days.slice(y + 1).find((H) => Lt(H.start, J))?.x ?? w.width, L = Math.max(0, -u.x), _ = Math.min(E, w.width) - Math.max(u.x, 0);
+            return /* @__PURE__ */ m("span", { className: k.day, style: { left: `${u.x}px`, width: `${I ? E - u.x : u.width}px` }, children: /* @__PURE__ */ m("span", { className: k.dayLabel, "data-schedule-overlay": "day label", style: { marginLeft: `${L}px` }, children: I ? Ze(u.start, J === 1 ? _ : Math.min(_, At)) : "" }) }, u.start);
           }) }),
-          /* @__PURE__ */ g("div", { ref: de, className: v.headers, "data-schedule-headers": "", children: /* @__PURE__ */ g("div", { className: v.headerRun, style: { transform: `translateY(${-b.scrollY}px)` }, children: b.headers.map((c) => /* @__PURE__ */ G(
+          /* @__PURE__ */ m("div", { ref: re, className: k.headers, "data-schedule-headers": "", children: /* @__PURE__ */ m("div", { className: k.headerRun, style: { transform: `translateY(${-w.scrollY}px)` }, children: w.headers.map((u) => /* @__PURE__ */ x(
             "div",
             {
-              id: Mt(c),
-              className: v.header,
-              style: { height: `${c.height}px`, paddingLeft: `calc(var(--u-space-3) + ${c.depth} * var(--u-space-3))` },
-              "data-lane": c.lane,
-              "data-group": c.group,
-              "data-row": c.kind,
-              "data-schedule-clip": `header ${c.kind}`,
-              "data-refused": c.lane !== void 0 && rs.has(c.lane) ? "" : void 0,
+              id: yt(u),
+              className: k.header,
+              style: { height: `${u.height}px`, paddingLeft: `calc(var(--u-space-3) + ${u.depth} * var(--u-space-3))` },
+              "data-lane": u.lane,
+              "data-group": u.group,
+              "data-row": u.kind,
+              "data-schedule-clip": `header ${u.kind}`,
+              "data-refused": u.lane !== void 0 && es.has(u.lane) ? "" : void 0,
               children: [
-                c.kind !== "lane" && c.group !== void 0 && /* @__PURE__ */ g(
+                u.kind !== "lane" && u.group !== void 0 && /* @__PURE__ */ m(
                   "button",
                   {
                     type: "button",
-                    className: v.chevron,
+                    className: k.chevron,
                     "data-schedule-overlay": "fold control",
-                    "aria-expanded": c.collapsed === !1,
-                    "aria-controls": (is.get(c.group) ?? [Mt(c)]).join(" "),
-                    "aria-label": `${c.collapsed === !0 ? B.scheduleUnfoldGroup : B.scheduleFoldGroup}: ${typeof c.label == "string" ? c.label : c.group}`,
-                    onClick: () => s.toggleGroup(c.group),
-                    children: /* @__PURE__ */ g(ws, { size: 9, "data-open": c.collapsed === !1 ? "" : void 0 })
+                    "aria-expanded": u.collapsed === !1,
+                    "aria-controls": (ts.get(u.group) ?? [yt(u)]).join(" "),
+                    "aria-label": `${u.collapsed === !0 ? B.scheduleUnfoldGroup : B.scheduleFoldGroup}: ${typeof u.label == "string" ? u.label : u.group}`,
+                    onClick: () => e.toggleGroup(u.group),
+                    children: /* @__PURE__ */ m(fs, { size: 9, "data-open": u.collapsed === !1 ? "" : void 0 })
                   }
                 ),
-                /* @__PURE__ */ g("span", { className: v.headerLabel, "data-schedule-overlay": "header label", children: c.label }),
-                c.kind !== "lane" && /* @__PURE__ */ g("span", { className: v.headerCount, "data-schedule-overlay": "lane count", "data-lane-count": c.lanes, children: B.scheduleLaneCount(c.lanes) })
+                /* @__PURE__ */ m("span", { className: k.headerLabel, "data-schedule-overlay": "header label", children: u.label }),
+                u.kind !== "lane" && /* @__PURE__ */ m("span", { className: k.headerCount, "data-schedule-overlay": "lane count", "data-lane-count": u.lanes, children: B.scheduleLaneCount(u.lanes) })
               ]
             },
-            c.key
+            u.key
           )) }) }),
-          /* @__PURE__ */ G(
+          /* @__PURE__ */ x(
             "div",
             {
-              ref: Zt,
-              className: v.plot,
+              ref: qt,
+              className: k.plot,
               "data-schedule-plot": "",
               "data-schedule-clip": "plot",
-              style: { cursor: b.cursor },
+              style: { cursor: w.cursor },
               tabIndex: 0,
               role: "application",
               "aria-roledescription": B.scheduleRoleDescription,
-              "aria-label": o,
-              "aria-describedby": jt,
-              onKeyDown: (c) => {
-                s.key(c.nativeEvent) && c.preventDefault();
+              "aria-label": n,
+              "aria-describedby": Ut,
+              onKeyDown: (u) => {
+                e.key(u.nativeEvent) && u.preventDefault();
               },
-              onFocus: (c) => s.focus(Tn(c.currentTarget)),
-              onBlur: () => s.blur(),
-              onPointerDown: (c) => s.pointerDown(c.nativeEvent),
-              onPointerMove: (c) => s.pointerMove(c.nativeEvent),
-              onPointerUp: (c) => s.pointerUp(c.nativeEvent),
-              onPointerCancel: (c) => s.pointerCancel(c.nativeEvent),
-              onPointerLeave: () => s.pointerLeave(),
-              onContextMenu: (c) => s.contextMenu(c.nativeEvent),
-              onDragOver: (c) => s.dragOver(c.nativeEvent),
-              onDrop: (c) => s.drop(c.nativeEvent),
-              onDragLeave: (c) => {
-                const w = c.nativeEvent.relatedTarget;
-                (!(w instanceof Node) || !c.currentTarget.contains(w)) && s.dragLeave();
+              onFocus: (u) => e.focus(kn(u.currentTarget)),
+              onBlur: () => e.blur(),
+              onPointerDown: (u) => e.pointerDown(u.nativeEvent),
+              onPointerMove: (u) => e.pointerMove(u.nativeEvent),
+              onPointerUp: (u) => e.pointerUp(u.nativeEvent),
+              onPointerCancel: (u) => e.pointerCancel(u.nativeEvent),
+              onPointerLeave: () => e.pointerLeave(),
+              onContextMenu: (u) => e.contextMenu(u.nativeEvent),
+              onDragOver: (u) => e.dragOver(u.nativeEvent),
+              onDrop: (u) => e.drop(u.nativeEvent),
+              onDragLeave: (u) => {
+                const y = u.nativeEvent.relatedTarget;
+                (!(y instanceof Node) || !u.currentTarget.contains(y)) && e.dragLeave();
               },
               children: [
-                /* @__PURE__ */ g("canvas", { ref: Qt, className: v.layer, "aria-hidden": "true" }),
-                /* @__PURE__ */ g("canvas", { ref: te, className: v.layer, "aria-hidden": "true" }),
-                b.grips.map((c) => /* @__PURE__ */ g(
+                /* @__PURE__ */ m("canvas", { ref: jt, className: k.layer, "aria-hidden": "true" }),
+                /* @__PURE__ */ m("canvas", { ref: Jt, className: k.layer, "aria-hidden": "true" }),
+                w.grips.map((u) => /* @__PURE__ */ m(
                   "span",
                   {
-                    "data-grip": c.kind,
-                    "data-schedule-overlay": `${c.kind} grip`,
+                    "data-grip": u.kind,
+                    "data-schedule-overlay": `${u.kind} grip`,
                     "aria-hidden": "true",
-                    className: v.grip,
-                    style: { left: `${c.x}px`, top: `${c.y}px`, height: `${c.height}px` }
+                    className: k.grip,
+                    style: { left: `${u.x}px`, top: `${u.y}px`, height: `${u.height}px` }
                   },
-                  c.kind
+                  u.kind
                 )),
-                E !== void 0 && b.bars.map((c) => /* @__PURE__ */ g(
+                T !== void 0 && w.bars.map((u) => /* @__PURE__ */ m(
                   "span",
                   {
-                    className: v.barLabel,
-                    "data-bar-label": c.subtask.id,
+                    className: k.barLabel,
+                    "data-bar-label": u.subtask.id,
                     "data-schedule-overlay": "bar label",
                     "data-schedule-may-cover": "",
-                    "data-on": c.dark ? "dark" : "light",
-                    style: { left: `${c.x}px`, top: `${c.y}px`, width: `${c.width}px`, height: `${c.height}px` },
-                    children: /* @__PURE__ */ g("span", { className: v.barLabelText, children: E(c.subtask) })
+                    "data-on": u.dark ? "dark" : "light",
+                    style: { left: `${u.x}px`, top: `${u.y}px`, width: `${u.width}px`, height: `${u.height}px` },
+                    children: /* @__PURE__ */ m("span", { className: k.barLabelText, children: T(u.subtask) })
                   },
-                  c.subtask.id
+                  u.subtask.id
                 )),
-                _ !== !1 && b.tooltip !== null && /* @__PURE__ */ g(
+                F !== !1 && w.tooltip !== null && /* @__PURE__ */ m(
                   "span",
                   {
-                    ref: ce,
+                    ref: le,
                     role: "tooltip",
-                    className: v.tooltip,
+                    className: k.tooltip,
                     "data-schedule-tooltip": "",
                     "data-schedule-overlay": "tooltip",
                     style: {
-                      left: `${St.x}px`,
-                      top: `${St.y}px`,
-                      visibility: St.at === Lt ? void 0 : "hidden"
+                      left: `${Mt.x}px`,
+                      top: `${Mt.y}px`,
+                      visibility: Mt.at === Tt ? void 0 : "hidden"
                     },
-                    children: typeof _ == "function" ? _(b.tooltip.target) : /* @__PURE__ */ g(vn, { target: b.tooltip.target })
+                    children: typeof F == "function" ? F(w.tooltip.target) : /* @__PURE__ */ m(fn, { target: w.tooltip.target })
                   }
                 ),
-                M !== null && /* @__PURE__ */ G(
+                b !== null && /* @__PURE__ */ x(
                   "span",
                   {
-                    ref: he,
-                    className: v.ghostLabel,
+                    ref: ae,
+                    className: k.ghostLabel,
                     "data-ghost": "",
                     "data-schedule-overlay": "ghost label",
-                    "data-findings": [M.overlap ? "overlap" : "", M.violated ? "violated-dependency" : ""].filter(Boolean).join(" "),
-                    "data-refused": M.refused ? "" : void 0,
-                    "data-blocked": M.blocked ? "" : void 0,
+                    "data-findings": [b.overlap ? "overlap" : "", b.violated ? "violated-dependency" : ""].filter(Boolean).join(" "),
+                    "data-refused": b.refused ? "" : void 0,
+                    "data-blocked": b.blocked ? "" : void 0,
                     style: {
-                      left: `${Tt.x}px`,
-                      top: `${Tt.y}px`,
-                      visibility: Tt.at === It ? void 0 : "hidden"
+                      left: `${wt.x}px`,
+                      top: `${wt.y}px`,
+                      visibility: wt.at === bt ? void 0 : "hidden"
                     },
                     children: [
-                      B.scheduleGhostTimes(Y.time(new Date(M.from), !1), Y.time(new Date(M.to), !1)),
-                      M.refused && /* @__PURE__ */ g("span", { className: v.refusal, children: B.scheduleLaneRefused }),
-                      M.blocked && /* @__PURE__ */ g("span", { className: v.refusal, children: B.scheduleBlockedTime }),
-                      M.overlap && /* @__PURE__ */ g("span", { className: v.finding, children: B.scheduleOverlap }),
-                      M.violated && /* @__PURE__ */ g("span", { className: v.finding, children: B.scheduleViolatedDependency })
+                      B.scheduleGhostTimes(G.time(new Date(b.from), !1), G.time(new Date(b.to), !1)),
+                      b.refused && /* @__PURE__ */ m("span", { className: k.refusal, children: B.scheduleLaneRefused }),
+                      b.blocked && /* @__PURE__ */ m("span", { className: k.refusal, children: B.scheduleBlockedTime }),
+                      b.overlap && /* @__PURE__ */ m("span", { className: k.finding, children: B.scheduleOverlap }),
+                      b.violated && /* @__PURE__ */ m("span", { className: k.finding, children: B.scheduleViolatedDependency })
                     ]
                   }
                 ),
-                /* @__PURE__ */ g("span", { className: v.focusRing, "aria-hidden": "true" })
+                /* @__PURE__ */ m("span", { className: k.focusRing, "aria-hidden": "true" })
               ]
             }
           ),
-          /* @__PURE__ */ g("div", { className: v.corner }),
-          /* @__PURE__ */ G("div", { className: v.tickBand, "aria-hidden": "true", "data-schedule-ticks": "", "data-schedule-clip": "time band", children: [
-            b.now !== null && /* @__PURE__ */ g("span", { className: v.now, "data-now": "", "data-schedule-overlay": "now mark", style: { left: `${b.now}px` } }),
-            b.ticks.map((c) => /* @__PURE__ */ g("span", { className: v.tick, style: { left: `${c.x}px` }, children: c.x >= be && c.x <= b.width - be && (ae === 1 || Dt(c.wallClock, ae)) && /* @__PURE__ */ g("span", { className: v.tickLabel, "data-schedule-overlay": "time label", children: b.step >= X ? Y.dateShort(new Date(c.wallClock)) : Y.time(new Date(c.wallClock), !1) }) }, c.wallClock))
+          /* @__PURE__ */ m("div", { className: k.corner }),
+          /* @__PURE__ */ x("div", { className: k.tickBand, "aria-hidden": "true", "data-schedule-ticks": "", "data-schedule-clip": "time band", children: [
+            w.now !== null && /* @__PURE__ */ m("span", { className: k.now, "data-now": "", "data-schedule-overlay": "now mark", style: { left: `${w.now}px` } }),
+            w.ticks.map((u) => /* @__PURE__ */ m("span", { className: k.tick, style: { left: `${u.x}px` }, children: u.x >= ke && u.x <= w.width - ke && (ie === 1 || Lt(u.wallClock, ie)) && /* @__PURE__ */ m("span", { className: k.tickLabel, "data-schedule-overlay": "time label", children: w.step >= z ? G.dateShort(new Date(u.wallClock)) : G.time(new Date(u.wallClock), !1) }) }, u.wallClock))
           ] }),
-          /* @__PURE__ */ g(fe, { "aria-live": "polite", children: Z !== null && /* @__PURE__ */ g(
-            yn,
+          /* @__PURE__ */ m(de, { "aria-live": "polite", children: Z !== null && /* @__PURE__ */ m(
+            cn,
             {
               target: Z.target,
-              lane: Z.lane === null ? null : ((ue = s.data.lanes.find((c) => c.id === Z.lane)) == null ? void 0 : ue.label) ?? Z.lane
+              lane: Z.lane === null ? null : e.data.lanes.find((u) => u.id === Z.lane)?.label ?? Z.lane
             },
             Z.count
           ) }),
-          /* @__PURE__ */ g(fe, { id: jt, children: `${B.scheduleSummary({ ...bt, from: le(bt.from), to: le(bt.to) })} ${B.scheduleKeyHelp}` })
+          /* @__PURE__ */ m(de, { id: Ut, children: `${B.scheduleSummary({ ...vt, from: oe(vt.from), to: oe(vt.to) })} ${B.scheduleKeyHelp}` })
         ]
       }
     ),
-    ht
+    kt
   ] });
-});
-function Tn(n) {
+}
+function kn(s) {
   try {
-    return n.matches(":focus-visible");
+    return s.matches(":focus-visible");
   } catch {
     return !0;
   }
 }
-function In({ id: n, label: t }) {
-  const e = He(), s = W(() => ({ id: n, label: t ?? n, ...e === null ? {} : { parent: e } }), [n, t, e]);
-  return Is(s), null;
+function vn({ id: s, label: t }) {
+  const e = Ne(), n = K(() => ({ id: s, label: t ?? s, ...e === null ? {} : { parent: e } }), [s, t, e]);
+  return ks(n), null;
 }
-function Sn({ id: n, label: t, children: e }) {
-  const s = He(), o = W(() => ({ id: n, label: t ?? n, ...s === null ? {} : { parent: s } }), [n, t, s]);
-  return Ss(o), /* @__PURE__ */ g(Ge.Provider, { value: n, children: e });
+function yn({ id: s, label: t, children: e }) {
+  const n = Ne(), i = K(() => ({ id: s, label: t ?? s, ...n === null ? {} : { parent: n } }), [s, t, n]);
+  return vs(i), /* @__PURE__ */ m(Be, { value: s, children: e });
 }
-function Ln({ data: n, tasks: t }) {
-  const e = W(() => ({ kind: "subtasks", data: n, tasks: t }), [n, t]);
-  return yt("Subtasks", e), null;
+function wn({ data: s, tasks: t }) {
+  const e = K(() => ({ kind: "subtasks", data: s, tasks: t }), [s, t]);
+  return gt("Subtasks", e), null;
 }
-function An({ data: n }) {
-  const t = W(() => ({ kind: "dependencies", data: n }), [n]);
-  return yt("Dependencies", t), null;
+function bn({ data: s }) {
+  const t = K(() => ({ kind: "dependencies", data: s }), [s]);
+  return gt("Dependencies", t), null;
 }
-function Cn({ data: n }) {
-  const t = W(() => ({ kind: "blocked", data: n }), [n]);
-  return yt("BlockedTimes", t), null;
+function Mn({ data: s }) {
+  const t = K(() => ({ kind: "blocked", data: s }), [s]);
+  return gt("BlockedTimes", t), null;
 }
-function Dn({ data: n }) {
-  const t = W(() => ({ kind: "milestones", data: n }), [n]);
-  return yt("Milestones", t), null;
+function Tn({ data: s }) {
+  const t = K(() => ({ kind: "milestones", data: s }), [s]);
+  return gt("Milestones", t), null;
 }
-class _n {
+class In {
   /** `changed` is called after every registration change. */
   constructor(t) {
-    f(this, "nextId", 1);
-    f(this, "laneEntries", /* @__PURE__ */ new Map());
-    f(this, "groupEntries", /* @__PURE__ */ new Map());
-    f(this, "layerEntries", /* @__PURE__ */ new Map());
-    f(this, "dirty", !0);
-    f(this, "lanes", []);
-    /** The groups in registration order. */
-    f(this, "groups", []);
-    /** The layers in registration order - the drawing order. */
-    f(this, "layers", []);
-    f(this, "subtasks", []);
-    f(this, "subtaskById", /* @__PURE__ */ new Map());
-    f(this, "dependencies", []);
-    /** Every blocked time, whichever layer declared it. */
-    f(this, "blocked", []);
-    /** Every milestone, whichever layer declared it. */
-    f(this, "milestones", []);
-    f(this, "tasks", /* @__PURE__ */ new Map());
-    f(this, "overlaps", []);
-    f(this, "violatedById", /* @__PURE__ */ new Map());
-    f(this, "depth", /* @__PURE__ */ new Map());
-    f(this, "inBlocked", []);
     this.changed = t;
   }
+  nextId = 1;
+  laneEntries = /* @__PURE__ */ new Map();
+  groupEntries = /* @__PURE__ */ new Map();
+  layerEntries = /* @__PURE__ */ new Map();
+  dirty = !0;
+  lanes = [];
+  /** The groups in registration order. */
+  groups = [];
+  /** The layers in registration order - the drawing order. */
+  layers = [];
+  subtasks = [];
+  subtaskById = /* @__PURE__ */ new Map();
+  dependencies = [];
+  /** Every blocked time, whichever layer declared it. */
+  blocked = [];
+  /** Every milestone, whichever layer declared it. */
+  milestones = [];
+  tasks = /* @__PURE__ */ new Map();
+  overlaps = [];
+  violatedById = /* @__PURE__ */ new Map();
+  depth = /* @__PURE__ */ new Map();
+  inBlocked = [];
   registerLane(t) {
     const e = this.nextId++;
     return this.laneEntries.set(e, t), this.touch(), e;
@@ -1066,94 +1086,93 @@ class _n {
   rebuild() {
     if (!this.dirty) return !1;
     this.dirty = !1;
-    const t = (e) => [...e.keys()].sort((s, o) => s - o).map((s) => e.get(s));
+    const t = (e) => [...e.keys()].sort((n, i) => n - i).map((n) => e.get(n));
     this.lanes = t(this.laneEntries), this.groups = t(this.groupEntries), this.layers = t(this.layerEntries), this.subtasks = [], this.dependencies = [], this.blocked = [], this.milestones = [], this.tasks = /* @__PURE__ */ new Map();
     for (const e of this.layers)
       if (e.kind === "subtasks") {
         this.subtasks.push(...e.data);
-        for (const s of e.tasks) this.tasks.set(s.id, s);
+        for (const n of e.tasks) this.tasks.set(n.id, n);
       } else e.kind === "dependencies" ? this.dependencies.push(...e.data) : e.kind === "milestones" ? this.milestones.push(...e.data) : this.blocked.push(...e.data);
-    return this.subtaskById = new Map(this.subtasks.map((e) => [e.id, e])), this.overlaps = Vt(this.subtasks), this.violatedById = new Map(Wt(this.subtasks, this.dependencies).map((e) => [e.dependency, e])), this.depth = bs(this.subtasks), this.inBlocked = Be(this.subtasks, this.blocked), !0;
+    return this.subtaskById = new Map(this.subtasks.map((e) => [e.id, e])), this.overlaps = Ht(this.subtasks), this.violatedById = new Map(Yt(this.subtasks, this.dependencies).map((e) => [e.dependency, e])), this.depth = ms(this.subtasks), this.inBlocked = Ee(this.subtasks, this.blocked), !0;
   }
   /** The task a dependency belongs to: its departing subtask's. */
   taskOfDependency(t) {
-    var e;
-    return ((e = this.subtaskById.get(t.from)) == null ? void 0 : e.task) ?? null;
+    return this.subtaskById.get(t.from)?.task ?? null;
   }
   /** What a tooltip is about: the hovered subtask or dependency with what this
       data knows about it - its task, and the findings it stands in. */
   tooltipTargetFor(t) {
     if (t.kind === "subtask") {
-      const o = t.subtask.id, i = this.overlaps.filter((l) => l.first === o || l.second === o).map((l) => this.subtaskById.get(l.first === o ? l.second : l.first)).filter((l) => l !== void 0), r = this.dependencies.filter((l) => l.from === o || l.to === o).map((l) => this.violatedById.get(l.id)).filter((l) => l !== void 0), a = this.inBlocked.filter((l) => l.subtask === o).map((l) => this.blocked.find((h) => h.id === l.blocked)).filter((l) => l !== void 0);
-      return { kind: "subtask", subtask: t.subtask, task: this.tasks.get(t.subtask.task), overlapping: i, violatedDependencies: r, blocked: a };
+      const i = t.subtask.id, o = this.overlaps.filter((l) => l.first === i || l.second === i).map((l) => this.subtaskById.get(l.first === i ? l.second : l.first)).filter((l) => l !== void 0), r = this.dependencies.filter((l) => l.from === i || l.to === i).map((l) => this.violatedById.get(l.id)).filter((l) => l !== void 0), a = this.inBlocked.filter((l) => l.subtask === i).map((l) => this.blocked.find((d) => d.id === l.blocked)).filter((l) => l !== void 0);
+      return { kind: "subtask", subtask: t.subtask, task: this.tasks.get(t.subtask.task), overlapping: o, violatedDependencies: r, blocked: a };
     }
     if (t.kind === "milestone") return { kind: "milestone", milestone: t.milestone };
     if (t.kind !== "dependency") return null;
-    const e = t.dependency, s = this.taskOfDependency(e);
+    const e = t.dependency, n = this.taskOfDependency(e);
     return {
       kind: "dependency",
       dependency: e,
-      task: s !== null ? this.tasks.get(s) : void 0,
+      task: n !== null ? this.tasks.get(n) : void 0,
       from: this.subtaskById.get(e.from),
       to: this.subtaskById.get(e.to),
       violated: this.violatedById.get(e.id)
     };
   }
 }
-const Fn = 6;
-function Xe(n, t, e, s, o, i) {
-  n.save(), n.beginPath(), n.rect(t, e, s, o), n.clip(), n.globalAlpha = 0.35, n.strokeStyle = i, n.lineWidth = 1, n.beginPath();
-  for (let r = t - o; r < t + s + o; r += Fn)
-    n.moveTo(r, e + o), n.lineTo(r + o, e);
-  n.stroke(), n.restore();
+const Sn = 6;
+function Ke(s, t, e, n, i, o) {
+  s.save(), s.beginPath(), s.rect(t, e, n, i), s.clip(), s.globalAlpha = 0.35, s.strokeStyle = o, s.lineWidth = 1, s.beginPath();
+  for (let r = t - i; r < t + n + i; r += Sn)
+    s.moveTo(r, e + i), s.lineTo(r + i, e);
+  s.stroke(), s.restore();
 }
-function On(n, t, e, s) {
-  if (s.size === 0) return;
-  const { width: o, height: i } = t.view;
-  for (const r of s) {
-    const a = j(e, r);
+function Ln(s, t, e, n) {
+  if (n.size === 0) return;
+  const { width: i, height: o } = t.view;
+  for (const r of n) {
+    const a = q(e, r);
     if (a === null) continue;
-    const { top: l, height: h } = a;
-    l + h < 0 || l > i || (n.globalAlpha = 0.6, n.fillStyle = t.colours.surface, n.fillRect(0, l, o, h), n.globalAlpha = 1, Xe(n, 0, l, o, h, t.colours.muted));
+    const { top: l, height: d } = a;
+    l + d < 0 || l > o || (s.globalAlpha = 0.6, s.fillStyle = t.colours.surface, s.fillRect(0, l, i, d), s.globalAlpha = 1, Ke(s, 0, l, i, d, t.colours.muted));
   }
 }
-function En(n, t, e) {
-  const { data: s } = t;
-  if (s.violatedById.size !== 0)
-    for (const o of s.violatedById.values()) {
-      const i = s.dependencies.find((u) => u.id === o.dependency), r = i === void 0 ? void 0 : s.subtaskById.get(i.to);
+function An(s, t, e) {
+  const { data: n } = t;
+  if (n.violatedById.size !== 0)
+    for (const i of n.violatedById.values()) {
+      const o = n.dependencies.find((c) => c.id === i.dependency), r = o === void 0 ? void 0 : n.subtaskById.get(o.to);
       if (r === void 0) continue;
-      const a = j(e, r.lane);
+      const a = q(e, r.lane);
       if (a === null || !a.miniature) continue;
       const l = tt(e.rows, a.top + e.scrollY);
       if (l === null) continue;
-      const h = R(e, o.arrival), d = Math.max(h + 2, R(e, o.arrival + o.shortBy));
-      Rt(n, t, h, d, l.top - e.scrollY + 1, 3);
+      const d = P(e, i.arrival), h = Math.max(d + 2, P(e, i.arrival + i.shortBy));
+      Ot(s, t, d, h, l.top - e.scrollY + 1, 3);
     }
 }
-function Rt(n, t, e, s, o, i) {
+function Ot(s, t, e, n, i, o) {
   if (!t.colours.forced) {
-    n.fillStyle = t.colours.alarm, n.fillRect(e, o, s - e, i);
+    s.fillStyle = t.colours.alarm, s.fillRect(e, i, n - e, o);
     return;
   }
-  n.strokeStyle = t.colours.alarm, n.lineWidth = i, n.setLineDash([4, 3]), n.beginPath(), n.moveTo(e, o + i / 2), n.lineTo(s, o + i / 2), n.stroke(), n.setLineDash([]);
+  s.strokeStyle = t.colours.alarm, s.lineWidth = o, s.setLineDash([4, 3]), s.beginPath(), s.moveTo(e, i + o / 2), s.lineTo(n, i + o / 2), s.stroke(), s.setLineDash([]);
 }
-function Nn(n, t, e, s) {
-  const o = j(e, s.lane);
-  if (o === null || o.top + o.height < 0 || o.top > t.view.height) return;
-  const i = Math.max(0, R(e, s.from)), r = Math.min(t.view.width, R(e, s.to));
-  r <= i || (n.globalAlpha = 0.1, n.fillStyle = t.colours.muted, n.fillRect(i, o.top, r - i, o.height), n.globalAlpha = 1, Xe(n, i, o.top, r - i, o.height, t.colours.muted));
+function Cn(s, t, e, n) {
+  const i = q(e, n.lane);
+  if (i === null || i.top + i.height < 0 || i.top > t.view.height) return;
+  const o = Math.max(0, P(e, n.from)), r = Math.min(t.view.width, P(e, n.to));
+  r <= o || (s.globalAlpha = 0.1, s.fillStyle = t.colours.muted, s.fillRect(o, i.top, r - o, i.height), s.globalAlpha = 1, Ke(s, o, i.top, r - o, i.height, t.colours.muted));
 }
-function Pt(n, t, e, s) {
-  const o = j(e, s.lane);
-  if (o === null) return;
-  const i = R(e, s.from), r = Math.max(i + 2, R(e, s.to));
-  if (n.fillStyle = t.colours.alarm, n.globalAlpha = 0.14, n.fillRect(i, o.top + 1, r - i, Math.max(1, o.height - 2)), n.globalAlpha = 1, Rt(n, t, i, r, o.top + 1, Math.min(3, Math.max(1, o.height - 1))), o.miniature) {
-    const a = tt(e.rows, o.top + e.scrollY);
-    a !== null && Rt(n, t, i, r, a.top - e.scrollY + 1, 3);
+function Et(s, t, e, n) {
+  const i = q(e, n.lane);
+  if (i === null) return;
+  const o = P(e, n.from), r = Math.max(o + 2, P(e, n.to));
+  if (s.fillStyle = t.colours.alarm, s.globalAlpha = 0.14, s.fillRect(o, i.top + 1, r - o, Math.max(1, i.height - 2)), s.globalAlpha = 1, Ot(s, t, o, r, i.top + 1, Math.min(3, Math.max(1, i.height - 1))), i.miniature) {
+    const a = tt(e.rows, i.top + e.scrollY);
+    a !== null && Ot(s, t, o, r, a.top - e.scrollY + 1, 3);
   }
 }
-const Rn = {
+const Dn = {
   line: "var(--u-hairline)",
   lineStrong: "var(--u-hairline-strong)",
   text: "var(--u-color-text)",
@@ -1167,7 +1186,7 @@ const Rn = {
   /* What text and marks take ON a filled bar - the same token the bar labels
      use in CSS, so a cap and the label beside it are one colour. */
   onAccent: "var(--u-color-on-accent)"
-}, qe = {
+}, Ve = {
   line: "GrayText",
   lineStrong: "CanvasText",
   text: "CanvasText",
@@ -1177,329 +1196,329 @@ const Rn = {
   active: "Highlight",
   now: "GrayText",
   onAccent: "Canvas"
-}, Pn = (n) => n ? qe : Rn, $n = () => typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(forced-colors: active)").matches;
-function Bn(n, t) {
-  const e = $n(), s = {};
-  for (const r of t.tasks.values()) s[`task:${r.id}`] = e ? qe.text : r.color;
-  const o = ms(n, { ...Pn(e), ...s }), i = /* @__PURE__ */ new Map();
-  for (const r of t.tasks.values()) i.set(r.id, o[`task:${r.id}`] ?? r.color);
+}, _n = (s) => s ? Ve : Dn, Fn = () => typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(forced-colors: active)").matches;
+function On(s, t) {
+  const e = Fn(), n = {};
+  for (const r of t.tasks.values()) n[`task:${r.id}`] = e ? Ve.text : r.color;
+  const i = as(s, { ..._n(e), ...n }), o = /* @__PURE__ */ new Map();
+  for (const r of t.tasks.values()) o.set(r.id, i[`task:${r.id}`] ?? r.color);
   return {
-    line: o.line,
-    lineStrong: o.lineStrong,
-    text: o.text,
-    muted: o.muted,
-    alarm: o.alarm,
-    surface: o.surface,
-    active: o.active,
-    now: o.now,
-    onAccent: o.onAccent,
-    tasks: i,
+    line: i.line,
+    lineStrong: i.lineStrong,
+    text: i.text,
+    muted: i.muted,
+    alarm: i.alarm,
+    surface: i.surface,
+    active: i.active,
+    now: i.now,
+    onAccent: i.onAccent,
+    tasks: o,
     forced: e
   };
 }
-function lt(n) {
-  const t = n.match(/[\d.]+/g);
+function at(s) {
+  const t = s.match(/[\d.]+/g);
   return t === null || t.length < 3 ? null : [Number(t[0]), Number(t[1]), Number(t[2])];
 }
-function Me(n) {
-  const t = lt(n);
-  return t === null ? 0 : Je(je(t));
+function ve(s) {
+  const t = at(s);
+  return t === null ? 0 : ze(We(t));
 }
-function je(n) {
-  return n.map((t) => {
+function We(s) {
+  return s.map((t) => {
     const e = t / 255;
     return e <= 0.04045 ? e / 12.92 : ((e + 0.055) / 1.055) ** 2.4;
   });
 }
-function Je([n, t, e]) {
-  return 0.2126 * n + 0.7152 * t + 0.0722 * e;
-}
-function Te(n, t) {
-  const e = Me(n), s = Me(t);
-  return (Math.max(e, s) + 0.05) / (Math.min(e, s) + 0.05);
-}
-function Ie(n, t, e) {
-  if (n === null) return null;
-  const s = typeof window > "u" ? 1 : window.devicePixelRatio || 1, o = Math.round(t * s), i = Math.round(e * s);
-  n.width !== o && (n.width = o), n.height !== i && (n.height = i);
-  const r = n.getContext("2d");
-  return r === null ? null : (r.setTransform(s, 0, 0, s, 0, 0), r.clearRect(0, 0, t, e), r);
-}
-function xn(n, t) {
-  const { data: e, view: s } = t, o = s.viewport();
-  Yn(n, t, o);
-  for (const i of e.blocked) Nn(n, t, o, i);
-  Kn(n, t);
-  for (const i of e.layers) {
-    if (i.kind === "blocked" || i.kind === "milestones") continue;
-    const r = new Set(i.data);
-    if (i.kind === "dependencies")
-      for (const a of s.paths) r.has(a.dependency) && $t(n, t, a, !1);
+function ze([s, t, e]) {
+  return 0.2126 * s + 0.7152 * t + 0.0722 * e;
+}
+function ye(s, t) {
+  const e = ve(s), n = ve(t);
+  return (Math.max(e, n) + 0.05) / (Math.min(e, n) + 0.05);
+}
+function we(s, t, e) {
+  if (s === null) return null;
+  const n = typeof window > "u" ? 1 : window.devicePixelRatio || 1, i = Math.round(t * n), o = Math.round(e * n);
+  s.width !== i && (s.width = i), s.height !== o && (s.height = o);
+  const r = s.getContext("2d");
+  return r === null ? null : (r.setTransform(n, 0, 0, n, 0, 0), r.clearRect(0, 0, t, e), r);
+}
+function En(s, t) {
+  const { data: e, view: n } = t, i = n.viewport();
+  Nn(s, t, i);
+  for (const o of e.blocked) Cn(s, t, i, o);
+  xn(s, t);
+  for (const o of e.layers) {
+    if (o.kind === "blocked" || o.kind === "milestones") continue;
+    const r = new Set(o.data);
+    if (o.kind === "dependencies")
+      for (const a of n.paths) r.has(a.dependency) && Ls(a, n.width, n.height) && Pt(s, t, a, !1);
     else
-      for (const a of s.boxes) r.has(a.subtask) && Qe(n, t, a, 1);
+      for (const a of n.boxes) r.has(a.subtask) && Xe(s, t, a, 1);
   }
-  for (const i of e.overlaps) Pt(n, t, o, i);
-  for (const i of e.inBlocked) Pt(n, t, o, i);
-  En(n, t, o);
-  for (const i of e.milestones) ts(n, t, o, i, !1);
-  Jn(n, t);
+  for (const o of e.overlaps) Et(s, t, i, o);
+  for (const o of e.inBlocked) Et(s, t, i, o);
+  An(s, t, i);
+  for (const o of e.milestones) qe(s, t, i, o, !1);
+  Wn(s, t);
 }
-function Gn(n, t) {
-  const { view: e, hover: s } = t, o = e.viewport();
+function Pn(s, t) {
+  const { view: e, hover: n } = t, i = e.viewport();
   if (t.ghost === null) {
-    if (s.kind === "subtask") {
-      const u = e.boxById.get(s.subtask.id);
-      u !== void 0 && qn(n, t, u);
-    } else if (s.kind === "dependency") {
-      const u = e.paths.find((m) => m.dependency === s.dependency);
-      u !== void 0 && $t(n, t, u, !0);
-    } else s.kind === "milestone" && ts(n, t, o, s.milestone, !0);
+    if (n.kind === "subtask") {
+      const c = e.boxById.get(n.subtask.id);
+      c !== void 0 && Kn(s, t, c);
+    } else if (n.kind === "dependency") {
+      const c = e.paths.find((f) => f.dependency === n.dependency);
+      c !== void 0 && Pt(s, t, c, !0);
+    } else n.kind === "milestone" && qe(s, t, i, n.milestone, !0);
     return;
   }
-  const i = t.ghost, { ghost: r, overlaps: a, violated: l } = i;
-  On(n, t, o, i.refusedLanes);
-  const h = Ze(o, r);
-  if (h === null) return;
-  for (const u of a) Pt(n, t, o, u);
-  const d = new Set(l.map((u) => u.dependency));
-  for (const u of t.data.dependencies) {
-    if (u.from !== r.id && u.to !== r.id) continue;
-    const m = e.boxById.get(u.from === r.id ? u.to : u.from);
-    if (m === void 0) continue;
-    const p = u.from === r.id ? Et(o, u, h, m, e.options) : Et(o, u, m, h, e.options);
-    $t(n, t, p, !0, d.has(u.id));
-  }
-  Qe(n, { ...t, selectedTask: null }, h, 0.55), n.strokeStyle = t.colours.text, n.lineWidth = 1, n.setLineDash([3, 2]), n.strokeRect(h.outerFrom + 0.5, h.y + 0.5, Math.max(1, h.outerTo - h.outerFrom - 1), h.height - 1), n.setLineDash([]), i.tether !== null && Hn(n, t, h, i.tether);
-}
-function Hn(n, t, e, s) {
-  const o = Math.max(e.outerFrom, Math.min(e.outerTo, s.x)), i = Math.max(e.y, Math.min(e.y + e.height, s.y));
-  Math.hypot(s.x - o, s.y - i) < 2 || (n.strokeStyle = t.colours.text, n.lineWidth = 1, n.setLineDash([2, 3]), n.beginPath(), n.moveTo(o + 0.5, i + 0.5), n.lineTo(s.x + 0.5, s.y + 0.5), n.stroke(), n.setLineDash([]));
-}
-function Ze(n, t) {
-  const e = zt(n.rows, t.lane);
-  return e === null ? null : Ke(n, t, e, 0);
-}
-function Yn(n, t, e) {
-  const { view: s, colours: o, bands: i } = t, { width: r, height: a } = s;
-  n.lineWidth = 1, n.strokeStyle = o.line, n.beginPath();
-  for (const d of i.ticks)
-    n.moveTo(d.x + 0.5, 0), n.lineTo(d.x + 0.5, a);
-  for (const d of e.rows.rows) {
-    const u = d.top + d.height - e.scrollY - 0.5;
-    u < 0 || u > a || (n.moveTo(0, u), n.lineTo(r, u));
-  }
-  const l = [...e.rows.slots.values()].filter((d) => d.miniature).sort((d, u) => d.top - u.top);
-  l.forEach((d, u) => {
-    const m = l[u + 1];
-    if (m === void 0 || m.top !== d.top + d.height || m.group === d.group) return;
-    const p = d.top + d.height - e.scrollY - 0.5;
-    p < 0 || p > a || (n.moveTo(0, p), n.lineTo(r, p));
-  }), n.stroke(), n.strokeStyle = o.lineStrong, n.beginPath();
-  for (const d of i.days)
-    n.moveTo(d.x + 0.5, 0), n.lineTo(d.x + 0.5, a);
-  n.stroke();
-  const h = ps(s.options.calendar);
-  if (h.length > 0) {
-    n.strokeStyle = o.muted, n.setLineDash([2, 3]), n.beginPath();
-    for (const d of h) {
-      const u = Math.round(e.scale.toPx(d.workingTime)) + 0.5;
-      u < 0 || u > r || (n.moveTo(u, 0), n.lineTo(u, a));
+  const o = t.ghost, { ghost: r, overlaps: a, violated: l } = o;
+  Ln(s, t, i, o.refusedLanes);
+  const d = Ue(i, r);
+  if (d === null) return;
+  for (const c of a) Et(s, t, i, c);
+  const h = new Set(l.map((c) => c.dependency));
+  for (const c of t.data.dependencies) {
+    if (c.from !== r.id && c.to !== r.id) continue;
+    const f = e.boxById.get(c.from === r.id ? c.to : c.from);
+    if (f === void 0) continue;
+    const g = c.from === r.id ? _t(i, c, d, f, e.options) : _t(i, c, f, d, e.options);
+    Pt(s, t, g, !0, h.has(c.id));
+  }
+  Xe(s, { ...t, selectedTask: null }, d, 0.55), s.strokeStyle = t.colours.text, s.lineWidth = 1, s.setLineDash([3, 2]), s.strokeRect(d.outerFrom + 0.5, d.y + 0.5, Math.max(1, d.outerTo - d.outerFrom - 1), d.height - 1), s.setLineDash([]), o.tether !== null && Bn(s, t, d, o.tether);
+}
+function Bn(s, t, e, n) {
+  const i = Math.max(e.outerFrom, Math.min(e.outerTo, n.x)), o = Math.max(e.y, Math.min(e.y + e.height, n.y));
+  Math.hypot(n.x - i, n.y - o) < 2 || (s.strokeStyle = t.colours.text, s.lineWidth = 1, s.setLineDash([2, 3]), s.beginPath(), s.moveTo(i + 0.5, o + 0.5), s.lineTo(n.x + 0.5, n.y + 0.5), s.stroke(), s.setLineDash([]));
+}
+function Ue(s, t) {
+  const e = Vt(s.rows, t.lane);
+  return e === null ? null : Re(s, t, e, 0);
+}
+function Nn(s, t, e) {
+  const { view: n, colours: i, bands: o } = t, { width: r, height: a } = n;
+  s.lineWidth = 1, s.strokeStyle = i.line, s.beginPath();
+  for (const h of o.ticks)
+    s.moveTo(h.x + 0.5, 0), s.lineTo(h.x + 0.5, a);
+  for (const h of e.rows.rows) {
+    const c = h.top + h.height - e.scrollY - 0.5;
+    c < 0 || c > a || (s.moveTo(0, c), s.lineTo(r, c));
+  }
+  const l = [...e.rows.slots.values()].filter((h) => h.miniature).sort((h, c) => h.top - c.top);
+  l.forEach((h, c) => {
+    const f = l[c + 1];
+    if (f === void 0 || f.top !== h.top + h.height || f.group === h.group) return;
+    const g = h.top + h.height - e.scrollY - 0.5;
+    g < 0 || g > a || (s.moveTo(0, g), s.lineTo(r, g));
+  }), s.stroke(), s.strokeStyle = i.lineStrong, s.beginPath();
+  for (const h of o.days)
+    s.moveTo(h.x + 0.5, 0), s.lineTo(h.x + 0.5, a);
+  s.stroke();
+  const d = ls(n.options.calendar);
+  if (d.length > 0) {
+    s.strokeStyle = i.muted, s.setLineDash([2, 3]), s.beginPath();
+    for (const h of d) {
+      const c = Math.round(e.scale.toPx(h.workingTime)) + 0.5;
+      c < 0 || c > r || (s.moveTo(c, 0), s.lineTo(c, a));
     }
-    n.stroke(), n.setLineDash([]);
+    s.stroke(), s.setLineDash([]);
   }
 }
-function Kn(n, t) {
+function xn(s, t) {
   const e = t.view.nowX();
-  e !== null && (n.fillStyle = t.colours.now, n.fillRect(e, 0, 2, t.view.height));
+  e !== null && (s.fillStyle = t.colours.now, s.fillRect(e, 0, 2, t.view.height));
 }
-function Vn(n, t, e, s) {
-  const o = dt(t.colours, t, e.subtask.task, e.subtask.id);
-  n.fillStyle = o;
-  for (const [i, r] of [
+function Rn(s, t, e, n) {
+  const i = lt(t.colours, t, e.subtask.task, e.subtask.id);
+  s.fillStyle = i;
+  for (const [o, r] of [
     [e.outerFrom, e.mainFrom],
     [e.mainTo, e.outerTo]
   ])
-    r <= i || (n.globalAlpha = 0.28 * s, n.fillRect(i, e.y, r - i, e.height));
-  n.globalAlpha = s, n.fillRect(e.mainFrom, e.y, Math.max(1, e.mainTo - e.mainFrom), e.height), n.globalAlpha = 1;
-}
-function qt(n, t, e) {
-  if (n.dashed) return { fill: null, onDark: !1 };
-  const s = n.muted ? Wn(t, e.surface, 0.5) : t;
-  return { fill: s, onDark: Te(s, e.onAccent) > Te(s, e.text) };
-}
-function Wn(n, t, e) {
-  const s = lt(n), o = lt(t);
-  if (s === null || o === null) return n;
-  const i = (r) => Math.round(s[r] + (o[r] - s[r]) * e);
-  return `rgb(${i(0)}, ${i(1)}, ${i(2)})`;
-}
-function Se(n, t) {
-  const e = lt(n);
-  if (e === null || t === 0) return n;
-  const s = je(e), o = Je(s), [i, r, a] = s.map((l) => {
-    const h = l + (o - l) * t, d = h <= 31308e-7 ? h * 12.92 : 1.055 * h ** (1 / 2.4) - 0.055;
-    return Math.round(Math.min(1, Math.max(0, d)) * 255);
+    r <= o || (s.globalAlpha = 0.28 * n, s.fillRect(o, e.y, r - o, e.height));
+  s.globalAlpha = n, s.fillRect(e.mainFrom, e.y, Math.max(1, e.mainTo - e.mainFrom), e.height), s.globalAlpha = 1;
+}
+function zt(s, t, e) {
+  if (s.dashed) return { fill: null, onDark: !1 };
+  const n = s.muted ? $n(t, e.surface, 0.5) : t;
+  return { fill: n, onDark: ye(n, e.onAccent) > ye(n, e.text) };
+}
+function $n(s, t, e) {
+  const n = at(s), i = at(t);
+  if (n === null || i === null) return s;
+  const o = (r) => Math.round(n[r] + (i[r] - n[r]) * e);
+  return `rgb(${o(0)}, ${o(1)}, ${o(2)})`;
+}
+function be(s, t) {
+  const e = at(s);
+  if (e === null || t === 0) return s;
+  const n = We(e), i = ze(n), [o, r, a] = n.map((l) => {
+    const d = l + (i - l) * t, h = d <= 31308e-7 ? d * 12.92 : 1.055 * d ** (1 / 2.4) - 0.055;
+    return Math.round(Math.min(1, Math.max(0, h)) * 255);
   });
-  return `rgb(${i}, ${r}, ${a})`;
+  return `rgb(${o}, ${r}, ${a})`;
 }
-function dt(n, t, e, s) {
-  const o = (e === null ? void 0 : n.tasks.get(e)) ?? n.muted;
-  return t.selectedTask === null ? o : e !== t.selectedTask ? n.forced ? n.muted : Se(o, 1) : n.forced || t.selectedSubtask === null || s === null || s === t.selectedSubtask ? o : Se(o, 0.5);
+function lt(s, t, e, n) {
+  const i = (e === null ? void 0 : s.tasks.get(e)) ?? s.muted;
+  return t.selectedTask === null ? i : e !== t.selectedTask ? s.forced ? s.muted : be(i, 1) : s.forced || t.selectedSubtask === null || n === null || n === t.selectedSubtask ? i : be(i, 0.5);
 }
-const Un = 2;
-function Qe(n, t, e, s) {
-  const { view: o, colours: i } = t;
-  if (!Ot(e, o.width, o.height)) return;
+const Gn = 2;
+function Xe(s, t, e, n) {
+  const { view: i, colours: o } = t;
+  if (!Dt(e, i.width, i.height)) return;
   if (e.miniature) {
-    Vn(n, t, e, s);
+    Rn(s, t, e, n);
     return;
   }
-  const r = kt(e.subtask.appearance), a = dt(i, t, e.subtask.task, e.subtask.id), l = qt(r, a, i), h = e.y, d = e.height, u = Math.max(1, e.mainTo - e.mainFrom), m = l.onDark ? i.onAccent : i.text;
-  n.lineWidth = 1, n.fillStyle = a, n.strokeStyle = a;
-  for (const [y, I] of [
+  const r = pt(e.subtask.appearance), a = lt(o, t, e.subtask.task, e.subtask.id), l = zt(r, a, o), d = e.y, h = e.height, c = Math.max(1, e.mainTo - e.mainFrom), f = l.onDark ? o.onAccent : o.text;
+  s.lineWidth = 1, s.fillStyle = a, s.strokeStyle = a;
+  for (const [v, A] of [
     [e.outerFrom, e.mainFrom],
     [e.mainTo, e.outerTo]
   ])
-    I <= y || (n.globalAlpha = 0.28 * s, n.fillRect(y, h, I - y, d), n.globalAlpha = s, n.strokeRect(y + 0.5, h + 0.5, I - y - 1, d - 1));
-  l.fill !== null && (n.globalAlpha = s, n.fillStyle = l.fill, n.fillRect(e.mainFrom, h, u, d));
-  const p = e.subtask.progress;
-  if (p !== void 0) {
-    const y = Math.min(4, Math.max(2, Math.round(d / 6))), I = h + d - y - Un, A = Math.round(u * Math.max(0, Math.min(1, p)));
-    n.fillStyle = l.fill === null ? a : m, n.globalAlpha = 0.3 * s, n.fillRect(e.mainFrom, I, u, y), n.globalAlpha = s, A > 0 && n.fillRect(e.mainFrom, I, A, y);
+    A <= v || (s.globalAlpha = 0.28 * n, s.fillRect(v, d, A - v, h), s.globalAlpha = n, s.strokeRect(v + 0.5, d + 0.5, A - v - 1, h - 1));
+  l.fill !== null && (s.globalAlpha = n, s.fillStyle = l.fill, s.fillRect(e.mainFrom, d, c, h));
+  const g = e.subtask.progress;
+  if (g !== void 0) {
+    const v = Math.min(4, Math.max(2, Math.round(h / 6))), A = d + h - v - Gn, C = Math.round(c * Math.max(0, Math.min(1, g)));
+    s.fillStyle = l.fill === null ? a : f, s.globalAlpha = 0.3 * n, s.fillRect(e.mainFrom, A, c, v), s.globalAlpha = n, C > 0 && s.fillRect(e.mainFrom, A, C, v);
   }
   if (r.hatched) {
-    const y = Math.max(1, Math.min(Ye, Math.floor((u - 2 * nt) / 3))), I = u >= 4 * y ? nt : 0, A = d >= 4 * nt ? nt : 0;
-    n.globalAlpha = s, n.fillStyle = m, n.fillRect(e.mainFrom + I, h + A, y, d - 2 * A), n.fillRect(e.mainTo - I - y, h + A, y, d - 2 * A);
+    const v = Math.max(1, Math.min(xe, Math.floor((c - 2 * st) / 3))), A = c >= 4 * v ? st : 0, C = h >= 4 * st ? st : 0;
+    s.globalAlpha = n, s.fillStyle = f, s.fillRect(e.mainFrom + A, d + C, v, h - 2 * C), s.fillRect(e.mainTo - A - v, d + C, v, h - 2 * C);
   }
-  r.open && Xn(n, e, h, d, i.surface, o.width), r.dashed && (n.globalAlpha = s, n.strokeStyle = a, n.setLineDash([4, 3]), n.strokeRect(e.mainFrom + 0.5, h + 0.5, u - 1, d - 1), n.setLineDash([])), n.globalAlpha = 1, e.depth > 0 && s === 1 && (n.strokeStyle = i.surface, n.strokeRect(e.outerFrom - 0.5, h - 0.5, e.outerTo - e.outerFrom + 1, d + 1));
+  r.open && Yn(s, e, d, h, o.surface, i.width), r.dashed && (s.globalAlpha = n, s.strokeStyle = a, s.setLineDash([4, 3]), s.strokeRect(e.mainFrom + 0.5, d + 0.5, c - 1, h - 1), s.setLineDash([])), s.globalAlpha = 1, e.depth > 0 && n === 1 && (s.strokeStyle = o.surface, s.strokeRect(e.outerFrom - 0.5, d - 0.5, e.outerTo - e.outerFrom + 1, h + 1));
 }
-const zn = 16;
-function Xn(n, t, e, s, o, i) {
-  const r = t.mainFrom < 0, a = t.mainTo > i, l = Math.max(1, Math.min(t.mainTo, i) - Math.max(t.mainFrom, 0)), h = Math.min(zn, l);
-  r && Le(n, 0, h, e, s, o), a && Le(n, i, -h, e, s, o);
+const Hn = 16;
+function Yn(s, t, e, n, i, o) {
+  const r = t.mainFrom < 0, a = t.mainTo > o, l = Math.max(1, Math.min(t.mainTo, o) - Math.max(t.mainFrom, 0)), d = Math.min(Hn, l);
+  r && Me(s, 0, d, e, n, i), a && Me(s, o, -d, e, n, i);
 }
-function Le(n, t, e, s, o, i) {
-  const r = n.createLinearGradient(t, 0, t + e, 0);
-  r.addColorStop(0, Ae(i, 1)), r.addColorStop(1, Ae(i, 0)), n.globalAlpha = 1, n.fillStyle = r, n.fillRect(Math.min(t, t + e), s, Math.abs(e), o);
+function Me(s, t, e, n, i, o) {
+  const r = s.createLinearGradient(t, 0, t + e, 0);
+  r.addColorStop(0, Te(o, 1)), r.addColorStop(1, Te(o, 0)), s.globalAlpha = 1, s.fillStyle = r, s.fillRect(Math.min(t, t + e), n, Math.abs(e), i);
 }
-function Ae(n, t) {
-  const e = lt(n);
-  return e === null ? n : `rgba(${e[0]}, ${e[1]}, ${e[2]}, ${t})`;
+function Te(s, t) {
+  const e = at(s);
+  return e === null ? s : `rgba(${e[0]}, ${e[1]}, ${e[2]}, ${t})`;
 }
-function $t(n, t, e, s, o) {
-  const { data: i, colours: r } = t, a = i.taskOfDependency(e.dependency), l = o ?? i.violatedById.has(e.dependency.id), h = a !== null && a === t.selectedTask, d = l ? r.alarm : dt(r, t, a, null);
-  if (n.strokeStyle = d, n.fillStyle = d, n.lineWidth = s || h ? 2 : 1.25, n.setLineDash(l ? [4, 3] : []), n.beginPath(), n.moveTo(e.x1, e.y1), e.kind === "curve")
-    n.bezierCurveTo(e.c1x, e.y1, e.c2x, e.y2, e.x2, e.y2);
+function Pt(s, t, e, n, i) {
+  const { data: o, colours: r } = t, a = o.taskOfDependency(e.dependency), l = i ?? o.violatedById.has(e.dependency.id), d = a !== null && a === t.selectedTask, h = l ? r.alarm : lt(r, t, a, null);
+  if (s.strokeStyle = h, s.fillStyle = h, s.lineWidth = n || d ? 2 : 1.25, s.setLineDash(l ? [4, 3] : []), s.beginPath(), s.moveTo(e.x1, e.y1), e.kind === "curve")
+    s.bezierCurveTo(e.c1x, e.y1, e.c2x, e.y2, e.x2, e.y2);
   else
-    for (let u = 2; u + 1 < e.points.length; u += 2) n.lineTo(e.points[u], e.points[u + 1]);
-  if (n.stroke(), n.setLineDash([]), e.ends === "dot")
-    for (const [u, m] of [
+    for (let c = 2; c + 1 < e.points.length; c += 2) s.lineTo(e.points[c], e.points[c + 1]);
+  if (s.stroke(), s.setLineDash([]), e.ends === "dot")
+    for (const [c, f] of [
       [e.x1, e.y1],
       [e.x2, e.y2]
     ])
-      n.beginPath(), n.arc(u, m, l ? 3 : 2.5, 0, Math.PI * 2), n.fill();
+      s.beginPath(), s.arc(c, f, l ? 3 : 2.5, 0, Math.PI * 2), s.fill();
 }
-function ts(n, t, e, s, o) {
-  const i = Xt(e, s);
-  if (i === null || i.x < -i.half || i.x > t.view.width + i.half) return;
+function qe(s, t, e, n, i) {
+  const o = Wt(e, n);
+  if (o === null || o.x < -o.half || o.x > t.view.width + o.half) return;
   const r = (a) => {
-    n.beginPath(), n.moveTo(i.x, i.y - a), n.lineTo(i.x + a, i.y), n.lineTo(i.x, i.y + a), n.lineTo(i.x - a, i.y), n.closePath();
+    s.beginPath(), s.moveTo(o.x, o.y - a), s.lineTo(o.x + a, o.y), s.lineTo(o.x, o.y + a), s.lineTo(o.x - a, o.y), s.closePath();
   };
-  o && (r(i.half + 3), n.fillStyle = t.colours.active, n.fill()), r(i.half + 1), n.fillStyle = t.colours.surface, n.fill(), r(i.half), n.fillStyle = t.colours.text, n.fill();
+  i && (r(o.half + 3), s.fillStyle = t.colours.active, s.fill()), r(o.half + 1), s.fillStyle = t.colours.surface, s.fill(), r(o.half), s.fillStyle = t.colours.text, s.fill();
 }
-function qn(n, t, e) {
-  const { colours: s } = t, o = kt(e.subtask.appearance), i = qt(o, dt(s, t, e.subtask.task, e.subtask.id), s);
-  if (s.forced) {
-    n.strokeStyle = s.active, n.lineWidth = 2, n.strokeRect(e.outerFrom - 2, e.y - 2, Math.max(1, e.outerTo - e.outerFrom) + 4, e.height + 4);
+function Kn(s, t, e) {
+  const { colours: n } = t, i = pt(e.subtask.appearance), o = zt(i, lt(n, t, e.subtask.task, e.subtask.id), n);
+  if (n.forced) {
+    s.strokeStyle = n.active, s.lineWidth = 2, s.strokeRect(e.outerFrom - 2, e.y - 2, Math.max(1, e.outerTo - e.outerFrom) + 4, e.height + 4);
     return;
   }
-  n.globalAlpha = jn, n.fillStyle = i.onDark ? s.onAccent : s.text, n.fillRect(e.outerFrom, e.y, Math.max(1, e.outerTo - e.outerFrom), e.height), n.globalAlpha = 1;
+  s.globalAlpha = Vn, s.fillStyle = o.onDark ? n.onAccent : n.text, s.fillRect(e.outerFrom, e.y, Math.max(1, e.outerTo - e.outerFrom), e.height), s.globalAlpha = 1;
 }
-const jn = 0.2;
-function Jn(n, t) {
+const Vn = 0.2;
+function Wn(s, t) {
   const e = t.selectedTask;
   if (e !== null) {
-    n.strokeStyle = t.colours.text;
-    for (const s of t.view.boxes) {
-      if (s.subtask.task !== e) continue;
-      const o = s.subtask.id === t.selectedSubtask;
-      n.lineWidth = o ? 2 : 1;
-      const i = o ? 1 : 0.5;
-      n.strokeRect(s.outerFrom - i, s.y - i, s.outerTo - s.outerFrom + 2 * i, s.height + 2 * i);
+    s.strokeStyle = t.colours.text;
+    for (const n of t.view.boxes) {
+      if (n.subtask.task !== e) continue;
+      const i = n.subtask.id === t.selectedSubtask;
+      s.lineWidth = i ? 2 : 1;
+      const o = i ? 1 : 0.5;
+      s.strokeRect(n.outerFrom - o, n.y - o, n.outerTo - n.outerFrom + 2 * o, n.height + 2 * o);
     }
   }
 }
-const ft = 32, Zn = 18;
-function Ce(n, t) {
-  if (!(t > 2 * ft)) return 0;
-  const e = ft - n, s = n - (t - ft), o = Math.max(e, s);
-  if (o <= 0) return 0;
-  const i = Math.min(1, o / ft), r = Zn * i * i;
+const ut = 32, zn = 18;
+function Ie(s, t) {
+  if (!(t > 2 * ut)) return 0;
+  const e = ut - s, n = s - (t - ut), i = Math.max(e, n);
+  if (i <= 0) return 0;
+  const o = Math.min(1, i / ut), r = zn * o * o;
   return e > 0 ? -r : r;
 }
-function rt(n, t, e) {
-  const s = (o, i) => {
-    const r = et(o);
-    return o.lane === i.lane && r.from < i.to && i.from < r.to;
+function ot(s, t, e) {
+  const n = (i, o) => {
+    const r = et(i);
+    return i.lane === o.lane && r.from < o.to && o.from < r.to;
   };
-  return e.some((o) => s(n, o) && !(t !== null && s(t, o)));
-}
-function Qn(n, t, e, s) {
-  const o = /* @__PURE__ */ new Set();
-  if (s === void 0) return o;
-  for (const i of n)
-    i !== e && (s(t, i) || o.add(i));
-  return o;
-}
-const De = "\0placing", _e = /* @__PURE__ */ new Set();
-function Ft(n) {
-  switch (n.kind) {
+  return e.some((i) => n(s, i) && !(t !== null && n(t, i)));
+}
+function Un(s, t, e, n) {
+  const i = /* @__PURE__ */ new Set();
+  if (n === void 0) return i;
+  for (const o of s)
+    o !== e && (n(t, o) || i.add(o));
+  return i;
+}
+const Se = "\0placing", Le = /* @__PURE__ */ new Set();
+function Ct(s) {
+  switch (s.kind) {
     case "subtask":
-      return `subtask:${n.subtask.id}:${n.part}`;
+      return `subtask:${s.subtask.id}:${s.part}`;
     case "dependency":
-      return `dependency:${n.dependency.id}`;
+      return `dependency:${s.dependency.id}`;
     case "milestone":
-      return `milestone:${n.milestone.id}`;
+      return `milestone:${s.milestone.id}`;
     case "lane":
-      return `lane:${n.lane}`;
+      return `lane:${s.lane}`;
     default:
       return "nothing";
   }
 }
-const Fe = 3, to = 10, eo = 600;
-class so {
+const Ae = 3, Xn = 10, qn = 600;
+class jn {
   constructor(t) {
-    f(this, "gesture", { kind: "none" });
-    f(this, "touches", /* @__PURE__ */ new Map());
-    f(this, "hoverKey", "nothing");
-    /** The last pointer of a drag, in client coordinates, and the frame that
-        pans along while it is near an edge. */
-    f(this, "lastClient", { x: 0, y: 0 });
-    f(this, "panFrame", 0);
-    /** Whether the pointer last stood over a lane the dragged work may not go
-        to. It is a fact about the pointer and not about the ghost, which stayed
-        where it was allowed. */
-    f(this, "refused", !1);
-    /** Whether the pointer last stood where the dragged work would cover blocked
-        time - as `refused`, a fact about the pointer and not about the ghost. */
-    f(this, "blocked", !1);
-    /** Where the pointer stands on the plot while a drag is in flight - what the
-        tether is drawn to, since the ghost is not following it. */
-    f(this, "dragPoint", { x: 0, y: 0 });
-    /** The folded group the pointer is resting over, and the timer that will
-        open it for this gesture. */
-    f(this, "resting", null);
-    f(this, "hover", { kind: "nothing" });
-    /** Where the pointer rests on the plot while nothing is being dragged - or,
-        where the keyboard set the hover, the point its tooltip stands at. */
-    f(this, "hoverPoint", { x: 0, y: 0 });
-    /** Whether the keyboard set the hover (ADR-0030): pointer and keys share one
-        **Active subtask**, and the last input wins. The keys' hover stays when
-        the pointer leaves, and the pointer takes it over by moving. */
-    f(this, "byKeyboard", !1);
-    f(this, "cursor", "default");
     this.host = t;
   }
+  gesture = { kind: "none" };
+  touches = /* @__PURE__ */ new Map();
+  hoverKey = "nothing";
+  /** The last pointer of a drag, in client coordinates, and the frame that
+      pans along while it is near an edge. */
+  lastClient = { x: 0, y: 0 };
+  panFrame = 0;
+  /** Whether the pointer last stood over a lane the dragged work may not go
+      to. It is a fact about the pointer and not about the ghost, which stayed
+      where it was allowed. */
+  refused = !1;
+  /** Whether the pointer last stood where the dragged work would cover blocked
+      time - as `refused`, a fact about the pointer and not about the ghost. */
+  blocked = !1;
+  /** Where the pointer stands on the plot while a drag is in flight - what the
+      tether is drawn to, since the ghost is not following it. */
+  dragPoint = { x: 0, y: 0 };
+  /** The folded group the pointer is resting over, and the timer that will
+      open it for this gesture. */
+  resting = null;
+  hover = { kind: "nothing" };
+  /** Where the pointer rests on the plot while nothing is being dragged - or,
+      where the keyboard set the hover, the point its tooltip stands at. */
+  hoverPoint = { x: 0, y: 0 };
+  /** Whether the keyboard set the hover (ADR-0030): pointer and keys share one
+      **Active subtask**, and the last input wins. The keys' hover stays when
+      the pointer leaves, and the pointer takes it over by moving. */
+  byKeyboard = !1;
+  cursor = "default";
   /* ---------------------------------------------------------------- */
   /* What the scene reads                                              */
   /* ---------------------------------------------------------------- */
@@ -1528,45 +1547,42 @@ class so {
   ghostSummary() {
     const t = this.gesture;
     if (t.kind !== "edit" && t.kind !== "place") return null;
-    const e = Ze(this.host.view.viewport(), t.ghost);
+    const e = Ue(this.host.view.viewport(), t.ghost);
     if (e === null) return null;
-    const s = this.ghostFindings(t.ghost, this.ghostHome(t)), o = t.kind === "edit" && (t.mode === "leadIn" || t.mode === "leadOut"), i = o ? et(t.ghost) : t.ghost;
+    const n = this.ghostFindings(t.ghost, this.ghostHome(t)), i = t.kind === "edit" && (t.mode === "leadIn" || t.mode === "leadOut"), o = i ? et(t.ghost) : t.ghost;
     return {
       refused: this.refused,
       refusedLanes: [...t.refused],
       blocked: this.blocked,
-      x: o ? e.outerFrom : e.mainFrom,
+      x: i ? e.outerFrom : e.mainFrom,
       y: e.y,
       height: e.height,
-      from: i.from,
-      to: i.to,
-      overlap: s.overlaps.length > 0,
-      violated: s.violated.length > 0
+      from: o.from,
+      to: o.to,
+      overlap: n.overlaps.length > 0,
+      violated: n.violated.length > 0
     };
   }
   /* ---------------------------------------------------------------- */
   /* Pointer                                                           */
   /* ---------------------------------------------------------------- */
   local(t, e) {
-    var o;
-    const s = (o = this.host.plotElement()) == null ? void 0 : o.getBoundingClientRect();
-    return { x: t - ((s == null ? void 0 : s.left) ?? 0), y: e - ((s == null ? void 0 : s.top) ?? 0) };
+    const n = this.host.plotElement()?.getBoundingClientRect();
+    return { x: t - (n?.left ?? 0), y: e - (n?.top ?? 0) };
   }
-  report(t, e, s, o, i, r) {
-    var l, h;
+  report(t, e, n, i, o, r) {
     const a = this.host.view;
-    (h = (l = this.host.handlers()).onInteraction) == null || h.call(l, { type: t, hit: e, clientX: s, clientY: o, time: a.timeAt(i), lane: a.laneIdAt(r) });
+    this.host.handlers().onInteraction?.({ type: t, hit: e, clientX: n, clientY: i, time: a.timeAt(o), lane: a.laneIdAt(r) });
   }
   pointerDown(t) {
-    var a, l, h, d, u;
-    const { x: e, y: s } = this.local(t.clientX, t.clientY);
-    if (t.pointerType === "touch" && (this.touches.set(t.pointerId, { x: e, y: s }), this.touches.size >= 2)) {
+    const { x: e, y: n } = this.local(t.clientX, t.clientY);
+    if (t.pointerType === "touch" && (this.touches.set(t.pointerId, { x: e, y: n }), this.touches.size >= 2)) {
       this.gesture.kind !== "pinch" && (this.cancelEdit(), this.gesture = { kind: "pinch", distance: this.touchDistance() });
       return;
     }
     if (t.button !== 0) return;
-    const o = (h = (l = (a = t.target) == null ? void 0 : a.closest) == null ? void 0 : l.call(a, "[data-grip]")) == null ? void 0 : h.getAttribute("data-grip"), i = this.host.selectedSubtask(), r = i !== null ? this.host.data.subtaskById.get(i) ?? null : null;
-    t.pointerType === "touch" ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, mode: "pan", subtask: null } : (o === "leadIn" || o === "leadOut") && r !== null ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, mode: o, subtask: r } : this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, ...this.modeAt(e, s) }, (u = (d = this.host.plotElement()) == null ? void 0 : d.setPointerCapture) == null || u.call(d, t.pointerId);
+    const i = t.target?.closest?.("[data-grip]")?.getAttribute("data-grip"), o = this.host.selectedSubtask(), r = o !== null ? this.host.data.subtaskById.get(o) ?? null : null;
+    t.pointerType === "touch" ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, mode: "pan", subtask: null } : (i === "leadIn" || i === "leadOut") && r !== null ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, mode: i, subtask: r } : this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, ...this.modeAt(e, n) }, this.host.plotElement()?.setPointerCapture?.(t.pointerId);
   }
   /** A drag over a folded group: resting on one opens it for the GESTURE.
   
@@ -1576,13 +1592,12 @@ class so {
         never written to and no change is reported, because the application did
         not fold anything (ADR-0025). */
   restOver(t) {
-    var o;
-    const e = this.host.view, s = e.foldedGroupAt(t);
-    s !== ((o = this.resting) == null ? void 0 : o.group) && (this.stopResting(), s !== null && (this.resting = {
-      group: s,
+    const e = this.host.view, n = e.foldedGroupAt(t);
+    n !== this.resting?.group && (this.stopResting(), n !== null && (this.resting = {
+      group: n,
       timer: setTimeout(() => {
-        this.resting = null, e.openForGesture = /* @__PURE__ */ new Set([...e.openForGesture, s]), this.host.viewChanged();
-      }, eo)
+        this.resting = null, e.openForGesture = /* @__PURE__ */ new Set([...e.openForGesture, n]), this.host.viewChanged();
+      }, qn)
     }));
   }
   stopResting() {
@@ -1604,90 +1619,88 @@ class so {
       lane is open. Asked at a drop, where the answer has to be current; while
       a drag runs, the held set answers instead. */
   allowed(t, e) {
-    var s, o;
-    return ((o = (s = this.host.handlers()).canMoveTo) == null ? void 0 : o.call(s, t, e)) ?? !0;
+    return this.host.handlers().canMoveTo?.(t, e) ?? !0;
   }
   /** The lanes this work may not go to, for the gesture that is beginning. A
       gesture that cannot change a lane at all asks nothing: the intents the
       caller handles decide whether the question exists. */
   askRefused(t, e) {
-    if (!this.host.view.options.intents.includes(e === null ? "place" : "lane")) return _e;
-    const s = this.host.data.lanes.map((o) => o.id);
-    return Qn(s, t, e, this.host.handlers().canMoveTo);
+    if (!this.host.view.options.intents.includes(e === null ? "place" : "lane")) return Le;
+    const n = this.host.data.lanes.map((i) => i.id);
+    return Un(n, t, e, this.host.handlers().canMoveTo);
   }
   /** What a press at a point would start, given the intents the caller handles. */
   modeAt(t, e) {
-    const s = this.host.view, o = s.options.intents;
-    if (s.hitAt(t, e).kind === "milestone") return { mode: "pan", subtask: null };
-    for (let i = s.boxes.length - 1; i >= 0; i--) {
-      const r = s.boxes[i];
-      if (o.includes("stretch")) {
-        const a = Os(r, t, e);
+    const n = this.host.view, i = n.options.intents;
+    if (n.hitAt(t, e).kind === "milestone") return { mode: "pan", subtask: null };
+    for (let o = n.boxes.length - 1; o >= 0; o--) {
+      const r = n.boxes[o];
+      if (i.includes("stretch")) {
+        const a = Ss(r, t, e);
         if (a !== null) return { mode: a === "from" ? "stretch-from" : "stretch-to", subtask: r.subtask };
       }
-      if (Ve(r, t, e) !== null)
-        return o.includes("move") || o.includes("lane") ? { mode: "move", subtask: r.subtask } : { mode: "pan", subtask: r.subtask };
+      if ($e(r, t, e) !== null)
+        return i.includes("move") || i.includes("lane") ? { mode: "move", subtask: r.subtask } : { mode: "pan", subtask: r.subtask };
     }
     return { mode: "pan", subtask: null };
   }
   pointerMove(t) {
-    const { x: e, y: s } = this.local(t.clientX, t.clientY);
-    if (t.pointerType === "touch" && this.touches.has(t.pointerId) && (this.touches.set(t.pointerId, { x: e, y: s }), this.gesture.kind === "pinch")) {
+    const { x: e, y: n } = this.local(t.clientX, t.clientY);
+    if (t.pointerType === "touch" && this.touches.has(t.pointerId) && (this.touches.set(t.pointerId, { x: e, y: n }), this.gesture.kind === "pinch")) {
       const r = this.touchDistance();
       r > 0 && this.gesture.distance > 0 && this.host.view.zoomAt(this.touchCentre(), this.gesture.distance / r) && this.host.viewMoved(!0), this.gesture = { kind: "pinch", distance: r };
       return;
     }
-    const o = this.gesture;
-    if (o.kind === "pending" && o.pointerId === t.pointerId) {
-      if (Math.hypot(e - o.x0, s - o.y0) < (t.pointerType === "touch" ? to : Fe)) return;
-      if (o.mode === "pan" || o.subtask === null)
-        this.gesture = { kind: "pan", pointerId: o.pointerId, lastX: o.x0, lastY: o.y0 }, this.setCursor("grabbing");
+    const i = this.gesture;
+    if (i.kind === "pending" && i.pointerId === t.pointerId) {
+      if (Math.hypot(e - i.x0, n - i.y0) < (t.pointerType === "touch" ? Xn : Ae)) return;
+      if (i.mode === "pan" || i.subtask === null)
+        this.gesture = { kind: "pan", pointerId: i.pointerId, lastX: i.x0, lastY: i.y0 }, this.setCursor("grabbing");
       else {
-        const r = this.host.view.viewport().scale.fromPx(o.x0);
+        const r = this.host.view.viewport().scale.fromPx(i.x0);
         this.gesture = {
           kind: "edit",
-          pointerId: o.pointerId,
-          mode: o.mode,
-          subtask: o.subtask,
+          pointerId: i.pointerId,
+          mode: i.mode,
+          subtask: i.subtask,
           t0: r,
-          ghost: o.subtask,
+          ghost: i.subtask,
           /* Asked here, once, and drawn from the first frame of the drag: the
              lanes that are closed are marked before the pointer reaches one. */
-          refused: o.mode === "move" ? this.askRefused(o.subtask, o.subtask.lane) : _e
-        }, this.setCursor(o.mode === "move" ? "grabbing" : "ew-resize");
+          refused: i.mode === "move" ? this.askRefused(i.subtask, i.subtask.lane) : Le
+        }, this.setCursor(i.mode === "move" ? "grabbing" : "ew-resize");
       }
     }
-    const i = this.gesture;
-    if (i.kind === "pan" && i.pointerId === t.pointerId) {
-      const r = this.host.view.pan(i.lastX - e, i.lastY - s);
-      r.moved && this.host.viewMoved(r.time), this.gesture = { ...i, lastX: e, lastY: s };
+    const o = this.gesture;
+    if (o.kind === "pan" && o.pointerId === t.pointerId) {
+      const r = this.host.view.pan(o.lastX - e, o.lastY - n);
+      r.moved && this.host.viewMoved(r.time), this.gesture = { ...o, lastX: e, lastY: n };
       return;
     }
-    if (i.kind === "edit" && i.pointerId === t.pointerId) {
-      this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: e, y: s }, this.restOver(s), this.gesture = { ...i, ghost: this.heldGhost(i, e, s) }, this.setCursor(this.refused || this.blocked ? "not-allowed" : i.mode === "move" ? "grabbing" : "ew-resize"), this.host.interactionChanged(), this.autoPan();
+    if (o.kind === "edit" && o.pointerId === t.pointerId) {
+      this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: e, y: n }, this.restOver(n), this.gesture = { ...o, ghost: this.heldGhost(o, e, n) }, this.setCursor(this.refused || this.blocked ? "not-allowed" : o.mode === "move" ? "grabbing" : "ew-resize"), this.host.interactionChanged(), this.autoPan();
       return;
     }
-    i.kind === "none" && (this.byKeyboard = !1, this.hoverAt(t.clientX, t.clientY, e, s));
+    o.kind === "none" && (this.byKeyboard = !1, this.hoverAt(t.clientX, t.clientY, e, n));
   }
   pointerUp(t) {
-    var i, r;
     if (t.pointerType === "touch" && (this.touches.delete(t.pointerId), this.gesture.kind === "pinch")) {
-      const [a] = this.touches;
-      this.touches.size === 1 && a !== void 0 ? this.gesture = { kind: "pan", pointerId: a[0], lastX: a[1].x, lastY: a[1].y } : this.touches.size === 0 && (this.gesture = { kind: "none" });
+      const [o] = this.touches;
+      this.touches.size === 1 && o !== void 0 ? this.gesture = { kind: "pan", pointerId: o[0], lastX: o[1].x, lastY: o[1].y } : this.touches.size === 0 && (this.gesture = { kind: "none" });
       return;
     }
-    const e = this.gesture, { x: s, y: o } = this.local(t.clientX, t.clientY);
+    const e = this.gesture, { x: n, y: i } = this.local(t.clientX, t.clientY);
     if (e.kind === "pending" && e.pointerId === t.pointerId)
-      this.gesture = { kind: "none" }, this.click(t.clientX, t.clientY, s, o);
+      this.gesture = { kind: "none" }, this.click(t.clientX, t.clientY, n, i);
     else if (e.kind === "pan" && e.pointerId === t.pointerId)
-      this.gesture = { kind: "none" }, this.setCursor("default"), this.hoverAt(t.clientX, t.clientY, s, o);
+      this.gesture = { kind: "none" }, this.setCursor("default"), this.hoverAt(t.clientX, t.clientY, n, i);
     else if (e.kind === "edit" && e.pointerId === t.pointerId) {
       this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" };
-      const a = e.ghost.lane === e.subtask.lane || this.allowed(e.subtask, e.ghost.lane), l = this.intentsOf(e.subtask, e.ghost, e.mode).filter(
-        (h) => a || h.kind !== "lane"
+      const o = e.ghost.lane === e.subtask.lane || this.allowed(e.subtask, e.ghost.lane), r = this.intentsOf(e.subtask, e.ghost, e.mode).filter(
+        (a) => o || a.kind !== "lane"
       );
       this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged();
-      for (const h of l) (r = (i = this.host.handlers()).onIntent) == null || r.call(i, h);
+      for (const a of r) this.host.handlers().onIntent?.(a);
     }
   }
   /** While a drag is in flight near an edge, pans along once per frame and
@@ -1699,15 +1712,15 @@ class so {
       this.panFrame = 0;
       const e = this.gesture;
       if (e.kind !== "edit" && e.kind !== "place") return;
-      const s = this.host.view, { x: o, y: i } = this.local(this.lastClient.x, this.lastClient.y), r = Ce(o, s.width), a = Ce(i, s.height);
+      const n = this.host.view, { x: i, y: o } = this.local(this.lastClient.x, this.lastClient.y), r = Ie(i, n.width), a = Ie(o, n.height);
       if (r === 0 && a === 0) return;
-      const l = s.pan(r, a);
+      const l = n.pan(r, a);
       if (l.moved) {
-        if (this.dragPoint = { x: o, y: i }, e.kind === "edit")
-          this.gesture = { ...e, ghost: this.heldGhost(e, o, i) };
+        if (this.dragPoint = { x: i, y: o }, e.kind === "edit")
+          this.gesture = { ...e, ghost: this.heldGhost(e, i, o) };
         else {
-          const h = this.placeGhost(e.item, o, i, e.refused);
-          this.refused = h.refused, this.blocked = h.blocked, this.gesture = { ...e, ghost: h.ghost ?? e.ghost };
+          const d = this.placeGhost(e.item, i, o, e.refused);
+          this.refused = d.refused, this.blocked = d.blocked, this.gesture = { ...e, ghost: d.ghost ?? e.ghost };
         }
         this.host.viewMoved(l.time), this.panFrame = requestAnimationFrame(t);
       }
@@ -1726,8 +1739,8 @@ class so {
       times would be a lie. Nothing is reported: no interaction happened. */
   refreshHover() {
     if (!this.idle || this.hoverKey === "nothing" || this.byKeyboard) return;
-    const { x: t, y: e } = this.hoverPoint, s = this.host.view.hitAt(t, e);
-    this.hover = s, this.hoverKey = Ft(s);
+    const { x: t, y: e } = this.hoverPoint, n = this.host.view.hitAt(t, e);
+    this.hover = n, this.hoverKey = Ct(n);
   }
   pointerLeave() {
     this.gesture.kind !== "none" || this.byKeyboard || this.setHover({ kind: "nothing" }, "nothing");
@@ -1740,25 +1753,25 @@ class so {
   contextMenu(t) {
     if (this.host.handlers().onInteraction === void 0) return;
     t.preventDefault();
-    const { x: e, y: s } = this.local(t.clientX, t.clientY);
-    this.report("contextmenu", this.host.view.hitAt(e, s), t.clientX, t.clientY, e, s);
+    const { x: e, y: n } = this.local(t.clientX, t.clientY);
+    this.report("contextmenu", this.host.view.hitAt(e, n), t.clientX, t.clientY, e, n);
   }
   /** The wheel, as every scrolling area has it:
       vertical scrolls the lanes, and lets the page scroll on once they are at
       their end; Ctrl or ⌘ zooms - a trackpad pinch arrives as a wheel with
       Ctrl -; horizontal or Shift pans through time. */
   wheel(t) {
-    const e = this.host.view, s = Math.max(0, Math.min(e.width, this.local(t.clientX, t.clientY).x)), o = t.deltaMode === 1 ? 16 : t.deltaMode === 2 ? e.height : 1, i = t.deltaX * o, r = t.deltaY * o;
+    const e = this.host.view, n = Math.max(0, Math.min(e.width, this.local(t.clientX, t.clientY).x)), i = t.deltaMode === 1 ? 16 : t.deltaMode === 2 ? e.height : 1, o = t.deltaX * i, r = t.deltaY * i;
     if (t.ctrlKey || t.metaKey) {
       t.preventDefault();
-      const h = Math.abs(r) < 50 ? 0.01 : 15e-4;
-      e.zoomAt(s, Math.exp(r * h)) && this.host.viewMoved(!0);
+      const d = Math.abs(r) < 50 ? 0.01 : 15e-4;
+      e.zoomAt(n, Math.exp(r * d)) && this.host.viewMoved(!0);
       return;
     }
-    if (Math.abs(i) > Math.abs(r) || t.shiftKey) {
+    if (Math.abs(o) > Math.abs(r) || t.shiftKey) {
       t.preventDefault();
-      const h = e.pan(t.shiftKey && i === 0 ? r : i, 0);
-      h.moved && this.host.viewMoved(h.time);
+      const d = e.pan(t.shiftKey && o === 0 ? r : o, 0);
+      d.moved && this.host.viewMoved(d.time);
       return;
     }
     const a = r > 0 ? e.maxScroll() - e.scrollY : e.scrollY;
@@ -1767,26 +1780,26 @@ class so {
     const l = e.pan(0, r);
     l.moved && this.host.viewMoved(l.time);
   }
-  click(t, e, s, o) {
-    const i = this.host.view.hitAt(s, o), r = i.kind === "subtask" ? i.subtask.task : i.kind === "dependency" ? this.host.data.taskOfDependency(i.dependency) : null;
-    this.host.select(r, i.kind === "subtask" ? i.subtask.id : null), this.report("click", i, t, e, s, o);
+  click(t, e, n, i) {
+    const o = this.host.view.hitAt(n, i), r = o.kind === "subtask" ? o.subtask.task : o.kind === "dependency" ? this.host.data.taskOfDependency(o.dependency) : null;
+    this.host.select(r, o.kind === "subtask" ? o.subtask.id : null), this.report("click", o, t, e, n, i);
   }
-  hoverAt(t, e, s, o) {
-    const i = this.host.view.hitAt(s, o), r = Ft(i), { mode: a } = this.modeAt(s, o);
-    if (this.setCursor(a === "move" ? "grab" : a === "stretch-from" || a === "stretch-to" ? "ew-resize" : "default"), this.hoverPoint = { x: s, y: o }, r === this.hoverKey) {
-      (i.kind === "subtask" || i.kind === "dependency" || i.kind === "milestone") && this.host.interactionChanged();
+  hoverAt(t, e, n, i) {
+    const o = this.host.view.hitAt(n, i), r = Ct(o), { mode: a } = this.modeAt(n, i);
+    if (this.setCursor(a === "move" ? "grab" : a === "stretch-from" || a === "stretch-to" ? "ew-resize" : "default"), this.hoverPoint = { x: n, y: i }, r === this.hoverKey) {
+      (o.kind === "subtask" || o.kind === "dependency" || o.kind === "milestone") && this.host.hoverChanged();
       return;
     }
-    this.setHover(i, r), this.report("hover", i, t, e, s, o);
+    this.setHover(o, r), this.report("hover", o, t, e, n, i);
   }
   /** The keyboard sets the hover: drawn, and its tooltip shown, as the
       pointer's would be - and reported to nobody, since `onInteraction`
       speaks of pointer positions. `nothing` hands the hover back. */
   setKeyboardHover(t, e) {
-    this.byKeyboard = t.kind !== "nothing", this.hoverPoint = e, this.hover = t, this.hoverKey = Ft(t), this.host.interactionChanged();
+    this.byKeyboard = t.kind !== "nothing", this.hoverPoint = e, this.hover = t, this.hoverKey = Ct(t), this.host.interactionChanged();
   }
   setHover(t, e) {
-    e !== this.hoverKey && (this.hoverKey = e, this.hover = t, this.host.interactionChanged());
+    e !== this.hoverKey && (this.hoverKey = e, this.hover = t, this.host.hoverChanged());
   }
   setCursor(t) {
     t !== this.cursor && (this.cursor = t, this.host.interactionChanged());
@@ -1806,47 +1819,47 @@ class so {
       dragging and handles the place intent, the drop is accepted and a ghost
       shows where the work would land. */
   dragOver(t, e) {
-    const s = this.host.view;
-    if (e === null || !s.options.intents.includes("place")) return;
-    const { x: o, y: i } = this.local(t.clientX, t.clientY);
-    if (s.laneIdAt(i) === null && s.foldedGroupAt(i) === null) {
+    const n = this.host.view;
+    if (e === null || !n.options.intents.includes("place")) return;
+    const { x: i, y: o } = this.local(t.clientX, t.clientY);
+    if (n.laneIdAt(o) === null && n.foldedGroupAt(o) === null) {
       this.clearPlacing();
       return;
     }
-    t.preventDefault(), this.restOver(i);
+    t.preventDefault(), this.restOver(o);
     const r = this.gesture.kind === "place" ? this.gesture.refused : (
       /* Work dragged in sits on no lane until it is dropped. Where the
          pointer is not over one either, the rule is asked about an item
          whose own lane is empty - which is the truth of it: `canMoveTo`
          is asked ABOUT a lane, and the one this item is on is none. */
-      this.askRefused(this.askedFor(e, this.onLane(i) ?? "", o), null)
-    ), a = this.placeGhost(e, o, i, r);
+      this.askRefused(this.askedFor(e, this.onLane(o) ?? "", i), null)
+    ), a = this.placeGhost(e, i, o, r);
     this.refused = a.refused, this.blocked = a.blocked, this.setCursor(a.refused || a.blocked ? "not-allowed" : "default");
-    const l = this.gesture.kind === "place" ? this.gesture.ghost : null, h = a.ghost ?? (a.refused || a.blocked ? l : null);
-    t.dataTransfer !== null && (t.dataTransfer.dropEffect = h === null ? "none" : "copy"), h !== null && (this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: o, y: i }, this.gesture = { kind: "place", ghost: h, item: e, refused: r }, this.host.interactionChanged(), this.autoPan());
+    const l = this.gesture.kind === "place" ? this.gesture.ghost : null, d = a.ghost ?? (a.refused || a.blocked ? l : null);
+    t.dataTransfer !== null && (t.dataTransfer.dropEffect = d === null ? "none" : "copy"), d !== null && (this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: i, y: o }, this.gesture = { kind: "place", ghost: d, item: e, refused: r }, this.host.interactionChanged(), this.autoPan());
   }
   /** The ghost of a drag from outside at a point on the plot: none off the
       lanes, none where the caller refuses that lane and none where it would
       cover blocked time - which the answer says apart, because they mean
       different things to the drag. */
-  placeGhost(t, e, s, o) {
-    const i = this.onLane(s);
-    if (i === null) return { ghost: null, refused: !1, blocked: !1 };
-    if (o.has(i)) return { ghost: null, refused: !0, blocked: !1 };
-    const r = { ...this.askedFor(t, i, e), id: De };
-    return rt(r, null, this.host.data.blocked) ? { ghost: null, refused: !1, blocked: !0 } : { ghost: r, refused: !1, blocked: !1 };
+  placeGhost(t, e, n, i) {
+    const o = this.onLane(n);
+    if (o === null) return { ghost: null, refused: !1, blocked: !1 };
+    if (i.has(o)) return { ghost: null, refused: !0, blocked: !1 };
+    const r = { ...this.askedFor(t, o, e), id: Se };
+    return ot(r, null, this.host.data.blocked) ? { ghost: null, refused: !1, blocked: !0 } : { ghost: r, refused: !1, blocked: !1 };
   }
   /** The dragged item as a subtask, under the caller's key for it - not the
       internal sentinel: the rule is asked about the thing the application says
       it is dragging, and the ghost only afterwards takes the sentinel. */
-  askedFor(t, e, s) {
-    const o = this.snapInside(this.host.view.timeAt(s), this.snapStep());
+  askedFor(t, e, n) {
+    const i = this.snapInside(this.host.view.timeAt(n), this.snapStep());
     return {
       id: t.item,
       task: t.task,
       lane: e,
-      from: o,
-      to: o + t.duration,
+      from: i,
+      to: i + t.duration,
       ...t.leadIn === void 0 ? {} : { leadIn: t.leadIn },
       ...t.leadOut === void 0 ? {} : { leadOut: t.leadOut }
     };
@@ -1854,23 +1867,22 @@ class so {
   /** The drop: the place intent, and the ghost goes. Off every lane, or with
       nothing declared, nothing is reported. */
   drop(t) {
-    var r, a;
     const e = this.gesture;
     if (e.kind !== "place") return;
     t.preventDefault();
-    const { ghost: s, item: o } = e;
-    if (this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" }, this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged(), !this.allowed({ ...s, id: o.item }, s.lane)) return;
-    const i = {
+    const { ghost: n, item: i } = e;
+    if (this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" }, this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged(), !this.allowed({ ...n, id: i.item }, n.lane)) return;
+    const o = {
       kind: "place",
-      item: o.item,
-      task: s.task,
-      lane: s.lane,
-      from: s.from,
-      to: s.to,
-      ...s.leadIn === void 0 ? {} : { leadIn: s.leadIn },
-      ...s.leadOut === void 0 ? {} : { leadOut: s.leadOut }
+      item: i.item,
+      task: n.task,
+      lane: n.lane,
+      from: n.from,
+      to: n.to,
+      ...n.leadIn === void 0 ? {} : { leadIn: n.leadIn },
+      ...n.leadOut === void 0 ? {} : { leadOut: n.leadOut }
     };
-    (a = (r = this.host.handlers()).onIntent) == null || a.call(r, i);
+    this.host.handlers().onIntent?.(o);
   }
   /** The drag left the plot, or the application stopped dragging - which is
       also how Escape arrives: the browser ends its own drag and sends a leave
@@ -1890,52 +1902,52 @@ class so {
       put the work into blocked time it did not already cover, the ghost where
       it last stood. It is held, not clamped: a pointer carried on past the
       blocked time takes the ghost along again. */
-  heldGhost(t, e, s) {
-    const o = this.ghostFor(t, e, s);
-    return this.blocked = rt(o, t.subtask, this.host.data.blocked), this.blocked ? t.ghost : o;
+  heldGhost(t, e, n) {
+    const i = this.ghostFor(t, e, n);
+    return this.blocked = ot(i, t.subtask, this.host.data.blocked), this.blocked ? t.ghost : i;
   }
-  ghostFor(t, e, s) {
-    const o = this.host.view, i = t.subtask, r = this.snapStep(), a = o.options.intents, l = this.snapInside(o.timeAt(e), r);
+  ghostFor(t, e, n) {
+    const i = this.host.view, o = t.subtask, r = this.snapStep(), a = i.options.intents, l = this.snapInside(i.timeAt(e), r);
     switch (t.mode) {
       case "move": {
-        let h = i.from;
-        const d = o.viewport().scale, u = d.fromPx(e) - t.t0;
-        a.includes("move") && Math.abs(u * d.m) >= Fe && (h = this.shifted(i.from, u, r));
-        let m = t.ghost.lane;
+        let d = o.from;
+        const h = i.viewport().scale, c = h.fromPx(e) - t.t0;
+        a.includes("move") && Math.abs(c * h.m) >= Ae && (d = this.shifted(o.from, c, r));
+        let f = t.ghost.lane;
         if (a.includes("lane")) {
-          const p = this.onLane(s) ?? m;
-          this.refused = t.refused.has(p), this.refused || (m = p);
+          const g = this.onLane(n) ?? f;
+          this.refused = t.refused.has(g), this.refused || (f = g);
         } else
           this.refused = !1;
-        return { ...i, from: h, to: h + (i.to - i.from), lane: m };
+        return { ...o, from: d, to: d + (o.to - o.from), lane: f };
       }
       case "stretch-from":
-        return { ...i, from: Math.min(l, i.to - Math.max(r.step, q)) };
+        return { ...o, from: Math.min(l, o.to - Math.max(r.step, X)) };
       case "stretch-to":
-        return { ...i, to: Math.max(l, i.from + Math.max(r.step, q)) };
+        return { ...o, to: Math.max(l, o.from + Math.max(r.step, X)) };
       case "leadIn":
-        return { ...i, leadIn: Math.max(0, i.from - l) };
+        return { ...o, leadIn: Math.max(0, o.from - l) };
       case "leadOut":
-        return { ...i, leadOut: Math.max(0, l - i.to) };
+        return { ...o, leadOut: Math.max(0, l - o.to) };
     }
   }
   /** A time moved by an amount of WORKING time and snapped: a drag moves
       a start this way, and a key by one step of the raster - one arithmetic,
       so a key proposes exactly what a drag of that length would. */
-  shifted(t, e, s) {
-    const o = pt(this.host.view.options.calendar), i = H(t, o) + e, r = at(i, o);
-    return this.snapInside(r, s);
+  shifted(t, e, n) {
+    const i = ft(this.host.view.options.calendar), o = R(t, i) + e, r = rt(o, i);
+    return this.snapInside(r, n);
   }
   /** Snapped - and, where the raster lands in time the calendar removes, moved
       on to the seam, where time counts again. An intent never asks for a time
       nobody works. */
   snapInside(t, e) {
-    const s = Ms(t, e), o = pt(this.host.view.options.calendar);
-    return o.intervals.length === 0 ? s : xt(H(s, o), o);
+    const n = ps(t, e), i = ft(this.host.view.options.calendar);
+    return i.intervals.length === 0 ? n : Nt(R(n, i), i);
   }
-  intentsOf(t, e, s) {
-    const o = [], i = this.host.view.options.intents, r = t.id;
-    return s === "move" ? (e.from !== t.from && i.includes("move") && o.push({ kind: "move", subtask: r, from: e.from, to: e.to }), e.lane !== t.lane && i.includes("lane") && o.push({ kind: "lane", subtask: r, lane: e.lane })) : s === "stretch-from" || s === "stretch-to" ? (e.from !== t.from || e.to !== t.to) && o.push({ kind: "stretch", subtask: r, from: e.from, to: e.to }) : s === "leadIn" ? (e.leadIn ?? 0) !== (t.leadIn ?? 0) && o.push({ kind: "leadIn", subtask: r, leadIn: e.leadIn ?? 0 }) : (e.leadOut ?? 0) !== (t.leadOut ?? 0) && o.push({ kind: "leadOut", subtask: r, leadOut: e.leadOut ?? 0 }), o;
+  intentsOf(t, e, n) {
+    const i = [], o = this.host.view.options.intents, r = t.id;
+    return n === "move" ? (e.from !== t.from && o.includes("move") && i.push({ kind: "move", subtask: r, from: e.from, to: e.to }), e.lane !== t.lane && o.includes("lane") && i.push({ kind: "lane", subtask: r, lane: e.lane })) : n === "stretch-from" || n === "stretch-to" ? (e.from !== t.from || e.to !== t.to) && i.push({ kind: "stretch", subtask: r, from: e.from, to: e.to }) : n === "leadIn" ? (e.leadIn ?? 0) !== (t.leadIn ?? 0) && i.push({ kind: "leadIn", subtask: r, leadIn: e.leadIn ?? 0 }) : (e.leadOut ?? 0) !== (t.leadOut ?? 0) && i.push({ kind: "leadOut", subtask: r, leadOut: e.leadOut ?? 0 }), i;
   }
   /** The lane the ghost came from - the only other lane a drag can touch. */
   ghostHome(t) {
@@ -1951,69 +1963,68 @@ class so {
         keeps a plan of hundreds of tasks fluid while a drag runs, since this is
         computed on every pointer movement. */
   ghostFindings(t, e) {
-    const s = this.host.data, o = (d) => d.lane === t.lane || d.lane === e, r = [...s.subtasks.filter((d) => d.id !== t.id && o(d)), t], a = (d) => d.first === t.id || d.second === t.id, l = s.dependencies.filter((d) => d.from === t.id || d.to === t.id), h = t.id === De ? s.subtasks : s.subtasks.map((d) => d.id === t.id ? t : d);
-    return { overlaps: Vt(r).filter(a), violated: Wt(h, l) };
+    const n = this.host.data, i = (h) => h.lane === t.lane || h.lane === e, r = [...n.subtasks.filter((h) => h.id !== t.id && i(h)), t], a = (h) => h.first === t.id || h.second === t.id, l = n.dependencies.filter((h) => h.from === t.id || h.to === t.id), d = t.id === Se ? n.subtasks : n.subtasks.map((h) => h.id === t.id ? t : h);
+    return { overlaps: Ht(r).filter(a), violated: Yt(d, l) };
   }
 }
-function no(n, t) {
+function Jn(s, t) {
   const e = /* @__PURE__ */ new Map();
-  for (const s of t) {
-    const o = n.slots.get(s.lane), i = o === void 0 ? null : tt(n, o.top);
-    if (i === null) continue;
-    const r = n.rows.indexOf(i);
-    e.set(r, [...e.get(r) ?? [], s]);
-  }
-  return [...e.entries()].sort(([s], [o]) => s - o).map(([, s]) => s.sort((o, i) => o.from - i.from || o.to - i.to));
-}
-const Oe = (n, t) => t < n.from ? n.from - t : t > n.to ? t - n.to : 0;
-function oo(n, t, e, s) {
-  var h;
-  let o = -1, i = -1;
-  for (let d = 0; d < n.length && t !== null && o < 0; d++)
-    i = n[d].findIndex((u) => u.id === t), i >= 0 && (o = d);
-  if (o < 0) {
-    for (const d of n) {
-      const u = d.find((m) => m.to > s[0] && m.from < s[1]);
-      if (u !== void 0) return u;
+  for (const n of t) {
+    const i = s.slots.get(n.lane), o = i === void 0 ? null : tt(s, i.top);
+    if (o === null) continue;
+    const r = s.rows.indexOf(o);
+    e.set(r, [...e.get(r) ?? [], n]);
+  }
+  return [...e.entries()].sort(([n], [i]) => n - i).map(([, n]) => n.sort((i, o) => i.from - o.from || i.to - o.to));
+}
+const Ce = (s, t) => t < s.from ? s.from - t : t > s.to ? t - s.to : 0;
+function Zn(s, t, e, n) {
+  let i = -1, o = -1;
+  for (let d = 0; d < s.length && t !== null && i < 0; d++)
+    o = s[d].findIndex((h) => h.id === t), o >= 0 && (i = d);
+  if (i < 0) {
+    for (const d of s) {
+      const h = d.find((c) => c.to > n[0] && c.from < n[1]);
+      if (h !== void 0) return h;
     }
-    return ((h = n[0]) == null ? void 0 : h[0]) ?? null;
+    return s[0]?.[0] ?? null;
   }
-  const r = n[o], a = r[i], l = (s[1] - s[0]) / 10;
+  const r = s[i], a = r[o], l = (n[1] - n[0]) / 10;
   switch (e) {
     case "next":
-      return r[i + 1] ?? a;
+      return r[o + 1] ?? a;
     case "previous":
-      return r[i - 1] ?? a;
+      return r[o - 1] ?? a;
     case "first":
       return r[0];
     case "last":
       return r[r.length - 1];
     case "pageNext":
-      return r.find((d, u) => u > i && d.from >= a.from + l) ?? r[r.length - 1];
+      return r.find((d, h) => h > o && d.from >= a.from + l) ?? r[r.length - 1];
     case "pagePrevious":
-      for (let d = i - 1; d >= 0; d--) if (r[d].from <= a.from - l) return r[d];
+      for (let d = o - 1; d >= 0; d--) if (r[d].from <= a.from - l) return r[d];
       return r[0];
     case "up":
     case "down": {
-      const d = n[e === "up" ? o - 1 : o + 1];
+      const d = s[e === "up" ? i - 1 : i + 1];
       if (d === void 0) return a;
-      const u = (a.from + a.to) / 2;
-      return d.reduce((m, p) => Oe(p, u) < Oe(m, u) ? p : m);
+      const h = (a.from + a.to) / 2;
+      return d.reduce((c, f) => Ce(f, h) < Ce(c, h) ? f : c);
     }
   }
 }
-function io(n, t, e, s) {
+function Qn(s, t, e, n) {
   if (e.kind === "milestone") return e;
   if (e.kind === "dependency") {
-    const i = n.find((a) => a.id === e.id), r = i === void 0 ? void 0 : s === "out" ? i.to : i.from;
+    const o = s.find((a) => a.id === e.id), r = o === void 0 ? void 0 : n === "out" ? o.to : o.from;
     return r !== void 0 && t.has(r) ? { kind: "subtask", id: r } : e;
   }
-  const o = n.find(
-    (i) => (s === "out" ? i.from : i.to) === e.id && t.has(s === "out" ? i.to : i.from)
+  const i = s.find(
+    (o) => (n === "out" ? o.from : o.to) === e.id && t.has(n === "out" ? o.to : o.from)
   );
-  return o === void 0 ? e : { kind: "dependency", id: o.id };
+  return i === void 0 ? e : { kind: "dependency", id: i.id };
 }
-const mt = "\0milestone:", ro = 150, ao = {
+const ct = "\0milestone:", ti = 150, ei = {
   ArrowRight: "next",
   ArrowLeft: "previous",
   ArrowUp: "up",
@@ -2023,12 +2034,12 @@ const mt = "\0milestone:", ro = 150, ao = {
   PageDown: "pageNext",
   PageUp: "pagePrevious"
 };
-class lo {
+class si {
   constructor(t) {
-    f(this, "spoken", null);
-    f(this, "timer", null);
     this.host = t;
   }
+  spoken = null;
+  timer = null;
   /** Where the keys stand: the hover, whoever set it. */
   active() {
     const t = this.host.gestures.hover;
@@ -2048,34 +2059,33 @@ class lo {
   key(t) {
     const e = this.host.gestures;
     if (t.metaKey || !e.idle) return !1;
-    const s = t.key.toLowerCase() === "t" && !t.ctrlKey && !t.altKey;
-    if (t.key === "]" || t.key === "[" || s) {
-      const i = this.active();
-      if (i === null) return !1;
-      const r = this.host.data, a = s ? !t.shiftKey : t.key === "]";
-      return this.show(io(r.dependencies, r.subtaskById, i, a ? "out" : "back")), !0;
+    const n = t.key.toLowerCase() === "t" && !t.ctrlKey && !t.altKey;
+    if (t.key === "]" || t.key === "[" || n) {
+      const o = this.active();
+      if (o === null) return !1;
+      const r = this.host.data, a = n ? !t.shiftKey : t.key === "]";
+      return this.show(Qn(r.dependencies, r.subtaskById, o, a ? "out" : "back")), !0;
     }
     if (t.ctrlKey) return !1;
     if (t.altKey) return this.edit(t);
     if (t.key === "Escape")
       return e.byKeyboard ? (this.blur(), !0) : !1;
     if (t.key === "Enter" || t.key === " ") return this.select();
-    const o = t.shiftKey ? void 0 : ao[t.key];
-    return o === void 0 ? !1 : (this.walk(o), !0);
+    const i = t.shiftKey ? void 0 : ei[t.key];
+    return i === void 0 ? !1 : (this.walk(i), !0);
   }
   walk(t) {
-    var h;
-    const { data: e, view: s } = this.host, o = this.active(), i = o === null ? null : o.kind === "subtask" ? o.id : o.kind === "milestone" ? mt + o.id : ((h = e.dependencies.find((d) => d.id === o.id)) == null ? void 0 : h.from) ?? null, r = [...e.subtasks, ...e.milestones.map((d) => ({ id: mt + d.id, lane: d.lane, from: d.at, to: d.at }))];
-    let a = no(s.rows, r);
-    if (i === null) {
-      const d = a.filter((u) => {
-        const m = j(s.viewport(), u[0].lane);
-        return m !== null && m.top + m.height > 0 && m.top < s.height;
+    const { data: e, view: n } = this.host, i = this.active(), o = i === null ? null : i.kind === "subtask" ? i.id : i.kind === "milestone" ? ct + i.id : e.dependencies.find((d) => d.id === i.id)?.from ?? null, r = [...e.subtasks, ...e.milestones.map((d) => ({ id: ct + d.id, lane: d.lane, from: d.at, to: d.at }))];
+    let a = Jn(n.rows, r);
+    if (o === null) {
+      const d = a.filter((h) => {
+        const c = q(n.viewport(), h[0].lane);
+        return c !== null && c.top + c.height > 0 && c.top < n.height;
       });
       d.length > 0 && (a = d);
     }
-    const l = oo(a, i, t, this.host.visibleDomain());
-    l !== null && this.show(l.id.startsWith(mt) ? { kind: "milestone", id: l.id.slice(mt.length) } : { kind: "subtask", id: l.id });
+    const l = Zn(a, o, t, this.host.visibleDomain());
+    l !== null && this.show(l.id.startsWith(ct) ? { kind: "milestone", id: l.id.slice(ct.length) } : { kind: "subtask", id: l.id });
   }
   /** Space and Enter select as a click does: the whole task, and the subtask. */
   select() {
@@ -2089,81 +2099,80 @@ class lo {
       end - the intents a drag of that length reports (ADR-0023), and only
       where the caller handles them. Nothing is applied here. */
   edit(t) {
-    var u, m;
-    const e = this.host.gestures.hover, s = t.key === "ArrowRight" ? 1 : t.key === "ArrowLeft" ? -1 : 0;
-    if (s === 0) return !1;
+    const e = this.host.gestures.hover, n = t.key === "ArrowRight" ? 1 : t.key === "ArrowLeft" ? -1 : 0;
+    if (n === 0) return !1;
     if (e.kind !== "subtask") return !0;
-    const o = e.subtask, i = this.host.gestures, r = this.host.view.options.intents, a = i.snapStep(), l = a.step > 0 ? a : { step: this.host.view.step(), offset: 0 }, h = this.host.data.blocked;
-    let d = null;
+    const i = e.subtask, o = this.host.gestures, r = this.host.view.options.intents, a = o.snapStep(), l = a.step > 0 ? a : { step: this.host.view.step(), offset: 0 }, d = this.host.data.blocked;
+    let h = null;
     if (!t.shiftKey && r.includes("move")) {
-      const p = (I) => ({ ...o, from: I, to: I + (o.to - o.from) });
-      let y = o.from;
-      for (let I = 0; I < 1e3; I++) {
-        const A = i.shifted(y, s * l.step, l);
-        if (A === y || (y = A, !rt(p(y), o, h))) break;
+      const c = (g) => ({ ...i, from: g, to: g + (i.to - i.from) });
+      let f = i.from;
+      for (let g = 0; g < 1e3; g++) {
+        const v = o.shifted(f, n * l.step, l);
+        if (v === f || (f = v, !ot(c(f), i, d))) break;
       }
-      y !== o.from && !rt(p(y), o, h) && (d = { kind: "move", subtask: o.id, from: y, to: p(y).to });
+      f !== i.from && !ot(c(f), i, d) && (h = { kind: "move", subtask: i.id, from: f, to: c(f).to });
     } else if (t.shiftKey && r.includes("stretch")) {
-      const p = Math.max(i.shifted(o.to, s * l.step, l), o.from + Math.max(l.step, q));
-      p !== o.to && !rt({ ...o, to: p }, o, h) && (d = { kind: "stretch", subtask: o.id, from: o.from, to: p });
+      const c = Math.max(o.shifted(i.to, n * l.step, l), i.from + Math.max(l.step, X));
+      c !== i.to && !ot({ ...i, to: c }, i, d) && (h = { kind: "stretch", subtask: i.id, from: i.from, to: c });
     }
-    return i.byKeyboard = !0, d !== null && ((m = (u = this.host.handlers()).onIntent) == null || m.call(u, d)), this.scheduleReadout(), !0;
+    return o.byKeyboard = !0, h !== null && this.host.handlers().onIntent?.(h), this.scheduleReadout(), !0;
   }
   /** The keys stand on this target: brought into view, drawn as the hover. */
   show(t, e = !0) {
-    const s = this.hitOf(t);
-    if (s === null) return;
+    const n = this.hitOf(t);
+    if (n === null) return;
     e && this.reveal(t);
-    const o = this.bounds(t);
-    if (o === null) return;
-    const { view: i } = this.host, r = (a, l) => Math.max(0, Math.min(l, a));
-    this.host.gestures.setKeyboardHover(s, {
-      x: (r(o.x0, i.width) + r(o.x1, i.width)) / 2,
-      y: (r(o.y0, i.height) + r(o.y1, i.height)) / 2
+    const i = this.bounds(t);
+    if (i === null) return;
+    const { view: o } = this.host, r = (a, l) => Math.max(0, Math.min(l, a));
+    this.host.gestures.setKeyboardHover(n, {
+      x: (r(i.x0, o.width) + r(i.x1, o.width)) / 2,
+      y: (r(i.y0, o.height) + r(i.y1, o.height)) / 2
     }), e && this.scheduleReadout();
   }
   hitOf(t) {
     const e = this.host.data;
     if (t.kind === "subtask") {
-      const o = e.subtaskById.get(t.id);
-      return o === void 0 ? null : { kind: "subtask", subtask: o, part: "main" };
+      const i = e.subtaskById.get(t.id);
+      return i === void 0 ? null : { kind: "subtask", subtask: i, part: "main" };
     }
     if (t.kind === "milestone") {
-      const o = e.milestones.find((i) => i.id === t.id);
-      return o === void 0 ? null : { kind: "milestone", milestone: o };
+      const i = e.milestones.find((o) => o.id === t.id);
+      return i === void 0 ? null : { kind: "milestone", milestone: i };
     }
-    const s = e.dependencies.find((o) => o.id === t.id);
-    return s === void 0 ? null : { kind: "dependency", dependency: s };
+    const n = e.dependencies.find((i) => i.id === t.id);
+    return n === void 0 ? null : { kind: "dependency", dependency: n };
   }
   /** Where a target lies on the plot: a subtask's bar, or the span between
       the two bars a dependency joins. */
   bounds(t) {
-    const e = this.host.view, s = (a) => e.boxById.get(a);
+    const e = this.host.view, n = (a) => e.boxById.get(a);
     if (t.kind === "subtask") {
-      const a = s(t.id);
+      const a = n(t.id);
       return a === void 0 ? null : { x0: a.outerFrom, x1: a.outerTo, y0: a.y, y1: a.y + a.height };
     }
     if (t.kind === "milestone") {
-      const a = this.host.data.milestones.find((h) => h.id === t.id), l = a === void 0 ? null : Xt(e.viewport(), a);
+      const a = this.host.data.milestones.find((d) => d.id === t.id), l = a === void 0 ? null : Wt(e.viewport(), a);
       return l === null ? null : { x0: l.x - l.half, x1: l.x + l.half, y0: l.y - l.half, y1: l.y + l.half };
     }
-    const o = this.host.data.dependencies.find((a) => a.id === t.id), i = o === void 0 ? void 0 : s(o.from), r = o === void 0 ? void 0 : s(o.to);
-    return i === void 0 || r === void 0 ? null : {
-      x0: Math.min(i.mainTo, r.mainFrom),
-      x1: Math.max(i.mainTo, r.mainFrom),
-      y0: Math.min(i.y, r.y),
-      y1: Math.max(i.y + i.height, r.y + r.height)
+    const i = this.host.data.dependencies.find((a) => a.id === t.id), o = i === void 0 ? void 0 : n(i.from), r = i === void 0 ? void 0 : n(i.to);
+    return o === void 0 || r === void 0 ? null : {
+      x0: Math.min(o.mainTo, r.mainFrom),
+      x1: Math.max(o.mainTo, r.mainFrom),
+      y0: Math.min(o.y, r.y),
+      y1: Math.max(o.y + o.height, r.y + r.height)
     };
   }
   /** Pans and scrolls just enough to bring a target into view, with a margin
       at the side it came in from; a target wider than the view shows its
       start. As a drag at the edge pans along, the keys do. */
   reveal(t) {
-    const e = this.bounds(t), s = this.host.view;
-    if (e === null || s.width <= 0) return;
-    const o = Math.min(24, s.width / 10), i = e.x0 < 0 ? e.x0 - o : e.x1 > s.width ? Math.max(0, Math.min(e.x1 - s.width + o, e.x0 - o)) : 0, r = e.y0 < 0 ? e.y0 : e.y1 > s.height ? Math.min(e.y1 - s.height, e.y0) : 0;
-    if (i === 0 && r === 0) return;
-    const a = s.pan(i, r);
+    const e = this.bounds(t), n = this.host.view;
+    if (e === null || n.width <= 0) return;
+    const i = Math.min(24, n.width / 10), o = e.x0 < 0 ? e.x0 - i : e.x1 > n.width ? Math.max(0, Math.min(e.x1 - n.width + i, e.x0 - i)) : 0, r = e.y0 < 0 ? e.y0 : e.y1 > n.height ? Math.min(e.y1 - n.height, e.y0) : 0;
+    if (o === 0 && r === 0) return;
+    const a = n.pan(o, r);
     a.moved && this.host.viewMoved(a.time);
   }
   /** After the data or the view changed: the keys' target is read anew by its
@@ -2176,42 +2185,41 @@ class lo {
       the hover: a pointer that took it over in the pause is not spoken for. */
   scheduleReadout() {
     this.timer !== null && clearTimeout(this.timer), this.timer = setTimeout(() => {
-      var s;
       this.timer = null;
       const t = this.host.gestures.hover;
       if (!this.host.gestures.byKeyboard) return;
       const e = this.host.data.tooltipTargetFor(t);
-      e !== null && (this.spoken = { target: e, lane: t.kind === "subtask" ? t.subtask.lane : t.kind === "milestone" ? t.milestone.lane : null, count: (((s = this.spoken) == null ? void 0 : s.count) ?? 0) + 1 }, this.host.spokenChanged());
-    }, ro);
+      e !== null && (this.spoken = { target: e, lane: t.kind === "subtask" ? t.subtask.lane : t.kind === "milestone" ? t.milestone.lane : null, count: (this.spoken?.count ?? 0) + 1 }, this.host.spokenChanged());
+    }, ti);
   }
   /** Unmount: no readout after it. */
   stop() {
     this.timer !== null && clearTimeout(this.timer), this.timer = null;
   }
 }
-const Q = (n) => JSON.stringify([n.domain ?? null, [...n.folded ?? []].sort()]);
-function ho(n, t) {
-  if (t.size === 0 || n.folded === void 0) return n;
-  const e = n.folded.filter((s) => t.has(s));
-  return e.length === n.folded.length ? n : { ...n.domain ? { domain: n.domain } : {}, ...e.length ? { folded: e } : {} };
+const Q = (s) => JSON.stringify([s.domain ?? null, [...s.folded ?? []].sort()]);
+function ni(s, t) {
+  if (t.size === 0 || s.folded === void 0) return s;
+  const e = s.folded.filter((n) => t.has(n));
+  return e.length === s.folded.length ? s : { ...s.domain ? { domain: s.domain } : {}, ...e.length ? { folded: e } : {} };
 }
-function co(n, t, e = (s) => s) {
-  if (n.length === 0) return null;
-  let s = 1 / 0, o = -1 / 0;
-  for (const a of n)
-    s = Math.min(s, a.from - (a.leadIn ?? 0)), o = Math.max(o, a.to + (a.leadOut ?? 0));
-  s = e(s), o = e(o);
-  const i = Math.min(t.max, Math.max(t.min, o - s)), r = (s + o) / 2;
-  return [r - i / 2, r + i / 2];
+function ii(s, t, e = (n) => n) {
+  if (s.length === 0) return null;
+  let n = 1 / 0, i = -1 / 0;
+  for (const a of s)
+    n = Math.min(n, a.from - (a.leadIn ?? 0)), i = Math.max(i, a.to + (a.leadOut ?? 0));
+  n = e(n), i = e(i);
+  const o = Math.min(t.max, Math.max(t.min, i - n)), r = (n + i) / 2;
+  return [r - o / 2, r + o / 2];
 }
-const Ee = {
+const De = {
   width: 0,
   height: 0,
   scrollY: 0,
   headers: [],
   days: [],
   ticks: [],
-  step: Gt,
+  step: xt,
   ghost: null,
   grips: [],
   cursor: "default",
@@ -2221,130 +2229,86 @@ const Ee = {
   spoken: null,
   summary: { lanes: 0, subtasks: 0, from: 0, to: 0, overlaps: 0, violated: 0, blocked: 0, milestones: 0 }
 };
-class uo {
+class oi {
+  data = new In(() => this.viewChanged());
+  view = new Rs(this.data);
+  gestures;
+  keys;
+  handlersNow = {};
+  placing = null;
+  controlledTask = void 0;
+  ownTask = null;
+  selected = null;
+  /** Which **Lane group**s are folded. Folding changes the view and not the
+      plan, so it is no **Intent** (ADR-0025). */
+  folded;
+  /** The span the view names, in wall-clock time - null while it names none
+      and the schedule shows the subtasks' extent. */
+  domainInView;
+  /** Whether the extent has been put in view since the view stopped naming a
+      span. Once, and not after every change of the data: a bar the planner
+      dragged past the end must not make the whole plan jump. */
+  fitted = !1;
+  /** The view as `useSchedule` reads it - a new object only when its content
+      changed. */
+  viewNow;
+  viewListeners = /* @__PURE__ */ new Set();
+  /** Whether the planner, a setter or `setView` has changed the view
+      yet. Until then a change is the start losing the groups no LaneGroup
+      declares - where the schedule starts, not a change to report. */
+  actedOn = !1;
+  get acted() {
+    return this.actedOn;
+  }
+  root = null;
+  plot = null;
+  dataCanvas = null;
+  overlayCanvas = null;
+  colours = null;
+  frame = 0;
+  /** Whether the data canvas is out of date; a hover alone leaves it be. */
+  dataStale = !0;
+  /** A pan or zoom whose consequences wait for the frame. */
+  movePending = !1;
+  domainFrame = 0;
+  unsubscribeTheme = null;
+  snapshot = De;
+  listeners = /* @__PURE__ */ new Set();
   constructor(t = {}) {
-    f(this, "data", new _n(() => this.viewChanged()));
-    f(this, "view", new Vs(this.data));
-    f(this, "gestures");
-    f(this, "keys");
-    f(this, "handlersNow", {});
-    f(this, "placing", null);
-    f(this, "controlledTask");
-    f(this, "ownTask", null);
-    f(this, "selected", null);
-    /** Which **Lane group**s are folded. Folding changes the view and not the
-        plan, so it is no **Intent** (ADR-0025). */
-    f(this, "folded");
-    /** The span the view names, in wall-clock time - null while it names none
-        and the schedule shows the subtasks' extent. */
-    f(this, "domainInView");
-    /** Whether the extent has been put in view since the view stopped naming a
-        span. Once, and not after every change of the data: a bar the planner
-        dragged past the end must not make the whole plan jump. */
-    f(this, "fitted", !1);
-    /** The view as `useSchedule` reads it - a new object only when its content
-        changed. */
-    f(this, "viewNow");
-    f(this, "viewListeners", /* @__PURE__ */ new Set());
-    /** Whether the planner, a setter or `setView` has changed the view
-        yet. Until then a change is the start losing the groups no LaneGroup
-        declares - where the schedule starts, not a change to report. */
-    f(this, "actedOn", !1);
-    f(this, "root", null);
-    f(this, "plot", null);
-    f(this, "dataCanvas", null);
-    f(this, "overlayCanvas", null);
-    f(this, "colours", null);
-    f(this, "frame", 0);
-    f(this, "domainFrame", 0);
-    f(this, "unsubscribeTheme", null);
-    f(this, "snapshot", Ee);
-    f(this, "listeners", /* @__PURE__ */ new Set());
-    /* ---------------------------------------------------------------- */
-    /* Registration and options                                          */
-    /* ---------------------------------------------------------------- */
-    f(this, "registerLane", (t) => this.data.registerLane(t));
-    f(this, "updateLane", (t, e) => this.data.updateLane(t, e));
-    f(this, "unregisterLane", (t) => this.data.unregisterLane(t));
-    f(this, "registerGroup", (t) => this.data.registerGroup(t));
-    f(this, "updateGroup", (t, e) => this.data.updateGroup(t, e));
-    f(this, "unregisterGroup", (t) => this.data.unregisterGroup(t));
-    f(this, "registerLayer", (t) => this.data.registerLayer(t));
-    f(this, "updateLayer", (t, e) => this.data.updateLayer(t, e));
-    f(this, "unregisterLayer", (t) => this.data.unregisterLayer(t));
-    /* ---------------------------------------------------------------- */
-    /* The view (ADR-0047)                                               */
-    /* ---------------------------------------------------------------- */
-    f(this, "subscribeView", (t) => (this.viewListeners.add(t), () => {
-      this.viewListeners.delete(t);
-    }));
-    f(this, "getView", () => this.viewNow);
-    /** Puts a span of two wall-clock instants in view; null shows the
-        subtasks' extent. */
-    f(this, "setDomain", (t) => {
-      this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.domainFrame = 0, this.actedOn = !0, this.domainInView = t === null ? null : [t[0], t[1]], t === null ? this.fitted = !1 : this.view.showWall(t), this.viewChanged();
-    });
-    /** Folds or unfolds one group. */
-    f(this, "toggleGroup", (t) => {
-      const e = this.viewNow.folded ?? [];
-      this.actedOn = !0, this.folded = e.includes(t) ? e.filter((s) => s !== t) : [...e, t], this.viewChanged();
-    });
-    f(this, "foldAll", () => {
-      this.actedOn = !0, this.folded = this.data.groups.map((t) => t.id), this.viewChanged();
-    });
-    f(this, "unfoldAll", () => {
-      this.actedOn = !0, this.folded = [], this.viewChanged();
-    });
-    f(this, "subscribe", (t) => (this.listeners.add(t), () => {
-      this.listeners.delete(t);
-    }));
-    f(this, "getSnapshot", () => this.snapshot);
-    f(this, "getServerSnapshot", () => Ee);
-    /* ---------------------------------------------------------------- */
-    /* Gestures, as the component hands them in                          */
-    /* ---------------------------------------------------------------- */
-    f(this, "pointerDown", (t) => this.gestures.pointerDown(t));
-    f(this, "pointerMove", (t) => this.gestures.pointerMove(t));
-    f(this, "pointerUp", (t) => this.gestures.pointerUp(t));
-    f(this, "pointerCancel", (t) => this.gestures.pointerCancel(t));
-    f(this, "pointerLeave", () => this.gestures.pointerLeave());
-    f(this, "contextMenu", (t) => this.gestures.contextMenu(t));
-    f(this, "wheel", (t) => this.gestures.wheel(t));
-    f(this, "dragOver", (t) => this.gestures.dragOver(t, this.placing));
-    f(this, "drop", (t) => this.gestures.drop(t));
-    f(this, "dragLeave", () => this.gestures.clearPlacing());
-    f(this, "cancelEdit", () => this.gestures.cancelEdit());
-    f(this, "key", (t) => this.keys.key(t));
-    f(this, "focus", (t) => this.keys.focus(t));
-    f(this, "blur", () => this.keys.blur());
-    this.folded = t.folded ?? [], this.domainInView = t.domain ?? null, this.domainInView !== null && this.view.showWall(this.domainInView), this.viewNow = this.currentView(), this.gestures = new so({
+    this.folded = t.folded ?? [], this.domainInView = t.domain ?? null, this.domainInView !== null && this.view.showWall(this.domainInView), this.viewNow = this.currentView(), this.gestures = new jn({
       data: this.data,
       view: this.view,
       plotElement: () => this.plot,
       handlers: () => this.handlersNow,
       selectedSubtask: () => this.selected,
-      select: (e, s) => this.select(e, s),
+      select: (e, n) => this.select(e, n),
       viewChanged: () => this.viewChanged(),
-      viewMoved: (e) => {
-        this.viewChanged(), e && this.reportDomain();
-      },
-      interactionChanged: () => this.interactionChanged()
-    }), this.keys = new lo({
+      viewMoved: (e) => this.viewMoved(e),
+      interactionChanged: () => this.interactionChanged(),
+      hoverChanged: () => this.hoverChanged()
+    }), this.keys = new si({
       data: this.data,
       view: this.view,
       gestures: this.gestures,
       handlers: () => this.handlersNow,
       visibleDomain: () => this.visibleDomain(),
-      select: (e, s) => this.select(e, s),
-      viewMoved: (e) => {
-        this.viewChanged(), e && this.reportDomain();
-      },
+      select: (e, n) => this.select(e, n),
+      viewMoved: (e) => this.viewMoved(e),
       spokenChanged: () => this.publish()
     });
   }
-  get acted() {
-    return this.actedOn;
-  }
+  /* ---------------------------------------------------------------- */
+  /* Registration and options                                          */
+  /* ---------------------------------------------------------------- */
+  registerLane = (t) => this.data.registerLane(t);
+  updateLane = (t, e) => this.data.updateLane(t, e);
+  unregisterLane = (t) => this.data.unregisterLane(t);
+  registerGroup = (t) => this.data.registerGroup(t);
+  updateGroup = (t, e) => this.data.updateGroup(t, e);
+  unregisterGroup = (t) => this.data.unregisterGroup(t);
+  registerLayer = (t) => this.data.registerLayer(t);
+  updateLayer = (t, e) => this.data.updateLayer(t, e);
+  unregisterLayer = (t) => this.data.unregisterLayer(t);
   setOptions(t) {
     this.view.setOptions(t), this.viewChanged();
   }
@@ -2355,12 +2319,35 @@ class uo {
   setPlacing(t) {
     this.placing = t, t === null && this.gestures.clearPlacing();
   }
+  /* ---------------------------------------------------------------- */
+  /* The view (ADR-0047)                                               */
+  /* ---------------------------------------------------------------- */
+  subscribeView = (t) => (this.viewListeners.add(t), () => {
+    this.viewListeners.delete(t);
+  });
+  getView = () => this.viewNow;
   /** Goes to a whole view (`setView`); what it leaves out goes back to its default. */
   applyView(t) {
     Q(t) !== Q(this.viewNow) && (this.actedOn = !0, this.folded = t.folded ?? [], this.setDomain(t.domain ?? null));
   }
+  /** Puts a span of two wall-clock instants in view; null shows the
+      subtasks' extent. */
+  setDomain = (t) => {
+    this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.domainFrame = 0, this.actedOn = !0, this.domainInView = t === null ? null : [t[0], t[1]], t === null ? this.fitted = !1 : this.view.showWall(t), this.viewChanged();
+  };
+  /** Folds or unfolds one group. */
+  toggleGroup = (t) => {
+    const e = this.viewNow.folded ?? [];
+    this.actedOn = !0, this.folded = e.includes(t) ? e.filter((n) => n !== t) : [...e, t], this.viewChanged();
+  };
+  foldAll = () => {
+    this.actedOn = !0, this.folded = this.data.groups.map((t) => t.id), this.viewChanged();
+  };
+  unfoldAll = () => {
+    this.actedOn = !0, this.folded = [], this.viewChanged();
+  };
   currentView() {
-    return ho(
+    return ni(
       { ...this.domainInView === null ? {} : { domain: this.domainInView }, ...this.folded.length > 0 ? { folded: this.folded } : {} },
       new Set(this.data.groups.map((t) => t.id))
     );
@@ -2375,13 +2362,13 @@ class uo {
   /** The subtasks' extent within the zoom limits, while the view names no
       span - and the local day of today while there is no work to show. */
   fit() {
-    const t = this.view.options.calendar, e = co(this.data.subtasks, this.view.options.zoomLimits, (o) => H(o, t));
+    const t = this.view.options.calendar, e = ii(this.data.subtasks, this.view.options.zoomLimits, (i) => R(i, t));
     if (e !== null) {
       this.view.domain = e, this.fitted = !0;
       return;
     }
-    const s = /* @__PURE__ */ new Date();
-    s.setHours(0, 0, 0, 0), this.view.showWall([s.getTime(), s.getTime() + X]);
+    const n = /* @__PURE__ */ new Date();
+    n.setHours(0, 0, 0, 0), this.view.showWall([n.getTime(), n.getTime() + z]);
   }
   /** `undefined`: the scene keeps the selection itself. */
   setControlledTask(t) {
@@ -2398,45 +2385,68 @@ class uo {
     return t !== void 0 && t.task === this.selectedTask ? t.id : null;
   }
   select(t, e) {
-    var o, i;
-    const s = t !== this.selectedTask || e !== this.selected;
-    this.selected = e, t !== this.selectedTask && this.controlledTask === void 0 && (this.ownTask = t), s && ((i = (o = this.handlersNow).onSelectedTaskChange) == null || i.call(o, t, e)), this.interactionChanged();
+    const n = t !== this.selectedTask || e !== this.selected;
+    this.selected = e, t !== this.selectedTask && this.controlledTask === void 0 && (this.ownTask = t), n && this.handlersNow.onSelectedTaskChange?.(t, e), this.interactionChanged();
   }
   /* ---------------------------------------------------------------- */
   /* DOM binding                                                       */
   /* ---------------------------------------------------------------- */
-  bind(t, e, s, o) {
-    this.root = t, this.plot = e, this.dataCanvas = s, this.overlayCanvas = o, this.unsubscribeTheme = gs(() => {
-      this.colours = null, this.requestDraw();
+  bind(t, e, n, i) {
+    this.root = t, this.plot = e, this.dataCanvas = n, this.overlayCanvas = i, this.unsubscribeTheme = ds(() => {
+      this.colours = null, this.dataStale = !0, this.requestDraw();
     }), this.viewChanged();
   }
   unbind() {
-    var t;
-    this.gestures.cancelEdit(), this.keys.stop(), (t = this.unsubscribeTheme) == null || t.call(this), this.unsubscribeTheme = null, this.frame !== 0 && cancelAnimationFrame(this.frame), this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.frame = this.domainFrame = 0, this.root = this.plot = this.dataCanvas = this.overlayCanvas = null;
+    this.gestures.cancelEdit(), this.keys.stop(), this.unsubscribeTheme?.(), this.unsubscribeTheme = null, this.frame !== 0 && cancelAnimationFrame(this.frame), this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.frame = this.domainFrame = 0, this.movePending = !1, this.root = this.plot = this.dataCanvas = this.overlayCanvas = null;
   }
   resize(t, e) {
-    const s = Math.max(0, Math.round(t)), o = Math.max(0, Math.round(e));
-    s === this.view.width && o === this.view.height || (this.view.width = s, this.view.height = o, this.viewChanged());
+    const n = Math.max(0, Math.round(t)), i = Math.max(0, Math.round(e));
+    n === this.view.width && i === this.view.height || (this.view.width = n, this.view.height = i, this.viewChanged());
   }
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  getSnapshot = () => this.snapshot;
+  getServerSnapshot = () => De;
   /* ---------------------------------------------------------------- */
   /* Changes                                                           */
   /* ---------------------------------------------------------------- */
+  /** The span or the scroll moved. The layout is made when something reads
+      it (`SceneView.boxes`), so a hit, a key or a report sees the current
+      view; the rest of `viewChanged` - the hover and key targets, the
+      snapshot, the drawing - runs once in the frame, however many events came. */
+  viewMoved(t) {
+    this.dataCanvas === null || typeof requestAnimationFrame != "function" ? this.viewChanged() : (this.view.invalidate(), this.movePending = !0, this.requestDraw()), t && this.reportDomain();
+  }
   viewChanged() {
-    this.view.collapsed = new Set(this.folded), this.data.rebuild() && (this.colours = null, this.selected !== null && !this.data.subtaskById.has(this.selected) && (this.selected = null)), this.domainInView === null && !this.fitted && this.fit(), this.publishView(), this.view.layout(), this.gestures.refreshHover(), this.keys.refresh(), this.interactionChanged();
+    this.view.collapsed = new Set(this.folded), this.data.rebuild() && (this.colours = null, this.selected !== null && !this.data.subtaskById.has(this.selected) && (this.selected = null)), this.domainInView === null && !this.fitted && this.fit(), this.view.layout(), this.moveSettled();
+  }
+  /** What a pan or zoom changes beyond the layout: the view's listeners, the
+      hover and key targets read anew, the snapshot and the drawing. */
+  moveSettled() {
+    this.movePending = !1, this.publishView(), this.gestures.refreshHover(), this.keys.refresh(), this.interactionChanged();
   }
   interactionChanged() {
-    this.publish(), this.requestDraw();
+    this.dataStale = !0, this.publish(), this.requestDraw();
+  }
+  /** A hover moved along its hit or on to another: the tooltip and the cursor
+      are republished into the snapshot as it stands, whose headers, bars and
+      summary do not depend on the pointer, and only the overlay is drawn. */
+  hoverChanged() {
+    this.snapshot = { ...this.snapshot, cursor: this.gestures.cursor, tooltip: this.tooltip() };
+    for (const t of this.listeners) t();
+    this.requestDraw();
   }
   publish() {
-    const t = this.view, e = this.selected !== null ? t.boxById.get(this.selected) : void 0, s = [];
-    e !== void 0 && !e.miniature && !this.gestures.editing && e.subtask.task === this.selectedTask && (t.options.intents.includes("leadIn") && s.push({ kind: "leadIn", x: e.outerFrom, y: e.y, height: e.height }), t.options.intents.includes("leadOut") && s.push({ kind: "leadOut", x: e.outerTo, y: e.y, height: e.height })), this.snapshot = {
+    const t = this.view, e = this.selected !== null ? t.boxById.get(this.selected) : void 0, n = [];
+    e !== void 0 && !e.miniature && !this.gestures.editing && e.subtask.task === this.selectedTask && (t.options.intents.includes("leadIn") && n.push({ kind: "leadIn", x: e.outerFrom, y: e.y, height: e.height }), t.options.intents.includes("leadOut") && n.push({ kind: "leadOut", x: e.outerTo, y: e.y, height: e.height })), this.snapshot = {
       width: t.width,
       height: t.height,
       scrollY: t.scrollY,
       headers: this.headers(),
       ...t.bands(),
       ghost: this.gestures.ghostSummary(),
-      grips: s,
+      grips: n,
       cursor: this.gestures.cursor,
       tooltip: this.tooltip(),
       now: t.nowX(),
@@ -2444,25 +2454,25 @@ class uo {
       spoken: this.keys.spoken,
       summary: this.summary()
     };
-    for (const o of this.listeners) o();
+    for (const i of this.listeners) i();
   }
   /** One header per row, with what it says and where it sits. The scroll is
       not taken off here: the header column is moved as a whole, as it always
       was, so that a header and its row cannot drift apart by a rounding. */
   headers() {
-    const t = new Map(this.data.lanes.map((o) => [o.id, o.label])), e = new Map(this.data.groups.map((o) => [o.id, o.label])), s = new Set(this.folded);
-    return this.view.rows.rows.map((o) => ({
-      key: o.lane ?? o.group ?? "",
-      kind: o.kind,
-      lane: o.lane,
-      group: o.group,
-      label: (o.lane !== void 0 ? t.get(o.lane) : e.get(o.group ?? "")) ?? o.lane ?? o.group ?? "",
-      depth: o.depth,
-      within: o.within,
-      lanes: o.lanes,
-      collapsed: o.group === void 0 ? void 0 : s.has(o.group),
-      top: o.top,
-      height: o.height
+    const t = new Map(this.data.lanes.map((i) => [i.id, i.label])), e = new Map(this.data.groups.map((i) => [i.id, i.label])), n = new Set(this.folded);
+    return this.view.rows.rows.map((i) => ({
+      key: i.lane ?? i.group ?? "",
+      kind: i.kind,
+      lane: i.lane,
+      group: i.group,
+      label: (i.lane !== void 0 ? t.get(i.lane) : e.get(i.group ?? "")) ?? i.lane ?? i.group ?? "",
+      depth: i.depth,
+      within: i.within,
+      lanes: i.lanes,
+      collapsed: i.group === void 0 ? void 0 : n.has(i.group),
+      top: i.top,
+      height: i.height
     }));
   }
   /** The bars a label could stand in: the visible part of every main time,
@@ -2472,27 +2482,27 @@ class uo {
     const t = this.view;
     if (t.width <= 0) return [];
     const e = this.colours;
-    return t.boxes.flatMap((s) => {
-      if (!Ot(s, t.width, t.height)) return [];
-      const o = Ns(s, t.width);
-      if (o === null) return [];
-      const i = e === null ? !0 : qt(
-        kt(s.subtask.appearance),
-        dt(e, { selectedTask: this.selectedTask, selectedSubtask: this.selectedSubtask }, s.subtask.task, s.subtask.id),
+    return t.boxes.flatMap((n) => {
+      if (!Dt(n, t.width, t.height)) return [];
+      const i = Cs(n, t.width);
+      if (i === null) return [];
+      const o = e === null ? !0 : zt(
+        pt(n.subtask.appearance),
+        lt(e, { selectedTask: this.selectedTask, selectedSubtask: this.selectedSubtask }, n.subtask.task, n.subtask.id),
         e
       ).onDark;
-      return [{ subtask: s.subtask, ...o, dark: i }];
+      return [{ subtask: n.subtask, ...i, dark: o }];
     });
   }
   /** The findings count the whole plan - an overlap out of view is still one
       to know of -, the subtasks only what is in view. */
   summary() {
-    const t = this.view, [e, s] = this.visibleDomain();
+    const t = this.view, [e, n] = this.visibleDomain();
     return {
       lanes: this.data.lanes.length,
-      subtasks: t.boxes.filter((o) => Ot(o, t.width, t.height)).length,
+      subtasks: t.boxes.filter((i) => Dt(i, t.width, t.height)).length,
       from: e,
-      to: s,
+      to: n,
       overlaps: this.data.overlaps.length,
       violated: this.data.violatedById.size,
       blocked: this.data.inBlocked.length,
@@ -2504,12 +2514,12 @@ class uo {
     if (!this.gestures.idle) return null;
     const e = this.data.tooltipTargetFor(t);
     if (e === null) return null;
-    const { x: s, y: o } = this.gestures.hoverPoint;
-    return { target: e, x: s, y: o };
+    const { x: n, y: i } = this.gestures.hoverPoint;
+    return { target: e, x: n, y: i };
   }
   /** The visible span, as two wall-clock instants. */
   visibleDomain() {
-    const t = (e) => at(e, this.view.options.calendar);
+    const t = (e) => rt(e, this.view.options.calendar);
     return [t(this.view.domain[0]), t(this.view.domain[1])];
   }
   /** A pan or zoom of the planner's goes into the view once per frame,
@@ -2523,32 +2533,31 @@ class uo {
   }
   /** The time and the lane at a client point, or null outside the plot. */
   positionAt(t, e) {
-    var r;
-    const s = (r = this.plot) == null ? void 0 : r.getBoundingClientRect();
-    if (s === void 0) return null;
-    const o = t - s.left, i = e - s.top;
-    return o < 0 || i < 0 || o > s.width || i > s.height ? null : { time: this.view.timeAt(o), lane: this.view.laneIdAt(i) };
+    const n = this.plot?.getBoundingClientRect();
+    if (n === void 0) return null;
+    const i = t - n.left, o = e - n.top;
+    return i < 0 || o < 0 || i > n.width || o > n.height ? null : { time: this.view.timeAt(i), lane: this.view.laneIdAt(o) };
   }
   /** The client point of a time, on a lane's middle where one is named, or
       null while the schedule is not on screen. */
   clientPointOf(t, e) {
-    var a;
-    const s = (a = this.plot) == null ? void 0 : a.getBoundingClientRect();
-    if (s === void 0) return null;
-    const o = this.view.viewport(), i = e === void 0 ? null : j(o, e), r = i === null ? 0 : i.top + i.height / 2;
-    return { x: s.left + R(o, t), y: s.top + r };
+    const n = this.plot?.getBoundingClientRect();
+    if (n === void 0) return null;
+    const i = this.view.viewport(), o = e === void 0 ? null : q(i, e), r = o === null ? 0 : o.top + o.height / 2;
+    return { x: n.left + P(i, t), y: n.top + r };
   }
   requestDraw() {
     this.frame !== 0 || this.dataCanvas === null || typeof requestAnimationFrame != "function" || (this.frame = requestAnimationFrame(() => {
-      this.frame = 0, this.draw();
+      this.movePending && this.moveSettled(), this.frame = 0, this.draw();
     }));
   }
   draw() {
     if (this.root === null) return;
-    this.colours === null && (this.colours = Bn(this.root, this.data), this.publish());
-    const { width: t, height: e } = this.view, s = Ie(this.dataCanvas, t, e), o = Ie(this.overlayCanvas, t, e);
-    if (s === null || o === null || t === 0) return;
-    const i = {
+    this.colours === null && (this.colours = On(this.root, this.data), this.publish());
+    const { width: t, height: e } = this.view, n = this.dataStale ? we(this.dataCanvas, t, e) : null, i = we(this.overlayCanvas, t, e);
+    if (i === null || t === 0 || this.dataStale && n === null) return;
+    this.dataStale = !1;
+    const o = {
       data: this.data,
       view: this.view,
       colours: this.colours,
@@ -2558,46 +2567,63 @@ class uo {
       hover: this.gestures.hover,
       ghost: this.gestures.ghostDrawing()
     };
-    xn(s, i), Gn(o, i);
+    n !== null && En(n, o), Pn(i, o);
   }
-}
-function Mo(n = {}) {
-  const { initialView: t, onViewChange: e } = n, [s] = ot(() => new uo(t)), o = V(""), [i] = ot(() => {
-    const l = Pe((h, d) => vs(Mn, { ...h, scene: s, ref: d }));
+  /* ---------------------------------------------------------------- */
+  /* Gestures, as the component hands them in                          */
+  /* ---------------------------------------------------------------- */
+  pointerDown = (t) => this.gestures.pointerDown(t);
+  pointerMove = (t) => this.gestures.pointerMove(t);
+  pointerUp = (t) => this.gestures.pointerUp(t);
+  pointerCancel = (t) => this.gestures.pointerCancel(t);
+  pointerLeave = () => this.gestures.pointerLeave();
+  contextMenu = (t) => this.gestures.contextMenu(t);
+  wheel = (t) => this.gestures.wheel(t);
+  dragOver = (t) => this.gestures.dragOver(t, this.placing);
+  drop = (t) => this.gestures.drop(t);
+  dragLeave = () => this.gestures.clearPlacing();
+  cancelEdit = () => this.gestures.cancelEdit();
+  key = (t) => this.keys.key(t);
+  focus = (t) => this.keys.focus(t);
+  blur = () => this.keys.blur();
+}
+function mi(s = {}) {
+  const { initialView: t, onViewChange: e } = s, [n] = nt(() => new oi(t)), i = Y(""), [o] = nt(() => {
+    const l = (d) => cs(gn, { ...d, scene: n });
     return l.displayName = "Schedule", {
       Schedule: l,
-      Lane: In,
-      LaneGroup: Sn,
-      Subtasks: Ln,
-      Dependencies: An,
-      BlockedTimes: Cn,
-      Milestones: Dn,
-      setView: (h) => {
-        s.applyView(h), o.current = Q(s.getView());
+      Lane: vn,
+      LaneGroup: yn,
+      Subtasks: wn,
+      Dependencies: bn,
+      BlockedTimes: Mn,
+      Milestones: Tn,
+      setView: (d) => {
+        n.applyView(d), i.current = Q(n.getView());
       },
-      setDomain: s.setDomain,
-      toggleGroup: s.toggleGroup,
-      foldAll: s.foldAll,
-      unfoldAll: s.unfoldAll
+      setDomain: n.setDomain,
+      toggleGroup: n.toggleGroup,
+      foldAll: n.foldAll,
+      unfoldAll: n.unfoldAll
     };
-  }), r = $e(s.subscribeView, s.getView, s.getView), a = Q(r);
-  return z(() => {
-    o.current !== a && (o.current = a, s.acted && (e == null || e(r)));
-  }, [a]), W(() => ({ ...i, view: r }), [i, r]);
+  }), r = Oe(n.subscribeView, n.getView, n.getView), a = Q(r);
+  return W(() => {
+    i.current !== a && (i.current = a, n.acted && e?.(r));
+  }, [a]), K(() => ({ ...o, view: r }), [o, r]);
 }
 export {
-  me as applyIntent,
-  Kt as arrival,
-  Yt as departure,
-  vo as findings,
-  Be as inBlockedTime,
+  he as applyIntent,
+  Gt as arrival,
+  $t as departure,
+  ui as findings,
+  Ee as inBlockedTime,
   et as occupied,
-  Vt as overlaps,
-  kt as resolveAppearance,
-  wo as ripple,
-  bo as shiftTask,
-  Ms as snapTime,
-  yo as subtaskFromPlace,
-  Mo as useSchedule,
-  Wt as violatedDependencies
+  Ht as overlaps,
+  pt as resolveAppearance,
+  ci as ripple,
+  fi as shiftTask,
+  ps as snapTime,
+  hi as subtaskFromPlace,
+  mi as useSchedule,
+  Yt as violatedDependencies
 };