@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/calendar/drag.js

@@ -0,0 +1,74 @@
+import { dateFormat as l } from "../intl-cache.js";
+import { addDuration as m, instantToPlainDateTime as c, instantAtFraction as x, startOfDay as v, dayFraction as h } from "../time/zone.js";
+function M(t, n) {
+  const { zone: e, columns: a, snapMinutes: s } = n, r = a.findIndex(
+    (u) => t.x >= u.left && t.x < u.right
+  );
+  if (r < 0) return null;
+  const o = a[r], i = o.bottom - o.top;
+  if (i <= 0) return null;
+  const d = Math.max(0, Math.min(1, (t.y - o.top) / i));
+  return {
+    dayIndex: r,
+    day: o.day,
+    instant: D(e, o.day, x(e, o.day, d), s)
+  };
+}
+function D(t, n, e, a) {
+  if (a <= 0) throw new Error(`snapMinutes must be positive, got ${a}`);
+  const s = v(t, n), r = a * 6e4;
+  return s + Math.round((e - s) / r) * r;
+}
+const f = 15;
+function p(t, n, e, a = f) {
+  const s = n.dayIndex - t.from.dayIndex, r = c(e, t.from.instant), o = c(e, n.instant), i = o.hour * 60 + o.minute - (r.hour * 60 + r.minute);
+  if (t.kind === "move")
+    return { delta: { days: s, minutes: i }, moved: s !== 0 || i !== 0 };
+  const d = Math.round((n.instant - t.from.instant) / 6e4), u = t.event.endExclusive - t.event.start;
+  return t.kind === "resize-end" ? u + d * 6e4 < a * 6e4 ? { delta: {}, moved: !1, invalid: "too-short" } : { delta: { minutes: d }, moved: d !== 0 } : t.kind === "resize-start" ? u - d * 6e4 < a * 6e4 ? { delta: {}, moved: !1, invalid: "too-short" } : { delta: { minutes: d }, moved: d !== 0 } : { delta: { days: s, minutes: i }, moved: !0 };
+}
+function T(t, n, e, a) {
+  if (n === "resize-end")
+    return { ...t, endExclusive: m(a, t.endExclusive, e) };
+  if (n === "resize-start")
+    return { ...t, start: m(a, t.start, e) };
+  const s = m(a, t.start, e);
+  return { ...t, start: s, endExclusive: s + (t.endExclusive - t.start) };
+}
+function w(t, n, e = f) {
+  const a = t.dayIndex === n.dayIndex, s = t.day, r = Math.min(t.instant, a ? n.instant : t.instant), o = Math.max(t.instant, a ? n.instant : t.instant), i = e * 6e4;
+  return {
+    day: s,
+    start: r,
+    /* A click with no drag still creates something usable rather than a
+       zero-length event nobody can see or grab. */
+    endExclusive: o - r < i ? r + i : o
+  };
+}
+function C(t, n, e) {
+  const a = c(n, t.instant), s = l(e, {
+    timeZone: n,
+    hour: "numeric",
+    ...a.minute === 0 ? {} : { minute: "2-digit" }
+  }).format(new Date(t.instant)), r = l(e, {
+    timeZone: "UTC",
+    weekday: "long",
+    day: "numeric",
+    month: "long"
+  }).format(Date.UTC(t.day.year, t.day.month - 1, t.day.day));
+  return `${s}, ${r}`;
+}
+function N(t, n, e) {
+  return h(t, n, e);
+}
+export {
+  f as MIN_DURATION_MINUTES,
+  T as applyCalendarDelta,
+  p as calendarDragResult,
+  w as createdEvent,
+  C as describeTarget,
+  N as fractionOf,
+  M as resolveCalendarTarget,
+  D as snapInstant
+};
+//# sourceMappingURL=drag.js.map

package/dist/lib/calendar/drag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag.js","sources":["../../../src/lib/calendar/drag.ts"],"sourcesContent":["import {\n  addDuration,\n  dayFraction,\n  instantAtFraction,\n  instantToPlainDateTime,\n  startOfDay,\n  type Instant,\n  type PlainDate,\n  type TimeZone,\n} from \"@/lib/time\";\nimport type { CalendarDuration } from \"@/lib/time\";\nimport { dateFormat } from \"@/lib/intl-cache\";\nimport type { DragKind, TimedEvent } from \"./types\";\n\n/* ============================================================================\n   THE CALENDAR'S TARGET MODEL, and it has nothing in common with the list's.\n\n   A LIST target is `{container, index}`, resolved from the MIDPOINTS OF SIBLING\n   ITEMS — it is ordinal, and it depends on every other item in the container.\n\n   A CALENDAR target is `{dayIndex, instant}`, read off a FIXED grid from the\n   pointer's position. It is continuous, and it depends on no other event at\n   all. Two events can occupy the same time; that is a layout problem, not a\n   drop problem.\n\n   That is why this file exists rather than a parameterisation of the list\n   engine: the INPUT layer is genuinely shared (`lib/dnd/sensors/gesture.ts`),\n   and the target model is genuinely not.\n\n   EVERYTHING HERE IS PURE. Rects and fractions in, a delta out. The React layer\n   supplies the measurements and applies the result, which is what lets the\n   whole of this be tested without a browser — including the DST cases, which no\n   browser test could reach reliably.\n   ========================================================================= */\n\n/** A day column, as the view measured it. */\nexport interface ColumnRect {\n  readonly day: PlainDate;\n  readonly left: number;\n  readonly right: number;\n  readonly top: number;\n  readonly bottom: number;\n}\n\n/** Where a pointer is, in calendar terms. */\nexport interface CalendarTarget {\n  readonly dayIndex: number;\n  readonly day: PlainDate;\n  /** Snapped to `snapMinutes`, measured from that day's own first instant. */\n  readonly instant: Instant;\n}\n\nexport interface ResolveOptions {\n  readonly zone: TimeZone;\n  readonly columns: readonly ColumnRect[];\n  readonly snapMinutes: number;\n}\n\n/**\n * Which day and which time a point is over.\n *\n * `null` outside every column — and the caller KEEPS THE LAST NON-NULL TARGET\n * rather than treating that as \"no drop\". A pointer leaves the columns\n * constantly while dragging toward the edge of the grid, and an event that\n * snapped back to its origin every time the finger crossed the gutter would be\n * unusable.\n */\nexport function resolveCalendarTarget(\n  point: { x: number; y: number },\n  options: ResolveOptions,\n): CalendarTarget | null {\n  const { zone, columns, snapMinutes } = options;\n  const index = columns.findIndex(\n    (column) => point.x >= column.left && point.x < column.right,\n  );\n  if (index < 0) return null;\n\n  const column = columns[index];\n  const height = column.bottom - column.top;\n  if (height <= 0) return null;\n\n  /* Clamped to the column, so a pointer above or below the grid resolves to the\n     first or last moment of that day rather than to nothing. */\n  const fraction = Math.max(0, Math.min(1, (point.y - column.top) / height));\n  return {\n    dayIndex: index,\n    day: column.day,\n    instant: snapInstant(zone, column.day, instantAtFraction(zone, column.day, fraction), snapMinutes),\n  };\n}\n\n/**\n * Snap an instant to the nearest `snapMinutes`, measured from the DAY'S OWN\n * first instant.\n *\n * Not from midnight and not from the epoch. On a day that begins at 01:00 —\n * Havana in March — snapping to the epoch puts every slot boundary an hour away\n * from the rails the grid drew, in exactly the zones where a user is least able\n * to explain what they are seeing.\n */\nexport function snapInstant(\n  zone: TimeZone,\n  day: PlainDate,\n  instant: Instant,\n  snapMinutes: number,\n): Instant {\n  if (snapMinutes <= 0) throw new Error(`snapMinutes must be positive, got ${snapMinutes}`);\n  const from = startOfDay(zone, day);\n  const step = snapMinutes * 60_000;\n  return from + Math.round((instant - from) / step) * step;\n}\n\n/* ---------------------------------------------------------------- the drag --- */\n\nexport interface CalendarDragOrigin {\n  readonly event: TimedEvent;\n  readonly kind: DragKind;\n  /** The target under the pointer when the gesture activated. */\n  readonly from: CalendarTarget;\n}\n\nexport interface CalendarDragResult {\n  /**\n   * The change, as a CALENDAR duration — never milliseconds.\n   *\n   * \"One day later\" is 23 hours across a spring-forward boundary and 25 across\n   * a fall-back. A user dragging an event from Saturday to Sunday expects it to\n   * keep its wall-clock time, and a millisecond delta cannot express that. It\n   * is the bug in every library surveyed.\n   */\n  readonly delta: CalendarDuration;\n  /** False when the gesture would leave the event exactly where it was. */\n  readonly moved: boolean;\n  /**\n   * Set when a resize would produce a zero or negative duration.\n   *\n   * REJECTED, NOT CLAMPED. FullCalendar returns no mutation at all;\n   * react-big-calendar clamps, and asymmetrically — its bottom-edge rule can\n   * produce a ZERO-DURATION event, which then renders as an invisible sliver\n   * the user cannot grab to fix. Refusing the gesture leaves the event where it\n   * was, which the user can see and try again from.\n   */\n  readonly invalid?: \"too-short\";\n}\n\n/**\n * The minimum an event may be resized to, in minutes.\n *\n * One snap step. Anything smaller cannot be expressed by the gesture that made\n * it, so it could never be undone by the same gesture.\n */\nexport const MIN_DURATION_MINUTES = 15;\n\n/**\n * What a gesture from `origin` to `target` means.\n *\n * DAYS AND MINUTES SEPARATELY, and that separation is the whole point. The day\n * component is a CALENDAR move — re-anchored to the same wall-clock time on the\n * new day. The minute component is EXACT elapsed time — dragging down two hours\n * means two hours. Both are true at once, and collapsing them into one number\n * loses whichever property the collapse did not preserve.\n */\nexport function calendarDragResult(\n  origin: CalendarDragOrigin,\n  target: CalendarTarget,\n  zone: TimeZone,\n  minDurationMinutes = MIN_DURATION_MINUTES,\n): CalendarDragResult {\n  const days = target.dayIndex - origin.from.dayIndex;\n\n  /* THE MINUTE COMPONENT OF A MOVE IS A WALL-CLOCK DIFFERENCE, and getting this\n     wrong is the defect the DST gate caught on its first run.\n   *\n   * My first version measured ELAPSED time from each day's own start. On 8\n   * March in New York the clock skips 02:00, so 09:00 is only EIGHT elapsed\n   * hours into the day while on the 7th it is nine — and dragging an event\n   * one column right produced `{days: 1, minutes: -60}`, which is precisely\n   * the folding-in this split exists to prevent. The wall clock is what the\n   * user is dragging along, so the wall clock is what the delta measures. */\n  const originWall = instantToPlainDateTime(zone, origin.from.instant);\n  const targetWall = instantToPlainDateTime(zone, target.instant);\n  const minutes =\n    targetWall.hour * 60 + targetWall.minute - (originWall.hour * 60 + originWall.minute);\n\n  if (origin.kind === \"move\") {\n    return { delta: { days, minutes }, moved: days !== 0 || minutes !== 0 };\n  }\n\n  /* A RESIZE IS ELAPSED TIME, NOT WALL-CLOCK TIME, and that is the other half\n     of the same distinction. Dragging the end edge from 10:00 on one day to\n     10:00 on the next across a 23-hour day lengthens the event by 23 hours, not\n     24 — the duration is real time, and a wall-clock difference would report\n     zero. So the resize path measures instants directly.\n   *\n     It also carries no `days` component: a resize moves ONE edge and the other\n     stays put, so a day term would silently move the whole event. An overnight\n     resize is simply a large number of minutes. */\n  const totalMinutes = Math.round((target.instant - origin.from.instant) / 60_000);\n  const durationMs = origin.event.endExclusive - origin.event.start;\n\n  if (origin.kind === \"resize-end\") {\n    const nextDuration = durationMs + totalMinutes * 60_000;\n    if (nextDuration < minDurationMinutes * 60_000) {\n      return { delta: {}, moved: false, invalid: \"too-short\" };\n    }\n    return { delta: { minutes: totalMinutes }, moved: totalMinutes !== 0 };\n  }\n\n  if (origin.kind === \"resize-start\") {\n    const nextDuration = durationMs - totalMinutes * 60_000;\n    if (nextDuration < minDurationMinutes * 60_000) {\n      return { delta: {}, moved: false, invalid: \"too-short\" };\n    }\n    return { delta: { minutes: totalMinutes }, moved: totalMinutes !== 0 };\n  }\n\n  /* `create` — the delta is the whole extent of the new event. */\n  return { delta: { days, minutes }, moved: true };\n}\n\n/**\n * The event as it would be after `delta`, for the live preview.\n *\n * COMPOSED ONTO THE EVENT AT CALL TIME, never onto a snapshot taken at\n * pointer-down. Two real failures from other calendars' trackers: a re-render\n * replaces the event store mid-drag and the drag is left holding an instance\n * from the dead one; and a concurrent server update during a drag DUPLICATES\n * the times, because a snapshot was composited on top of data that had moved\n * underneath it. Recomputing from whatever the event says now makes a change\n * arriving mid-gesture compose rather than clobber.\n */\nexport function applyCalendarDelta(\n  event: TimedEvent,\n  kind: DragKind,\n  delta: CalendarDuration,\n  zone: TimeZone,\n): TimedEvent {\n  if (kind === \"resize-end\") {\n    return { ...event, endExclusive: addDuration(zone, event.endExclusive, delta) };\n  }\n  if (kind === \"resize-start\") {\n    return { ...event, start: addDuration(zone, event.start, delta) };\n  }\n  /* A MOVE preserves the duration exactly, and does so by moving the start and\n     adding the ORIGINAL length — not by moving both ends independently. Across\n     a transition the two ends would otherwise shift by different amounts and a\n     one-hour meeting would become fifty minutes. */\n  const start = addDuration(zone, event.start, delta);\n  return { ...event, start, endExclusive: start + (event.endExclusive - event.start) };\n}\n\n/**\n * The event a drag-to-create gesture would produce.\n *\n * The two ends are ordered, so dragging upward creates the same event as\n * dragging downward across the same span — which is what every calendar does\n * and what a user expects from a rubber-band gesture.\n */\nexport function createdEvent(\n  anchor: CalendarTarget,\n  target: CalendarTarget,\n  minDurationMinutes = MIN_DURATION_MINUTES,\n): { start: Instant; endExclusive: Instant; day: PlainDate } {\n  const sameDay = anchor.dayIndex === target.dayIndex;\n  /* A create that crosses columns lands entirely in the column it started in.\n     Rubber-banding across days reads as selecting a range of DAYS, which is a\n     different gesture and is not this one. */\n  const day = anchor.day;\n  const from = Math.min(anchor.instant, sameDay ? target.instant : anchor.instant);\n  const to = Math.max(anchor.instant, sameDay ? target.instant : anchor.instant);\n  const minimum = minDurationMinutes * 60_000;\n  return {\n    day,\n    start: from,\n    /* A click with no drag still creates something usable rather than a\n       zero-length event nobody can see or grab. */\n    endExclusive: to - from < minimum ? from + minimum : to,\n  };\n}\n\n/**\n * A human description of the position, for the live region.\n *\n * \"Moved to 2:30 PM, Wednesday\" — the SLOT, not the fact that something moved.\n * \"Moved\" alone tells a screen-reader user nothing they can act on.\n */\nexport function describeTarget(\n  target: CalendarTarget,\n  zone: TimeZone,\n  locale: string,\n): string {\n  const wall = instantToPlainDateTime(zone, target.instant);\n  const time = dateFormat(locale, {\n    timeZone: zone,\n    hour: \"numeric\",\n    ...(wall.minute === 0 ? {} : { minute: \"2-digit\" }),\n  }).format(new Date(target.instant));\n  const dayName = dateFormat(locale, {\n    timeZone: \"UTC\",\n    weekday: \"long\",\n    day: \"numeric\",\n    month: \"long\",\n  }).format(Date.UTC(target.day.year, target.day.month - 1, target.day.day));\n  return `${time}, ${dayName}`;\n}\n\n/** Where in the grid a fraction sits, for the preview. Inverse of the resolve. */\nexport function fractionOf(zone: TimeZone, day: PlainDate, instant: Instant): number {\n  return dayFraction(zone, day, instant);\n}\n"],"names":["resolveCalendarTarget","point","options","zone","columns","snapMinutes","index","column","height","fraction","snapInstant","instantAtFraction","day","instant","from","startOfDay","step","MIN_DURATION_MINUTES","calendarDragResult","origin","target","minDurationMinutes","days","originWall","instantToPlainDateTime","targetWall","minutes","totalMinutes","durationMs","applyCalendarDelta","event","kind","delta","addDuration","start","createdEvent","anchor","sameDay","to","minimum","describeTarget","locale","wall","time","dateFormat","dayName","fractionOf","dayFraction"],"mappings":"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"}

package/dist/lib/calendar/lane-packer.js

@@ -0,0 +1,67 @@
+const d = {
+  mode: "cascade",
+  minSpan: 0,
+  maxLanes: Number.POSITIVE_INFINITY,
+  minWidth: 0
+};
+function l(e, t) {
+  return e.start < t.end && t.start < e.end;
+}
+function I(e, t) {
+  if (e.start !== t.start) return e.start - t.start;
+  const m = t.end - t.start - (e.end - e.start);
+  return m !== 0 ? m : e.key < t.key ? -1 : e.key > t.key ? 1 : 0;
+}
+function k(e, t = {}) {
+  const m = {
+    mode: t.mode ?? d.mode,
+    minSpan: t.minSpan ?? d.minSpan,
+    maxLanes: t.maxLanes ?? d.maxLanes,
+    minWidth: t.minWidth ?? d.minWidth
+  }, h = e.map((n) => ({
+    key: n.key,
+    start: n.start,
+    /* Inflated HERE, before anything else looks at it, so collision and
+       geometry can never be computed from different spans. */
+    end: Math.max(n.end, n.start + m.minSpan)
+  })).sort(I), i = [];
+  let s = [], o = Number.NEGATIVE_INFINITY;
+  const u = () => {
+    if (s.length === 0) return;
+    const n = Math.min(
+      s.reduce((a, r) => Math.max(a, r.column), 0) + 1,
+      m.maxLanes
+    );
+    for (const a of s) {
+      const r = Math.min(a.column, n - 1), c = r / n * 1, f = Math.max(
+        m.mode === "cascade" ? 1 - c : 1 / n,
+        m.minWidth
+      );
+      i.push({
+        key: a.key,
+        start: a.start,
+        end: a.end,
+        column: r,
+        lanes: n,
+        left: c,
+        width: f,
+        /* `item.column`, not the clamped one: two events stacked in the same
+           capped lane must still paint in a stable order. */
+        zIndex: a.column
+      });
+    }
+    s = [], o = Number.NEGATIVE_INFINITY;
+  };
+  for (const n of h) {
+    n.start >= o && u();
+    let a = 0;
+    for (; s.some((c) => c.column === a && l(c, n)); )
+      a++;
+    s.push({ ...n, column: a }), o = Math.max(o, n.end);
+  }
+  return u(), i;
+}
+export {
+  k as packLanes
+};
+//# sourceMappingURL=lane-packer.js.map

package/dist/lib/calendar/lane-packer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-packer.js","sources":["../../../src/lib/calendar/lane-packer.ts"],"sourcesContent":["/* ============================================================================\n   THE OVERLAP ALGORITHM — greedy interval-graph colouring over sweep-line\n   batches.\n\n   This is the hardest visual logic in the calendar and the thing that makes it\n   look real or look broken. It is O(n log n), deterministic, and has no\n   dependency on React, the DOM, pixels or the clock — so it is unit-testable\n   without a browser, which is the whole reason it lives in its own file.\n\n   Schedule-X names this algorithm in its own source; Toast UI reaches the\n   identical result through a matrix. BOTH VISUAL MODES FALL OUT OF ONE BRANCH\n   on the width formula, which is the part worth noticing: \"cascade\" and \"split\"\n   are not two layouts, they are one layout asked for a different width.\n\n   WHAT NOT TO COPY, and it is instructive. react-big-calendar groups two events\n   into the same row when `|b.start - a.start| < minimumStartDifference`, and\n   that constant is `ceil(step * timeslots / 2)` — THIRTY MINUTES at its own\n   defaults. So two adjacent 15-minute events that merely start near each other\n   are forced to overlap instead of sitting side by side. It is open, unfixed,\n   and the workaround shipped alongside it is a second entire layout\n   implementation. The lesson generalises past that one constant:\n\n       A NEAR-SIMULTANEOUS-START TOLERANCE IS A HEURISTIC, NOT A CORRECTNESS\n       RULE. Use true interval overlap only.\n\n   Everything here works in FRACTIONS of a column, never pixels. The view knows\n   how tall its column is; the packer must not, or it acquires a second position\n   calculation next to the ratio-based one in `zone.ts` — which is exactly the\n   divergence that crashed Kendo's scheduler.\n   ========================================================================= */\n\n/** A half-open interval `[start, end)` in column fractions, with an identity. */\nexport interface LaneInput {\n  readonly key: string;\n  readonly start: number;\n  readonly end: number;\n}\n\nexport interface LanePlacement {\n  readonly key: string;\n  /** As laid out — possibly inflated past the input by `minSpan`. */\n  readonly start: number;\n  readonly end: number;\n  /** 0-based lane within this event's collision batch. */\n  readonly column: number;\n  /** Lanes in that batch. Uniform across every member of it — see below. */\n  readonly lanes: number;\n  /** Fraction of the container's width, from its leading edge. */\n  readonly left: number;\n  readonly width: number;\n  /** Later columns paint over earlier ones. Equal to `column`. */\n  readonly zIndex: number;\n}\n\nexport interface LaneOptions {\n  /**\n   * `cascade` — every event runs to the container's trailing edge and later\n   * columns paint over earlier ones. **This is the Google look and the\n   * default.** `split` — the batch divides the width evenly and nothing\n   * overlaps.\n   *\n   * Three products, three different cascade multipliers: Schedule-X runs to the\n   * edge, FullCalendar doubles the lane width capped at 1, and\n   * react-big-calendar uses 1.7x — arbitrary and unexplained anywhere in its\n   * source. Running to the edge is the only one of the three that is a rule\n   * rather than a number someone liked.\n   */\n  readonly mode?: \"cascade\" | \"split\";\n\n  /**\n   * The smallest span an event may occupy, as a column fraction.\n   *\n   * A 5-minute event on a 12-hour column is 0.7% of it — unclickable, and\n   * unreadable long before that. So it is inflated to a floor.\n   *\n   * **THE INFLATED SPAN IS WHAT COLLISION USES TOO**, which is the part that is\n   * easy to get wrong. Two 5-minute events a minute apart do not overlap as\n   * intervals, but they overlap ON SCREEN once both are inflated to a clickable\n   * height — so laying them in the same lane stacks one on the other. Detecting\n   * collisions on the true interval and drawing the inflated one is how a\n   * calendar ends up with events sitting invisibly behind each other.\n   */\n  readonly minSpan?: number;\n\n  /**\n   * Cap on lanes per batch. Beyond it, events STACK in the last lane rather\n   * than disappear.\n   *\n   * A week column is around 120px; a fifth lane in it is 24px and unreadable.\n   * But hiding an event in a time grid is worse than overlapping one — the user\n   * can see and click something that overlaps, and cannot do either with\n   * something that is not there. So the cap limits the DIVISION, not the\n   * membership. Day view passes no cap.\n   */\n  readonly maxLanes?: number;\n\n  /**\n   * Floor on the rendered width, as a fraction.\n   *\n   * Guards the width-0 collapse — an open FullCalendar bug where enough\n   * concurrent events divide the column into nothing and the whole batch\n   * becomes invisible. A floor makes a crowded column ugly instead of empty.\n   */\n  readonly minWidth?: number;\n}\n\nconst DEFAULTS = {\n  mode: \"cascade\" as const,\n  minSpan: 0,\n  maxLanes: Number.POSITIVE_INFINITY,\n  minWidth: 0,\n};\n\n/** True interval overlap on half-open ranges. No tolerance, deliberately. */\nfunction overlaps(a: { start: number; end: number }, b: { start: number; end: number }): boolean {\n  return a.start < b.end && b.start < a.end;\n}\n\n/**\n * A TOTAL order, which is what makes the output independent of input order.\n *\n * Start ascending, then longer first, then by key. The key tiebreak is not\n * decoration: without it, two events with identical start and duration are\n * ordered by however they arrived, so the same set of events fetched in a\n * different order lays out differently between renders. That looks exactly like\n * a rendering bug and is untraceable, because nothing about the layout changed\n * — only the array did.\n */\nfunction compare(a: LaneInput, b: LaneInput): number {\n  if (a.start !== b.start) return a.start - b.start;\n  const byLength = b.end - b.start - (a.end - a.start);\n  if (byLength !== 0) return byLength;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/**\n * Lay out overlapping events across lanes.\n *\n * Four steps, and the third is the colouring:\n *\n *   1. Sort by the total order above.\n *   2. Sweep into COLLISION BATCHES — a batch closes when the next event starts\n *      at or after the maximum end of everything accumulated so far. Two events\n *      in different batches provably cannot overlap, so lane counts never leak\n *      between them and one crowded hour does not narrow the whole day.\n *   3. Within a batch, give each event the SMALLEST lane index not taken by an\n *      earlier member it overlaps. That is greedy colouring of an interval\n *      graph, and on interval graphs greedy in start order is OPTIMAL — it uses\n *      exactly the number of lanes the maximum concurrency requires.\n *   4. `lanes = maxColumn + 1`, computed ONCE PER BATCH and applied uniformly to\n *      every member. Per-event lane counts are what make two side-by-side\n *      events different widths for no visible reason.\n */\nexport function packLanes(inputs: readonly LaneInput[], options: LaneOptions = {}): LanePlacement[] {\n  const cfg = {\n    mode: options.mode ?? DEFAULTS.mode,\n    minSpan: options.minSpan ?? DEFAULTS.minSpan,\n    maxLanes: options.maxLanes ?? DEFAULTS.maxLanes,\n    minWidth: options.minWidth ?? DEFAULTS.minWidth,\n  };\n\n  const items = inputs\n    .map((input) => ({\n      key: input.key,\n      start: input.start,\n      /* Inflated HERE, before anything else looks at it, so collision and\n         geometry can never be computed from different spans. */\n      end: Math.max(input.end, input.start + cfg.minSpan),\n    }))\n    .sort(compare);\n\n  const placements: LanePlacement[] = [];\n\n  let batch: { key: string; start: number; end: number; column: number }[] = [];\n  let batchMaxEnd = Number.NEGATIVE_INFINITY;\n\n  const flush = () => {\n    if (batch.length === 0) return;\n    const lanes = Math.min(\n      batch.reduce((most, item) => Math.max(most, item.column), 0) + 1,\n      cfg.maxLanes,\n    );\n    for (const item of batch) {\n      /* Past the cap events stack in the last lane rather than vanish. */\n      const column = Math.min(item.column, lanes - 1);\n      const left = (column / lanes) * 1;\n      const width = Math.max(\n        cfg.mode === \"cascade\" ? 1 - left : 1 / lanes,\n        cfg.minWidth,\n      );\n      placements.push({\n        key: item.key,\n        start: item.start,\n        end: item.end,\n        column,\n        lanes,\n        left,\n        width,\n        /* `item.column`, not the clamped one: two events stacked in the same\n           capped lane must still paint in a stable order. */\n        zIndex: item.column,\n      });\n    }\n    batch = [];\n    batchMaxEnd = Number.NEGATIVE_INFINITY;\n  };\n\n  for (const item of items) {\n    if (item.start >= batchMaxEnd) flush();\n\n    let column = 0;\n    /* Smallest free lane. Linear in the batch, and a batch is the set of\n       genuinely concurrent events — single digits in any real calendar. */\n    for (;;) {\n      const taken = batch.some((other) => other.column === column && overlaps(other, item));\n      if (!taken) break;\n      column++;\n    }\n\n    batch.push({ ...item, column });\n    batchMaxEnd = Math.max(batchMaxEnd, item.end);\n  }\n  flush();\n\n  return placements;\n}\n"],"names":["DEFAULTS","overlaps","a","b","compare","byLength","packLanes","inputs","options","cfg","items","input","placements","batch","batchMaxEnd","flush","lanes","most","item","column","left","width","other"],"mappings":"AA0GA,MAAMA,IAAW;AAAA,EACf,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,OAAO;AAAA,EACjB,UAAU;AACZ;AAGA,SAASC,EAASC,GAAmCC,GAA4C;AAC/F,SAAOD,EAAE,QAAQC,EAAE,OAAOA,EAAE,QAAQD,EAAE;AACxC;AAYA,SAASE,EAAQF,GAAcC,GAAsB;AACnD,MAAID,EAAE,UAAUC,EAAE,MAAO,QAAOD,EAAE,QAAQC,EAAE;AAC5C,QAAME,IAAWF,EAAE,MAAMA,EAAE,SAASD,EAAE,MAAMA,EAAE;AAC9C,SAAIG,MAAa,IAAUA,IACpBH,EAAE,MAAMC,EAAE,MAAM,KAAKD,EAAE,MAAMC,EAAE,MAAM,IAAI;AAClD;AAoBO,SAASG,EAAUC,GAA8BC,IAAuB,IAAqB;AAClG,QAAMC,IAAM;AAAA,IACV,MAAMD,EAAQ,QAAQR,EAAS;AAAA,IAC/B,SAASQ,EAAQ,WAAWR,EAAS;AAAA,IACrC,UAAUQ,EAAQ,YAAYR,EAAS;AAAA,IACvC,UAAUQ,EAAQ,YAAYR,EAAS;AAAA,EAAA,GAGnCU,IAAQH,EACX,IAAI,CAACI,OAAW;AAAA,IACf,KAAKA,EAAM;AAAA,IACX,OAAOA,EAAM;AAAA;AAAA;AAAA,IAGb,KAAK,KAAK,IAAIA,EAAM,KAAKA,EAAM,QAAQF,EAAI,OAAO;AAAA,EAAA,EAClD,EACD,KAAKL,CAAO,GAETQ,IAA8B,CAAA;AAEpC,MAAIC,IAAuE,CAAA,GACvEC,IAAc,OAAO;AAEzB,QAAMC,IAAQ,MAAM;AAClB,QAAIF,EAAM,WAAW,EAAG;AACxB,UAAMG,IAAQ,KAAK;AAAA,MACjBH,EAAM,OAAO,CAACI,GAAMC,MAAS,KAAK,IAAID,GAAMC,EAAK,MAAM,GAAG,CAAC,IAAI;AAAA,MAC/DT,EAAI;AAAA,IAAA;AAEN,eAAWS,KAAQL,GAAO;AAExB,YAAMM,IAAS,KAAK,IAAID,EAAK,QAAQF,IAAQ,CAAC,GACxCI,IAAQD,IAASH,IAAS,GAC1BK,IAAQ,KAAK;AAAA,QACjBZ,EAAI,SAAS,YAAY,IAAIW,IAAO,IAAIJ;AAAA,QACxCP,EAAI;AAAA,MAAA;AAEN,MAAAG,EAAW,KAAK;AAAA,QACd,KAAKM,EAAK;AAAA,QACV,OAAOA,EAAK;AAAA,QACZ,KAAKA,EAAK;AAAA,QACV,QAAAC;AAAA,QACA,OAAAH;AAAA,QACA,MAAAI;AAAA,QACA,OAAAC;AAAA;AAAA;AAAA,QAGA,QAAQH,EAAK;AAAA,MAAA,CACd;AAAA,IACH;AACA,IAAAL,IAAQ,CAAA,GACRC,IAAc,OAAO;AAAA,EACvB;AAEA,aAAWI,KAAQR,GAAO;AACxB,IAAIQ,EAAK,SAASJ,KAAaC,EAAA;AAE/B,QAAII,IAAS;AAGb,WACgBN,EAAM,KAAK,CAACS,MAAUA,EAAM,WAAWH,KAAUlB,EAASqB,GAAOJ,CAAI,CAAC;AAEpF,MAAAC;AAGF,IAAAN,EAAM,KAAK,EAAE,GAAGK,GAAM,QAAAC,GAAQ,GAC9BL,IAAc,KAAK,IAAIA,GAAaI,EAAK,GAAG;AAAA,EAC9C;AACA,SAAAH,EAAA,GAEOH;AACT;"}

package/dist/lib/calendar/segments.js

@@ -0,0 +1,82 @@
+import { isoDateString as x } from "../time/types.js";
+import { nextDay as m, startOfDay as a, instantToPlainDateTime as S, instantAtFraction as b, dayFraction as E } from "../time/zone.js";
+import { comparePlainDate as f, daysBetween as g } from "../time/plain.js";
+function $(r, t, n) {
+  const s = [];
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i], u = E(r, o, n.start), l = E(r, o, n.endExclusive);
+    u < 1 && l > 0 && s.push({
+      event: n,
+      day: o,
+      dayIndex: i,
+      top: Math.max(0, u),
+      bottom: Math.min(1, l),
+      isStart: u >= 0,
+      isEnd: l <= 1
+    });
+  }
+  return s;
+}
+function w(r, t) {
+  if (r.length === 0) return null;
+  const n = r[0], s = m(r[r.length - 1]);
+  if (f(t.start, t.endExclusive) >= 0 || f(t.endExclusive, n) <= 0 || f(t.start, s) >= 0) return null;
+  const i = g(n, t.start), o = g(n, t.endExclusive) - 1;
+  return {
+    event: t,
+    startColumn: Math.max(0, i),
+    endColumn: Math.min(r.length - 1, o),
+    isStart: i >= 0,
+    isEnd: o <= r.length - 1
+  };
+}
+function F(r, t, n) {
+  if (t.length === 0 || n.endExclusive <= n.start) return null;
+  const s = a(r, t[0]), i = a(r, m(t[t.length - 1]));
+  if (n.endExclusive <= s || n.start >= i) return null;
+  let o = -1, u = -1;
+  for (let l = 0; l < t.length; l++) {
+    const e = a(r, t[l]), c = a(r, m(t[l]));
+    n.start < c && n.endExclusive > e && (o === -1 && (o = l), u = l);
+  }
+  return o === -1 ? null : {
+    event: n,
+    startColumn: o,
+    endColumn: u,
+    isStart: n.start >= s,
+    isEnd: n.endExclusive <= i
+  };
+}
+function M(r, t, n = 60) {
+  if (n <= 0) throw new Error(`slotMinutes must be positive, got ${n}`);
+  const s = a(r, t), i = a(r, m(t)) - s, o = n * 6e4, u = [], l = /* @__PURE__ */ new Set();
+  for (let e = 0; e < i; e += o) {
+    const c = s + e, p = e / i, d = S(r, c), h = `${d.hour}:${d.minute}`;
+    u.push({
+      instant: c,
+      fraction: p,
+      hour: d.hour,
+      minute: d.minute,
+      /* A fall-back day genuinely reads "1 AM" twice, and both rails are real.
+         Flagged rather than de-duplicated: hiding the second leaves an hour of
+         the column with no rail at all, which reads as a rendering fault. */
+      repeated: l.has(h)
+    }), l.add(h);
+  }
+  return u;
+}
+function I(r, t, n, s) {
+  if (s <= 0) throw new Error(`snapMinutes must be positive, got ${s}`);
+  const i = a(r, t), o = b(r, t, n), u = s * 6e4;
+  return i + Math.round((o - i) / u) * u;
+}
+const P = x;
+export {
+  w as allDayBandSegment,
+  P as dayKey,
+  M as daySlots,
+  I as snapFractionToInstant,
+  $ as timeSegments,
+  F as timedBandSegment
+};
+//# sourceMappingURL=segments.js.map

package/dist/lib/calendar/segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.js","sources":["../../../src/lib/calendar/segments.ts"],"sourcesContent":["import {\n  comparePlainDate,\n  dayFraction,\n  daysBetween,\n  instantAtFraction,\n  instantToPlainDateTime,\n  isoDateString,\n  nextDay,\n  startOfDay,\n  type Instant,\n  type PlainDate,\n  type TimeZone,\n} from \"@/lib/time\";\nimport type { AllDayEvent, CalendarEvent, TimedEvent } from \"./types\";\n\n/* ============================================================================\n   CUTTING EVENTS INTO THE PIECES A VIEW DRAWS.\n\n   An event is one object; on screen it may be six rectangles across six days,\n   the first clipped at its top and the last at its bottom. This file is the\n   only place that cut happens, and it produces the SAME two booleans for every\n   case that needs them.\n\n   CLIPPING IS TWO BOOLEANS, NOT A GLYPH. `isStart` and `isEnd` fall straight\n   out of the clamp, and week boundary, month boundary, multi-day slice and\n   \"runs off the visible hour range\" all reduce to them. A view decides what to\n   draw for a clipped edge — an arrow, a squared-off corner, nothing at all —\n   but it never has to work out THAT an edge is clipped.\n\n   VERTICAL POSITION IS A FRACTION OF THE DAY, never an hour multiplied by a row\n   height. See `zone.ts`; the whole time layer exists so this file can divide.\n   ========================================================================= */\n\n/** One day's worth of a timed event, positioned within that day's column. */\nexport interface TimeSegment {\n  readonly event: TimedEvent;\n  readonly day: PlainDate;\n  /** Index into the range's `days`, so a view can address a column directly. */\n  readonly dayIndex: number;\n  /** Fraction down the column, 0 at the day's first instant, 1 at the next day's. */\n  readonly top: number;\n  readonly bottom: number;\n  /** False when the event began before this day — draw the top edge as cut. */\n  readonly isStart: boolean;\n  /** False when the event continues past this day. */\n  readonly isEnd: boolean;\n}\n\n/** A run of whole days, for the month grid or the all-day band. */\nexport interface BandSegment {\n  readonly event: CalendarEvent;\n  /** Inclusive column index within the row. */\n  readonly startColumn: number;\n  readonly endColumn: number;\n  readonly isStart: boolean;\n  readonly isEnd: boolean;\n}\n\n/**\n * Cut a timed event into one segment per day it touches.\n *\n * `days` is a contiguous run — a week, or a single day. Days the event does not\n * touch produce nothing.\n */\nexport function timeSegments(\n  zone: TimeZone,\n  days: readonly PlainDate[],\n  event: TimedEvent,\n): TimeSegment[] {\n  const out: TimeSegment[] = [];\n  for (let dayIndex = 0; dayIndex < days.length; dayIndex++) {\n    const day = days[dayIndex];\n    const rawTop = dayFraction(zone, day, event.start);\n    const rawBottom = dayFraction(zone, day, event.endExclusive);\n\n    /* HALF-OPEN, STRICTLY. An event ending exactly at midnight ends AT the next\n       day's first instant, which means `rawBottom === 0` there — and `> 0`\n       excludes it. Written as `>=` this produces a phantom zero-height segment\n       at the top of the following day, which is the single most common\n       \"why is there a sliver on Tuesday\" bug in this class of component. */\n    if (!(rawTop < 1 && rawBottom > 0)) continue;\n\n    out.push({\n      event,\n      day,\n      dayIndex,\n      top: Math.max(0, rawTop),\n      bottom: Math.min(1, rawBottom),\n      isStart: rawTop >= 0,\n      isEnd: rawBottom <= 1,\n    });\n  }\n  return out;\n}\n\n/**\n * Where an all-day event sits within a row of days.\n *\n * `null` when it does not reach this row at all. Both `endColumn` and the\n * event's own end are handled here so no caller ever does the ±1: the model is\n * half-open (`endExclusive` is the first day NOT in the event) and a column\n * index is inclusive, so the conversion happens once, here.\n */\nexport function allDayBandSegment(\n  rowDays: readonly PlainDate[],\n  event: AllDayEvent,\n): BandSegment | null {\n  if (rowDays.length === 0) return null;\n  const first = rowDays[0];\n  const lastExclusive = nextDay(rowDays[rowDays.length - 1]);\n\n  /* Empty or inverted ranges are data errors, not something to lay out. */\n  if (comparePlainDate(event.start, event.endExclusive) >= 0) return null;\n  if (comparePlainDate(event.endExclusive, first) <= 0) return null;\n  if (comparePlainDate(event.start, lastExclusive) >= 0) return null;\n\n  const rawStart = daysBetween(first, event.start);\n  /* `-1` converts the exclusive end into an inclusive column. The ONE place. */\n  const rawEnd = daysBetween(first, event.endExclusive) - 1;\n\n  return {\n    event,\n    startColumn: Math.max(0, rawStart),\n    endColumn: Math.min(rowDays.length - 1, rawEnd),\n    isStart: rawStart >= 0,\n    isEnd: rawEnd <= rowDays.length - 1,\n  };\n}\n\n/**\n * Where a TIMED event sits within a row of days, as whole columns.\n *\n * The month grid draws timed events as chips in a day cell, so a timed event\n * that crosses midnight occupies both cells and needs the same clipping\n * booleans an all-day bar does.\n */\nexport function timedBandSegment(\n  zone: TimeZone,\n  rowDays: readonly PlainDate[],\n  event: TimedEvent,\n): BandSegment | null {\n  if (rowDays.length === 0) return null;\n  if (event.endExclusive <= event.start) return null;\n\n  const rowStart = startOfDay(zone, rowDays[0]);\n  const rowEnd = startOfDay(zone, nextDay(rowDays[rowDays.length - 1]));\n  if (event.endExclusive <= rowStart || event.start >= rowEnd) return null;\n\n  let startColumn = -1;\n  let endColumn = -1;\n  for (let i = 0; i < rowDays.length; i++) {\n    const dayStart = startOfDay(zone, rowDays[i]);\n    const dayEnd = startOfDay(zone, nextDay(rowDays[i]));\n    if (event.start < dayEnd && event.endExclusive > dayStart) {\n      if (startColumn === -1) startColumn = i;\n      endColumn = i;\n    }\n  }\n  if (startColumn === -1) return null;\n\n  return {\n    event,\n    startColumn,\n    endColumn,\n    isStart: event.start >= rowStart,\n    isEnd: event.endExclusive <= rowEnd,\n  };\n}\n\n/* ------------------------------------------------------------------ slots --- */\n\n/** One horizontal rail in the time grid, and the wall time it is labelled by. */\nexport interface DaySlot {\n  readonly instant: Instant;\n  /** Position down the column, 0–1. */\n  readonly fraction: number;\n  /** 0–23. On a fall-back day one value appears TWICE — see below. */\n  readonly hour: number;\n  readonly minute: number;\n  /** True for the second of a repeated reading, so a view can mark it. */\n  readonly repeated: boolean;\n}\n\n/**\n * The rails for one day, generated by WALKING WALL-CLOCK TIME through the zone.\n *\n * NOT by dividing the column into 24. That is the difference between a\n * fall-back day showing **25 rails with 1 AM twice** — which is what the clock\n * on the wall actually did — and showing 24 evenly spaced labels that are each\n * an hour wrong after 02:00.\n *\n * Walking forward by real elapsed time and reading the clock at each step is\n * also what makes the 30-minute zone fall out for free: Lord Howe's short day\n * produces 23 hourly rails and a half-hour remainder, with no branch.\n */\nexport function daySlots(zone: TimeZone, day: PlainDate, slotMinutes = 60): DaySlot[] {\n  if (slotMinutes <= 0) throw new Error(`slotMinutes must be positive, got ${slotMinutes}`);\n\n  const from = startOfDay(zone, day);\n  const length = startOfDay(zone, nextDay(day)) - from;\n  const step = slotMinutes * 60_000;\n\n  const out: DaySlot[] = [];\n  const seen = new Set<string>();\n\n  for (let elapsed = 0; elapsed < length; elapsed += step) {\n    const instant = from + elapsed;\n    const fraction = elapsed / length;\n    const wall = instantToPlainDateTime(zone, instant);\n    const label = `${wall.hour}:${wall.minute}`;\n    out.push({\n      instant,\n      fraction,\n      hour: wall.hour,\n      minute: wall.minute,\n      /* A fall-back day genuinely reads \"1 AM\" twice, and both rails are real.\n         Flagged rather than de-duplicated: hiding the second leaves an hour of\n         the column with no rail at all, which reads as a rendering fault. */\n      repeated: seen.has(label),\n    });\n    seen.add(label);\n  }\n  return out;\n}\n\n/* ------------------------------------------------------------- hit testing --- */\n\n/**\n * The instant a pointer at `fraction` down `day`'s column is over, snapped.\n *\n * SNAP IS A HIT-CHANGE, NOT COORDINATE ROUNDING, and the difference is what the\n * gesture feels like. Resolving which slot the pointer is IN and only reacting\n * when that slot changes makes the preview jump discretely between positions,\n * and **that discreteness IS the feedback** — a preview that tracks the pointer\n * continuously and rounds on drop reads as mushy and imprecise.\n *\n * `snapMinutes` is deliberately independent of the rail spacing. FullCalendar,\n * react-big-calendar and Schedule-X all couple them; Google and Mobiscroll do\n * not, and **Google is 15-minute snap on 60-minute rails**, which is the\n * combination that feels right. Retrofitting the split is a rewrite, so the two\n * are separate values from the first commit.\n */\nexport function snapFractionToInstant(\n  zone: TimeZone,\n  day: PlainDate,\n  fraction: number,\n  snapMinutes: number,\n): Instant {\n  if (snapMinutes <= 0) throw new Error(`snapMinutes must be positive, got ${snapMinutes}`);\n  const from = startOfDay(zone, day);\n  const raw = instantAtFraction(zone, day, fraction);\n  const step = snapMinutes * 60_000;\n  /* Snapped against the DAY'S OWN START, not against midnight and not against\n     the epoch. On a day that begins at 01:00 — Havana in March — snapping to\n     the epoch puts every slot boundary an hour off the rails being drawn. */\n  return from + Math.round((raw - from) / step) * step;\n}\n\n/** Stable key for a day, for maps and React keys. */\nexport const dayKey = isoDateString;\n"],"names":["timeSegments","zone","days","event","out","dayIndex","day","rawTop","dayFraction","rawBottom","allDayBandSegment","rowDays","first","lastExclusive","nextDay","comparePlainDate","rawStart","daysBetween","rawEnd","timedBandSegment","rowStart","startOfDay","rowEnd","startColumn","endColumn","i","dayStart","dayEnd","daySlots","slotMinutes","from","length","step","seen","elapsed","instant","fraction","wall","instantToPlainDateTime","label","snapFractionToInstant","snapMinutes","raw","instantAtFraction","dayKey","isoDateString"],"mappings":"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"}

package/dist/lib/calendar/types.js

@@ -0,0 +1,7 @@
+function a(l) {
+  return l.allDay;
+}
+export {
+  a as isAllDay
+};
+//# sourceMappingURL=types.js.map

package/dist/lib/calendar/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../src/lib/calendar/types.ts"],"sourcesContent":["import type { CalendarDuration, Instant, PlainDate, TimeZone } from \"@/lib/time/types\";\n\n/* ============================================================================\n   THE EVENT MODEL.\n\n   Four decisions here are load-bearing and none of them can be retrofitted\n   cheaply. Each is stated where the field is declared; collected here so the\n   shape is legible at a glance:\n\n     1. END IS EXCLUSIVE, and the field says so in its name.\n     2. AN ALL-DAY EVENT CARRIES NO ZONE. It is a pair of calendar dates.\n     3. `seriesId` + `originalStart` EXIST FROM THE FIRST COMMIT, even though\n        recurrence expansion is not in v1.\n     4. A DRAG IN PROGRESS IS A DELTA, never a rewritten event.\n   ========================================================================= */\n\nexport type CalendarEventId = string;\n\ninterface EventCommon {\n  readonly id: CalendarEventId;\n  readonly title: string;\n\n  /**\n   * Which series this occurrence belongs to, if any.\n   *\n   * PRESENT FROM THE FIRST COMMIT ALTHOUGH RECURRENCE SHIPS LATER, because\n   * this is the half that cannot be added afterwards. The moment any real data\n   * exists, backfilling series identity onto rows that never had it is a\n   * migration nobody can write correctly — there is no way to tell, later,\n   * which of two identical Tuesday stand-ups belonged to which series.\n   */\n  readonly seriesId?: string;\n\n  /**\n   * A short human label for the calendar this event came from, rendered ON the\n   * chip.\n   *\n   * NOT decoration, and not satisfied by a legend. Colour-coding is only\n   * conforming when the information it carries is also available another way,\n   * and the remedy has to sit on the coded item itself — a key elsewhere on the\n   * page requires the reader to hold a colour in their head and go looking.\n   */\n  readonly calendarLabel?: string;\n\n  /** A key into the calendar's palette. Never a raw colour — see `EventPalette`. */\n  readonly paletteKey?: string;\n\n  /**\n   * Whether this event may be dragged, resized, or otherwise moved.\n   *\n   * Defaults to editable at the calendar level, not here: an undefined value\n   * means \"ask the calendar\", and only an explicit `false` pins one event down\n   * while its neighbours stay live.\n   */\n  readonly editable?: boolean;\n\n  /** Anything the consumer wants back in a render prop or an event handler. */\n  readonly data?: unknown;\n}\n\n/**\n * An event with a time of day, anchored to a real instant.\n *\n * Both ends are `Instant`s, so the event means the same moment regardless of\n * which zone renders it. A meeting at 09:00 in New York is at 14:00 in London\n * and both are the same event; storing wall-clock fields instead makes it two\n * different events that happen to be spelled alike.\n */\nexport interface TimedEvent extends EventCommon {\n  readonly allDay: false;\n  readonly start: Instant;\n\n  /**\n   * The first instant NOT in the event. Half-open: `start <= t < endExclusive`.\n   *\n   * THE NAME IS THE DOCUMENTATION, deliberately. Half-open intervals make\n   * `duration = end - start` correct, make adjacent events provably\n   * non-overlapping, and make every algorithm in the layout core fall out\n   * without a `+1` anywhere — overlap is `aStart < bEnd && bStart < aEnd`, with\n   * no special case for two events that merely touch.\n   *\n   * The cost is the most-reported bug in calendar interoperability: a\n   * one-day event stored as 23rd → 24th renders as two days in any consumer\n   * that reads the end as inclusive. So the ±1 conversion happens in exactly\n   * TWO places — the display formatter and the date-picker binding — and the\n   * field is named so that nobody has to remember which convention this is.\n   */\n  readonly endExclusive: Instant;\n\n  /**\n   * The start this occurrence had when the series first produced it.\n   *\n   * THE PERMANENT JOIN KEY FOR AN OVERRIDE, and the single most common\n   * recurrence-model mistake is keying by the CURRENT start instead. Do that\n   * and the override becomes unjoinable the moment somebody drags the event:\n   * the series still generates an occurrence at the original time, the\n   * override now claims a different one, and the calendar shows both.\n   *\n   * Set once, never updated. Absent on an event that is not part of a series.\n   */\n  readonly originalStart?: Instant;\n}\n\n/**\n * An event that occupies whole days.\n *\n * IT CARRIES NO ZONE, AND THAT IS THE POINT. A birthday is on the 4th of March\n * everywhere; model it as an instant and it moves to the 3rd for anyone far\n * enough west. `PlainDate` has no offset to be wrong about.\n */\nexport interface AllDayEvent extends EventCommon {\n  readonly allDay: true;\n  readonly start: PlainDate;\n\n  /** The first day NOT in the event — same half-open rule as `TimedEvent`. */\n  readonly endExclusive: PlainDate;\n\n  /** See `TimedEvent.originalStart`. A date, because an all-day event has no time. */\n  readonly originalStart?: PlainDate;\n}\n\nexport type CalendarEvent = TimedEvent | AllDayEvent;\n\n/** Narrowing helper, so consumers never test `allDay` by hand. */\nexport function isAllDay(event: CalendarEvent): event is AllDayEvent {\n  return event.allDay;\n}\n\n/* ------------------------------------------------------------------ drafts --- */\n\n/** Which part of an event a gesture is moving. */\nexport type DragKind = \"move\" | \"resize-start\" | \"resize-end\" | \"create\";\n\n/**\n * A gesture in progress, as a DELTA against the committed event.\n *\n * NEVER A REWRITTEN COPY OF THE EVENT, and never a reference to one. Two real\n * failures from other calendars' trackers, both of which this shape makes\n * impossible:\n *\n *   A re-render replaces the event store mid-drag, and the drag is left holding\n *   an instance from the store that no longer exists — so the drop writes stale\n *   values over fresh ones.\n *\n *   A concurrent update arrives from a server during a drag and the times end\n *   up DUPLICATED, because a snapshot taken at pointer-down was composited on\n *   top of data that had moved underneath it.\n *\n * A delta keyed by id composes instead of clobbering: whatever the event says\n * at the moment of the drop, the gesture's meaning is \"two hours later than\n * that\", and a change arriving underneath is respected rather than overwritten.\n *\n * `delta` IS A CALENDAR DURATION, not a number of milliseconds — see\n * `CalendarDuration`. Dragging across a spring-forward boundary must preserve\n * the wall-clock time, and a millisecond delta cannot express that.\n */\nexport interface EventDraft {\n  readonly id: CalendarEventId;\n  readonly kind: DragKind;\n  readonly delta: CalendarDuration;\n}\n\n/* ----------------------------------------------------------------- palette --- */\n\n/**\n * One swatch, with its text colour ALREADY PAIRED and verified.\n *\n * WHY NOT COMPUTE THE TEXT COLOUR. The familiar trick — measure the fill's\n * luminance and flip to black or white — fails in a band in the middle where\n * NEITHER clears AA against the fill. The threshold is also not 0.5: it is\n * around 0.38, and implementations that use 0.5 pick white on colours that\n * needed black. Google ships two entire palettes (\"white text\" and \"black\n * text\") rather than compute a flip, which is the same conclusion arrived at\n * from the other direction.\n *\n * So the palette is curated, each pair is measured, and a consumer supplying\n * arbitrary hex gets a documented refusal rather than an unreadable chip.\n */\n/** The eight swatch keys. Each one's spoken name is a built-in string (`calendar.colors`), so colour is never the only cue. */\nexport type PaletteKey = \"iris\" | \"aqua\" | \"mint\" | \"amber\" | \"rose\" | \"azure\" | \"orchid\" | \"slate\";\n\nexport interface PaletteEntry {\n  readonly key: PaletteKey;\n  readonly fill: string;\n  readonly text: string;\n  /** Border and left-edge accent; darker than `fill`, still AA against it. */\n  readonly edge: string;\n}\n\nexport type EventPalette = readonly PaletteEntry[];\n\n/* -------------------------------------------------------------- view range --- */\n\nexport type CalendarView = \"day\" | \"week\" | \"month\";\n\n/**\n * The days a view is currently showing, and the zone it is showing them in.\n *\n * `days` is EXPLICIT rather than a start/end pair, because a month grid's days\n * are not a contiguous range in any useful sense — they cross two month\n * boundaries and the layout core needs to address them positionally.\n */\nexport interface VisibleRange {\n  readonly view: CalendarView;\n  readonly zone: TimeZone;\n  readonly days: readonly PlainDate[];\n  /** 0 = Sunday. Carried on the range so the packers never have to guess. */\n  readonly weekStartsOn: number;\n}\n"],"names":["isAllDay","event"],"mappings":"AA4HO,SAASA,EAASC,GAA4C;AACnE,SAAOA,EAAM;AACf;"}

package/dist/lib/chart-palette.js

@@ -0,0 +1,27 @@
+const o = 8, c = [
+  "--chart-1",
+  "--chart-2",
+  "--chart-3",
+  "--chart-4",
+  "--chart-5",
+  "--chart-6",
+  "--chart-7",
+  "--chart-8"
+], e = "--chart-seq";
+function a(r) {
+  const t = c[r];
+  if (!Number.isInteger(r) || t === void 0)
+    throw new Error(
+      `chartSeriesColor: there are 8 categorical hues (index 0-7); got ${r}. Fold the rest into "Other".`
+    );
+  return `var(${t})`;
+}
+const h = `var(${e})`;
+export {
+  h as CHART_SEQUENTIAL_COLOR,
+  e as CHART_SEQUENTIAL_TOKEN,
+  o as CHART_SERIES_COUNT,
+  c as CHART_SERIES_TOKENS,
+  a as chartSeriesColor
+};
+//# sourceMappingURL=chart-palette.js.map

package/dist/lib/chart-palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-palette.js","sources":["../../src/lib/chart-palette.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   THE CHART PALETTE, AS DATA (DX-3963) — the token names any chart reads.\n\n   The values live in `styles/chart-palette.css`, one set per theme and per\n   contrast level; this module is only the NAMES, so a chart component, a\n   consumer's own SVG and a test all say `chartSeriesColor(2)` instead of each\n   spelling `var(--chart-3)` by hand. React-free on purpose (exported from\n   `@50arms/ui/pure`): a server-rendered report or a non-React surface reads\n   the same names.\n   -------------------------------------------------------------------------- */\n\n/** How many categorical hues exist. A 9th series is never a 9th hue: it folds into \"Other\". */\nexport const CHART_SERIES_COUNT = 8;\n\n/** The eight categorical tokens, in the fixed order series are assigned. */\nexport const CHART_SERIES_TOKENS = [\n  \"--chart-1\",\n  \"--chart-2\",\n  \"--chart-3\",\n  \"--chart-4\",\n  \"--chart-5\",\n  \"--chart-6\",\n  \"--chart-7\",\n  \"--chart-8\",\n] as const;\n\n/** The one sequential hue: a single series of magnitudes (a ranked bar list). */\nexport const CHART_SEQUENTIAL_TOKEN = \"--chart-seq\" as const;\n\n/**\n * The CSS colour for the series at zero-based `index` — `var(--chart-1)` for\n * index 0. Throws past the eighth: a ninth series is folded into \"Other\" by\n * the caller, never given a generated hue.\n */\nexport function chartSeriesColor(index: number): string {\n  const token = CHART_SERIES_TOKENS[index];\n  if (!Number.isInteger(index) || token === undefined) {\n    throw new Error(\n      `chartSeriesColor: there are ${CHART_SERIES_COUNT} categorical hues (index 0-${CHART_SERIES_COUNT - 1}); got ${index}. Fold the rest into \"Other\".`,\n    );\n  }\n  return `var(${token})`;\n}\n\n/** The CSS colour of the sequential hue. */\nexport const CHART_SEQUENTIAL_COLOR = `var(${CHART_SEQUENTIAL_TOKEN})`;\n"],"names":["CHART_SERIES_COUNT","CHART_SERIES_TOKENS","CHART_SEQUENTIAL_TOKEN","chartSeriesColor","index","token","CHART_SEQUENTIAL_COLOR"],"mappings":"AAYO,MAAMA,IAAqB,GAGrBC,IAAsB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAGaC,IAAyB;AAO/B,SAASC,EAAiBC,GAAuB;AACtD,QAAMC,IAAQJ,EAAoBG,CAAK;AACvC,MAAI,CAAC,OAAO,UAAUA,CAAK,KAAKC,MAAU;AACxC,UAAM,IAAI;AAAA,MACR,mEAA+GD,CAAK;AAAA,IAAA;AAGxH,SAAO,OAAOC,CAAK;AACrB;AAGO,MAAMC,IAAyB,OAAOJ,CAAsB;"}

package/dist/lib/clipboard.js

@@ -0,0 +1,30 @@
+async function l(n) {
+  if (typeof navigator < "u" && navigator.clipboard?.writeText)
+    try {
+      await navigator.clipboard.writeText(n);
+      return;
+    } catch {
+    }
+  if (typeof document > "u" || typeof document.execCommand != "function")
+    throw new Error("Clipboard copy failed: no clipboard API and no execCommand fallback available.");
+  const c = document.activeElement, t = document.getSelection?.(), a = [];
+  if (t)
+    for (let o = 0; o < t.rangeCount; o++)
+      a.push(t.getRangeAt(o).cloneRange());
+  const e = document.createElement("textarea");
+  e.value = n, e.setAttribute("readonly", ""), e.style.position = "fixed", e.style.top = "0", e.style.left = "0", e.style.width = "1px", e.style.height = "1px", e.style.padding = "0", e.style.border = "none", e.style.outline = "none", e.style.boxShadow = "none", e.style.background = "transparent", e.style.opacity = "0", document.body.appendChild(e);
+  try {
+    if (e.focus(), e.select(), e.setSelectionRange(0, e.value.length), !document.execCommand("copy"))
+      throw new Error("Clipboard copy failed: document.execCommand('copy') returned false.");
+  } finally {
+    if (document.body.removeChild(e), t) {
+      t.removeAllRanges();
+      for (const o of a) t.addRange(o);
+    }
+    c?.focus?.();
+  }
+}
+export {
+  l as copyText
+};
+//# sourceMappingURL=clipboard.js.map

package/dist/lib/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","sources":["../../src/lib/clipboard.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   COPYING TEXT TO THE OS CLIPBOARD — THE FALLBACK IS ENVIRONMENTAL, NOT\n   DEFENSIVE, in the same spirit as `code-editor/editing.ts`'s documented\n   `execCommand(\"insertText\")` rationale.\n\n   DX-3661: the operator saw \"Could not copy PLAN-11 — Your browser blocked\n   clipboard access\" in the Claude Code desktop in-app browser, while the same\n   copy worked in desktop Chrome and on a phone. Verified live there\n   (isSecureContext true, `navigator.clipboard` present):\n     - `navigator.permissions.query({name:'clipboard-write'})` returned\n       `denied`.\n     - `navigator.clipboard.writeText(...)` threw\n       `NotAllowedError: Write permission denied.`\n     - The SAME click handler, after that await, ran\n       `document.execCommand('copy')` on a selected hidden textarea. It\n       returned `true`, and the OS clipboard held the copied text afterward.\n\n   So: try the async Clipboard API first (it is the correct, modern API and\n   works everywhere else); when it is absent OR rejects, fall back to a\n   hidden, selected `<textarea>` plus `document.execCommand('copy')`,\n   restoring whatever selection/focus was active before. Reject only when\n   BOTH methods fail — that is a genuine, unrecoverable copy failure, and\n   callers (e.g. a \"Could not copy\" toast) should still see it.\n   -------------------------------------------------------------------------- */\n\n/**\n * Copy `text` to the OS clipboard.\n *\n * Tries `navigator.clipboard.writeText` first. If that API is unavailable or\n * rejects (e.g. permission denied, as in the Claude Code desktop in-app\n * browser — DX-3661), falls back to selecting a hidden `<textarea>` and\n * running `document.execCommand('copy')`, restoring the document's prior\n * selection and focused element afterward.\n *\n * Rejects only when both the async API and the fallback fail.\n */\nexport async function copyText(text: string): Promise<void> {\n  if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n    try {\n      await navigator.clipboard.writeText(text);\n      return;\n    } catch {\n      // Fall through to the execCommand fallback below — see file header.\n    }\n  }\n\n  if (typeof document === \"undefined\" || typeof document.execCommand !== \"function\") {\n    throw new Error(\"Clipboard copy failed: no clipboard API and no execCommand fallback available.\");\n  }\n\n  const previouslyFocused = document.activeElement as HTMLElement | null;\n  const selection = document.getSelection?.();\n  const priorRanges: Range[] = [];\n  if (selection) {\n    for (let i = 0; i < selection.rangeCount; i++) {\n      priorRanges.push(selection.getRangeAt(i).cloneRange());\n    }\n  }\n\n  const textarea = document.createElement(\"textarea\");\n  textarea.value = text;\n  // Keep it out of the visible/interactive document without affecting layout\n  // or being skipped by `execCommand`, which needs the element focusable and\n  // its content selected.\n  textarea.setAttribute(\"readonly\", \"\");\n  textarea.style.position = \"fixed\";\n  textarea.style.top = \"0\";\n  textarea.style.left = \"0\";\n  textarea.style.width = \"1px\";\n  textarea.style.height = \"1px\";\n  textarea.style.padding = \"0\";\n  textarea.style.border = \"none\";\n  textarea.style.outline = \"none\";\n  textarea.style.boxShadow = \"none\";\n  textarea.style.background = \"transparent\";\n  textarea.style.opacity = \"0\";\n\n  document.body.appendChild(textarea);\n  try {\n    textarea.focus();\n    textarea.select();\n    textarea.setSelectionRange(0, textarea.value.length);\n\n    const ok = document.execCommand(\"copy\");\n    if (!ok) {\n      throw new Error(\"Clipboard copy failed: document.execCommand('copy') returned false.\");\n    }\n  } finally {\n    document.body.removeChild(textarea);\n\n    if (selection) {\n      selection.removeAllRanges();\n      for (const range of priorRanges) selection.addRange(range);\n    }\n    previouslyFocused?.focus?.();\n  }\n}\n"],"names":["copyText","text","previouslyFocused","selection","priorRanges","i","textarea","range"],"mappings":"AAoCA,eAAsBA,EAASC,GAA6B;AAC1D,MAAI,OAAO,YAAc,OAAe,UAAU,WAAW;AAC3D,QAAI;AACF,YAAM,UAAU,UAAU,UAAUA,CAAI;AACxC;AAAA,IACF,QAAQ;AAAA,IAER;AAGF,MAAI,OAAO,WAAa,OAAe,OAAO,SAAS,eAAgB;AACrE,UAAM,IAAI,MAAM,gFAAgF;AAGlG,QAAMC,IAAoB,SAAS,eAC7BC,IAAY,SAAS,eAAA,GACrBC,IAAuB,CAAA;AAC7B,MAAID;AACF,aAASE,IAAI,GAAGA,IAAIF,EAAU,YAAYE;AACxC,MAAAD,EAAY,KAAKD,EAAU,WAAWE,CAAC,EAAE,YAAY;AAIzD,QAAMC,IAAW,SAAS,cAAc,UAAU;AAClD,EAAAA,EAAS,QAAQL,GAIjBK,EAAS,aAAa,YAAY,EAAE,GACpCA,EAAS,MAAM,WAAW,SAC1BA,EAAS,MAAM,MAAM,KACrBA,EAAS,MAAM,OAAO,KACtBA,EAAS,MAAM,QAAQ,OACvBA,EAAS,MAAM,SAAS,OACxBA,EAAS,MAAM,UAAU,KACzBA,EAAS,MAAM,SAAS,QACxBA,EAAS,MAAM,UAAU,QACzBA,EAAS,MAAM,YAAY,QAC3BA,EAAS,MAAM,aAAa,eAC5BA,EAAS,MAAM,UAAU,KAEzB,SAAS,KAAK,YAAYA,CAAQ;AAClC,MAAI;AAMF,QALAA,EAAS,MAAA,GACTA,EAAS,OAAA,GACTA,EAAS,kBAAkB,GAAGA,EAAS,MAAM,MAAM,GAG/C,CADO,SAAS,YAAY,MAAM;AAEpC,YAAM,IAAI,MAAM,qEAAqE;AAAA,EAEzF,UAAA;AAGE,QAFA,SAAS,KAAK,YAAYA,CAAQ,GAE9BH,GAAW;AACb,MAAAA,EAAU,gBAAA;AACV,iBAAWI,KAASH,EAAa,CAAAD,EAAU,SAASI,CAAK;AAAA,IAC3D;AACA,IAAAL,GAAmB,QAAA;AAAA,EACrB;AACF;"}

package/dist/lib/cn.js

@@ -0,0 +1,9 @@
+import { clsx as o } from "clsx";
+import { twMerge as t } from "tailwind-merge";
+function n(...r) {
+  return t(o(r));
+}
+export {
+  n as cn
+};
+//# sourceMappingURL=cn.js.map

package/dist/lib/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.js","sources":["../../src/lib/cn.ts"],"sourcesContent":["import { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\n/**\n * Merge conditional class names, resolving Tailwind conflicts last-wins.\n * Every component funnels its class composition through this so a consumer's\n * `className` always beats the component's own defaults.\n */\nexport function cn(...inputs: ClassValue[]): string {\n  return twMerge(clsx(inputs));\n}\n"],"names":["cn","inputs","twMerge","clsx"],"mappings":";;AAQO,SAASA,KAAMC,GAA8B;AAClD,SAAOC,EAAQC,EAAKF,CAAM,CAAC;AAC7B;"}

package/dist/lib/color.js

@@ -0,0 +1,24 @@
+const u = /^#[0-9a-f]{6}$/i;
+function h(t) {
+  return u.test(t);
+}
+const f = (t) => Math.min(1, Math.max(0, t));
+function m(t) {
+  if (!h(t)) throw new Error(`hexToHsv: "${t}" is not a #rrggbb colour`);
+  const r = parseInt(t.slice(1, 3), 16) / 255, a = parseInt(t.slice(3, 5), 16) / 255, c = parseInt(t.slice(5, 7), 16) / 255, o = Math.max(r, a, c), s = o - Math.min(r, a, c);
+  let n = 0;
+  return s !== 0 && (o === r ? n = (a - c) / s % 6 : o === a ? n = (c - r) / s + 2 : n = (r - a) / s + 4, n *= 60, n < 0 && (n += 360)), { h: n, s: o === 0 ? 0 : s / o, v: o };
+}
+function M({ h: t, s: r, v: a }) {
+  const c = (t % 360 + 360) % 360 / 60, o = f(r), s = f(a), n = (i) => {
+    const l = (i + c) % 6;
+    return s - s * o * Math.max(0, Math.min(l, 4 - l, 1));
+  }, e = (i) => Math.round(i * 255).toString(16).padStart(2, "0");
+  return `#${e(n(5))}${e(n(3))}${e(n(1))}`;
+}
+export {
+  m as hexToHsv,
+  M as hsvToHex,
+  h as isHexColor
+};
+//# sourceMappingURL=color.js.map

package/dist/lib/color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.js","sources":["../../src/lib/color.ts"],"sourcesContent":["/* DXUI-28 — the colour maths behind `ColorPicker`, kept React-free so a consumer (and the tests)\n   can use it on its own. A colour is always a `#rrggbb` string at the boundary; the picker works\n   in HSV because its two surfaces (saturation/brightness area, hue slider) are HSV axes. */\n\nexport interface Hsv {\n  /** Hue in degrees, `[0, 360)` from `hexToHsv`. `hsvToHex` also accepts 360, the same colour as 0. */\n  h: number;\n  /** Saturation, `0..1`. */\n  s: number;\n  /** Brightness (value), `0..1`. */\n  v: number;\n}\n\nconst HEX = /^#[0-9a-f]{6}$/i;\n\n/** True for exactly `#rrggbb` (either case); shorthand `#rgb` and alpha forms are not accepted. */\nexport function isHexColor(value: string): boolean {\n  return HEX.test(value);\n}\n\nconst clamp01 = (n: number) => Math.min(1, Math.max(0, n));\n\n/** `#rrggbb` to HSV. Throws on anything else: a stored colour that is not a hex is a caller bug, never defaulted. */\nexport function hexToHsv(hex: string): Hsv {\n  if (!isHexColor(hex)) throw new Error(`hexToHsv: \"${hex}\" is not a #rrggbb colour`);\n  const r = parseInt(hex.slice(1, 3), 16) / 255;\n  const g = parseInt(hex.slice(3, 5), 16) / 255;\n  const b = parseInt(hex.slice(5, 7), 16) / 255;\n  const max = Math.max(r, g, b);\n  const delta = max - Math.min(r, g, b);\n  let h = 0;\n  if (delta !== 0) {\n    if (max === r) h = ((g - b) / delta) % 6;\n    else if (max === g) h = (b - r) / delta + 2;\n    else h = (r - g) / delta + 4;\n    h *= 60;\n    if (h < 0) h += 360;\n  }\n  return { h, s: max === 0 ? 0 : delta / max, v: max };\n}\n\n/** HSV to lowercase `#rrggbb`. Components outside range are clamped (hue wraps). */\nexport function hsvToHex({ h, s, v }: Hsv): string {\n  const hue = (((h % 360) + 360) % 360) / 60;\n  const sat = clamp01(s);\n  const val = clamp01(v);\n  const f = (n: number) => {\n    const k = (n + hue) % 6;\n    return val - val * sat * Math.max(0, Math.min(k, 4 - k, 1));\n  };\n  const byte = (x: number) => Math.round(x * 255).toString(16).padStart(2, \"0\");\n  return `#${byte(f(5))}${byte(f(3))}${byte(f(1))}`;\n}\n"],"names":["HEX","isHexColor","value","clamp01","n","hexToHsv","hex","g","b","max","delta","h","hsvToHex","s","v","hue","sat","val","f","k","byte","x"],"mappings":"AAaA,MAAMA,IAAM;AAGL,SAASC,EAAWC,GAAwB;AACjD,SAAOF,EAAI,KAAKE,CAAK;AACvB;AAEA,MAAMC,IAAU,CAACC,MAAc,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGA,CAAC,CAAC;AAGlD,SAASC,EAASC,GAAkB;AACzC,MAAI,CAACL,EAAWK,CAAG,SAAS,IAAI,MAAM,cAAcA,CAAG,2BAA2B;AAClF,QAAM,IAAI,SAASA,EAAI,MAAM,GAAG,CAAC,GAAG,EAAE,IAAI,KACpCC,IAAI,SAASD,EAAI,MAAM,GAAG,CAAC,GAAG,EAAE,IAAI,KACpCE,IAAI,SAASF,EAAI,MAAM,GAAG,CAAC,GAAG,EAAE,IAAI,KACpCG,IAAM,KAAK,IAAI,GAAGF,GAAGC,CAAC,GACtBE,IAAQD,IAAM,KAAK,IAAI,GAAGF,GAAGC,CAAC;AACpC,MAAIG,IAAI;AACR,SAAID,MAAU,MACRD,MAAQ,IAAGE,KAAMJ,IAAIC,KAAKE,IAAS,IAC9BD,MAAQF,IAAGI,KAAKH,IAAI,KAAKE,IAAQ,IACrCC,KAAK,IAAIJ,KAAKG,IAAQ,GAC3BC,KAAK,IACDA,IAAI,MAAGA,KAAK,OAEX,EAAE,GAAAA,GAAG,GAAGF,MAAQ,IAAI,IAAIC,IAAQD,GAAK,GAAGA,EAAA;AACjD;AAGO,SAASG,EAAS,EAAE,GAAAD,GAAG,GAAAE,GAAG,GAAAC,KAAkB;AACjD,QAAMC,KAASJ,IAAI,MAAO,OAAO,MAAO,IAClCK,IAAMb,EAAQU,CAAC,GACfI,IAAMd,EAAQW,CAAC,GACfI,IAAI,CAACd,MAAc;AACvB,UAAMe,KAAKf,IAAIW,KAAO;AACtB,WAAOE,IAAMA,IAAMD,IAAM,KAAK,IAAI,GAAG,KAAK,IAAIG,GAAG,IAAIA,GAAG,CAAC,CAAC;AAAA,EAC5D,GACMC,IAAO,CAACC,MAAc,KAAK,MAAMA,IAAI,GAAG,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC5E,SAAO,IAAID,EAAKF,EAAE,CAAC,CAAC,CAAC,GAAGE,EAAKF,EAAE,CAAC,CAAC,CAAC,GAAGE,EAAKF,EAAE,CAAC,CAAC,CAAC;AACjD;"}