gridsmith-ui 0.26.0 → 0.27.0

package/dist/utils.js

@@ -1,3 +1,877 @@
-export { ACTIVE_RING, FOCUS_RING, FOCUS_WITHIN_RING, GLASS_BACKDROP, GLASS_DROPDOWN, GLASS_OVERLAY, GLASS_SURFACE, HAS_FOCUS_RING, cn } from './chunk-M2QRNBDQ.js';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+// ../../showcase/src/lib/utils.ts
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var GLASS_BACKDROP = "[backdrop-filter:var(--ds-glass-filter)] [-webkit-backdrop-filter:var(--ds-glass-filter)]";
+var GLASS_SURFACE = `${GLASS_BACKDROP} shadow-[var(--ds-shadow-card),var(--ds-glass-inset)]`;
+var GLASS_OVERLAY = `${GLASS_BACKDROP} shadow-[var(--ds-shadow-modal),var(--ds-glass-inset)]`;
+var GLASS_DROPDOWN = `${GLASS_BACKDROP} shadow-[var(--ds-shadow-dropdown),var(--ds-glass-inset)]`;
+var ACTIVE_RING = "border-[var(--ds-border-focus)] ring-2 ring-[var(--ds-ring-active)]";
+var FOCUS_RING = "focus-visible:outline-none focus-visible:border-[var(--ds-border-focus)] focus-visible:ring-2 focus-visible:ring-[var(--ds-ring-active)]";
+var FOCUS_WITHIN_RING = "focus-within:border-[var(--ds-border-focus)] focus-within:ring-2 focus-within:ring-[var(--ds-ring-active)]";
+var HAS_FOCUS_RING = "has-[:focus-visible]:border-[var(--ds-border-focus)] has-[:focus-visible]:ring-2 has-[:focus-visible]:ring-[var(--ds-ring-active)]";
+
+// ../../showcase/src/lib/format-locale.ts
+var last = null;
+var FIXED_FORM = "en";
+function formatLocale() {
+  if (typeof document === "undefined") return FIXED_FORM;
+  const page = document.documentElement.lang?.trim();
+  if (!page) return void 0;
+  return localeFor(page, browserLanguages());
+}
+function browserLanguages() {
+  if (typeof navigator === "undefined") return [];
+  return navigator.languages?.length ? navigator.languages : navigator.language ? [navigator.language] : [];
+}
+function localeFor(page, spoken) {
+  const key = `${page}|${spoken.join(",")}`;
+  if (last?.key !== key) last = { key, locale: choose(page, spoken) };
+  return last.locale;
+}
+function localeChoice(lang, acceptLanguage) {
+  const page = lang?.trim() || FIXED_FORM;
+  const spoken = acceptedLanguages(acceptLanguage);
+  return { lang: page, spoken, hasHeader: !!acceptLanguage, server: localeFor(page, spoken) ?? FIXED_FORM };
+}
+function requestLocale(lang, acceptLanguage) {
+  return localeChoice(lang, acceptLanguage).server;
+}
+var MAX_LANGUAGES = 20;
+function acceptedLanguages(header) {
+  if (!header) return [];
+  const read = [];
+  header.split(",").slice(0, MAX_LANGUAGES).forEach((part, at) => {
+    const [tag, ...params] = part.trim().split(";");
+    const name = tag?.trim();
+    if (!name || name === "*") return;
+    const qParam = params.map((p) => p.trim()).find((p) => /^q=/i.test(p));
+    const q = qParam ? Number(qParam.slice(2)) : 1;
+    if (!(q > 0)) return;
+    read.push({ tag: name, q, at });
+  });
+  return read.sort((a, b) => b.q - a.q || a.at - b.at).map((r) => r.tag);
+}
+function writtenIn(tag) {
+  try {
+    const locale = new Intl.Locale(tag).maximize();
+    return `${locale.language}-${locale.script ?? ""}`;
+  } catch {
+    return null;
+  }
+}
+function plainTag(tag) {
+  try {
+    const locale = new Intl.Locale(tag);
+    return [locale.language, locale.script, locale.region].filter(Boolean).join("-");
+  } catch {
+    return void 0;
+  }
+}
+function choose(page, spoken) {
+  const language = writtenIn(page);
+  if (language === null) return void 0;
+  const own = spoken.find((tag) => typeof tag === "string" && writtenIn(tag) === language);
+  try {
+    return Intl.getCanonicalLocales(own && plainTag(own) || page)[0];
+  } catch {
+    return void 0;
+  }
+}
+
+// ../../showcase/src/lib/date-grid.ts
+function dayKey(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+
+// ../../showcase/src/lib/locale-cache.ts
+var caches = /* @__PURE__ */ new Set();
+function localeCache(limit) {
+  const map = /* @__PURE__ */ new Map();
+  caches.add(map);
+  return (key, make) => {
+    const hit = map.get(key);
+    if (hit !== void 0) {
+      map.delete(key);
+      map.set(key, hit);
+      return hit;
+    }
+    const made = make();
+    map.set(key, made);
+    if (map.size > limit) map.delete(map.keys().next().value);
+    return made;
+  };
+}
+
+// ../../showcase/src/lib/recurrence.ts
+var DAY_CODES = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+var FREQS = { DAILY: "daily", WEEKLY: "weekly", MONTHLY: "monthly", YEARLY: "yearly" };
+var KNOWN_PARTS = /* @__PURE__ */ new Set(["FREQ", "INTERVAL", "WKST", "BYDAY", "BYSETPOS", "BYMONTHDAY", "BYMONTH", "UNTIL", "COUNT"]);
+var whole = (text) => text !== void 0 && /^[+-]?\d+$/.test(text) ? Number(text) : null;
+function plainDays(text) {
+  const days = text.split(",").map((code) => DAY_CODES.indexOf(code));
+  if (days.some((d) => d < 0) || new Set(days).size !== days.length) return null;
+  return days.sort((a, b) => a - b);
+}
+function nthDay(byday, setpos) {
+  const m = /^([+-]?\d)?(SU|MO|TU|WE|TH|FR|SA)$/.exec(byday);
+  if (!m) return null;
+  const week = m[1] !== void 0 ? setpos === void 0 ? Number(m[1]) : NaN : whole(setpos);
+  if (week === null || ![1, 2, 3, 4, -1].includes(week)) return null;
+  return { week, weekday: DAY_CODES.indexOf(m[2]) };
+}
+function parseUntil(text) {
+  const m = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$/.exec(text);
+  if (!m) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]) - 1, Number(m[3])];
+  const date = m[4] === void 0 ? new Date(y, mo, d) : m[7] ? new Date(Date.UTC(y, mo, d, Number(m[4]), Number(m[5]), Number(m[6]))) : new Date(y, mo, d, Number(m[4]), Number(m[5]), Number(m[6]));
+  return Number.isNaN(date.getTime()) || (m[7] ? date.getUTCMonth() : date.getMonth()) !== mo ? null : date;
+}
+function parseRRule(text) {
+  if (typeof text !== "string") return null;
+  const body = text.trim().replace(/^RRULE:/i, "");
+  if (!body) return null;
+  const parts = /* @__PURE__ */ new Map();
+  for (const part of body.split(";")) {
+    if (!part) continue;
+    const at = part.indexOf("=");
+    const key = part.slice(0, at).toUpperCase();
+    if (at <= 0 || parts.has(key) || !KNOWN_PARTS.has(key)) return null;
+    parts.set(key, part.slice(at + 1).toUpperCase());
+  }
+  const freq = FREQS[parts.get("FREQ") ?? ""];
+  if (!freq) return null;
+  const rule = { freq };
+  if (parts.has("INTERVAL")) {
+    const n = whole(parts.get("INTERVAL"));
+    if (n === null || n < 1) return null;
+    if (n > 1) rule.interval = n;
+  }
+  if (parts.has("WKST")) {
+    const d = DAY_CODES.indexOf(parts.get("WKST"));
+    if (d < 0) return null;
+    if (d !== 1) rule.weekStart = d;
+  }
+  if (parts.has("UNTIL") && parts.has("COUNT")) return null;
+  if (parts.has("COUNT")) {
+    const n = whole(parts.get("COUNT"));
+    if (n === null || n < 1) return null;
+    rule.count = n;
+  }
+  if (parts.has("UNTIL")) {
+    const until = parseUntil(parts.get("UNTIL"));
+    if (!until) return null;
+    rule.until = until;
+  }
+  const byday = parts.get("BYDAY"), setpos = parts.get("BYSETPOS"), monthday = parts.get("BYMONTHDAY"), month = parts.get("BYMONTH");
+  if (freq === "daily" || freq === "weekly") {
+    if (setpos !== void 0 || monthday !== void 0 || month !== void 0) return null;
+    if (byday === void 0) return rule;
+    if (freq === "daily" && rule.interval) return null;
+    const days = plainDays(byday);
+    if (!days) return null;
+    return { ...rule, freq: "weekly", weekdays: days };
+  }
+  if (month !== void 0) {
+    const m = whole(month);
+    if (freq !== "yearly" || m === null || m < 1 || m > 12) return null;
+    rule.month = m;
+  }
+  if (setpos !== void 0 && byday === void 0) return null;
+  if (byday !== void 0) {
+    const nth = nthDay(byday, setpos);
+    if (!nth || monthday !== void 0) return null;
+    rule.nth = nth;
+  } else if (monthday !== void 0) {
+    const d = whole(monthday);
+    if (d === null || !(d === -1 || d >= 1 && d <= 31)) return null;
+    rule.day = d;
+  }
+  if (freq === "yearly" && rule.month === void 0 !== (rule.day === void 0 && rule.nth === void 0)) return null;
+  return rule;
+}
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function toRRule(rule, { allDay = false } = {}) {
+  const out = [`FREQ=${rule.freq.toUpperCase()}`];
+  if (rule.interval && rule.interval > 1) out.push(`INTERVAL=${rule.interval}`);
+  if (rule.month !== void 0) out.push(`BYMONTH=${rule.month}`);
+  if (rule.day !== void 0) out.push(`BYMONTHDAY=${rule.day}`);
+  const weekStart = rule.weekStart ?? 1;
+  if (rule.weekdays?.length) out.push(`BYDAY=${inWeekOrder(rule.weekdays, weekStart).map((d) => DAY_CODES[d]).join(",")}`);
+  if (rule.nth) out.push(`BYDAY=${rule.nth.week}${DAY_CODES[rule.nth.weekday]}`);
+  if (weekStart !== 1) out.push(`WKST=${DAY_CODES[weekStart]}`);
+  if (rule.until) {
+    const u = rule.until;
+    out.push(allDay ? `UNTIL=${u.getFullYear()}${pad(u.getMonth() + 1)}${pad(u.getDate())}` : `UNTIL=${u.getUTCFullYear()}${pad(u.getUTCMonth() + 1)}${pad(u.getUTCDate())}T${pad(u.getUTCHours())}${pad(u.getUTCMinutes())}${pad(u.getUTCSeconds())}Z`);
+  }
+  if (rule.count !== void 0) out.push(`COUNT=${rule.count}`);
+  return `RRULE:${out.join(";")}`;
+}
+var inWeekOrder = (days, weekStart) => [...days].sort((a, b) => (a - weekStart + 7) % 7 - (b - weekStart + 7) % 7);
+function readRecurrence(value) {
+  if (!value) return null;
+  if (typeof value === "string") return parseRRule(value);
+  if (value.until === void 0 || value.until instanceof Date) return value;
+  const until = new Date(value.until);
+  return Number.isNaN(until.getTime()) ? null : { ...value, until };
+}
+var daysIn = (year, month) => new Date(year, month + 1, 0).getDate();
+var atDay = (year, month, day, time) => new Date(year, month, day, time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+var dayIndex = (d) => Math.round(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / 864e5);
+var isMidnight = (d) => d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;
+function nthWeekdayOf(year, month, week, weekday) {
+  const last2 = daysIn(year, month);
+  if (week === -1) return last2 - (new Date(year, month, last2).getDay() - weekday + 7) % 7;
+  const day = 1 + (weekday - new Date(year, month, 1).getDay() + 7) % 7 + (week - 1) * 7;
+  return day <= last2 ? day : null;
+}
+function nthOf(date) {
+  const d = date.getDate();
+  return { week: d + 7 > daysIn(date.getFullYear(), date.getMonth()) ? -1 : Math.ceil(d / 7), weekday: date.getDay() };
+}
+function nthChoices(date) {
+  const d = date.getDate(), weekday = date.getDay();
+  const out = [];
+  if (d <= 28) out.push({ week: Math.ceil(d / 7), weekday });
+  if (d + 7 > daysIn(date.getFullYear(), date.getMonth())) out.push({ week: -1, weekday });
+  return out;
+}
+function weekOnMoved(week, to) {
+  const d = to.getDate();
+  if (week === -1 && d + 7 > daysIn(to.getFullYear(), to.getMonth())) return -1;
+  return d <= 28 ? Math.ceil(d / 7) : -1;
+}
+function withinUntil(at, until) {
+  return at <= until || isMidnight(until) && dayIndex(at) === dayIndex(until);
+}
+function* starts(rule, first) {
+  const interval = Math.max(1, Math.floor(rule.interval ?? 1));
+  const firstDay = dayIndex(first);
+  let produced = 0;
+  const accept = (d) => {
+    if (rule.until && !withinUntil(d, rule.until)) return false;
+    return rule.count === void 0 || produced < rule.count;
+  };
+  if (rule.count !== void 0 && rule.count < 1) return;
+  produced++;
+  yield first;
+  const y0 = first.getFullYear(), m0 = first.getMonth();
+  for (let k = 0, empty = 0; k < 146100 && empty < 400 * 12; k++) {
+    const dates = [];
+    if (rule.freq === "daily") dates.push(atDay(y0, m0, first.getDate() + k * interval, first));
+    else if (rule.freq === "weekly") {
+      const weekStart = rule.weekStart ?? 1;
+      const base = first.getDate() - (first.getDay() - weekStart + 7) % 7 + k * interval * 7;
+      for (const wd of inWeekOrder(rule.weekdays?.length ? rule.weekdays : [first.getDay()], weekStart)) dates.push(atDay(y0, m0, base + (wd - weekStart + 7) % 7, first));
+    } else {
+      const monthsFrom = rule.freq === "monthly" ? k * interval : k * interval * 12;
+      const at = new Date(y0, m0 + monthsFrom, 1);
+      const year = at.getFullYear(), month = rule.freq === "yearly" && rule.month !== void 0 ? rule.month - 1 : at.getMonth();
+      let day;
+      if (rule.nth) day = nthWeekdayOf(year, month, rule.nth.week, rule.nth.weekday);
+      else if (rule.day === -1) day = daysIn(year, month);
+      else day = rule.day ?? first.getDate();
+      if (day !== null && day <= daysIn(year, month)) dates.push(atDay(year, month, day, first));
+    }
+    let any = false;
+    for (const d of dates) {
+      if (dayIndex(d) <= firstDay) continue;
+      if (!accept(d)) return;
+      produced++;
+      any = true;
+      yield d;
+    }
+    empty = any ? 0 : empty + 1;
+  }
+}
+function lengthOf(event) {
+  return event.end ? { days: dayIndex(event.end) - dayIndex(event.start), end: event.end } : null;
+}
+function occurrenceAt(event, start) {
+  const { repeat: _repeat, exceptions: _exceptions, ...rest } = event;
+  const length = lengthOf(event);
+  const date = dayKey(start);
+  const end = length ? atDay(start.getFullYear(), start.getMonth(), start.getDate() + length.days, length.end) : void 0;
+  return { ...rest, id: `${event.id}::${date}`, start, ...end ? { end } : {}, series: { id: event.id, date } };
+}
+function stopOf(event) {
+  if (event.allDay) {
+    const last2 = event.end ?? event.start;
+    return new Date(last2.getFullYear(), last2.getMonth(), last2.getDate() + 1);
+  }
+  return event.end ?? new Date(event.start.getTime() + 36e5);
+}
+function occurrences(event, from, to) {
+  const rule = readRecurrence(event.repeat);
+  if (!rule) return event.start < to && stopOf(event) > from ? [event] : [];
+  const skip = new Set(event.exceptions ?? []);
+  const reach = stopOf(event).getTime() - event.start.getTime();
+  const out = [];
+  for (const start of starts(rule, event.start)) {
+    if (start >= to) break;
+    if (start.getTime() + reach + 864e5 <= from.getTime()) continue;
+    if (skip.has(dayKey(start))) continue;
+    const occurrence = occurrenceAt(event, start);
+    if (stopOf(occurrence) > from) out.push(occurrence);
+  }
+  return out;
+}
+function startsBefore(rule, first, date) {
+  let n = 0;
+  for (const start of starts(rule, first)) {
+    if (dayKey(start) >= date) break;
+    n++;
+  }
+  return n;
+}
+var asWritten = (event, rule) => typeof event.repeat === "string" ? toRRule(rule, { allDay: event.allDay }) : rule;
+var shiftKey = (key, days) => {
+  const [y, m, d] = key.split("-").map(Number);
+  return dayKey(new Date(y, m - 1, d + days));
+};
+var occurrenceOnDay = (series, date) => {
+  const [y, m, d] = date.split("-").map(Number);
+  return occurrenceAt(series, atDay(y, m - 1, d, series.start));
+};
+var editedOf = (events, seriesId) => events.filter((e) => e.series?.id === seriesId && e.id !== seriesId);
+function occurrenceOn(series, date, events) {
+  const edited = events && editedOf(events, series.id).find((e) => e.series.date === date);
+  if (edited) return edited;
+  const [y, m, d] = date.split("-").map(Number);
+  return occurrences(series, new Date(y, m - 1, d), new Date(y, m - 1, d + 1)).find((o) => "series" in o && o.series?.date === date);
+}
+var editOf = (changes) => {
+  if (!changes) return {};
+  const { id: _id, repeat: _repeat, exceptions: _exceptions, ...rest } = changes;
+  delete rest.series;
+  return rest;
+};
+var repeatChanged = (series, changes) => {
+  if (!changes || !("repeat" in changes)) return false;
+  const given = changes.repeat;
+  if (given === series.repeat) return false;
+  const a = readRecurrence(given), b = readRecurrence(series.repeat);
+  return !(a && b && sameRecurrence(a, b));
+};
+function sameValue(a, b) {
+  if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+  if (a && b && typeof a === "object" && typeof b === "object") return JSON.stringify(a) === JSON.stringify(b);
+  return a === b;
+}
+function editFrom(opened, series, changes) {
+  const was = opened;
+  const edit = {};
+  for (const [key, value] of Object.entries(editOf(changes))) if (!sameValue(value, was[key])) edit[key] = value;
+  if (repeatChanged(series, changes)) edit.repeat = changes.repeat;
+  return edit;
+}
+function moveRule(rule, days, to) {
+  const next = { ...rule };
+  if (rule.weekdays?.length) next.weekdays = rule.weekdays.map((d) => ((d + days) % 7 + 7) % 7).sort((a, b) => a - b);
+  if (rule.freq === "monthly" || rule.freq === "yearly") {
+    if (rule.nth) next.nth = { week: weekOnMoved(rule.nth.week, to), weekday: to.getDay() };
+    else if (rule.day === -1) {
+      if (to.getDate() !== daysIn(to.getFullYear(), to.getMonth())) next.day = to.getDate();
+    } else if (rule.day !== void 0) next.day = to.getDate();
+    if (rule.freq === "yearly" && rule.month !== void 0) next.month = to.getMonth() + 1;
+  }
+  return next;
+}
+function onMovedRule(rule, start, days) {
+  const endless = { ...rule, until: void 0, count: void 0 };
+  return (key) => {
+    const shifted = shiftKey(key, days);
+    const [y, m, d] = shifted.split("-").map(Number);
+    const target = dayIndex(new Date(y, m - 1, d));
+    let found = null;
+    for (const at of starts(endless, start)) {
+      const i = dayIndex(at);
+      if (i > target + 7) break;
+      if (i >= target - 7 && (!found || Math.abs(i - target) < Math.abs(dayIndex(found) - target))) found = at;
+    }
+    return found ? dayKey(found) : shifted;
+  };
+}
+var sameClock = (a, b) => a.getHours() === b.getHours() && a.getMinutes() === b.getMinutes() && a.getSeconds() === b.getSeconds() && a.getMilliseconds() === b.getMilliseconds();
+var spanOf = (event) => event.end ? dayIndex(event.end) - dayIndex(event.start) : null;
+function changeSeries(series, occurrence, changes) {
+  const at = typeof occurrence === "string" ? occurrenceOnDay(series, occurrence) : occurrence;
+  const { start: newStart, end: newEnd, ...rest } = editOf(changes);
+  const next = { ...series, ...rest };
+  const moveBy = (from, to, base) => atDay(base.getFullYear(), base.getMonth(), base.getDate() + dayIndex(to) - dayIndex(from), sameClock(to, from) ? base : to);
+  let days = 0;
+  if (newStart) {
+    days = dayIndex(newStart) - dayIndex(at.start);
+    next.start = moveBy(at.start, newStart, series.start);
+  }
+  if (newEnd) {
+    const from = at.end ?? at.start;
+    next.end = moveBy(from, newEnd, series.end ?? series.start);
+  }
+  const rule = readRecurrence(series.repeat);
+  let moveKey = (key) => shiftKey(key, days);
+  const moveExceptions = () => {
+    if (days !== 0 && series.exceptions?.length) next.exceptions = series.exceptions.map(moveKey);
+  };
+  if (repeatChanged(series, changes)) {
+    if (changes.repeat) {
+      next.repeat = changes.repeat;
+      moveExceptions();
+    } else {
+      delete next.repeat;
+      delete next.exceptions;
+    }
+  } else if (days !== 0 && rule && newStart) {
+    const moved = moveRule(rule, days, newStart);
+    next.repeat = asWritten(series, moved);
+    if (moved.nth) {
+      const from = next.start;
+      const anchor = (k) => {
+        const at2 = new Date(from.getFullYear() + (moved.freq === "yearly" ? k : 0), (moved.freq === "yearly" && moved.month !== void 0 ? moved.month - 1 : from.getMonth()) + (moved.freq === "monthly" ? k : 0), 1);
+        const d = nthWeekdayOf(at2.getFullYear(), at2.getMonth(), moved.nth.week, moved.nth.weekday) ?? nthWeekdayOf(at2.getFullYear(), at2.getMonth(), -1, moved.nth.weekday);
+        return atDay(at2.getFullYear(), at2.getMonth(), d, from);
+      };
+      let first = anchor(0);
+      if (dayIndex(first) < dayIndex(from)) first = anchor(1);
+      const extra = dayIndex(first) - dayIndex(from);
+      if (extra) {
+        next.start = first;
+        if (next.end) next.end = atDay(next.end.getFullYear(), next.end.getMonth(), next.end.getDate() + extra, next.end);
+      }
+    }
+    moveKey = onMovedRule(moved, next.start, days);
+    moveExceptions();
+  }
+  return { next, moveKey };
+}
+function splitWith(series, date, id, at, changes) {
+  const rule = readRecurrence(series.repeat);
+  const firstDate = dayKey(series.start);
+  if (!rule || date <= firstDate) {
+    if (!changes) return { after: series, moveKey: (key) => key };
+    const { next: next2, moveKey: moveKey2 } = changeSeries(series, typeof at === "string" ? at <= firstDate ? firstDate : at : at, changes);
+    return { after: next2, moveKey: moveKey2 };
+  }
+  const [y, m, d] = date.split("-").map(Number);
+  const first = occurrenceOnDay(series, date);
+  const exceptions = series.exceptions ?? [];
+  const counted = rule.count !== void 0 ? startsBefore(rule, series.start, date) : 0;
+  const beforeRule = { ...rule };
+  if (rule.count !== void 0) beforeRule.count = counted;
+  else {
+    delete beforeRule.until;
+    beforeRule.until = series.allDay ? new Date(y, m - 1, d - 1) : new Date(y, m - 1, d - 1, 23, 59, 59);
+  }
+  const afterRule = { ...rule };
+  if (rule.count !== void 0) afterRule.count = rule.count - counted;
+  const before = { ...series, repeat: asWritten(series, beforeRule), exceptions: exceptions.filter((x) => x < date) };
+  const after = { ...series, id, start: first.start, ...first.end ? { end: first.end } : {}, repeat: asWritten(series, afterRule), exceptions: exceptions.filter((x) => x >= date) };
+  if (!changes) return { before, after, moveKey: (key) => key };
+  const edit = repeatChanged(series, changes) ? changes : editOf(changes);
+  const { next, moveKey } = changeSeries(after, typeof at === "string" ? date : at, edit);
+  return { before, after: next, moveKey };
+}
+function detachOccurrence(series, date, id = `${series.id}-${date}`, changes) {
+  return {
+    series: { ...series, exceptions: [.../* @__PURE__ */ new Set([...series.exceptions ?? [], date])].sort() },
+    event: { ...occurrenceOnDay(series, date), ...editOf(changes), id }
+  };
+}
+var NOT_FOLLOWED = /* @__PURE__ */ new Set(["id", "series", "start", "end", "repeat", "exceptions"]);
+function follow(edited, was, now) {
+  const out = { ...edited };
+  const before = was, after = now;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (NOT_FOLLOWED.has(key) || !sameValue(out[key], before[key])) continue;
+    if (after[key] === void 0) delete out[key];
+    else out[key] = after[key];
+  }
+  const ownDay = dayIndex(edited.start) !== dayIndex(was.start);
+  const ownTimes = !sameClock(edited.start, was.start) || spanOf(edited) !== spanOf(was) || !!edited.end && !!was.end && !sameClock(edited.end, was.end);
+  const day = ownDay ? edited.start : now.start;
+  const times = ownTimes ? edited : now;
+  const start = atDay(day.getFullYear(), day.getMonth(), day.getDate(), times.start);
+  out.start = start;
+  const span = spanOf(times);
+  if (times.end && span !== null) out.end = atDay(start.getFullYear(), start.getMonth(), start.getDate() + span, times.end);
+  else delete out.end;
+  return out;
+}
+function carry(old, next, linked, moveKey, changed, opened, edit) {
+  if (!linked.length) return { next, save: [], remove: [] };
+  if (changed) {
+    const freed = new Set(linked.map((e) => moveKey(e.series.date)));
+    return { next: next.exceptions ? { ...next, exceptions: next.exceptions.filter((x) => !freed.has(x)) } : next, save: [], remove: linked.map((e) => e.id) };
+  }
+  const save = linked.map((e) => {
+    const date = moveKey(e.series.date);
+    const followed = follow(e, occurrenceOnDay(old, e.series.date), occurrenceOnDay(next, date));
+    return { ...followed, ...e.id === opened?.id ? editOf(edit) : {}, series: { id: next.id, date } };
+  });
+  return { next, save, remove: [] };
+}
+function findSeries(events, occurrence) {
+  const stored = events.find((e) => e.id === occurrence.id);
+  const link = (stored ?? occurrence).series;
+  const series = link ? events.find((e) => e.id === link.id && readRecurrence(e.repeat) !== null) : void 0;
+  return { series, stored, date: link?.date };
+}
+function commit(events, save, remove) {
+  const gone = new Set(remove);
+  const saved = new Map(save.map((e) => [e.id, e]));
+  const had = new Set(events.map((e) => e.id));
+  return { events: [...events.filter((e) => !gone.has(e.id)).map((e) => saved.get(e.id) ?? e), ...save.filter((e) => !had.has(e.id))], save, remove };
+}
+function saveOccurrence(events, occurrence, scope, changes, newId) {
+  const { series, stored, date } = findSeries(events, occurrence);
+  if (!series || date === void 0) return commit(events, stored ? [{ ...stored, ...editOf(changes) }] : [], []);
+  const opened = stored ?? occurrenceOnDay(series, date);
+  const edit = editFrom(opened, series, changes);
+  if (scope === "this") {
+    if (stored) return commit(events, [{ ...stored, ...editOf(edit) }], []);
+    const { series: kept, event } = detachOccurrence(series, date, newId, edit);
+    return commit(events, [kept, event], []);
+  }
+  const linked = editedOf(events, series.id);
+  const changed = repeatChanged(series, edit);
+  if (scope === "following" && date > dayKey(series.start)) {
+    const { before, after, moveKey: moveKey2 } = splitWith(series, date, newId, opened, edit);
+    const carried2 = carry(series, after, linked.filter((e) => e.series.date >= date), moveKey2, changed, stored, edit);
+    return commit(events, [...before ? [before] : [], carried2.next, ...carried2.save], carried2.remove);
+  }
+  const { next, moveKey } = changeSeries(series, opened, edit);
+  const carried = carry(series, next, linked, moveKey, changed, stored, edit);
+  return commit(events, [carried.next, ...carried.save], carried.remove);
+}
+function deleteOccurrence(events, occurrence, scope) {
+  const { series, stored, date } = findSeries(events, occurrence);
+  if (!series || date === void 0) return commit(events, [], stored ? [stored.id] : []);
+  if (scope === "this") return stored ? commit(events, [], [stored.id]) : commit(events, [detachOccurrence(series, date).series], []);
+  const linked = editedOf(events, series.id);
+  if (scope === "following" && date > dayKey(series.start)) {
+    const { before } = splitWith(series, date, series.id, date);
+    return commit(events, before ? [before] : [], linked.filter((e) => e.series.date >= date).map((e) => e.id));
+  }
+  return commit(events, [], [series.id, ...linked.map((e) => e.id)]);
+}
+function countEdited(events, occurrence) {
+  const { series, date } = findSeries(events, occurrence);
+  if (!series || date === void 0) return { following: 0, all: 0 };
+  const linked = editedOf(events, series.id);
+  return { following: date > dayKey(series.start) ? linked.filter((e) => e.series.date >= date).length : linked.length, all: linked.length };
+}
+var formats = localeCache(128);
+function format(options, date, locale) {
+  return formats(`${locale ?? ""}|${JSON.stringify(options)}`, () => new Intl.DateTimeFormat(locale, options)).format(date);
+}
+var weekdayName = (d, locale) => format({ weekday: "long" }, new Date(2026, 0, 4 + d), locale);
+var monthName = (m, locale) => format({ month: "long" }, new Date(2026, m - 1, 1), locale);
+var ORDINAL = { 1: "first", 2: "second", 3: "third", 4: "fourth", [-1]: "last" };
+var list = (items) => items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+var every = (n, one, many) => n > 1 ? `Every ${n} ${many}` : `Every ${one}`;
+function describeRecurrence(rule, start, locale = formatLocale()) {
+  const n = Math.max(1, Math.floor(rule.interval ?? 1));
+  const weekStart = rule.weekStart ?? 1;
+  let text;
+  if (rule.freq === "daily") text = every(n, "day", "days");
+  else if (rule.freq === "weekly") {
+    const days = inWeekOrder(rule.weekdays?.length ? rule.weekdays : [start.getDay()], weekStart);
+    if (days.length === 7) text = every(n, "day", "weeks on every day");
+    else if (n === 1 && days.join() === "1,2,3,4,5") text = "Every weekday (Monday to Friday)";
+    else text = `${every(n, "week", "weeks")} on ${list(days.map((d) => weekdayName(d, locale)))}`;
+  } else {
+    const nth = rule.nth ? `the ${ORDINAL[rule.nth.week]} ${weekdayName(rule.nth.weekday, locale)}` : void 0;
+    if (rule.freq === "monthly") {
+      const on = nth ?? (rule.day === -1 ? "the last day" : `day ${rule.day ?? start.getDate()}`);
+      text = `${every(n, "month", "months")} on ${on}`;
+    } else {
+      const month = rule.month ?? start.getMonth() + 1;
+      const on = nth ? `${nth} of ${monthName(month, locale)}` : rule.day === -1 ? `the last day of ${monthName(month, locale)}` : (
+        // a leap year, so 29 February reads as itself
+        format({ day: "numeric", month: "long" }, new Date(2028, month - 1, rule.day ?? start.getDate()), locale)
+      );
+      text = `${every(n, "year", "years")} on ${on}`;
+    }
+  }
+  if (rule.until) text += `, until ${format({ day: "numeric", month: "long", year: "numeric" }, rule.until, locale)}`;
+  else if (rule.count !== void 0) text += rule.count === 1 ? ", once" : `, ${rule.count} times`;
+  return text;
+}
+function recurrencePresets(start, locale = formatLocale()) {
+  const rules = [{ freq: "daily" }];
+  const weekday = start.getDay();
+  if (weekday >= 1 && weekday <= 5) rules.push({ freq: "weekly", weekdays: [1, 2, 3, 4, 5] });
+  rules.push({ freq: "weekly" }, ...nthChoices(start).map((nth) => ({ freq: "monthly", nth })), { freq: "monthly" });
+  if (start.getDate() === daysIn(start.getFullYear(), start.getMonth())) rules.push({ freq: "monthly", day: -1 });
+  rules.push({ freq: "yearly" });
+  return rules.map((rule) => ({ rule, label: describeRecurrence(rule, start, locale) }));
+}
+function sameRecurrence(a, b) {
+  if (!a || !b) return a === b;
+  const norm = (r) => toRRule({ ...r, weekdays: r.weekdays?.length ? [...r.weekdays].sort() : void 0 });
+  return norm(a) === norm(b);
+}
+
+// ../../showcase/src/lib/time-zones.ts
+function canonicalTimeZone(zone) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: zone }).resolvedOptions().timeZone;
+  } catch {
+    return zone;
+  }
+}
+function timeZoneOffset(zone, at = /* @__PURE__ */ new Date(), locale = formatLocale()) {
+  try {
+    return new Intl.DateTimeFormat(locale, { timeZone: zone, timeZoneName: "shortOffset" }).formatToParts(at).find((p) => p.type === "timeZoneName")?.value ?? "";
+  } catch {
+    return "";
+  }
+}
+
+// ../../showcase/src/lib/time-days.ts
+var TIME_ZOOMS = ["day", "week", "month", "quarter"];
+var DAY_MS = 864e5;
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+var utcDay = (y, m, d) => Math.round(Date.UTC(y, m, d) / DAY_MS);
+function dayOfDate(d) {
+  const t = d.getTime();
+  if (Number.isNaN(t)) return NaN;
+  const day = utcDay(d.getFullYear(), d.getMonth(), d.getDate());
+  const first = new Date(t);
+  first.setHours(0, 0, 0, 0);
+  if (first.getTime() === t) return day;
+  const ms = ((d.getHours() * 60 + d.getMinutes()) * 60 + d.getSeconds()) * 1e3 + d.getMilliseconds();
+  return day + ms / DAY_MS;
+}
+function dayOf(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : NaN;
+  if (value instanceof Date) return dayOfDate(value);
+  if (typeof value !== "string") return NaN;
+  const m = DATE_ONLY.exec(value.trim());
+  if (!m) return dayOfDate(new Date(value));
+  const [y, mo, d] = [Number(m[1]), Number(m[2]) - 1, Number(m[3])];
+  const day = utcDay(y, mo, d);
+  const back = new Date(day * DAY_MS);
+  return back.getUTCFullYear() === y && back.getUTCMonth() === mo && back.getUTCDate() === d ? day : NaN;
+}
+function dateOfDay(day) {
+  const whole2 = Math.floor(day);
+  const u = new Date(whole2 * DAY_MS);
+  return new Date(u.getUTCFullYear(), u.getUTCMonth(), u.getUTCDate(), 0, 0, 0, Math.round((day - whole2) * DAY_MS));
+}
+function isWholeDay(value) {
+  return typeof value === "string" ? DATE_ONLY.test(value.trim()) : Number.isInteger(dayOf(value));
+}
+function endDayOf(value) {
+  const day = dayOf(value);
+  return typeof value !== "number" && isWholeDay(value) ? day + 1 : day;
+}
+function rangeEnd(start, end) {
+  return end instanceof Date && !isWholeDay(start) ? dayOf(end) : endDayOf(end);
+}
+var formats2 = localeCache(128);
+function dayFormatter(given, options) {
+  const locale = given ?? formatLocale();
+  return formats2(`${locale ?? ""}|${JSON.stringify(options)}`, () => new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }));
+}
+function timeExtent(ranges) {
+  let start = Infinity;
+  let end = -Infinity;
+  for (const r of ranges) {
+    if (r == null) continue;
+    const s = dayOf(r.start);
+    const e = r.end == null ? endDayOf(r.start) : rangeEnd(r.start, r.end);
+    if (Number.isFinite(s)) start = Math.min(start, s);
+    if (Number.isFinite(e)) end = Math.max(end, e);
+  }
+  return Number.isFinite(start) && Number.isFinite(end) ? { start, end: Math.max(start, end) } : { start: NaN, end: NaN };
+}
+var DAY_WORDS = { day: "numeric", month: "long" };
+var TIME_WORDS = { hour: "2-digit", minute: "2-digit" };
+var SEPARATOR = /\s*[\u2010-\u2015\u2212~\uff5e\u301c-]\s*/;
+var english = (f) => new Intl.Locale(f.resolvedOptions().locale).language === "en";
+function range(f, a, b, to) {
+  if (typeof f.formatRangeToParts !== "function") return to === void 0 ? f.formatRange(a, b) : `${f.format(a)}${to}${f.format(b)}`;
+  const parts = f.formatRangeToParts(a, b);
+  const lastOfStart = parts.map((p) => p.source).lastIndexOf("startRange");
+  const firstOfEnd = parts.findIndex((p) => p.source === "endRange");
+  if (lastOfStart < 0 || firstOfEnd < 0) return f.format(a);
+  if (to === void 0) return parts.map((p) => p.value).join("");
+  let joined = false;
+  const out = parts.map((p, i) => {
+    if (joined || i <= lastOfStart || i >= firstOfEnd || !SEPARATOR.test(p.value)) return p.value;
+    joined = true;
+    return p.value.replace(SEPARATOR, to);
+  });
+  if (!joined) out.splice(lastOfStart + 1, 0, to);
+  return out.join("");
+}
+function formatDateRange(start, end, words) {
+  const { locale, to, day = DAY_WORDS, time = TIME_WORDS } = words ?? {};
+  const until = end ?? start;
+  const from = dayOf(start);
+  const stop = rangeEnd(start, until);
+  if (!Number.isFinite(from) || !Number.isFinite(stop)) return "";
+  const timed = !isWholeDay(start) || !isWholeDay(until);
+  const first = timed ? from : Math.floor(from);
+  const last2 = timed ? Math.max(from, stop) : Math.max(first, Math.ceil(stop) - 1);
+  const a = new Date(first * DAY_MS);
+  const b = new Date(last2 * DAY_MS);
+  const years = a.getUTCFullYear() !== b.getUTCFullYear() && day.year === void 0;
+  const f = dayFormatter(locale, { ...day, ...years ? { year: "numeric" } : {}, ...timed ? time : {} });
+  return first === last2 ? f.format(a) : range(f, a, b, to ?? (english(f) ? " to " : void 0));
+}
+
+// ../../showcase/src/lib/chart-categories.ts
+var ENGLISH_MONTHS = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "sept",
+  "oct",
+  "nov",
+  "dec"
+];
+var ENGLISH_WEEKDAYS = [
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "mon",
+  "tue",
+  "tues",
+  "wed",
+  "thu",
+  "thur",
+  "thurs",
+  "fri",
+  "sat",
+  "sun"
+];
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var clean = (s) => s.trim().toLowerCase().replace(/\.$/, "");
+function intlNames(locale, kind) {
+  const out = [];
+  try {
+    for (const width of ["short", "long"]) {
+      const fmt = new Intl.DateTimeFormat(locale, kind === "month" ? { month: width, timeZone: "UTC" } : { weekday: width, timeZone: "UTC" });
+      const count = kind === "month" ? 12 : 7;
+      for (let i = 0; i < count; i++) {
+        const date = kind === "month" ? new Date(Date.UTC(2026, i, 15)) : new Date(Date.UTC(2026, 0, 5 + i));
+        out.push(clean(fmt.format(date)));
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function locales(given) {
+  const out = /* @__PURE__ */ new Set(["en"]);
+  if (given !== void 0) {
+    out.add(given);
+    return [...out];
+  }
+  try {
+    out.add(new Intl.DateTimeFormat().resolvedOptions().locale);
+  } catch {
+  }
+  if (typeof navigator !== "undefined" && navigator.language) out.add(navigator.language);
+  if (typeof document !== "undefined" && document.documentElement?.lang) out.add(document.documentElement.lang);
+  return [...out];
+}
+var cached = null;
+function patterns(given) {
+  const tags = locales(given);
+  const key = tags.join("|");
+  if (cached?.key === key) return cached;
+  const months = new Set(ENGLISH_MONTHS);
+  const weekdays = new Set(ENGLISH_WEEKDAYS);
+  for (const tag of tags) {
+    for (const m of intlNames(tag, "month")) if (m) months.add(m);
+    for (const d of intlNames(tag, "weekday")) if (d) weekdays.add(d);
+  }
+  const alt = (set) => [...set].sort((a, b) => b.length - a.length).map(escape).join("|");
+  const M = `(?:${alt(months)})\\.?`;
+  const D = `(?:${alt(weekdays)})\\.?`;
+  const day = String.raw`\d{1,2}(?:st|nd|rd|th|\.)?`;
+  const year = String.raw`'?\d{2,4}`;
+  const list2 = [
+    // dates in digits: 2026-09-21, 21/09, 09/21/2026, 21.09.2026, an ISO date-time
+    /^\d{4}[-/.]\d{1,2}(?:[-/.]\d{1,2})?$/,
+    /^\d{1,2}[-/.]\d{1,2}(?:[-/.]\d{2,4})?$/,
+    /^\d{4}-\d{2}-\d{2}[T ]\d{1,2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/,
+    // a day and a month in either order, and a month alone or with its year: 16 Sep, 21. Sept., Sept 21, March 2026
+    new RegExp(`^${day}\\s*${M}(?:,?\\s+${year})?$`, "iu"),
+    new RegExp(`^${M}\\s*${day}(?:,?\\s+${year})?$`, "iu"),
+    new RegExp(`^${M}(?:\\s*${year})?$`, "iu"),
+    // CJK dates: 9月21日, 2026年9月, 9월 21일
+    /^(?:\d{4}年)?\d{1,2}月(?:\d{1,2}日)?$/u,
+    /^\d{4}年(?:\d{1,2}月)?$/u,
+    /^(?:\d{4}년\s?)?\d{1,2}월(?:\s?\d{1,2}일)?$/u,
+    // a quarter or a half: Q3, Q3 2026, Q3 FY26, 2026 Q3, 3Q26, H1 2026
+    /^Q[1-4](?:\s*[-/']?\s*(?:FY\s?)?'?\d{2,4})?$/i,
+    /^[1-4]Q\s*'?\d{0,4}$/i,
+    /^(?:FY\s?)?'?\d{2,4}\s*[-/]?\s*Q[1-4]$/i,
+    /^H[12](?:\s*'?\d{2,4})?$/i,
+    // a year or a fiscal year: 2026, FY26, FY 2025/26, 2025/26, 2025-2026
+    /^(?:19|20)\d{2}$/,
+    /^FY\s?'?\d{2,4}(?:\s?[-/]\s?'?\d{2,4})?$/i,
+    /^(?:19|20)\d{2}\s?[-/–]\s?(?:(?:19|20)?\d{2})$/,
+    // a week: W12, Wk 3, Week 12, Week 12 2026, 2026-W12
+    /^(?:W|Wk|Week)\.?\s?\d{1,2}(?:\s*[,/-]?\s*\d{4})?$/i,
+    /^\d{4}-?W\d{1,2}(?:-?\d)?$/i,
+    // a weekday: Mon, Tuesday, and the runtime and page locales' own
+    new RegExp(`^${D}$`, "iu"),
+    // a time: 09:00, 9:30 pm, 9am, 14h
+    /^\d{1,2}:\d{2}(?::\d{2})?\s?(?:[ap]\.?m\.?)?$/i,
+    /^\d{1,2}\s?[ap]\.?m\.?$/i,
+    /^\d{1,2}h(?:\d{2})?$/i,
+    // a number, a percentage or an amount: 12, -3.5, 1,200, 12%, $5k, €1.2m, 5 €, a bin (10–20, <10, 50+)
+    /^[<>≤≥~]?\s?[+\-−]?\s?[$€£¥₹]?\s?\d[\d,. \u00a0\u202f]*(?:\s?(?:k|m|mn|bn|b|t))?\s?(?:%|[$€£¥₹])?\+?$/iu,
+    /^[$€£¥₹]?\d[\d,.]*\s?[-–]\s?[$€£¥₹]?\d[\d,.]*\s?(?:k|m|bn|%)?$/iu
+  ];
+  cached = { key, list: list2 };
+  return cached;
+}
+function categoryKind(labels, locale) {
+  const { list: list2 } = patterns(locale);
+  for (const raw of labels) {
+    if (raw == null) continue;
+    if (typeof raw === "number") {
+      if (Number.isFinite(raw)) continue;
+      return "names";
+    }
+    if (raw instanceof Date) continue;
+    const text = String(raw).trim();
+    if (!text) continue;
+    if (!list2.some((re) => re.test(text))) return "names";
+  }
+  return "scale";
+}
+
+export { ACTIVE_RING, FOCUS_RING, FOCUS_WITHIN_RING, GLASS_BACKDROP, GLASS_DROPDOWN, GLASS_OVERLAY, GLASS_SURFACE, HAS_FOCUS_RING, TIME_ZOOMS, canonicalTimeZone, categoryKind, cn, countEdited, dateOfDay, dayOf, deleteOccurrence, describeRecurrence, endDayOf, formatDateRange, nthOf, occurrenceOn, occurrences, parseRRule, readRecurrence, recurrencePresets, requestLocale, sameRecurrence, saveOccurrence, timeExtent, timeZoneOffset, toRRule };
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map