@umriss-ui/schedule 0.1.0

package/dist/schedule.js

@@ -0,0 +1,2015 @@
+import "./schedule.css";
+var He = Object.defineProperty;
+var Ye = (n, t, e) => t in n ? He(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var f = (n, t, e) => Ye(n, typeof t != "symbol" ? t + "" : t, e);
+import { jsxs as H, Fragment as zt, jsx as w } from "react/jsx-runtime";
+import { useContext as fe, createContext as pe, useRef as $, useEffect as B, forwardRef as Xe, useState as it, useId as Ke, useLayoutEffect as vt, useImperativeHandle as We, useSyncExternalStore as Ue, useMemo as q } from "react";
+import { toOperatingTimeClamped as Y, resolveColours as ze, removedIntervals as qe, MINUTE as U, calendarFrom as et, toWallClock as X, DAY as st, timeStep as je, operatingTimeTicks as Ve, HOUR as Tt, LinearScale as Ze, subscribeTheme as Je } from "@umriss-ui/charts";
+import { useFormats as me, useWording as ge } from "@umriss-ui/core";
+const ke = pe(null), we = pe(null);
+function ve() {
+  return fe(we);
+}
+function Qe(n) {
+  const t = fe(ke);
+  if (t === null)
+    throw new Error(`@umriss-ui/schedule: <${n}> must be used inside a <Schedule>.`);
+  return t;
+}
+function Ct(n, t, e, s, o) {
+  const i = Qe(n), r = $(null);
+  B(() => (r.current = e(i, t), () => {
+    r.current !== null && o(i, r.current), r.current = null;
+  }), [i]), B(() => {
+    r.current !== null && s(i, r.current, t);
+  });
+}
+function ts(n) {
+  Ct("Lane", n, (t, e) => t.registerLane(e), (t, e, s) => t.updateLane(e, s), (t, e) => t.unregisterLane(e));
+}
+function es(n) {
+  Ct("LaneGroup", n, (t, e) => t.registerGroup(e), (t, e, s) => t.updateGroup(e, s), (t, e) => t.unregisterGroup(e));
+}
+function ye(n, t) {
+  Ct(n, t, (e, s) => e.registerLayer(s), (e, s, o) => e.updateLayer(s, o), (e, s) => e.unregisterLayer(s));
+}
+function ht(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 };
+}
+const ss = 24, ns = 4, os = 3, yt = 4;
+function qt(n) {
+  const { lanes: t, groups: e, collapsed: s, laneHeight: o } = n, i = new Map(e.map((m) => [m.id, m])), r = (m) => m !== void 0 && i.has(m) ? m : void 0, a = /* @__PURE__ */ new Map(), u = (m) => {
+    const C = [];
+    let L = r(m.parent);
+    const E = /* @__PURE__ */ new Set();
+    for (; L !== void 0 && !E.has(L); )
+      E.add(L), C.unshift(L), L = r(i.get(L).parent);
+    return C;
+  }, c = /* @__PURE__ */ new Map();
+  for (const m of t) {
+    const C = u(m);
+    c.set(m.id, C);
+    for (const L of C) {
+      const E = a.get(L) ?? [];
+      E.push(m.id), a.set(L, E);
+    }
+  }
+  const l = [], d = /* @__PURE__ */ new Map();
+  let p = [], g = null, b = 0;
+  const A = (m) => (l.push({ ...m, top: b }), b += m.height, l.length - 1), _ = (m) => m.find((C) => s.has(C)), S = () => {
+    if (g === null) return;
+    const { row: m, lanes: C } = g, L = l[m], E = Math.max(L.height, C.length * ns + 2 * yt);
+    l[m] = { ...L, height: E }, b += E - L.height;
+    const F = E - 2 * yt, G = Math.max(os, Math.floor(F / C.length));
+    C.forEach((j, ot) => {
+      const z = c.get(j) ?? [];
+      d.set(j, {
+        top: L.top + yt + ot * G,
+        height: G,
+        miniature: !0,
+        group: z[z.length - 1]
+      });
+    }), g = null;
+  };
+  for (const m of t) {
+    const C = (c.get(m.id) ?? []).filter((F) => (a.get(F) ?? []).length > 0), L = _(C);
+    if (g !== null && L === g.group) {
+      g.lanes.push(m.id);
+      continue;
+    }
+    S();
+    const E = C.filter((F, G) => p[G] === F).length;
+    p = p.slice(0, E);
+    for (const F of C.slice(E)) {
+      if (p.push(F), F === L) break;
+      A({
+        kind: "groupHead",
+        lane: void 0,
+        group: F,
+        depth: p.length - 1,
+        within: [...p],
+        lanes: (a.get(F) ?? []).length,
+        height: ss
+      });
+    }
+    if (L !== void 0) {
+      const F = C.indexOf(L), G = A({
+        kind: "miniature",
+        lane: void 0,
+        group: L,
+        depth: F,
+        within: C.slice(0, F + 1),
+        lanes: (a.get(L) ?? []).length,
+        height: o
+      });
+      g = { group: L, row: G, lanes: [m.id] };
+      continue;
+    }
+    A({ kind: "lane", lane: m.id, group: C[C.length - 1], depth: C.length, within: C, lanes: 1, height: o }), d.set(m.id, {
+      top: l[l.length - 1].top,
+      height: o,
+      miniature: !1,
+      group: C[C.length - 1]
+    });
+  }
+  return S(), { rows: l, slots: d, height: b };
+}
+function is(n, t) {
+  if (t.size === 0) return n;
+  const e = /* @__PURE__ */ new Set();
+  for (const s of n) t.has(s) || e.add(s);
+  return e;
+}
+function nt(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;
+  }
+  return null;
+}
+function Lt(n, t) {
+  return n.slots.get(t) ?? null;
+}
+function rs(n, t) {
+  const e = nt(n, 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;
+  return null;
+}
+function ut(n) {
+  return { from: n.from - (n.setup ?? 0), to: n.to + (n.teardown ?? 0) };
+}
+function St(n, t) {
+  return (n.leaves ?? "teardown") === "main" ? t.to : t.to + (t.teardown ?? 0);
+}
+function At(n, t) {
+  return (n.arrives ?? "setup") === "main" ? t.from : t.from - (t.setup ?? 0);
+}
+function jt(n, t) {
+  if (t.kind === "place" || t.subtask !== n.id) return n;
+  switch (t.kind) {
+    case "move":
+    case "stretch":
+      return { ...n, from: t.from, to: t.to };
+    case "setup":
+      return { ...n, setup: t.setup };
+    case "teardown":
+      return { ...n, teardown: t.teardown };
+    case "lane":
+      return { ...n, lane: t.lane };
+  }
+}
+function In(n, t) {
+  return {
+    id: t,
+    task: n.task,
+    lane: n.lane,
+    from: n.from,
+    to: n.to,
+    ...n.setup === void 0 ? {} : { setup: n.setup },
+    ...n.teardown === void 0 ? {} : { teardown: n.teardown }
+  };
+}
+const as = 6, be = 3, tt = 2, Vt = 3, Zt = 3;
+function P(n, t) {
+  return Math.round(n.scale.toPx(Y(t, n.calendar)));
+}
+function ct(n, t) {
+  const e = Lt(n.rows, t);
+  return e === null ? null : { ...e, top: e.top - n.scrollY };
+}
+function Jt(n, t) {
+  return rs(n.rows, t + n.scrollY);
+}
+function Me(n, t, e, s, o) {
+  const i = s.miniature ? 0 : as, r = s.miniature ? 0 : Zt * Vt, a = Math.max(s.miniature ? 1 : 4, s.height - 2 * i - r), u = s.top - n.scrollY + Math.floor((s.height - a) / 2), c = ut(t);
+  return {
+    subtask: t,
+    lane: e,
+    miniature: s.miniature,
+    depth: o,
+    y: u + (s.miniature ? 0 : Math.min(o, Zt) * Vt),
+    height: a,
+    outerFrom: P(n, c.from),
+    mainFrom: P(n, t.from),
+    mainTo: P(n, t.to),
+    outerTo: P(n, c.to)
+  };
+}
+function Te(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 ? "setup" : t > n.mainTo ? "teardown" : "main";
+}
+function ls(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 Ce(n, t, e) {
+  return n.outerTo >= 0 && n.outerFrom <= t && n.y + n.height >= 0 && n.y <= e;
+}
+const hs = 64;
+function us(n, t) {
+  if (n.miniature) return null;
+  const e = ht(n.subtask.appearance).hatched ? tt + be + 1 : 0, s = Math.max(n.mainFrom + e, 0), o = Math.min(n.mainTo - e, t) - s;
+  return o < hs ? null : { x: s, width: o, y: n.y, height: n.height };
+}
+const cs = 10;
+function Qt(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 bt(n, t, e, s, o) {
+  const i = t.route ?? o.route, r = t.attach ?? o.attach, a = t.ends ?? o.ends, u = P(n, St(t, e.subtask)), c = P(n, At(t, s.subtask)), l = Qt(r, e, s), d = Qt(r, s, e);
+  if (i === "straight")
+    return { transport: t, kind: i, ends: a, x1: u, y1: l, x2: c, y2: d, c1x: u, c2x: c, points: [u, l, c, d] };
+  if (i === "orthogonal") {
+    const _ = u + cs, S = l === d ? _ : Math.round((_ + c) / 2);
+    return { transport: t, kind: i, ends: a, x1: u, y1: l, x2: c, y2: d, c1x: u, c2x: c, points: l === d ? [u, l, c, d] : [u, l, S, l, S, d, c, d] };
+  }
+  const p = Math.max(14, Math.abs(c - u) / 2), g = u + p, b = c - p, A = [];
+  for (let _ = 0; _ <= 16; _++) {
+    const S = _ / 16, m = 1 - S;
+    A.push(
+      m * m * m * u + 3 * m * m * S * g + 3 * m * S * S * b + S * S * S * c,
+      m * m * m * l + 3 * m * m * S * l + 3 * m * S * S * d + S * S * S * d
+    );
+  }
+  return { transport: t, kind: "curve", ends: a, x1: u, y1: l, x2: c, y2: d, c1x: g, c2x: b, points: A };
+}
+function ds(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], u = o[i + 2], c = o[i + 3], l = u - r, d = c - a, p = l * l + d * d, g = p === 0 ? 0 : Math.max(0, Math.min(1, ((t - r) * l + (e - a) * d) / p));
+    s = Math.min(s, Math.hypot(t - (r + g * l), e - (a + g * d)));
+  }
+  return s;
+}
+function It(n) {
+  const t = [], e = /* @__PURE__ */ new Map();
+  n.forEach((s, o) => {
+    const { from: i, to: r } = ut(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);
+  });
+  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 u = o[a];
+        if (u.from >= r.to) break;
+        t.push({ lane: s, first: r.subtask.id, second: u.subtask.id, from: u.from, to: Math.min(r.to, u.to) });
+      }
+    }
+  }
+  return t;
+}
+function fs(n) {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  for (const s of n) {
+    const o = ut(s), i = e.get(s.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);
+    }
+    e.set(s.lane, i), t.set(s.id, r);
+  }
+  return t;
+}
+function _t(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 = St(o, i), u = At(o, r), c = a + o.duration - u;
+    c > 0 && s.push({ transport: o.id, departure: a, arrival: u, shortBy: c });
+  }
+  return s;
+}
+function _n(n, t) {
+  return { overlaps: It(n), lateTransports: _t(n, t) };
+}
+class ps {
+  /** `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", []);
+    f(this, "laneIndex", /* @__PURE__ */ new Map());
+    /** The layers in registration order - the drawing order. */
+    f(this, "layers", []);
+    f(this, "subtasks", []);
+    f(this, "subtaskById", /* @__PURE__ */ new Map());
+    f(this, "transports", []);
+    f(this, "tasks", /* @__PURE__ */ new Map());
+    f(this, "overlaps", []);
+    f(this, "lateById", /* @__PURE__ */ new Map());
+    f(this, "depth", /* @__PURE__ */ new Map());
+    this.changed = t;
+  }
+  registerLane(t) {
+    const e = this.nextId++;
+    return this.laneEntries.set(e, t), this.touch(), e;
+  }
+  updateLane(t, e) {
+    this.laneEntries.get(t) !== e && (this.laneEntries.set(t, e), this.touch());
+  }
+  unregisterLane(t) {
+    this.laneEntries.delete(t), this.touch();
+  }
+  registerGroup(t) {
+    const e = this.nextId++;
+    return this.groupEntries.set(e, t), this.touch(), e;
+  }
+  updateGroup(t, e) {
+    this.groupEntries.get(t) !== e && (this.groupEntries.set(t, e), this.touch());
+  }
+  unregisterGroup(t) {
+    this.groupEntries.delete(t), this.touch();
+  }
+  registerLayer(t) {
+    const e = this.nextId++;
+    return this.layerEntries.set(e, t), this.touch(), e;
+  }
+  updateLayer(t, e) {
+    this.layerEntries.get(t) !== e && (this.layerEntries.set(t, e), this.touch());
+  }
+  unregisterLayer(t) {
+    this.layerEntries.delete(t), this.touch();
+  }
+  touch() {
+    this.dirty = !0, this.changed();
+  }
+  /** Derives anew if a registration changed since the last call; says whether
+      it did. */
+  rebuild() {
+    if (!this.dirty) return !1;
+    this.dirty = !1;
+    const t = (e) => [...e.keys()].sort((s, o) => s - o).map((s) => e.get(s));
+    this.lanes = t(this.laneEntries), this.groups = t(this.groupEntries), this.laneIndex = new Map(this.lanes.map((e, s) => [e.id, s])), this.layers = t(this.layerEntries), this.subtasks = [], this.transports = [], 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);
+      } else
+        this.transports.push(...e.data);
+    return this.subtaskById = new Map(this.subtasks.map((e) => [e.id, e])), this.overlaps = It(this.subtasks), this.lateById = new Map(_t(this.subtasks, this.transports).map((e) => [e.transport, e])), this.depth = fs(this.subtasks), !0;
+  }
+  /** The task a transport belongs to: its departing subtask's. */
+  taskOfTransport(t) {
+    var e;
+    return ((e = this.subtaskById.get(t.from)) == null ? void 0 : e.task) ?? null;
+  }
+  /** What a tooltip is about: the hovered subtask or transport 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((a) => a.first === o || a.second === o).map((a) => this.subtaskById.get(a.first === o ? a.second : a.first)).filter((a) => a !== void 0), r = this.transports.filter((a) => a.from === o || a.to === o).map((a) => this.lateById.get(a.id)).filter((a) => a !== void 0);
+      return { kind: "subtask", subtask: t.subtask, task: this.tasks.get(t.subtask.task), overlapping: i, lateTransports: r };
+    }
+    if (t.kind !== "transport") return null;
+    const e = t.transport, s = this.taskOfTransport(e);
+    return {
+      kind: "transport",
+      transport: e,
+      task: s !== null ? this.tasks.get(s) : void 0,
+      from: this.subtaskById.get(e.from),
+      to: this.subtaskById.get(e.to),
+      late: this.lateById.get(e.id)
+    };
+  }
+}
+const ms = {
+  line: "var(--u-hairline)",
+  lineStrong: "var(--u-hairline-strong)",
+  text: "var(--u-color-text)",
+  muted: "var(--u-color-text-muted)",
+  alarm: "var(--u-color-danger)",
+  surface: "var(--u-color-surface)",
+  accent: "var(--u-color-accent)",
+  /* 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)"
+};
+function gs(n, t) {
+  const e = {};
+  for (const i of t.tasks.values()) e[`task:${i.id}`] = i.color;
+  const s = ze(n, { ...ms, ...e }), o = /* @__PURE__ */ new Map();
+  for (const i of t.tasks.values()) o.set(i.id, s[`task:${i.id}`] ?? i.color);
+  return {
+    line: s.line,
+    lineStrong: s.lineStrong,
+    text: s.text,
+    muted: s.muted,
+    alarm: s.alarm,
+    surface: s.surface,
+    accent: s.accent,
+    onAccent: s.onAccent,
+    tasks: o
+  };
+}
+function at(n) {
+  const t = n.match(/[\d.]+/g);
+  return t === null || t.length < 3 ? null : [Number(t[0]), Number(t[1]), Number(t[2])];
+}
+function te(n) {
+  const t = at(n);
+  if (t === null) return 0;
+  const [e, s, o] = t.map((i) => {
+    const r = i / 255;
+    return r <= 0.04045 ? r / 12.92 : ((r + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * e + 0.7152 * s + 0.0722 * o;
+}
+function ee(n, t) {
+  const e = te(n), s = te(t);
+  return (Math.max(e, s) + 0.05) / (Math.min(e, s) + 0.05);
+}
+function se(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 ks(n, t) {
+  const { data: e, view: s } = t, o = s.viewport();
+  bs(n, t, o), Ms(n, t);
+  for (const i of e.layers) {
+    const r = new Set(i.data);
+    if (i.kind === "transports")
+      for (const a of s.paths) r.has(a.transport) && Mt(n, t, a, !1);
+    else
+      for (const a of s.boxes) r.has(a.subtask) && Se(n, t, a, 1);
+  }
+  for (const i of e.overlaps) Ae(n, t, o, i);
+  Es(n, t, o), Ps(n, t);
+}
+function ws(n, t) {
+  const { view: e, hover: s } = t, o = e.viewport();
+  if (t.ghost === null) {
+    if (s.kind === "subtask") {
+      const l = e.boxById.get(s.subtask.id);
+      l !== void 0 && Ds(n, t, l);
+    } else if (s.kind === "transport") {
+      const l = e.paths.find((d) => d.transport === s.transport);
+      l !== void 0 && Mt(n, t, l, !0);
+    }
+    return;
+  }
+  const { ghost: i, overlaps: r, late: a } = t.ghost;
+  vs(n, t, o, t.ghost.refusedLanes);
+  const u = Le(o, i);
+  if (u === null) return;
+  for (const l of r) Ae(n, t, o, l);
+  const c = new Set(a.map((l) => l.transport));
+  for (const l of t.data.transports) {
+    if (l.from !== i.id && l.to !== i.id) continue;
+    const d = e.boxById.get(l.from === i.id ? l.to : l.from);
+    if (d === void 0) continue;
+    const p = l.from === i.id ? bt(o, l, u, d, e.options) : bt(o, l, d, u, e.options);
+    Mt(n, t, p, !0, c.has(l.id));
+  }
+  Se(n, t, u, 0.55), n.strokeStyle = t.colours.text, n.lineWidth = 1, n.setLineDash([3, 2]), n.strokeRect(u.outerFrom + 0.5, u.y + 0.5, Math.max(1, u.outerTo - u.outerFrom - 1), u.height - 1), n.setLineDash([]), t.ghost.tether !== null && ys(n, t, u, t.ghost.tether);
+}
+function vs(n, t, e, s) {
+  if (s.size === 0) return;
+  const { width: o, height: i } = t.view;
+  for (const r of s) {
+    const a = ct(e, r);
+    if (a === null) continue;
+    const { top: u, height: c } = a;
+    u + c < 0 || u > i || (n.globalAlpha = 0.6, n.fillStyle = t.colours.surface, n.fillRect(0, u, o, c), n.globalAlpha = 1, _s(n, 0, u, o, c, t.colours.muted, 0.7, As, 1));
+  }
+}
+function ys(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 Le(n, t) {
+  const e = Lt(n.rows, t.lane);
+  return e === null ? null : Me(n, t, t.lane, e, 0);
+}
+function bs(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 l of i.ticks)
+    n.moveTo(l.x + 0.5, 0), n.lineTo(l.x + 0.5, a);
+  for (const l of e.rows.rows) {
+    const d = l.top + l.height - e.scrollY - 0.5;
+    d < 0 || d > a || (n.moveTo(0, d), n.lineTo(r, d));
+  }
+  const u = [...e.rows.slots.values()].filter((l) => l.miniature).sort((l, d) => l.top - d.top);
+  u.forEach((l, d) => {
+    const p = u[d + 1];
+    if (p === void 0 || p.top !== l.top + l.height || p.group === l.group) return;
+    const g = l.top + l.height - e.scrollY - 0.5;
+    g < 0 || g > a || (n.moveTo(0, g), n.lineTo(r, g));
+  }), n.stroke(), n.strokeStyle = o.lineStrong, n.beginPath();
+  for (const l of i.days)
+    n.moveTo(l.x + 0.5, 0), n.lineTo(l.x + 0.5, a);
+  n.stroke();
+  const c = qe(s.options.calendar);
+  if (c.length > 0) {
+    n.strokeStyle = o.muted, n.setLineDash([2, 3]), n.beginPath();
+    for (const l of c) {
+      const d = Math.round(e.scale.toPx(l.operatingTime)) + 0.5;
+      d < 0 || d > r || (n.moveTo(d, 0), n.lineTo(d, a));
+    }
+    n.stroke(), n.setLineDash([]);
+  }
+}
+function Ms(n, t) {
+  const e = t.view.nowX();
+  e !== null && (n.fillStyle = t.colours.accent, n.fillRect(e, 0, 2, t.view.height));
+}
+function Ts(n, t, e, s) {
+  const o = t.colours.tasks.get(e.subtask.task) ?? t.colours.muted;
+  n.fillStyle = o;
+  for (const [i, 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 Ft(n, t, e) {
+  if (n.dashed) return { fill: null, onDark: !1 };
+  const s = n.muted ? Cs(t, e.surface, 0.5) : t;
+  return { fill: s, onDark: ee(s, e.onAccent) > ee(s, e.text) };
+}
+function Cs(n, t, e) {
+  const s = at(n), o = at(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)})`;
+}
+const Ls = 2;
+function Se(n, t, e, s) {
+  const { view: o, colours: i } = t;
+  if (!Ce(e, o.width, o.height)) return;
+  if (e.miniature) {
+    Ts(n, t, e, s);
+    return;
+  }
+  const r = ht(e.subtask.appearance), a = i.tasks.get(e.subtask.task) ?? i.muted, u = Ft(r, a, i), c = e.y, l = e.height, d = Math.max(1, e.mainTo - e.mainFrom), p = u.onDark ? i.onAccent : i.text;
+  n.lineWidth = 1, n.fillStyle = a, n.strokeStyle = a;
+  for (const [b, A] of [
+    [e.outerFrom, e.mainFrom],
+    [e.mainTo, e.outerTo]
+  ])
+    A <= b || (n.globalAlpha = 0.28 * s, n.fillRect(b, c, A - b, l), n.globalAlpha = s, n.strokeRect(b + 0.5, c + 0.5, A - b - 1, l - 1));
+  u.fill !== null && (n.globalAlpha = s, n.fillStyle = u.fill, n.fillRect(e.mainFrom, c, d, l));
+  const g = e.subtask.progress;
+  if (g !== void 0) {
+    const b = Math.min(4, Math.max(2, Math.round(l / 6))), A = c + l - b - Ls, _ = Math.round(d * Math.max(0, Math.min(1, g)));
+    n.fillStyle = u.fill === null ? a : p, n.globalAlpha = 0.3 * s, n.fillRect(e.mainFrom, A, d, b), n.globalAlpha = s, _ > 0 && n.fillRect(e.mainFrom, A, _, b);
+  }
+  if (r.hatched) {
+    const b = Math.max(1, Math.min(be, Math.floor((d - 2 * tt) / 3))), A = d >= 4 * b ? tt : 0, _ = l >= 4 * tt ? tt : 0;
+    n.globalAlpha = s, n.fillStyle = p, n.fillRect(e.mainFrom + A, c + _, b, l - 2 * _), n.fillRect(e.mainTo - A - b, c + _, b, l - 2 * _);
+  }
+  r.open && Fs(n, e, c, l, i.surface, o.width), r.dashed && (n.globalAlpha = s, n.strokeStyle = a, n.setLineDash([4, 3]), n.strokeRect(e.mainFrom + 0.5, c + 0.5, d - 1, l - 1), n.setLineDash([])), n.globalAlpha = 1, e.depth > 0 && s === 1 && (n.strokeStyle = i.surface, n.strokeRect(e.outerFrom - 0.5, c - 0.5, e.outerTo - e.outerFrom + 1, l + 1));
+}
+const Ss = 7, As = 6, Is = 16;
+function _s(n, t, e, s, o, i, r, a = Ss, u = 2) {
+  n.save(), n.beginPath(), n.rect(t, e, s, o), n.clip(), n.globalAlpha = 0.5 * r, n.strokeStyle = i, n.lineWidth = u, n.beginPath();
+  for (let c = t - o; c < t + s + o; c += a)
+    n.moveTo(c, e + o), n.lineTo(c + o, e);
+  n.stroke(), n.restore();
+}
+function Fs(n, t, e, s, o, i) {
+  const r = t.mainFrom < 0, a = t.mainTo > i, u = Math.max(1, Math.min(t.mainTo, i) - Math.max(t.mainFrom, 0)), c = Math.min(Is, u);
+  r && ne(n, 0, c, e, s, o, 1), a && ne(n, i, -c, e, s, o, 1);
+}
+function ne(n, t, e, s, o, i, r) {
+  const a = n.createLinearGradient(t, 0, t + e, 0);
+  a.addColorStop(0, oe(i, r)), a.addColorStop(1, oe(i, 0)), n.globalAlpha = 1, n.fillStyle = a, n.fillRect(Math.min(t, t + e), s, Math.abs(e), o);
+}
+function oe(n, t) {
+  const e = at(n);
+  return e === null ? n : `rgba(${e[0]}, ${e[1]}, ${e[2]}, ${t})`;
+}
+function Mt(n, t, e, s, o) {
+  const { data: i, colours: r } = t, a = i.taskOfTransport(e.transport), u = o ?? i.lateById.has(e.transport.id), c = a !== null && a === t.selectedTask, l = u ? r.alarm : (a !== null ? r.tasks.get(a) : void 0) ?? r.muted;
+  if (n.strokeStyle = l, n.fillStyle = l, n.lineWidth = s || c ? 2 : 1.25, n.setLineDash(u ? [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);
+  else
+    for (let d = 2; d + 1 < e.points.length; d += 2) n.lineTo(e.points[d], e.points[d + 1]);
+  if (n.stroke(), n.setLineDash([]), e.ends === "dot")
+    for (const [d, p] of [
+      [e.x1, e.y1],
+      [e.x2, e.y2]
+    ])
+      n.beginPath(), n.arc(d, p, u ? 3 : 2.5, 0, Math.PI * 2), n.fill();
+}
+function Es(n, t, e) {
+  const { data: s } = t;
+  if (s.lateById.size !== 0) {
+    n.fillStyle = t.colours.alarm;
+    for (const o of s.lateById.values()) {
+      const i = s.transports.find((d) => d.id === o.transport), r = i === void 0 ? void 0 : s.subtaskById.get(i.to);
+      if (r === void 0) continue;
+      const a = ct(e, r.lane);
+      if (a === null || !a.miniature) continue;
+      const u = nt(e.rows, a.top + e.scrollY);
+      if (u === null) continue;
+      const c = P(e, o.arrival), l = Math.max(c + 2, P(e, o.arrival + o.shortBy));
+      n.fillRect(c, u.top - e.scrollY + 1, l - c, 3);
+    }
+  }
+}
+function Ae(n, t, e, s) {
+  const o = ct(e, s.lane);
+  if (o === null) return;
+  const i = P(e, s.from), r = Math.max(i + 2, P(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, n.fillRect(i, o.top + 1, r - i, Math.min(3, Math.max(1, o.height - 1))), o.miniature) {
+    const a = nt(e.rows, o.top + e.scrollY);
+    a !== null && n.fillRect(i, a.top - e.scrollY + 1, r - i, 3);
+  }
+}
+function Ds(n, t, e) {
+  const { colours: s } = t, o = ht(e.subtask.appearance), i = Ft(o, s.tasks.get(e.subtask.task) ?? s.muted, s);
+  n.globalAlpha = xs, 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;
+}
+const xs = 0.2;
+function Ps(n, 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);
+    }
+  }
+}
+const rt = 32, Ns = 18;
+function ie(n, t) {
+  if (!(t > 2 * rt)) return 0;
+  const e = rt - n, s = n - (t - rt), o = Math.max(e, s);
+  if (o <= 0) return 0;
+  const i = Math.min(1, o / rt), r = Ns * i * i;
+  return e > 0 ? -r : r;
+}
+function Gs(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;
+}
+function Ie(n) {
+  return new Date(n).getTimezoneOffset() * U;
+}
+function Rs(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 = Ie(n) + s;
+  return o + Math.round((n - o) / e) * e;
+}
+const re = "\0placing", ae = /* @__PURE__ */ new Set();
+function le(n) {
+  switch (n.kind) {
+    case "subtask":
+      return `subtask:${n.subtask.id}:${n.part}`;
+    case "transport":
+      return `transport:${n.transport.id}`;
+    case "lane":
+      return `lane:${n.lane}`;
+    default:
+      return "nothing";
+  }
+}
+const he = 3, $s = 600;
+class Bs {
+  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);
+    /** 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. */
+    f(this, "hoverPoint", { x: 0, y: 0 });
+    f(this, "cursor", "default");
+    this.host = t;
+  }
+  /* ---------------------------------------------------------------- */
+  /* What the scene reads                                              */
+  /* ---------------------------------------------------------------- */
+  get editing() {
+    return this.gesture.kind === "edit" || this.gesture.kind === "place";
+  }
+  /** No press, pan, pinch or drag in flight. */
+  get idle() {
+    return this.gesture.kind === "none";
+  }
+  ghostDrawing() {
+    const t = this.gesture;
+    if (t.kind !== "edit" && t.kind !== "place") return null;
+    const e = this.ghostFindings(t.ghost, this.ghostHome(t));
+    return {
+      ghost: t.ghost,
+      overlaps: e.overlaps,
+      late: e.late,
+      refusedLanes: t.refused,
+      /* The tether is drawn only while the pointer really stands on a refused
+         lane: the marked lanes say where the work may not go, the tether says
+         that the ghost is held on purpose right now. */
+      tether: this.refused ? this.dragPoint : null
+    };
+  }
+  ghostSummary() {
+    const t = this.gesture;
+    if (t.kind !== "edit" && t.kind !== "place") return null;
+    const e = Le(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 === "setup" || t.mode === "teardown"), i = o ? ut(t.ghost) : t.ghost;
+    return {
+      refused: this.refused,
+      refusedLanes: [...t.refused],
+      x: o ? e.outerFrom : e.mainFrom,
+      y: e.y,
+      height: e.height,
+      from: i.from,
+      to: i.to,
+      overlap: s.overlaps.length > 0,
+      late: s.late.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) };
+  }
+  report(t, e, s, o, i, r) {
+    var u, c;
+    const a = this.host.view;
+    (c = (u = this.host.handlers()).onInteraction) == null || c.call(u, { type: t, hit: e, clientX: s, clientY: o, time: a.timeAt(i), lane: a.laneIdAt(r) });
+  }
+  pointerDown(t) {
+    var a, u, c, l, d;
+    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)) {
+      this.cancelEdit(), this.gesture = { kind: "pinch", distance: this.touchDistance() };
+      return;
+    }
+    if (t.button !== 0) return;
+    const o = (c = (u = (a = t.target) == null ? void 0 : a.closest) == null ? void 0 : u.call(a, "[data-grip]")) == null ? void 0 : c.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 === "setup" || o === "teardown") && 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) }, (d = (l = this.host.plotElement()) == null ? void 0 : l.setPointerCapture) == null || d.call(l, t.pointerId);
+  }
+  /** A drag over a folded group: resting on one opens it for the GESTURE.
+  
+        Crossing one on the way somewhere else must not open it, so the timer
+        starts when the pointer arrives and is thrown away when it leaves. What
+        opens is a set the scene holds for the gesture; the caller's list is
+        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,
+      timer: setTimeout(() => {
+        this.resting = null, e.openForGesture = /* @__PURE__ */ new Set([...e.openForGesture, s]), this.host.viewChanged();
+      }, $s)
+    }));
+  }
+  stopResting() {
+    this.resting !== null && clearTimeout(this.resting.timer), this.resting = null;
+  }
+  /** The end of a gesture: whatever it held open, it lets go of. */
+  closeGestureFolds() {
+    this.stopResting();
+    const t = this.host.view;
+    t.openForGesture.size !== 0 && (t.openForGesture = /* @__PURE__ */ new Set(), this.host.viewChanged());
+  }
+  /** The lane a drop at this y would land on, with the y held inside the rows -
+      a drag carried past the last lane still aims at the last lane. */
+  onLane(t) {
+    const e = this.host.view;
+    return e.dropLaneIdAt(Math.max(0, Math.min(e.lanesBottom(), t)));
+  }
+  /** May this subtask go to this lane? Without a rule from the caller, every
+      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;
+  }
+  /** 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 ae;
+    const s = this.host.data.lanes.map((o) => o.id);
+    return Gs(s, 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;
+    for (let i = s.boxes.length - 1; i >= 0; i--) {
+      const r = s.boxes[i];
+      if (o.includes("stretch")) {
+        const a = ls(r, t, e);
+        if (a !== null) return { mode: a === "from" ? "stretch-from" : "stretch-to", subtask: r.subtask };
+      }
+      if (Te(r, t, e) !== null)
+        return o.includes("move") || o.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 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) < he) return;
+      if (o.mode === "pan" || o.subtask === null)
+        this.gesture = { kind: "pan", pointerId: o.pointerId, lastX: o.x0, lastY: o.y0 }, this.setCursor("grabbing");
+      else {
+        const r = this.host.view.viewport().scale.fromPx(o.x0);
+        this.gesture = {
+          kind: "edit",
+          pointerId: o.pointerId,
+          mode: o.mode,
+          subtask: o.subtask,
+          t0: r,
+          ghost: o.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) : ae
+        }, this.setCursor(o.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 };
+      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.ghostFor(i, e, s) }, this.setCursor(this.refused ? "not-allowed" : i.mode === "move" ? "grabbing" : "ew-resize"), this.host.interactionChanged(), this.autoPan();
+      return;
+    }
+    i.kind === "none" && this.hoverAt(t.clientX, t.clientY, e, s);
+  }
+  pointerUp(t) {
+    var i, r;
+    if (t.pointerType === "touch" && (this.touches.delete(t.pointerId), this.gesture.kind === "pinch")) {
+      this.touches.size < 2 && (this.gesture = { kind: "none" });
+      return;
+    }
+    const e = this.gesture, { x: s, y: o } = 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);
+    else if (e.kind === "pan" && e.pointerId === t.pointerId)
+      this.gesture = { kind: "none" }, this.setCursor("default"), this.hoverAt(t.clientX, t.clientY, s, o);
+    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), u = this.intentsOf(e.subtask, e.ghost, e.mode).filter(
+        (c) => a || c.kind !== "lane"
+      );
+      this.refused = !1, this.cursor = "default", this.host.interactionChanged();
+      for (const c of u) (r = (i = this.host.handlers()).onIntent) == null || r.call(i, c);
+    }
+  }
+  /** While a drag is in flight near an edge, pans along once per frame and
+      moves the ghost with the view. Stops by itself when the drag ends or the
+      pointer leaves the zone. */
+  autoPan() {
+    if (this.panFrame !== 0 || typeof requestAnimationFrame != "function") return;
+    const t = () => {
+      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 = ie(o, s.width), a = ie(i, s.height);
+      if (r === 0 && a === 0) return;
+      const u = s.pan(r, a);
+      if (u.moved) {
+        if (this.dragPoint = { x: o, y: i }, e.kind === "edit")
+          this.gesture = { ...e, ghost: this.ghostFor(e, o, i) };
+        else {
+          const c = this.placeGhost(e.item, o, i, e.refused);
+          this.refused = c.refused, this.gesture = { ...e, ghost: c.ghost ?? e.ghost };
+        }
+        this.host.viewMoved(u.time), this.panFrame = requestAnimationFrame(t);
+      }
+    };
+    this.panFrame = requestAnimationFrame(t);
+  }
+  stopAutoPan() {
+    this.panFrame !== 0 && cancelAnimationFrame(this.panFrame), this.panFrame = 0;
+  }
+  pointerCancel(t) {
+    this.touches.delete(t.pointerId), this.closeGestureFolds(), this.cancelEdit(), this.gesture = { kind: "none" };
+  }
+  /** Reads the hover anew where the pointer already is - after the data
+      changed under it. A drop that moves a subtask changes what lies under the
+      pointer without the pointer moving, and a tooltip still naming the old
+      times would be a lie. Nothing is reported: no interaction happened. */
+  refreshHover() {
+    if (!this.idle || this.hoverKey === "nothing") return;
+    const { x: t, y: e } = this.hoverPoint, s = this.host.view.hitAt(t, e);
+    this.hover = s, this.hoverKey = le(s);
+  }
+  pointerLeave() {
+    this.gesture.kind === "none" && this.setHover({ kind: "nothing" }, "nothing");
+  }
+  /** Escape while a drag is in flight: the ghost goes, and nothing is reported.
+      It ends a drag from outside as it ends one inside. */
+  cancelEdit() {
+    return this.gesture.kind !== "edit" && this.gesture.kind !== "place" ? !1 : (this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" }, this.refused = !1, this.cursor = "default", this.host.interactionChanged(), !0);
+  }
+  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);
+  }
+  /** The wheel, as every scrolling area has it (schedule-refinement 02):
+      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, { x: s } = this.local(t.clientX, t.clientY), o = t.deltaMode === 1 ? 16 : t.deltaMode === 2 ? e.height : 1, i = t.deltaX * o, r = t.deltaY * o;
+    if (t.ctrlKey || t.metaKey) {
+      t.preventDefault();
+      const c = Math.abs(r) < 50 ? 0.01 : 15e-4;
+      e.zoomAt(s, Math.exp(r * c)) && this.host.viewMoved(!0);
+      return;
+    }
+    if (Math.abs(i) > Math.abs(r) || t.shiftKey) {
+      t.preventDefault();
+      const c = e.pan(t.shiftKey && i === 0 ? r : i, 0);
+      c.moved && this.host.viewMoved(c.time);
+      return;
+    }
+    const a = r > 0 ? e.maxScroll() - e.scrollY : e.scrollY;
+    if (r === 0 || a <= 0) return;
+    t.preventDefault();
+    const u = e.pan(0, r);
+    u.moved && this.host.viewMoved(u.time);
+  }
+  click(t, e, s, o) {
+    const i = this.host.view.hitAt(s, o), r = i.kind === "subtask" ? i.subtask.task : i.kind === "transport" ? this.host.data.taskOfTransport(i.transport) : null;
+    this.host.select(r, i.kind === "subtask" ? i.subtask.id : null), this.report("click", i, t, e, s, o);
+  }
+  hoverAt(t, e, s, o) {
+    const i = this.host.view.hitAt(s, o), r = le(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 === "transport") && this.host.interactionChanged();
+      return;
+    }
+    this.setHover(i, r), this.report("hover", i, t, e, s, o);
+  }
+  setHover(t, e) {
+    e !== this.hoverKey && (this.hoverKey = e, this.hover = t, this.host.interactionChanged());
+  }
+  setCursor(t) {
+    t !== this.cursor && (this.cursor = t, this.host.interactionChanged());
+  }
+  touchDistance() {
+    const [t, e] = [...this.touches.values()];
+    return t && e ? Math.hypot(t.x - e.x, t.y - e.y) : 0;
+  }
+  touchCentre() {
+    const [t, e] = [...this.touches.values()];
+    return t && e ? (t.x + e.x) / 2 : 0;
+  }
+  /* ---------------------------------------------------------------- */
+  /* Dragging work in from outside                                     */
+  /* ---------------------------------------------------------------- */
+  /** An HTML drag over the plot. While the caller has declared what it is
+      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) {
+      this.clearPlacing();
+      return;
+    }
+    t.preventDefault(), this.restOver(i);
+    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.refused = a.refused, this.setCursor(a.refused ? "not-allowed" : "default");
+    const u = this.gesture.kind === "place" ? this.gesture.ghost : null, c = a.ghost ?? (a.refused ? u : null);
+    t.dataTransfer !== null && (t.dataTransfer.dropEffect = c === null ? "none" : "copy"), c !== null && (this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: o, y: i }, this.gesture = { kind: "place", ghost: c, 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, and none where the caller refuses that lane - which the answer
+      says apart, because the two mean different things to the drag. */
+  placeGhost(t, e, s, o) {
+    const i = this.onLane(s);
+    return i === null ? { ghost: null, refused: !1 } : o.has(i) ? { ghost: null, refused: !0 } : { ghost: { ...this.askedFor(t, i, e), id: re }, refused: !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());
+    return {
+      id: t.item,
+      task: t.task,
+      lane: e,
+      from: o,
+      to: o + t.duration,
+      ...t.setup === void 0 ? {} : { setup: t.setup },
+      ...t.teardown === void 0 ? {} : { teardown: t.teardown }
+    };
+  }
+  /** 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.cursor = "default", this.host.interactionChanged(), !this.allowed({ ...s, id: o.item }, s.lane)) return;
+    const i = {
+      kind: "place",
+      item: o.item,
+      task: s.task,
+      lane: s.lane,
+      from: s.from,
+      to: s.to,
+      ...s.setup === void 0 ? {} : { setup: s.setup },
+      ...s.teardown === void 0 ? {} : { teardown: s.teardown }
+    };
+    (a = (r = this.host.handlers()).onIntent) == null || a.call(r, i);
+  }
+  /** 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
+      and a `dragend`, since it delivers no key events while a native drag
+      runs. */
+  clearPlacing() {
+    this.refused = !1, this.cursor = "default", this.closeGestureFolds(), this.gesture.kind === "place" && (this.stopAutoPan(), this.gesture = { kind: "none" }, this.host.interactionChanged());
+  }
+  /* ---------------------------------------------------------------- */
+  /* Ghost and intents                                                 */
+  /* ---------------------------------------------------------------- */
+  snapStep() {
+    const t = this.host.view.options.snap;
+    return t === "ticks" ? { step: this.host.view.step(), offset: 0 } : t === !1 ? { step: 0, offset: 0 } : typeof t == "number" ? { step: t, offset: 0 } : t;
+  }
+  ghostFor(t, e, s) {
+    const o = this.host.view, i = t.subtask, r = this.snapStep(), a = o.options.intents, u = this.snapInside(o.timeAt(e), r);
+    switch (t.mode) {
+      case "move": {
+        let c = i.from;
+        const l = o.viewport().scale, d = l.fromPx(e) - t.t0;
+        if (a.includes("move") && Math.abs(d * l.m) >= he) {
+          const g = et(o.options.calendar), b = Y(i.from, g) + d, A = g.intervals.length === 0 ? b : X(Math.max(0, Math.min(g.total, b)), g);
+          c = this.snapInside(A, r);
+        }
+        let p = t.ghost.lane;
+        if (a.includes("lane")) {
+          const g = this.onLane(s) ?? p;
+          this.refused = t.refused.has(g), this.refused || (p = g);
+        } else
+          this.refused = !1;
+        return { ...i, from: c, to: c + (i.to - i.from), lane: p };
+      }
+      case "stretch-from":
+        return { ...i, from: Math.min(u, i.to - Math.max(r.step, U)) };
+      case "stretch-to":
+        return { ...i, to: Math.max(u, i.from + Math.max(r.step, U)) };
+      case "setup":
+        return { ...i, setup: Math.max(0, i.from - u) };
+      case "teardown":
+        return { ...i, teardown: Math.max(0, u - i.to) };
+    }
+  }
+  /** 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
+      the plant does not run. */
+  snapInside(t, e) {
+    const s = Rs(t, e), o = et(this.host.view.options.calendar);
+    return o.intervals.length === 0 ? s : X(Y(s, o), o);
+  }
+  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 === "setup" ? (e.setup ?? 0) !== (t.setup ?? 0) && o.push({ kind: "setup", subtask: r, setup: e.setup ?? 0 }) : (e.teardown ?? 0) !== (t.teardown ?? 0) && o.push({ kind: "teardown", subtask: r, teardown: e.teardown ?? 0 }), o;
+  }
+  /** The lane the ghost came from - the only other lane a drag can touch. */
+  ghostHome(t) {
+    return t.kind === "edit" ? t.subtask.lane : t.ghost.lane;
+  }
+  /** The findings the ghost would create, assessed as if it were data - the
+        ghost of a drag from outside is added to the data, the ghost of a drag
+        inside it replaces the subtask it came from.
+  
+        Only the two lanes a drag can touch are assessed, the one the ghost is
+        over and the one it came from: an overlap is a finding of one lane, and
+        every other lane's overlaps are the ones already assessed. That is what
+        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 = (l) => l.lane === t.lane || l.lane === e, r = [...s.subtasks.filter((l) => l.id !== t.id && o(l)), t], a = (l) => l.first === t.id || l.second === t.id, u = s.transports.filter((l) => l.from === t.id || l.to === t.id), c = t.id === re ? s.subtasks : s.subtasks.map((l) => l.id === t.id ? t : l);
+    return { overlaps: It(r).filter(a), late: _t(c, u) };
+  }
+}
+const _e = [], Os = 56;
+function Hs(n, t = Os) {
+  return n > 0 ? Math.min(st, Math.max(15 * U, je(n * t, 1))) : 15 * U;
+}
+function Ys(n, t, e = _e) {
+  const [s, o] = Fe(n, e);
+  return Ve(e, s, o, t, Ie(s)).filter(
+    (i) => i.operatingTime >= n[0] && i.operatingTime <= n[1]
+  );
+}
+function Xs(n, t = _e) {
+  const [e, s] = Fe(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({
+      start: r,
+      end: a,
+      from: Y(r, t),
+      to: Y(a, t)
+    });
+  }
+  return o;
+}
+function Ks(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 Ws(n, t) {
+  return [n[0] + t, n[1] + t];
+}
+function Fe(n, t) {
+  const e = et(t);
+  if (e.intervals.length === 0) return [n[0], n[1]];
+  const s = (o) => Math.max(0, Math.min(e.total, o));
+  return [X(s(n[0]), e), X(s(n[1]), e)];
+}
+const lt = 44;
+class Us {
+  constructor(t) {
+    f(this, "options", {
+      laneHeight: lt,
+      calendar: [],
+      zoomLimits: { min: Tt, max: 28 * st },
+      snap: "ticks",
+      intents: [],
+      now: null,
+      route: "curve",
+      attach: "centre",
+      ends: "dot"
+    });
+    f(this, "domain", [0, st]);
+    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", qt({ lanes: [], groups: [], collapsed: /* @__PURE__ */ new Set(), laneHeight: lt }));
+    /** 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;
+  }
+  /** Takes new options; an initial domain in wall-clock time puts the view
+      there, and a new calendar keeps the wall-clock span in view. */
+  setOptions(t, e) {
+    const s = t.calendar !== this.options.calendar, o = this.options.calendar;
+    if (this.options = t, e !== null || s) {
+      const i = e ?? [X(this.domain[0], o), X(this.domain[1], o)];
+      this.domain = [Y(i[0], t.calendar), Y(i[1], t.calendar)];
+    }
+  }
+  viewport() {
+    return {
+      scale: new Ze(this.domain, [0, this.width]),
+      calendar: this.options.calendar,
+      laneHeight: this.options.laneHeight,
+      scrollY: this.scrollY,
+      rows: this.rows
+    };
+  }
+  maxScroll() {
+    return Math.max(0, this.rows.height - this.height);
+  }
+  /** The lowest y that still lies on a lane. */
+  lanesBottom() {
+    return this.rows.height - this.scrollY - 1;
+  }
+  /** The fine band's step at the current zoom. */
+  step() {
+    const t = this.domain[1] - this.domain[0];
+    return Hs(this.width > 0 ? t / this.width : t);
+  }
+  /** Lays the rows out, clamps the scroll, and lays the data out anew. */
+  layout() {
+    this.rows = qt({
+      lanes: this.data.lanes,
+      groups: this.data.groups,
+      collapsed: is(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();
+    for (const e of this.data.subtasks) {
+      const s = Lt(this.rows, e.lane);
+      if (s === null) continue;
+      const o = Me(t, e, e.lane, s, this.data.depth.get(e.id) ?? 0);
+      this.boxes.push(o), this.boxById.set(e.id, o);
+    }
+    this.paths = [];
+    for (const e of this.data.transports) {
+      const s = this.boxById.get(e.from), o = this.boxById.get(e.to);
+      s === void 0 || o === void 0 || this.paths.push(bt(t, e, s, o, 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;
+    return {
+      days: Xs(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 };
+      }),
+      ticks: Ys(this.domain, t, s).map((o) => ({ wallClock: o.wallClock, x: Math.round(e.toPx(o.operatingTime)) })),
+      step: t
+    };
+  }
+  /** The now line's x, or null where there is none or it lies outside the plot. */
+  nowX() {
+    const t = this.options.now;
+    if (t === null || this.width <= 0) return null;
+    const e = Math.round(this.viewport().scale.toPx(Y(t, this.options.calendar)));
+    return e >= 0 && e <= this.width ? e : null;
+  }
+  hitAt(t, e) {
+    for (let r = this.boxes.length - 1; r >= 0; r--) {
+      const a = this.boxes[r], u = Te(a, t, e);
+      if (u !== null) return { kind: "subtask", subtask: a.subtask, part: u };
+    }
+    let s = null, o = 4;
+    for (const r of this.paths) {
+      const a = ds(r, t, e);
+      a <= o && (o = a, s = r);
+    }
+    if (s !== null) return { kind: "transport", transport: s.transport };
+    const i = Jt(this.viewport(), e);
+    return i !== null ? { kind: "lane", lane: i } : { kind: "nothing" };
+  }
+  /** The wall-clock time at a plot x; within the calendar's extent. */
+  timeAt(t) {
+    const e = this.viewport().scale.fromPx(t), s = et(this.options.calendar);
+    return s.intervals.length === 0 ? e : X(Math.max(0, Math.min(s.total, e)), s);
+  }
+  /** The lane at a y, strips included: what the pointer is ON.
+  
+        One line, and it stays a line of its own: it is one of the three
+        questions this object answers about a y - this one, `dropLaneIdAt` and
+        `foldedGroupAt` - and a caller that reached through `viewport()` for it
+        would be depending on the layout rather than asking the view. */
+  laneIdAt(t) {
+    return Jt(this.viewport(), t);
+  }
+  /** The lane a DROP at this y would land on.
+  
+        A **Miniature** is no drop target. A strip is three pixels of a machine's
+        whole day, and a drop aimed at one would be a guess; resting over the
+        group opens it for the gesture instead, and then there is a real lane to
+        aim at. Hover, the tooltip and selection do read a strip - they cost
+        nothing if they are a pixel out. */
+  dropLaneIdAt(t) {
+    const e = nt(this.rows, t + this.scrollY);
+    return e === null || e.kind !== "lane" ? null : e.lane ?? null;
+  }
+  /** The folded group a y lies over, or null. */
+  foldedGroupAt(t) {
+    const e = nt(this.rows, t + this.scrollY);
+    return e !== null && e.kind === "miniature" ? e.group ?? null : null;
+  }
+  /** 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 = Ws(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 };
+  }
+  /** 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 = Ks(this.domain, o, e, this.options.zoomLimits), s[0] !== this.domain[0] || s[1] !== this.domain[1];
+  }
+}
+const ue = {
+  width: 0,
+  height: 0,
+  laneHeight: lt,
+  scrollY: 0,
+  headers: [],
+  days: [],
+  ticks: [],
+  step: Tt,
+  ghost: null,
+  grips: [],
+  cursor: "default",
+  tooltip: null,
+  now: null,
+  bars: []
+};
+class zs {
+  constructor() {
+    f(this, "data", new ps(() => this.viewChanged()));
+    f(this, "view", new Us(this.data));
+    f(this, "gestures");
+    f(this, "handlersNow", {});
+    f(this, "placing", null);
+    f(this, "controlledTask");
+    f(this, "ownTask", null);
+    f(this, "selected", null);
+    /** Which **Lane group**s are folded. Controlled where the caller passes a
+        list, kept here otherwise - the shape `selectedTask` has. Folding changes
+        the view and not the plan, so it is no **Intent** (ADR-0025). */
+    f(this, "controlledCollapsed");
+    f(this, "ownCollapsed", []);
+    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", ue);
+    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));
+    f(this, "subscribe", (t) => (this.listeners.add(t), () => {
+      this.listeners.delete(t);
+    }));
+    f(this, "getSnapshot", () => this.snapshot);
+    f(this, "getServerSnapshot", () => ue);
+    /* ---------------------------------------------------------------- */
+    /* 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());
+    this.gestures = new Bs({
+      data: this.data,
+      view: this.view,
+      plotElement: () => this.plot,
+      handlers: () => this.handlersNow,
+      selectedSubtask: () => this.selected,
+      select: (t, e) => this.select(t, e),
+      viewChanged: () => this.viewChanged(),
+      viewMoved: (t) => {
+        this.viewChanged(), t && this.reportDomain();
+      },
+      interactionChanged: () => this.interactionChanged()
+    });
+  }
+  setOptions(t, e) {
+    this.view.setOptions(t, e), this.viewChanged();
+  }
+  setHandlers(t) {
+    this.handlersNow = t;
+  }
+  /** What the application says it is dragging in, while it drags it. */
+  setPlacing(t) {
+    this.placing = t, t === null && this.gestures.clearPlacing();
+  }
+  /** `undefined`: the scene keeps the folded groups itself. */
+  setCollapsedGroups(t) {
+    t !== this.controlledCollapsed && (this.controlledCollapsed = t, this.viewChanged());
+  }
+  /** The uncontrolled starting point, taken once. */
+  setDefaultCollapsedGroups(t) {
+    this.ownCollapsed = t, this.viewChanged();
+  }
+  get collapsedGroups() {
+    return this.controlledCollapsed ?? this.ownCollapsed;
+  }
+  /** Folds or unfolds one group. The caller's list is never written to: where
+      the state is controlled, only the report goes out. */
+  toggleGroup(t) {
+    var o, i;
+    const e = this.collapsedGroups, s = e.includes(t) ? e.filter((r) => r !== t) : [...e, t];
+    this.controlledCollapsed === void 0 && (this.ownCollapsed = s), (i = (o = this.handlersNow).onCollapsedGroupsChange) == null || i.call(o, s), this.viewChanged();
+  }
+  /** `undefined`: the scene keeps the selection itself. */
+  setControlledTask(t) {
+    t !== this.controlledTask && (this.controlledTask = t, this.interactionChanged());
+  }
+  get selectedTask() {
+    return this.controlledTask !== void 0 ? this.controlledTask : this.ownTask;
+  }
+  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();
+  }
+  /* ---------------------------------------------------------------- */
+  /* DOM binding                                                       */
+  /* ---------------------------------------------------------------- */
+  bind(t, e, s, o) {
+    this.root = t, this.plot = e, this.dataCanvas = s, this.overlayCanvas = o, this.unsubscribeTheme = Je(() => {
+      this.colours = null, this.requestDraw();
+    }), this.viewChanged();
+  }
+  unbind() {
+    var t;
+    (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;
+  }
+  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());
+  }
+  /* ---------------------------------------------------------------- */
+  /* Changes                                                           */
+  /* ---------------------------------------------------------------- */
+  viewChanged() {
+    this.view.collapsed = new Set(this.collapsedGroups), this.data.rebuild() && (this.colours = null, this.selected !== null && !this.data.subtaskById.has(this.selected) && (this.selected = null)), this.view.layout(), this.gestures.refreshHover(), this.interactionChanged();
+  }
+  interactionChanged() {
+    this.publish(), 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("setup") && s.push({ kind: "setup", x: e.outerFrom, y: e.y, height: e.height }), t.options.intents.includes("teardown") && s.push({ kind: "teardown", x: e.outerTo, y: e.y, height: e.height })), this.snapshot = {
+      width: t.width,
+      height: t.height,
+      laneHeight: t.options.laneHeight,
+      scrollY: t.scrollY,
+      headers: this.headers(),
+      ...t.bands(),
+      ghost: this.gestures.ghostSummary(),
+      grips: s,
+      cursor: this.gestures.cursor,
+      tooltip: this.tooltip(),
+      now: t.nowX(),
+      bars: this.bars()
+    };
+    for (const o of this.listeners) o();
+  }
+  /** 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.collapsedGroups);
+    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
+    }));
+  }
+  /** The bars a label could stand in: the visible part of every main time,
+      with the contrast its colour calls for. Computed on every publish, which
+      is what lets a label follow a bar while the plot pans. */
+  bars() {
+    const t = this.view;
+    if (t.width <= 0) return [];
+    const e = this.colours;
+    return t.boxes.flatMap((s) => {
+      if (!Ce(s, t.width, t.height)) return [];
+      const o = us(s, t.width);
+      if (o === null) return [];
+      const i = e === null ? void 0 : e.tasks.get(s.subtask.task), r = i === void 0 || e === null ? !0 : Ft(ht(s.subtask.appearance), i, e).onDark;
+      return [{ subtask: s.subtask, ...o, dark: r }];
+    });
+  }
+  tooltip() {
+    const t = this.gestures.hover;
+    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 };
+  }
+  /** The visible span, as two wall-clock instants. */
+  visibleDomain() {
+    const t = et(this.view.options.calendar), e = (s) => t.intervals.length === 0 ? s : X(Math.max(0, Math.min(t.total, s)), t);
+    return [e(this.view.domain[0]), e(this.view.domain[1])];
+  }
+  /** Reported once per frame, however many wheel steps a planner turns - and
+      only for their gestures: a span handed in from outside is not news to the
+      caller who handed it in, and reporting it would let two schedules
+      synchronised with each other feed one another for ever. */
+  reportDomain() {
+    var t, e;
+    if (typeof requestAnimationFrame != "function") {
+      (e = (t = this.handlersNow).onDomainChange) == null || e.call(t, this.visibleDomain());
+      return;
+    }
+    this.domainFrame === 0 && (this.domainFrame = requestAnimationFrame(() => {
+      var s, o;
+      this.domainFrame = 0, (o = (s = this.handlersNow).onDomainChange) == null || o.call(s, this.visibleDomain());
+    }));
+  }
+  /** 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) };
+  }
+  /** 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 : ct(o, e), r = i === null ? 0 : i.top + i.height / 2;
+    return { x: s.left + P(o, t), y: s.top + r };
+  }
+  requestDraw() {
+    this.frame !== 0 || this.dataCanvas === null || typeof requestAnimationFrame != "function" || (this.frame = requestAnimationFrame(() => {
+      this.frame = 0, this.draw();
+    }));
+  }
+  draw() {
+    if (this.root === null) return;
+    this.colours === null && (this.colours = gs(this.root, this.data), this.publish());
+    const { width: t, height: e } = this.view, s = se(this.dataCanvas, t, e), o = se(this.overlayCanvas, t, e);
+    if (s === null || o === null || t === 0) return;
+    const i = {
+      data: this.data,
+      view: this.view,
+      colours: this.colours,
+      bands: this.snapshot,
+      selectedTask: this.selectedTask,
+      selectedSubtask: this.selected,
+      hover: this.gestures.hover,
+      ghost: this.gestures.ghostDrawing()
+    };
+    ks(s, i), ws(o, i);
+  }
+}
+const qs = "_root_ekx9o_4 _text_18b86_23", js = "_corner_ekx9o_18", Vs = "_dayBand_ekx9o_22", Zs = "_tickBand_ekx9o_23", Js = "_day_ekx9o_22", Qs = "_dayLabel_ekx9o_46", tn = "_tick_ekx9o_23", en = "_tickLabel_ekx9o_64", sn = "_headers_ekx9o_72", nn = "_header_ekx9o_72", on = "_headerLabel_ekx9o_90", rn = "_headerCount_ekx9o_103", an = "_chevron_ekx9o_112", ln = "_plot_ekx9o_160", hn = "_layer_ekx9o_166", un = "_grip_ekx9o_175", cn = "_ghostLabel_ekx9o_185", dn = "_finding_ekx9o_198", fn = "_refusal_ekx9o_206", pn = "_tooltip_ekx9o_210", mn = "_tooltipHead_ekx9o_228", gn = "_tooltipTimes_ekx9o_233", kn = "_now_ekx9o_242", wn = "_barLabel_ekx9o_256", vn = "_barLabelText_ekx9o_269", v = {
+  root: qs,
+  corner: js,
+  dayBand: Vs,
+  tickBand: Zs,
+  day: Js,
+  dayLabel: Qs,
+  tick: tn,
+  tickLabel: en,
+  headers: sn,
+  header: nn,
+  headerLabel: on,
+  headerCount: rn,
+  chevron: an,
+  plot: ln,
+  layer: hn,
+  grip: un,
+  ghostLabel: cn,
+  finding: dn,
+  refusal: fn,
+  tooltip: pn,
+  tooltipHead: mn,
+  tooltipTimes: gn,
+  now: kn,
+  barLabel: wn,
+  barLabelText: vn
+};
+function yn({ target: n }) {
+  const t = me(), e = ge(), s = (l) => t.time(new Date(l), !1), o = (l) => {
+    const d = Math.round(l / U), p = Math.floor(d / 60), g = d % 60;
+    return [p > 0 ? e.hoursShort(p) : "", g > 0 || p === 0 ? e.minutesShort(g) : ""].filter(Boolean).join(" ");
+  };
+  if (n.kind === "subtask") {
+    const { subtask: l, task: d } = n;
+    return /* @__PURE__ */ H(zt, { children: [
+      /* @__PURE__ */ w("span", { className: v.tooltipHead, children: (d == null ? void 0 : d.name) ?? l.task }),
+      /* @__PURE__ */ w("span", { children: l.name ?? l.id }),
+      /* @__PURE__ */ w("span", { className: v.tooltipTimes, children: e.scheduleGhostTimes(s(l.from), s(l.to)) }),
+      (l.setup ?? 0) > 0 && /* @__PURE__ */ w("span", { children: `${e.scheduleSetup} ${o(l.setup)}` }),
+      (l.teardown ?? 0) > 0 && /* @__PURE__ */ w("span", { children: `${e.scheduleTeardown} ${o(l.teardown)}` }),
+      n.overlapping.map((p) => /* @__PURE__ */ w("span", { className: v.finding, children: e.scheduleOverlapWith(p.name ?? p.id) }, p.id)),
+      n.lateTransports.map((p) => /* @__PURE__ */ w("span", { className: v.finding, children: e.scheduleLateBy(o(p.shortBy)) }, p.transport))
+    ] });
+  }
+  const { transport: i, task: r, from: a, to: u, late: c } = n;
+  return /* @__PURE__ */ H(zt, { children: [
+    /* @__PURE__ */ w("span", { className: v.tooltipHead, children: (r == null ? void 0 : r.name) ?? (r == null ? void 0 : r.id) ?? i.id }),
+    /* @__PURE__ */ w("span", { children: e.scheduleRoute((a == null ? void 0 : a.name) ?? i.from, (u == null ? void 0 : u.name) ?? i.to) }),
+    /* @__PURE__ */ w("span", { children: `${e.scheduleTransport} ${o(i.duration)}` }),
+    c !== void 0 && /* @__PURE__ */ w("span", { className: v.finding, children: e.scheduleLateBy(o(c.shortBy)) })
+  ] });
+}
+const bn = [], ce = { min: Tt, max: 28 * st }, Mn = [], de = 20, Fn = Xe(function(t, e) {
+  const {
+    ariaLabel: s,
+    initialDomain: o,
+    height: i = 400,
+    laneHeight: r = lt,
+    headerWidth: a = 160,
+    calendar: u = Mn,
+    zoomLimits: c,
+    snap: l = "ticks",
+    intents: d = bn,
+    onIntent: p,
+    canMoveTo: g,
+    onInteraction: b,
+    selectedTask: A,
+    onSelectedTaskChange: _,
+    collapsedGroups: S,
+    defaultCollapsedGroups: m,
+    onCollapsedGroupsChange: C,
+    onDomainChange: L,
+    placing: E,
+    route: F = "curve",
+    attach: G = "centre",
+    ends: j = "dot",
+    label: ot,
+    tooltip: z,
+    now: V,
+    className: Et,
+    style: Ee,
+    children: De
+  } = t, [k] = it(() => new zs()), Dt = Ke(), xt = $(null), Pt = $(null), Nt = $(null), Gt = $(null), K = me(), W = ge(), [dt, ft] = o, Rt = (c == null ? void 0 : c.min) ?? ce.min, $t = (c == null ? void 0 : c.max) ?? ce.max, Bt = $(null), Ot = typeof l == "object" ? l.step : null, Ht = typeof l == "object" ? l.offset : null, Yt = typeof l == "object" ? null : l, [xe, Pe] = it(() => Date.now());
+  B(() => {
+    if (V !== !0) return;
+    const h = setInterval(() => Pe(Date.now()), U);
+    return () => clearInterval(h);
+  }, [V]);
+  const Xt = V === !0 ? xe : typeof V == "number" ? V : null;
+  vt(() => {
+    const h = `${dt}|${ft}`, y = Bt.current !== h;
+    Bt.current = h;
+    const I = Yt ?? { step: Ot ?? 0, offset: Ht ?? 0 };
+    k.setOptions(
+      { laneHeight: r, calendar: u, zoomLimits: { min: Rt, max: $t }, snap: I, intents: d, now: Xt, route: F, attach: G, ends: j },
+      y ? [dt, ft] : null
+    );
+  }, [k, dt, ft, r, u, Rt, $t, Yt, Ot, Ht, d, Xt, F, G, j]), B(() => {
+    k.setHandlers({ onIntent: p, canMoveTo: g, onInteraction: b, onSelectedTaskChange: _, onCollapsedGroupsChange: C, onDomainChange: L });
+  }, [k, p, g, b, _, C, L]);
+  const Ne = $(m);
+  B(() => {
+    const h = Ne.current;
+    h !== void 0 && k.setDefaultCollapsedGroups(h);
+  }, [k]), B(() => {
+    k.setCollapsedGroups(S);
+  }, [k, S]), We(
+    e,
+    () => ({
+      positionAt: (h, y) => k.positionAt(h, y),
+      clientPointOf: (h, y) => k.clientPointOf(h, y),
+      visibleDomain: () => k.visibleDomain()
+    }),
+    [k]
+  ), B(() => {
+    k.setControlledTask(A);
+  }, [k, A]), B(() => {
+    k.setPlacing(E ?? null);
+  }, [k, E]), B(() => {
+    const h = xt.current, y = Pt.current, I = Nt.current, R = Gt.current;
+    if (!h || !y || !I || !R) return;
+    k.bind(h, y, I, R);
+    const D = y.getBoundingClientRect();
+    k.resize(D.width, D.height);
+    const x = new ResizeObserver((N) => {
+      var Ut;
+      const Q = (Ut = N[N.length - 1]) == null ? void 0 : Ut.contentRect;
+      Q !== void 0 && k.resize(Q.width, Q.height);
+    });
+    x.observe(y);
+    const Z = (N) => k.wheel(N);
+    y.addEventListener("wheel", Z, { passive: !1 });
+    const J = (N) => {
+      N.key === "Escape" && k.cancelEdit() && N.preventDefault();
+    };
+    return window.addEventListener("keydown", J), () => {
+      window.removeEventListener("keydown", J), y.removeEventListener("wheel", Z), x.disconnect(), k.unbind();
+    };
+  }, [k]);
+  const T = Ue(k.subscribe, k.getSnapshot, k.getServerSnapshot), Ge = (h, y) => {
+    const I = new Date(h);
+    return y >= 200 ? K.dateLong(I) : y >= 84 ? K.date(I) : y >= 44 ? K.dateShort(I) : "";
+  }, M = T.ghost, pt = (h) => `${Dt}-row-${h.key}`, Re = q(() => {
+    const h = /* @__PURE__ */ new Map();
+    for (const y of T.headers)
+      for (const I of y.within)
+        y.kind === "groupHead" && I === y.group || h.set(I, [...h.get(I) ?? [], pt(y)]);
+    return h;
+  }, [T.headers, Dt]), $e = q(() => new Set((M == null ? void 0 : M.refusedLanes) ?? []), [M == null ? void 0 : M.refusedLanes]), Kt = $(null), [mt, Be] = it({ x: 0, y: 0, at: "" }), gt = M === null ? "" : `${M.x}:${M.y}:${M.from}:${M.to}:${M.overlap}:${M.late}`;
+  vt(() => {
+    const h = Kt.current;
+    if (M === null || h === null) return;
+    const y = 4, I = M.y - h.offsetHeight - y, R = M.y + M.height + y, D = {
+      x: Math.max(2, Math.min(M.x, T.width - h.offsetWidth - 2)),
+      y: I >= 2 ? I : Math.min(R, T.height - h.offsetHeight - 2),
+      at: gt
+    };
+    Be((x) => x.x === D.x && x.y === D.y && x.at === D.at ? x : D);
+  }, [M, gt, T.width, T.height]);
+  const Wt = $(null), [kt, Oe] = it({ x: 0, y: 0, at: "" }), O = T.tooltip, wt = O === null ? "" : `${O.x}:${O.y}:${O.target.kind}`;
+  return vt(() => {
+    const h = Wt.current;
+    if (O === null || h === null) return;
+    const y = 12, I = (D, x, Z) => {
+      const J = D + y, N = D - y - x, Q = J + x <= Z - 4 || N < 4 ? J : N;
+      return Math.max(4, Math.min(Q, Z - x - 4));
+    }, R = {
+      x: I(O.x, h.offsetWidth, T.width),
+      y: I(O.y, h.offsetHeight, T.height),
+      at: wt
+    };
+    Oe((D) => D.x === R.x && D.y === R.y && D.at === R.at ? D : R);
+  }, [O, wt, T.width, T.height]), /* @__PURE__ */ H(ke.Provider, { value: k, children: [
+    /* @__PURE__ */ H(
+      "div",
+      {
+        ref: xt,
+        role: "figure",
+        "aria-label": s,
+        className: Et ? `${v.root} ${Et}` : v.root,
+        style: { height: `${i}px`, gridTemplateColumns: `${a}px minmax(0, 1fr)`, ...Ee },
+        children: [
+          /* @__PURE__ */ w("div", { className: v.corner }),
+          /* @__PURE__ */ w("div", { className: v.dayBand, "aria-hidden": "true", "data-schedule-days": "", "data-schedule-clip": "day band", children: T.days.map((h) => {
+            const y = Math.max(0, -h.x), I = Math.min(h.x + h.width, T.width) - Math.max(h.x, 0);
+            return /* @__PURE__ */ w("span", { className: v.day, style: { left: `${h.x}px`, width: `${h.width}px` }, children: /* @__PURE__ */ w("span", { className: v.dayLabel, "data-schedule-overlay": "day label", style: { marginLeft: `${y}px` }, children: Ge(h.start, I) }) }, h.start);
+          }) }),
+          /* @__PURE__ */ w("div", { className: v.headers, "data-schedule-headers": "", children: /* @__PURE__ */ w("div", { className: v.headerRun, style: { transform: `translateY(${-T.scrollY}px)` }, children: T.headers.map((h) => /* @__PURE__ */ H(
+            "div",
+            {
+              id: pt(h),
+              className: v.header,
+              style: { height: `${h.height}px`, paddingLeft: `calc(var(--u-space-3) + ${h.depth} * var(--u-space-3))` },
+              "data-lane": h.lane,
+              "data-group": h.group,
+              "data-row": h.kind,
+              "data-schedule-clip": `header ${h.kind}`,
+              "data-refused": h.lane !== void 0 && $e.has(h.lane) ? "" : void 0,
+              children: [
+                h.kind !== "lane" && h.group !== void 0 && /* @__PURE__ */ w(
+                  "button",
+                  {
+                    type: "button",
+                    className: v.chevron,
+                    "data-schedule-overlay": "fold control",
+                    "aria-expanded": h.collapsed === !1,
+                    "aria-controls": (Re.get(h.group) ?? [pt(h)]).join(" "),
+                    "aria-label": `${h.collapsed === !0 ? W.scheduleUnfoldGroup : W.scheduleFoldGroup}: ${typeof h.label == "string" ? h.label : h.group}`,
+                    onClick: () => k.toggleGroup(h.group),
+                    children: /* @__PURE__ */ w("svg", { viewBox: "0 0 10 10", width: "9", height: "9", "aria-hidden": "true", "data-open": h.collapsed === !1 ? "" : void 0, children: /* @__PURE__ */ w("path", { d: "M3.5 1.5 7 5l-3.5 3.5", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+                  }
+                ),
+                /* @__PURE__ */ w("span", { className: v.headerLabel, "data-schedule-overlay": "header label", children: h.label }),
+                h.kind !== "lane" && /* @__PURE__ */ w("span", { className: v.headerCount, "data-schedule-overlay": "lane count", "data-lane-count": h.lanes, children: W.scheduleLaneCount(h.lanes) })
+              ]
+            },
+            h.key
+          )) }) }),
+          /* @__PURE__ */ H(
+            "div",
+            {
+              ref: Pt,
+              className: v.plot,
+              "data-schedule-plot": "",
+              "data-schedule-clip": "plot",
+              style: { cursor: T.cursor },
+              onPointerDown: (h) => k.pointerDown(h.nativeEvent),
+              onPointerMove: (h) => k.pointerMove(h.nativeEvent),
+              onPointerUp: (h) => k.pointerUp(h.nativeEvent),
+              onPointerCancel: (h) => k.pointerCancel(h.nativeEvent),
+              onPointerLeave: () => k.pointerLeave(),
+              onContextMenu: (h) => k.contextMenu(h.nativeEvent),
+              onDragOver: (h) => k.dragOver(h.nativeEvent),
+              onDrop: (h) => k.drop(h.nativeEvent),
+              onDragLeave: (h) => {
+                const y = h.nativeEvent.relatedTarget;
+                (!(y instanceof Node) || !h.currentTarget.contains(y)) && k.dragLeave();
+              },
+              children: [
+                /* @__PURE__ */ w("canvas", { ref: Nt, className: v.layer, "aria-hidden": "true" }),
+                /* @__PURE__ */ w("canvas", { ref: Gt, className: v.layer, "aria-hidden": "true" }),
+                T.grips.map((h) => /* @__PURE__ */ w(
+                  "span",
+                  {
+                    "data-grip": h.kind,
+                    "data-schedule-overlay": `${h.kind} grip`,
+                    "aria-hidden": "true",
+                    className: v.grip,
+                    style: { left: `${h.x}px`, top: `${h.y}px`, height: `${h.height}px` }
+                  },
+                  h.kind
+                )),
+                ot !== void 0 && T.bars.map((h) => /* @__PURE__ */ w(
+                  "span",
+                  {
+                    className: v.barLabel,
+                    "data-bar-label": h.subtask.id,
+                    "data-schedule-overlay": "bar label",
+                    "data-schedule-may-cover": "",
+                    "data-on": h.dark ? "dark" : "light",
+                    style: { left: `${h.x}px`, top: `${h.y}px`, width: `${h.width}px`, height: `${h.height}px` },
+                    children: /* @__PURE__ */ w("span", { className: v.barLabelText, children: ot(h.subtask) })
+                  },
+                  h.subtask.id
+                )),
+                z !== !1 && T.tooltip !== null && /* @__PURE__ */ w(
+                  "span",
+                  {
+                    ref: Wt,
+                    role: "tooltip",
+                    className: v.tooltip,
+                    "data-schedule-tooltip": "",
+                    "data-schedule-overlay": "tooltip",
+                    style: {
+                      left: `${kt.x}px`,
+                      top: `${kt.y}px`,
+                      visibility: kt.at === wt ? void 0 : "hidden"
+                    },
+                    children: typeof z == "function" ? z(T.tooltip.target) : /* @__PURE__ */ w(yn, { target: T.tooltip.target })
+                  }
+                ),
+                M !== null && /* @__PURE__ */ H(
+                  "span",
+                  {
+                    ref: Kt,
+                    className: v.ghostLabel,
+                    "data-ghost": "",
+                    "data-schedule-overlay": "ghost label",
+                    "data-findings": [M.overlap ? "overlap" : "", M.late ? "late-transport" : ""].filter(Boolean).join(" "),
+                    "data-refused": M.refused ? "" : void 0,
+                    style: {
+                      left: `${mt.x}px`,
+                      top: `${mt.y}px`,
+                      visibility: mt.at === gt ? void 0 : "hidden"
+                    },
+                    children: [
+                      W.scheduleGhostTimes(K.time(new Date(M.from), !1), K.time(new Date(M.to), !1)),
+                      M.refused && /* @__PURE__ */ w("span", { className: v.refusal, children: W.scheduleLaneRefused }),
+                      M.overlap && /* @__PURE__ */ w("span", { className: v.finding, children: W.scheduleOverlap }),
+                      M.late && /* @__PURE__ */ w("span", { className: v.finding, children: W.scheduleLateTransport })
+                    ]
+                  }
+                )
+              ]
+            }
+          ),
+          /* @__PURE__ */ w("div", { className: v.corner }),
+          /* @__PURE__ */ H("div", { className: v.tickBand, "aria-hidden": "true", "data-schedule-ticks": "", "data-schedule-clip": "time band", children: [
+            T.now !== null && /* @__PURE__ */ w("span", { className: v.now, "data-now": "", "data-schedule-overlay": "now mark", style: { left: `${T.now}px` } }),
+            T.ticks.map((h) => /* @__PURE__ */ w("span", { className: v.tick, style: { left: `${h.x}px` }, children: h.x >= de && h.x <= T.width - de && /* @__PURE__ */ w("span", { className: v.tickLabel, "data-schedule-overlay": "time label", children: T.step >= st ? K.dateShort(new Date(h.wallClock)) : K.time(new Date(h.wallClock), !1) }) }, h.wallClock))
+          ] })
+        ]
+      }
+    ),
+    De
+  ] });
+});
+function En({ id: n, label: t }) {
+  const e = ve(), s = q(() => ({ id: n, label: t ?? n, ...e === null ? {} : { parent: e } }), [n, t, e]);
+  return ts(s), null;
+}
+function Dn({ id: n, label: t, children: e }) {
+  const s = ve(), o = q(() => ({ id: n, label: t ?? n, ...s === null ? {} : { parent: s } }), [n, t, s]);
+  return es(o), /* @__PURE__ */ w(we.Provider, { value: n, children: e });
+}
+function xn({ data: n, tasks: t }) {
+  const e = q(() => ({ kind: "subtasks", data: n, tasks: t }), [n, t]);
+  return ye("Subtasks", e), null;
+}
+function Pn({ data: n }) {
+  const t = q(() => ({ kind: "transports", data: n }), [n]);
+  return ye("Transports", t), null;
+}
+function Nn(n, t, e) {
+  if (e.kind === "place") return [];
+  const s = new Map(n.map((u) => [u.id, jt(u, e)])), o = /* @__PURE__ */ new Map();
+  for (const u of t) {
+    const c = o.get(u.from) ?? [];
+    c.push(u), o.set(u.from, c);
+  }
+  const i = /* @__PURE__ */ new Map(), r = [e.subtask];
+  let a = (n.length + 1) * (t.length + 1);
+  for (; r.length > 0 && a-- > 0; ) {
+    const u = r.shift(), c = s.get(u);
+    if (c !== void 0)
+      for (const l of o.get(u) ?? []) {
+        if (l.to === e.subtask) continue;
+        const d = s.get(l.to);
+        if (d === void 0) continue;
+        const p = St(l, c) + l.duration - At(l, d);
+        if (!(p > 0)) continue;
+        const g = { kind: "move", subtask: d.id, from: d.from + p, to: d.to + p };
+        s.set(d.id, jt(d, g)), i.set(d.id, g), r.push(d.id);
+      }
+  }
+  return [...i.values()];
+}
+function Gn(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 }));
+}
+export {
+  En as Lane,
+  Dn as LaneGroup,
+  Fn as Schedule,
+  xn as Subtasks,
+  Pn as Transports,
+  jt as applyIntent,
+  At as arrival,
+  St as departure,
+  _n as findings,
+  _t as lateTransports,
+  ut as occupied,
+  It as overlaps,
+  ht as resolveAppearance,
+  Nn as ripple,
+  Gn as shiftTask,
+  Rs as snapTime,
+  In as subtaskFromPlace
+};