@nomideusz/svelte-calendar 0.8.0 → 0.9.0

package/README.md

@@ -706,7 +706,20 @@ Call `resetLabels()` to restore English defaults (`defaultLabels` exports them;
 
 ## Timezone Support
 
-Convert events between timezones using the built-in helpers:
+Render the whole calendar in any IANA timezone — events, the now-indicator
+and day boundaries all shift; ranges passed to `oneventcreate`/`oneventmove`
+convert back to real instants:
+
+```svelte
+<Calendar {adapter} timezone="Europe/Warsaw" />
+```
+
+Under the hood the adapter is wrapped with `wrapAdapterWithTimezone` (also
+exported) so views do plain local-time math on a zoned wall-clock plane.
+Known limit shared by every wall-clock calendar: the repeated hour of a DST
+fall-back is ambiguous, writes inside it resolve to one of the two instants.
+
+Convert events manually with the built-in helpers:
 
 ```ts
 import { toZonedTime, fromZonedTime, nowInZone } from '@nomideusz/svelte-calendar';

package/dist/calendar/Calendar.svelte

@@ -30,6 +30,7 @@ import Planner from "../views/planner/Planner.svelte";
 import Agenda from "../views/agenda/Agenda.svelte";
 import Mobile from "../views/mobile/Mobile.svelte";
 import MonthGrid from "../views/month/MonthGrid.svelte";
+import { wrapAdapterWithTimezone, toZonedTime, fromZonedTime } from "../core/timezone.js";
 const MOBILE_BREAKPOINT = 768;
 const DEFAULT_VIEWS = [
   { id: "day-planner", label: "Planner", mode: "day", component: Planner },
@@ -80,10 +81,16 @@ let {
   ondatechange,
   oneventhover,
   ondayclick,
-  onerror
+  onerror,
+  timezone
 } = $props();
-const effectiveCreate = $derived(readOnly ? void 0 : oneventcreate);
-const effectiveMove = $derived(readOnly ? void 0 : oneventmove);
+const unzone = (d) => timezone ? fromZonedTime(d, timezone) : d;
+const effectiveCreate = $derived(
+  readOnly || !oneventcreate ? void 0 : (range) => oneventcreate({ start: unzone(range.start), end: unzone(range.end) })
+);
+const effectiveMove = $derived(
+  readOnly || !oneventmove ? void 0 : (ev, start, end) => oneventmove(ev, unzone(start), unzone(end))
+);
 function handleEventClick(ev) {
   selection.select(ev.id);
   oneventclick?.(ev);
@@ -114,12 +121,17 @@ onMount(() => {
   };
 });
 const effectiveTheme = $derived(theme === auto && autoTheme !== false ? probedTheme : theme);
-const store = $derived(createEventStore(adapter));
+const effectiveAdapter = $derived(
+  timezone ? wrapAdapterWithTimezone(adapter, timezone) : adapter
+);
+const store = $derived(createEventStore(effectiveAdapter));
 const viewState = createViewState(untrack(() => ({
   view: activeViewId ?? views[0]?.id,
   mondayStart,
-  initialDate,
+  // Focus lives on the zoned plane too — day boundaries follow the zone.
+  initialDate: initialDate && timezone ? toZonedTime(initialDate, timezone) : initialDate,
   dayCount: days,
+  timezone,
   modeForView: (viewId) => views.find((v) => v.id === viewId)?.mode
 })));
 const selection = createSelection();
@@ -223,6 +235,9 @@ setContext("calendar", {
   get ondayclick() {
     return ondayclick;
   },
+  get timezone() {
+    return timezone;
+  },
   // Config (reactive via getters)
   get readOnly() {
     return readOnly;

package/dist/calendar/Calendar.svelte.d.ts

@@ -116,6 +116,13 @@ interface Props {
     ondayclick?: (date: Date) => void;
     /** Surfaced instead of silent console output when loading or mutations fail. */
     onerror?: (error: Error) => void;
+    /**
+     * Render the calendar in an IANA timezone (e.g. 'Europe/Warsaw').
+     * Events, "now" and day boundaries all shift; ranges passed to
+     * oneventcreate/oneventmove convert back to real instants.
+     * Default: the viewer's local time.
+     */
+    timezone?: string;
 }
 declare const Calendar: Component<Props, {}, "">;
 type Calendar = ReturnType<typeof Calendar>;

package/dist/core/clock.svelte.d.ts

@@ -18,4 +18,4 @@ export interface Clock {
  * Must be called during component initialisation (before first await).
  * Automatically cleans up on unmount via onMount return.
  */
-export declare function createClock(): Clock;
+export declare function createClock(timezone?: string): Clock;

package/dist/core/clock.svelte.js

@@ -13,19 +13,23 @@
  */
 import { onMount } from 'svelte';
 import { sod, fmtHM, fmtS, fractionalHour } from './time.js';
+import { toZonedTime } from './timezone.js';
 /**
  * Create a shared reactive clock.
  *
  * Must be called during component initialisation (before first await).
  * Automatically cleans up on unmount via onMount return.
  */
-export function createClock() {
-    let tick = $state(Date.now());
-    let today = $state(sod(Date.now()));
+export function createClock(timezone) {
+    // With a timezone, ticks are "zoned wall-clock" epoch ms — the same plane
+    // the wrapped adapter shifts event Dates into. Views stay zone-agnostic.
+    const now = () => (timezone ? toZonedTime(Date.now(), timezone).getTime() : Date.now());
+    let tick = $state(now());
+    let today = $state(sod(tick));
     let intervalId = null;
     function start() {
         intervalId = setInterval(() => {
-            tick = Date.now();
+            tick = now();
             const sd = sod(tick);
             if (sd !== today)
                 today = sd;

package/dist/core/timezone.d.ts

@@ -20,3 +20,15 @@ export declare function nowInZone(timezone: string): Date;
  * Returns a locale-aware string.
  */
 export declare function formatInTimeZone(date: Date | number, timezone: string, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+/**
+ * Wrap a CalendarAdapter so everything it emits is expressed as wall-clock
+ * Dates in `timezone`, and everything written through it is converted back to
+ * real instants. This is how the Calendar's `timezone` prop works: views keep
+ * doing plain local-time math on an already-shifted plane.
+ *
+ * Known limit shared by every wall-clock calendar UI: during a DST fall-back
+ * the repeated hour is ambiguous on the wall clock, so writes made inside it
+ * resolve to one of the two instants (date-fns-tz picks the offset).
+ */
+import type { CalendarAdapter } from '../adapters/types.js';
+export declare function wrapAdapterWithTimezone(adapter: CalendarAdapter, timezone: string): CalendarAdapter;

package/dist/core/timezone.js

@@ -51,3 +51,34 @@ export function formatInTimeZone(date, timezone, options = {}, locale) {
         timeZone: timezone,
     }).format(d);
 }
+export function wrapAdapterWithTimezone(adapter, timezone) {
+    const zoneEvent = (ev) => ({
+        ...ev,
+        start: toZonedTime(ev.start, timezone),
+        end: toZonedTime(ev.end, timezone),
+    });
+    const unzonePartial = (obj) => ({
+        ...obj,
+        ...(obj.start instanceof Date ? { start: fromZonedTime(obj.start, timezone) } : {}),
+        ...(obj.end instanceof Date ? { end: fromZonedTime(obj.end, timezone) } : {}),
+    });
+    const wrapped = {
+        async fetchEvents(range) {
+            const events = await adapter.fetchEvents({
+                start: fromZonedTime(range.start, timezone),
+                end: fromZonedTime(range.end, timezone),
+            });
+            return events.map(zoneEvent);
+        },
+    };
+    if (adapter.createEvent) {
+        wrapped.createEvent = async (event) => zoneEvent(await adapter.createEvent(unzonePartial(event)));
+    }
+    if (adapter.updateEvent) {
+        wrapped.updateEvent = async (id, patch) => zoneEvent(await adapter.updateEvent(id, unzonePartial(patch)));
+    }
+    if (adapter.deleteEvent) {
+        wrapped.deleteEvent = (id) => adapter.deleteEvent(id);
+    }
+    return wrapped;
+}

package/dist/headless/create-calendar.svelte.js

@@ -42,15 +42,18 @@
 import { untrack } from 'svelte';
 import { createEventStore } from '../engine/event-store.svelte.js';
 import { createViewState } from '../engine/view-state.svelte.js';
+import { toZonedTime, fromZonedTime, wrapAdapterWithTimezone } from '../core/timezone.js';
 import { createSelection } from '../engine/selection.svelte.js';
 import { createDragState } from '../engine/drag.svelte.js';
 import { createClock } from '../core/clock.svelte.js';
 import { sod, DAY_MS, HOUR_MS, startOfWeek as sowFn, isAllDay, isMultiDay, segmentForDay, } from '../core/time.js';
 import { monthLong, weekdayLong, weekdayShort } from '../core/locale.js';
 export function createCalendar(options) {
-    const { adapter, mondayStart: initialMondayStart = true, initialDate, locale, visibleHours, snapInterval = 15, equalDays = false, hideDays, blockedSlots, disabledDates, days: initialDayCount = 7, readOnly = false, minDuration, maxDuration, oneventclick, oneventcreate, oneventmove, } = options;
+    const { adapter, mondayStart: initialMondayStart = true, initialDate: rawInitialDate, locale, visibleHours, snapInterval = 15, equalDays = false, hideDays, blockedSlots, disabledDates, days: initialDayCount = 7, readOnly = false, minDuration, maxDuration, oneventclick, oneventcreate, oneventmove, } = options;
     // ── Create engine ────────────────────────────────────
-    const store = createEventStore(adapter);
+    const timezone = options.timezone;
+    const initialDate = rawInitialDate && timezone ? toZonedTime(rawInitialDate, timezone) : rawInitialDate;
+    const store = createEventStore(timezone ? wrapAdapterWithTimezone(adapter, timezone) : adapter);
     const viewState = createViewState({
         view: options.view ?? 'week-planner',
         mondayStart: initialMondayStart,
@@ -60,7 +63,8 @@ export function createCalendar(options) {
     });
     const selection = createSelection();
     const drag = createDragState();
-    const clock = createClock();
+    const clock = createClock(timezone);
+    const unzoneDate = (d) => (timezone ? fromZonedTime(d, timezone) : d);
     // ── Computed ──────────────────────────────────────────
     const disabledSet = $derived(new Set(disabledDates?.map((d) => sod(d.getTime())) ?? []));
     const startHour = visibleHours?.[0] ?? 0;
@@ -281,7 +285,7 @@ export function createCalendar(options) {
                 await store.move(payload.eventId, start, end);
                 const ev = store.byId(payload.eventId);
                 if (ev)
-                    oneventmove?.(ev, start, end);
+                    oneventmove?.(ev, unzoneDate(start), unzoneDate(end));
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : '';
@@ -290,7 +294,7 @@ export function createCalendar(options) {
                 if (msg.includes('read-only')) {
                     const ev = store.byId(payload.eventId);
                     if (ev)
-                        oneventmove?.(ev, start, end);
+                        oneventmove?.(ev, unzoneDate(start), unzoneDate(end));
                 }
                 else if (!msg.includes('not found')) {
                     console.warn('[calendar] drag commit failed:', e);
@@ -299,7 +303,9 @@ export function createCalendar(options) {
             }
         }
         else if (mode === 'create') {
-            oneventcreate?.({ start, end });
+            oneventcreate?.(timezone
+                ? { start: fromZonedTime(start, timezone), end: fromZonedTime(end, timezone) }
+                : { start, end });
         }
         return result;
     }

package/dist/headless/types.d.ts

@@ -22,6 +22,8 @@ export interface HeadlessCalendarOptions {
     mondayStart?: boolean;
     /** Initial date to focus on (default: today) */
     initialDate?: Date;
+    /** Render in an IANA timezone; events, "now" and day boundaries shift. */
+    timezone?: string;
     /** BCP 47 locale tag (e.g. 'en-US', 'pl-PL') */
     locale?: string;
     /** Visible hour range [startHour, endHour). Default: [0, 24] */

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export { createClock, startOfWeek, fmtH, fmtTime, fmtDuration, weekdayShort, wee
 export type { Clock, TimelineEvent, BlockedSlot, DaySegment, CalendarLabels, EventStatus, TextMeasure, TextMeasureOptions, ContentFit, } from './core/index.js';
 export { auto, neutral, midnight, presets } from './theme/index.js';
 export { probeHostTheme, observeHostTheme } from './theme/index.js';
+export { wrapAdapterWithTimezone } from './core/timezone.js';
 export type { PresetName, AutoThemeOptions } from './theme/index.js';
 export { createCalendar, createAgenda } from './headless/index.js';
 export type { HeadlessCalendarOptions, HeadlessCalendar, HeadlessDay, HeadlessWeek, TodayQueue, HeaderContext, NavigationContext, AgendaOptions, HeadlessAgenda, } from './headless/index.js';

package/dist/index.js

@@ -14,5 +14,6 @@ export { createClock, startOfWeek, fmtH, fmtTime, fmtDuration, weekdayShort, wee
 // ─── Themes ─────────────────────────────────────────────
 export { auto, neutral, midnight, presets } from './theme/index.js';
 export { probeHostTheme, observeHostTheme } from './theme/index.js';
+export { wrapAdapterWithTimezone } from './core/timezone.js';
 // ─── Headless API ───────────────────────────────────────
 export { createCalendar, createAgenda } from './headless/index.js';

package/dist/views/agenda/AgendaDay.svelte

@@ -16,7 +16,7 @@ let {
   oneventclick,
   selectedEventId = null
 } = $props();
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const viewState = $derived(ctx.viewState);
 const equalDays = $derived(ctx.equalDays);
 const isMobile = $derived(ctx.isMobile);

package/dist/views/agenda/AgendaWeek.svelte

@@ -16,7 +16,7 @@ let {
   oneventclick,
   selectedEventId = null
 } = $props();
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const viewState = $derived(ctx.viewState);
 const equalDays = $derived(ctx.equalDays);
 const showDates = $derived(ctx.showDates);

package/dist/views/mobile/MobileDay.svelte

@@ -35,7 +35,7 @@ const blockedSlots = $derived(ctx.blockedSlots);
 const drag = $derived(ctx.drag);
 const commitDragCtx = $derived(ctx.commitDrag);
 const SNAP_MS = $derived(ctx.snapInterval * 6e4);
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const HOUR_HEIGHT = 64;
 const GUTTER_W = 40;
 const startHour = $derived(visibleHours?.[0] ?? 0);

package/dist/views/mobile/MobileWeek.svelte

@@ -34,7 +34,7 @@ const oneventhover = $derived(ctx.oneventhover);
 const disabledSet = $derived(ctx.disabledSet);
 const loadRangeCtx = $derived(ctx.loadRange);
 const minDuration = $derived(ctx.minDuration);
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const MAX_EVENTS = 3;
 const customDays = $derived(viewState?.dayCount ?? 7);
 const todayMs = $derived(clock.today);

package/dist/views/month/MonthGrid.svelte

@@ -29,7 +29,7 @@ const oneventhover = $derived(ctx.oneventhover);
 const ondayclick = $derived(ctx.ondayclick);
 const eventSnippet = $derived(ctx.eventSnippet);
 const loadRangeCtx = $derived(ctx.loadRange);
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const todayMs = $derived(clock.today);
 const MAX_CHIPS = $derived(isMobile ? 2 : 3);
 const range = $derived(viewState?.range);

package/dist/views/planner/PlannerDay.svelte

@@ -29,7 +29,7 @@ let {
   visibleHours
 } = $props();
 const ctx = useCalendarContext();
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const drag = $derived(ctx.drag);
 const commitDragCtx = $derived(ctx.commitDrag);
 const viewState = $derived(ctx.viewState);

package/dist/views/planner/PlannerWeek.svelte

@@ -32,7 +32,7 @@ let {
   readOnly = false
 } = $props();
 const ctx = useCalendarContext();
-const clock = createClock();
+const clock = createClock(ctx.timezone);
 const ANIM = $derived(prefersReducedMotion.current ? 0 : 180);
 const [previewSend, previewReceive] = crossfade({ duration: () => prefersReducedMotion.current ? 0 : 160 });
 const drag = $derived(ctx.drag);

package/dist/views/shared/context.svelte.d.ts

@@ -24,6 +24,7 @@ export interface CalendarContext {
     readonly maxDuration: number | undefined;
     readonly oneventhover: ((event: TimelineEvent) => void) | undefined;
     readonly ondayclick: ((date: Date) => void) | undefined;
+    readonly timezone: string | undefined;
     readonly disabledDates: Date[] | undefined;
     readonly disabledSet: Set<number>;
     readonly loadRange: {

package/dist/views/shared/context.svelte.js

@@ -31,6 +31,7 @@ export function useCalendarContext() {
         get maxDuration() { return raw?.maxDuration; },
         get oneventhover() { return raw?.oneventhover; },
         get ondayclick() { return raw?.ondayclick; },
+        get timezone() { return raw?.timezone; },
         get disabledDates() { return raw?.disabledDates; },
         get disabledSet() { return new Set(raw?.disabledDates?.map(d => sod(d.getTime())) ?? []); },
         get loadRange() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomideusz/svelte-calendar",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"description": "A themeable Svelte 5 calendar with Day and Week views — Planner and Agenda.",
 	"type": "module",
 	"license": "MIT",

package/widget/widget.js

@@ -5358,11 +5358,11 @@
     if (date instanceof Date) return new date.constructor(value);
     return new Date(value);
   }
-  function toDate(argument, context) {
+  function toDate$1(argument, context) {
     return constructFrom(context || argument, argument);
   }
   function addDays(date, amount, options) {
-    const _date = toDate(date, options?.in);
+    const _date = toDate$1(date, options?.in);
     if (isNaN(amount)) return constructFrom(date, NaN);
     if (!amount) return _date;
     _date.setDate(_date.getDate() + amount);
@@ -5375,7 +5375,7 @@
   function startOfWeek$1(date, options) {
     const defaultOptions2 = getDefaultOptions();
     const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
-    const _date = toDate(date, options?.in);
+    const _date = toDate$1(date, options?.in);
     const day = _date.getDay();
     const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
     _date.setDate(_date.getDate() - diff);
@@ -5383,21 +5383,21 @@
     return _date;
   }
   function startOfDay(date, options) {
-    const _date = toDate(date, options?.in);
+    const _date = toDate$1(date, options?.in);
     _date.setHours(0, 0, 0, 0);
     return _date;
   }
   function getDate(date, options) {
-    return toDate(date, options?.in).getDate();
+    return toDate$1(date, options?.in).getDate();
   }
   function getHours(date, options) {
-    return toDate(date, options?.in).getHours();
+    return toDate$1(date, options?.in).getHours();
   }
   function getMinutes(date, options) {
-    return toDate(date, options?.in).getMinutes();
+    return toDate$1(date, options?.in).getMinutes();
   }
   function getSeconds(date) {
-    return toDate(date).getSeconds();
+    return toDate$1(date).getSeconds();
   }
   const DAY_MS = 864e5;
   const HOUR_MS = 36e5;
@@ -6307,6 +6307,9 @@
       get ondayclick() {
         return raw?.ondayclick;
       },
+      get timezone() {
+        return raw?.timezone;
+      },
       get disabledDates() {
         return raw?.disabledDates;
       },
@@ -6422,14 +6425,543 @@
     }
     return [transition2(to_send, to_receive, false), transition2(to_receive, to_send, true)];
   }
-  function createClock() {
-    let tick2 = /* @__PURE__ */ state(proxy(Date.now()));
-    let today = /* @__PURE__ */ state(proxy(sod(Date.now())));
+  function tzTokenizeDate(date, timeZone) {
+    const dtf = getDateTimeFormat(timeZone);
+    return "formatToParts" in dtf ? partsOffset(dtf, date) : hackyOffset(dtf, date);
+  }
+  const typeToPos = {
+    year: 0,
+    month: 1,
+    day: 2,
+    hour: 3,
+    minute: 4,
+    second: 5
+  };
+  function partsOffset(dtf, date) {
+    try {
+      const formatted = dtf.formatToParts(date);
+      const filled = [];
+      for (let i = 0; i < formatted.length; i++) {
+        const pos = typeToPos[formatted[i].type];
+        if (pos !== void 0) {
+          filled[pos] = parseInt(formatted[i].value, 10);
+        }
+      }
+      return filled;
+    } catch (error) {
+      if (error instanceof RangeError) {
+        return [NaN];
+      }
+      throw error;
+    }
+  }
+  function hackyOffset(dtf, date) {
+    const formatted = dtf.format(date);
+    const parsed = /(\d+)\/(\d+)\/(\d+),? (\d+):(\d+):(\d+)/.exec(formatted);
+    return [
+      parseInt(parsed[3], 10),
+      parseInt(parsed[1], 10),
+      parseInt(parsed[2], 10),
+      parseInt(parsed[4], 10),
+      parseInt(parsed[5], 10),
+      parseInt(parsed[6], 10)
+    ];
+  }
+  const dtfCache = {};
+  const testDateFormatted = new Intl.DateTimeFormat("en-US", {
+    hourCycle: "h23",
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).format(/* @__PURE__ */ new Date("2014-06-25T04:00:00.123Z"));
+  const hourCycleSupported = testDateFormatted === "06/25/2014, 00:00:00" || testDateFormatted === "‎06‎/‎25‎/‎2014‎ ‎00‎:‎00‎:‎00";
+  function getDateTimeFormat(timeZone) {
+    if (!dtfCache[timeZone]) {
+      dtfCache[timeZone] = hourCycleSupported ? new Intl.DateTimeFormat("en-US", {
+        hourCycle: "h23",
+        timeZone,
+        year: "numeric",
+        month: "numeric",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }) : new Intl.DateTimeFormat("en-US", {
+        hour12: false,
+        timeZone,
+        year: "numeric",
+        month: "numeric",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+    }
+    return dtfCache[timeZone];
+  }
+  function newDateUTC(fullYear, month, day, hour, minute, second, millisecond) {
+    const utcDate = /* @__PURE__ */ new Date(0);
+    utcDate.setUTCFullYear(fullYear, month, day);
+    utcDate.setUTCHours(hour, minute, second, millisecond);
+    return utcDate;
+  }
+  const MILLISECONDS_IN_HOUR$1 = 36e5;
+  const MILLISECONDS_IN_MINUTE$1 = 6e4;
+  const patterns$1 = {
+    timezoneZ: /^(Z)$/,
+    timezoneHH: /^([+-]\d{2})$/,
+    timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
+  };
+  function tzParseTimezone(timezoneString, date, isUtcDate) {
+    if (!timezoneString) {
+      return 0;
+    }
+    let token = patterns$1.timezoneZ.exec(timezoneString);
+    if (token) {
+      return 0;
+    }
+    let hours;
+    let absoluteOffset;
+    token = patterns$1.timezoneHH.exec(timezoneString);
+    if (token) {
+      hours = parseInt(token[1], 10);
+      if (!validateTimezone(hours)) {
+        return NaN;
+      }
+      return -(hours * MILLISECONDS_IN_HOUR$1);
+    }
+    token = patterns$1.timezoneHHMM.exec(timezoneString);
+    if (token) {
+      hours = parseInt(token[2], 10);
+      const minutes = parseInt(token[3], 10);
+      if (!validateTimezone(hours, minutes)) {
+        return NaN;
+      }
+      absoluteOffset = Math.abs(hours) * MILLISECONDS_IN_HOUR$1 + minutes * MILLISECONDS_IN_MINUTE$1;
+      return token[1] === "+" ? -absoluteOffset : absoluteOffset;
+    }
+    if (isValidTimezoneIANAString(timezoneString)) {
+      date = new Date(date || Date.now());
+      const utcDate = isUtcDate ? date : toUtcDate(date);
+      const offset = calcOffset(utcDate, timezoneString);
+      const fixedOffset = isUtcDate ? offset : fixOffset(date, offset, timezoneString);
+      return -fixedOffset;
+    }
+    return NaN;
+  }
+  function toUtcDate(date) {
+    return newDateUTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+  }
+  function calcOffset(date, timezoneString) {
+    const tokens = tzTokenizeDate(date, timezoneString);
+    const asUTC = newDateUTC(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0).getTime();
+    let asTS = date.getTime();
+    const over = asTS % 1e3;
+    asTS -= over >= 0 ? over : 1e3 + over;
+    return asUTC - asTS;
+  }
+  function fixOffset(date, offset, timezoneString) {
+    const localTS = date.getTime();
+    let utcGuess = localTS - offset;
+    const o2 = calcOffset(new Date(utcGuess), timezoneString);
+    if (offset === o2) {
+      return offset;
+    }
+    utcGuess -= o2 - offset;
+    const o3 = calcOffset(new Date(utcGuess), timezoneString);
+    if (o2 === o3) {
+      return o2;
+    }
+    return Math.max(o2, o3);
+  }
+  function validateTimezone(hours, minutes) {
+    return -23 <= hours && hours <= 23 && (minutes == null || 0 <= minutes && minutes <= 59);
+  }
+  const validIANATimezoneCache = {};
+  function isValidTimezoneIANAString(timeZoneString) {
+    if (validIANATimezoneCache[timeZoneString])
+      return true;
+    try {
+      new Intl.DateTimeFormat(void 0, { timeZone: timeZoneString });
+      validIANATimezoneCache[timeZoneString] = true;
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  function getTimezoneOffsetInMilliseconds(date) {
+    const utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+    utcDate.setUTCFullYear(date.getFullYear());
+    return +date - +utcDate;
+  }
+  const tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
+  const MILLISECONDS_IN_HOUR = 36e5;
+  const MILLISECONDS_IN_MINUTE = 6e4;
+  const DEFAULT_ADDITIONAL_DIGITS = 2;
+  const patterns = {
+    dateTimePattern: /^([0-9W+-]+)(T| )(.*)/,
+    datePattern: /^([0-9W+-]+)(.*)/,
+    // year tokens
+    YY: /^(\d{2})$/,
+    YYY: [
+      /^([+-]\d{2})$/,
+      // 0 additional digits
+      /^([+-]\d{3})$/,
+      // 1 additional digit
+      /^([+-]\d{4})$/
+      // 2 additional digits
+    ],
+    YYYY: /^(\d{4})/,
+    YYYYY: [
+      /^([+-]\d{4})/,
+      // 0 additional digits
+      /^([+-]\d{5})/,
+      // 1 additional digit
+      /^([+-]\d{6})/
+      // 2 additional digits
+    ],
+    // date tokens
+    MM: /^-(\d{2})$/,
+    DDD: /^-?(\d{3})$/,
+    MMDD: /^-?(\d{2})-?(\d{2})$/,
+    Www: /^-?W(\d{2})$/,
+    WwwD: /^-?W(\d{2})-?(\d{1})$/,
+    HH: /^(\d{2}([.,]\d*)?)$/,
+    HHMM: /^(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    HHMMSS: /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    // time zone tokens (to identify the presence of a tz)
+    timeZone: tzPattern
+  };
+  function toDate(argument, options = {}) {
+    if (arguments.length < 1) {
+      throw new TypeError("1 argument required, but only " + arguments.length + " present");
+    }
+    if (argument === null) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    const additionalDigits = options.additionalDigits == null ? DEFAULT_ADDITIONAL_DIGITS : Number(options.additionalDigits);
+    if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
+      throw new RangeError("additionalDigits must be 0, 1 or 2");
+    }
+    if (argument instanceof Date || typeof argument === "object" && Object.prototype.toString.call(argument) === "[object Date]") {
+      return new Date(argument.getTime());
+    } else if (typeof argument === "number" || Object.prototype.toString.call(argument) === "[object Number]") {
+      return new Date(argument);
+    } else if (!(Object.prototype.toString.call(argument) === "[object String]")) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    const dateStrings = splitDateString(argument);
+    const { year, restDateString } = parseYear(dateStrings.date, additionalDigits);
+    const date = parseDate(restDateString, year);
+    if (date === null || isNaN(date.getTime())) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    if (date) {
+      const timestamp = date.getTime();
+      let time = 0;
+      let offset;
+      if (dateStrings.time) {
+        time = parseTime(dateStrings.time);
+        if (time === null || isNaN(time)) {
+          return /* @__PURE__ */ new Date(NaN);
+        }
+      }
+      if (dateStrings.timeZone || options.timeZone) {
+        offset = tzParseTimezone(dateStrings.timeZone || options.timeZone, new Date(timestamp + time));
+        if (isNaN(offset)) {
+          return /* @__PURE__ */ new Date(NaN);
+        }
+      } else {
+        offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time));
+        offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time + offset));
+      }
+      return new Date(timestamp + time + offset);
+    } else {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+  }
+  function splitDateString(dateString) {
+    const dateStrings = {};
+    let parts = patterns.dateTimePattern.exec(dateString);
+    let timeString;
+    if (!parts) {
+      parts = patterns.datePattern.exec(dateString);
+      if (parts) {
+        dateStrings.date = parts[1];
+        timeString = parts[2];
+      } else {
+        dateStrings.date = null;
+        timeString = dateString;
+      }
+    } else {
+      dateStrings.date = parts[1];
+      timeString = parts[3];
+    }
+    if (timeString) {
+      const token = patterns.timeZone.exec(timeString);
+      if (token) {
+        dateStrings.time = timeString.replace(token[1], "");
+        dateStrings.timeZone = token[1].trim();
+      } else {
+        dateStrings.time = timeString;
+      }
+    }
+    return dateStrings;
+  }
+  function parseYear(dateString, additionalDigits) {
+    if (dateString) {
+      const patternYYY = patterns.YYY[additionalDigits];
+      const patternYYYYY = patterns.YYYYY[additionalDigits];
+      let token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
+      if (token) {
+        const yearString = token[1];
+        return {
+          year: parseInt(yearString, 10),
+          restDateString: dateString.slice(yearString.length)
+        };
+      }
+      token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
+      if (token) {
+        const centuryString = token[1];
+        return {
+          year: parseInt(centuryString, 10) * 100,
+          restDateString: dateString.slice(centuryString.length)
+        };
+      }
+    }
+    return {
+      year: null
+    };
+  }
+  function parseDate(dateString, year) {
+    if (year === null) {
+      return null;
+    }
+    let date;
+    let month;
+    let week;
+    if (!dateString || !dateString.length) {
+      date = /* @__PURE__ */ new Date(0);
+      date.setUTCFullYear(year);
+      return date;
+    }
+    let token = patterns.MM.exec(dateString);
+    if (token) {
+      date = /* @__PURE__ */ new Date(0);
+      month = parseInt(token[1], 10) - 1;
+      if (!validateDate(year, month)) {
+        return /* @__PURE__ */ new Date(NaN);
+      }
+      date.setUTCFullYear(year, month);
+      return date;
+    }
+    token = patterns.DDD.exec(dateString);
+    if (token) {
+      date = /* @__PURE__ */ new Date(0);
+      const dayOfYear = parseInt(token[1], 10);
+      if (!validateDayOfYearDate(year, dayOfYear)) {
+        return /* @__PURE__ */ new Date(NaN);
+      }
+      date.setUTCFullYear(year, 0, dayOfYear);
+      return date;
+    }
+    token = patterns.MMDD.exec(dateString);
+    if (token) {
+      date = /* @__PURE__ */ new Date(0);
+      month = parseInt(token[1], 10) - 1;
+      const day = parseInt(token[2], 10);
+      if (!validateDate(year, month, day)) {
+        return /* @__PURE__ */ new Date(NaN);
+      }
+      date.setUTCFullYear(year, month, day);
+      return date;
+    }
+    token = patterns.Www.exec(dateString);
+    if (token) {
+      week = parseInt(token[1], 10) - 1;
+      if (!validateWeekDate(week)) {
+        return /* @__PURE__ */ new Date(NaN);
+      }
+      return dayOfISOWeekYear(year, week);
+    }
+    token = patterns.WwwD.exec(dateString);
+    if (token) {
+      week = parseInt(token[1], 10) - 1;
+      const dayOfWeek = parseInt(token[2], 10) - 1;
+      if (!validateWeekDate(week, dayOfWeek)) {
+        return /* @__PURE__ */ new Date(NaN);
+      }
+      return dayOfISOWeekYear(year, week, dayOfWeek);
+    }
+    return null;
+  }
+  function parseTime(timeString) {
+    let hours;
+    let minutes;
+    let token = patterns.HH.exec(timeString);
+    if (token) {
+      hours = parseFloat(token[1].replace(",", "."));
+      if (!validateTime(hours)) {
+        return NaN;
+      }
+      return hours % 24 * MILLISECONDS_IN_HOUR;
+    }
+    token = patterns.HHMM.exec(timeString);
+    if (token) {
+      hours = parseInt(token[1], 10);
+      minutes = parseFloat(token[2].replace(",", "."));
+      if (!validateTime(hours, minutes)) {
+        return NaN;
+      }
+      return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE;
+    }
+    token = patterns.HHMMSS.exec(timeString);
+    if (token) {
+      hours = parseInt(token[1], 10);
+      minutes = parseInt(token[2], 10);
+      const seconds = parseFloat(token[3].replace(",", "."));
+      if (!validateTime(hours, minutes, seconds)) {
+        return NaN;
+      }
+      return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE + seconds * 1e3;
+    }
+    return null;
+  }
+  function dayOfISOWeekYear(isoWeekYear, week, day) {
+    week = week || 0;
+    day = day || 0;
+    const date = /* @__PURE__ */ new Date(0);
+    date.setUTCFullYear(isoWeekYear, 0, 4);
+    const fourthOfJanuaryDay = date.getUTCDay() || 7;
+    const diff = week * 7 + day + 1 - fourthOfJanuaryDay;
+    date.setUTCDate(date.getUTCDate() + diff);
+    return date;
+  }
+  const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  const DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  function isLeapYearIndex(year) {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+  }
+  function validateDate(year, month, date) {
+    if (month < 0 || month > 11) {
+      return false;
+    }
+    if (date != null) {
+      if (date < 1) {
+        return false;
+      }
+      const isLeapYear = isLeapYearIndex(year);
+      if (isLeapYear && date > DAYS_IN_MONTH_LEAP_YEAR[month]) {
+        return false;
+      }
+      if (!isLeapYear && date > DAYS_IN_MONTH[month]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function validateDayOfYearDate(year, dayOfYear) {
+    if (dayOfYear < 1) {
+      return false;
+    }
+    const isLeapYear = isLeapYearIndex(year);
+    if (isLeapYear && dayOfYear > 366) {
+      return false;
+    }
+    if (!isLeapYear && dayOfYear > 365) {
+      return false;
+    }
+    return true;
+  }
+  function validateWeekDate(week, day) {
+    if (week < 0 || week > 52) {
+      return false;
+    }
+    if (day != null && (day < 0 || day > 6)) {
+      return false;
+    }
+    return true;
+  }
+  function validateTime(hours, minutes, seconds) {
+    if (hours < 0 || hours >= 25) {
+      return false;
+    }
+    if (minutes != null && (minutes < 0 || minutes >= 60)) {
+      return false;
+    }
+    if (seconds != null && (seconds < 0 || seconds >= 60)) {
+      return false;
+    }
+    return true;
+  }
+  function toZonedTime$1(date, timeZone, options) {
+    date = toDate(date, options);
+    const offsetMilliseconds = tzParseTimezone(timeZone, date, true);
+    const d = new Date(date.getTime() - offsetMilliseconds);
+    const resultDate = /* @__PURE__ */ new Date(0);
+    resultDate.setFullYear(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    resultDate.setHours(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+    return resultDate;
+  }
+  function fromZonedTime$1(date, timeZone, options) {
+    if (typeof date === "string" && !date.match(tzPattern)) {
+      return toDate(date, { ...options, timeZone });
+    }
+    date = toDate(date, options);
+    const utc = newDateUTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()).getTime();
+    const offsetMilliseconds = tzParseTimezone(timeZone, new Date(utc));
+    return new Date(utc + offsetMilliseconds);
+  }
+  function toZonedTime(date, timezone) {
+    return toZonedTime$1(date, timezone);
+  }
+  function fromZonedTime(date, timezone) {
+    return fromZonedTime$1(date, timezone);
+  }
+  function wrapAdapterWithTimezone(adapter, timezone) {
+    const zoneEvent = (ev) => ({
+      ...ev,
+      start: toZonedTime(ev.start, timezone),
+      end: toZonedTime(ev.end, timezone)
+    });
+    const unzonePartial = (obj) => ({
+      ...obj,
+      ...obj.start instanceof Date ? { start: fromZonedTime(obj.start, timezone) } : {},
+      ...obj.end instanceof Date ? { end: fromZonedTime(obj.end, timezone) } : {}
+    });
+    const wrapped = {
+      async fetchEvents(range) {
+        const events = await adapter.fetchEvents({
+          start: fromZonedTime(range.start, timezone),
+          end: fromZonedTime(range.end, timezone)
+        });
+        return events.map(zoneEvent);
+      }
+    };
+    if (adapter.createEvent) {
+      wrapped.createEvent = async (event2) => zoneEvent(await adapter.createEvent(unzonePartial(event2)));
+    }
+    if (adapter.updateEvent) {
+      wrapped.updateEvent = async (id, patch) => zoneEvent(await adapter.updateEvent(id, unzonePartial(patch)));
+    }
+    if (adapter.deleteEvent) {
+      wrapped.deleteEvent = (id) => adapter.deleteEvent(id);
+    }
+    return wrapped;
+  }
+  function createClock(timezone) {
+    const now2 = () => timezone ? toZonedTime(Date.now(), timezone).getTime() : Date.now();
+    let tick2 = /* @__PURE__ */ state(proxy(now2()));
+    let today = /* @__PURE__ */ state(proxy(sod(get(tick2))));
     let intervalId = null;
     function start() {
       intervalId = setInterval(
         () => {
-          set(tick2, Date.now(), true);
+          set(tick2, now2(), true);
           const sd = sod(get(tick2));
           if (sd !== get(today)) set(today, sd, true);
         },
@@ -6633,7 +7165,7 @@
     const L = /* @__PURE__ */ user_derived(getLabels);
     let height = prop($$props, "height", 3, 520), events = prop($$props, "events", 19, () => []), style = prop($$props, "style", 3, ""), selectedEventId = prop($$props, "selectedEventId", 3, null), readOnly = prop($$props, "readOnly", 3, false);
     const ctx = useCalendarContext();
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const drag = /* @__PURE__ */ user_derived(() => ctx.drag);
     const commitDragCtx = /* @__PURE__ */ user_derived(() => ctx.commitDrag);
     const viewState = /* @__PURE__ */ user_derived(() => ctx.viewState);
@@ -7741,7 +8273,7 @@
     const L = /* @__PURE__ */ user_derived(getLabels);
     let mondayStart = prop($$props, "mondayStart", 3, true), height = prop($$props, "height", 3, 520), events = prop($$props, "events", 19, () => []), style = prop($$props, "style", 3, ""), selectedEventId = prop($$props, "selectedEventId", 3, null), readOnly = prop($$props, "readOnly", 3, false);
     const ctx = useCalendarContext();
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const ANIM = /* @__PURE__ */ user_derived(() => prefersReducedMotion.current ? 0 : 180);
     const [previewSend, previewReceive] = crossfade({ duration: () => prefersReducedMotion.current ? 0 : 160 });
     const drag = /* @__PURE__ */ user_derived(() => ctx.drag);
@@ -8424,7 +8956,7 @@
     const ctx = useCalendarContext();
     const emptySnippet = /* @__PURE__ */ user_derived(() => ctx.emptySnippet);
     let events = prop($$props, "events", 19, () => []), style = prop($$props, "style", 3, ""), selectedEventId = prop($$props, "selectedEventId", 3, null);
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const viewState = /* @__PURE__ */ user_derived(() => ctx.viewState);
     const equalDays = /* @__PURE__ */ user_derived(() => ctx.equalDays);
     const isMobile = /* @__PURE__ */ user_derived(() => ctx.isMobile);
@@ -9418,7 +9950,7 @@
     let mondayStart = prop($$props, "mondayStart", 3, true);
     prop($$props, "height", 3, 520);
     let events = prop($$props, "events", 19, () => []), style = prop($$props, "style", 3, ""), selectedEventId = prop($$props, "selectedEventId", 3, null);
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const viewState = /* @__PURE__ */ user_derived(() => ctx.viewState);
     const equalDays = /* @__PURE__ */ user_derived(() => ctx.equalDays);
     const showDates = /* @__PURE__ */ user_derived(() => ctx.showDates);
@@ -10060,7 +10592,7 @@
     const drag = /* @__PURE__ */ user_derived(() => ctx.drag);
     const commitDragCtx = /* @__PURE__ */ user_derived(() => ctx.commitDrag);
     const SNAP_MS = /* @__PURE__ */ user_derived(() => ctx.snapInterval * 6e4);
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const HOUR_HEIGHT = 64;
     const GUTTER_W = 40;
     const startHour = /* @__PURE__ */ user_derived(() => $$props.visibleHours?.[0] ?? 0);
@@ -10723,7 +11255,7 @@
     const oneventhover = /* @__PURE__ */ user_derived(() => ctx.oneventhover);
     const disabledSet = /* @__PURE__ */ user_derived(() => ctx.disabledSet);
     const loadRangeCtx = /* @__PURE__ */ user_derived(() => ctx.loadRange);
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const MAX_EVENTS = 3;
     const customDays = /* @__PURE__ */ user_derived(() => get(viewState)?.dayCount ?? 7);
     const todayMs = /* @__PURE__ */ user_derived(() => clock.today);
@@ -11034,7 +11566,7 @@
     const ondayclick = /* @__PURE__ */ user_derived(() => ctx.ondayclick);
     const eventSnippet = /* @__PURE__ */ user_derived(() => ctx.eventSnippet);
     const loadRangeCtx = /* @__PURE__ */ user_derived(() => ctx.loadRange);
-    const clock = createClock();
+    const clock = createClock(ctx.timezone);
     const todayMs = /* @__PURE__ */ user_derived(() => clock.today);
     const MAX_CHIPS = /* @__PURE__ */ user_derived(() => get(isMobile) ? 2 : 3);
     const range = /* @__PURE__ */ user_derived(() => get(viewState)?.range);
@@ -11294,8 +11826,9 @@
       }
     ];
     let views = prop($$props, "views", 3, DEFAULT_VIEWS), theme = prop($$props, "theme", 3, auto), mondayStart = prop($$props, "mondayStart", 3, true), heightProp = prop($$props, "height", 3, 600), borderRadius = prop($$props, "borderRadius", 3, 12), readOnly = prop($$props, "readOnly", 3, false), snapInterval = prop($$props, "snapInterval", 3, 15), showModePills = prop($$props, "showModePills", 3, true), showNavigation = prop($$props, "showNavigation", 3, true), equalDays = prop($$props, "equalDays", 3, false), showDates = prop($$props, "showDates", 3, true), compact = prop($$props, "compact", 3, false), mobileProp = prop($$props, "mobile", 3, "auto");
-    const effectiveCreate = /* @__PURE__ */ user_derived(() => readOnly() ? void 0 : $$props.oneventcreate);
-    const effectiveMove = /* @__PURE__ */ user_derived(() => readOnly() ? void 0 : $$props.oneventmove);
+    const unzone = (d) => $$props.timezone ? fromZonedTime(d, $$props.timezone) : d;
+    const effectiveCreate = /* @__PURE__ */ user_derived(() => readOnly() || !$$props.oneventcreate ? void 0 : (range) => $$props.oneventcreate({ start: unzone(range.start), end: unzone(range.end) }));
+    const effectiveMove = /* @__PURE__ */ user_derived(() => readOnly() || !$$props.oneventmove ? void 0 : (ev, start, end) => $$props.oneventmove(ev, unzone(start), unzone(end)));
     function handleEventClick(ev) {
       selection.select(ev.id);
       $$props.oneventclick?.(ev);
@@ -11328,12 +11861,15 @@
       };
     });
     const effectiveTheme = /* @__PURE__ */ user_derived(() => theme() === auto && $$props.autoTheme !== false ? get(probedTheme) : theme());
-    const store = /* @__PURE__ */ user_derived(() => createEventStore($$props.adapter));
+    const effectiveAdapter = /* @__PURE__ */ user_derived(() => $$props.timezone ? wrapAdapterWithTimezone($$props.adapter, $$props.timezone) : $$props.adapter);
+    const store = /* @__PURE__ */ user_derived(() => createEventStore(get(effectiveAdapter)));
     const viewState = createViewState(untrack(() => ({
       view: $$props.view ?? views()[0]?.id,
       mondayStart: mondayStart(),
-      initialDate: $$props.initialDate,
+      // Focus lives on the zoned plane too — day boundaries follow the zone.
+      initialDate: $$props.initialDate && $$props.timezone ? toZonedTime($$props.initialDate, $$props.timezone) : $$props.initialDate,
       dayCount: $$props.days,
+      timezone: $$props.timezone,
       modeForView: (viewId) => views().find((v) => v.id === viewId)?.mode
     })));
     const selection = createSelection();
@@ -11437,6 +11973,9 @@
       get ondayclick() {
         return $$props.ondayclick;
       },
+      get timezone() {
+        return $$props.timezone;
+      },
       // Config (reactive via getters)
       get readOnly() {
         return readOnly();