@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-NZGJN7HG.mjs

@@ -0,0 +1,314 @@
+import { startOfDay, timeStringToMinutes, addDays, minutesToPixels } from './chunk-WFUJWDST.mjs';
+import { createSchedulerDateFormatter, formatTimeRange } from './chunk-TNKJPFGI.mjs';
+
+// src/utils/appointment-slots.ts
+var DEFAULT_APPOINTMENT_SLOTS_OPTIONS = {
+  enabled: false,
+  displayMode: "overlay",
+  showAvailability: true,
+  showCapacity: false,
+  slotDuration: 30,
+  autoGenerate: false
+};
+function normalizeAppointmentSlotsOptions(options) {
+  if (options === false || options === void 0) {
+    return { ...DEFAULT_APPOINTMENT_SLOTS_OPTIONS, enabled: false };
+  }
+  if (options === true) {
+    return { ...DEFAULT_APPOINTMENT_SLOTS_OPTIONS, enabled: true };
+  }
+  return { ...DEFAULT_APPOINTMENT_SLOTS_OPTIONS, ...options, enabled: options.enabled ?? true };
+}
+function generateAppointmentSlots(date, slotDuration, minTime, maxTime, resourceId) {
+  const slots = [];
+  const dayStart = startOfDay(date);
+  const startMinutes = timeStringToMinutes(minTime);
+  const endMinutes = timeStringToMinutes(maxTime);
+  let currentMinutes = startMinutes;
+  let slotIndex = 0;
+  while (currentMinutes < endMinutes) {
+    const slotStart = new Date(dayStart);
+    slotStart.setMinutes(currentMinutes);
+    const slotEnd = new Date(dayStart);
+    slotEnd.setMinutes(Math.min(currentMinutes + slotDuration, endMinutes));
+    const slot = {
+      id: `slot-${date.toISOString().split("T")[0]}-${slotIndex}${resourceId ? `-${resourceId}` : ""}`,
+      start: slotStart,
+      end: slotEnd,
+      status: "available",
+      resourceId
+    };
+    slots.push(slot);
+    currentMinutes += slotDuration;
+    slotIndex++;
+  }
+  return slots;
+}
+function getSlotsForDay(options, date, resource, minTime = "00:00", maxTime = "24:00") {
+  const dayStart = startOfDay(date);
+  const dayEnd = addDays(dayStart, 1);
+  if (options.generateSlots) {
+    return options.generateSlots(date, resource);
+  }
+  if (options.autoGenerate && options.slotDuration) {
+    return generateAppointmentSlots(date, options.slotDuration, minTime, maxTime, resource?.id);
+  }
+  if (options.slots) {
+    return options.slots.filter((slot) => {
+      const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+      const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+      const isInDay = slotStart < dayEnd && slotEnd > dayStart;
+      if (resource) {
+        return isInDay && (slot.resourceId === resource.id || slot.resourceId === void 0);
+      }
+      return isInDay;
+    });
+  }
+  return [];
+}
+function getSlotsForTimeRange(options, startDate, endDate, resource, minTime = "00:00", maxTime = "24:00") {
+  const slots = [];
+  let currentDate = startOfDay(startDate);
+  const rangeEnd = startOfDay(endDate);
+  while (currentDate <= rangeEnd) {
+    const daySlots = getSlotsForDay(options, currentDate, resource, minTime, maxTime);
+    slots.push(...daySlots);
+    currentDate = addDays(currentDate, 1);
+  }
+  return slots;
+}
+function getEventDates(event) {
+  const start = typeof event.start === "string" ? new Date(event.start) : new Date(event.start);
+  const end = event.end ? typeof event.end === "string" ? new Date(event.end) : new Date(event.end) : new Date(start.getTime() + (event.duration ?? 30) * 60 * 1e3);
+  return { start, end };
+}
+function updateSlotAvailability(slot, events) {
+  const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+  const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+  const overlappingEvents = events.filter((event) => {
+    if (slot.resourceId !== void 0) {
+      const eventResourceId = event.resourceId ?? event.resourceIds?.[0];
+      if (eventResourceId !== slot.resourceId) return false;
+    }
+    const { start: eventStart, end: eventEnd } = getEventDates(event);
+    return eventStart < slotEnd && eventEnd > slotStart;
+  });
+  const bookedCount = overlappingEvents.length;
+  const capacity = slot.capacity ?? 1;
+  let status = slot.status;
+  if (slot.status !== "blocked") {
+    if (bookedCount >= capacity) {
+      status = "booked";
+    } else if (bookedCount > 0) {
+      status = "tentative";
+    } else {
+      status = "available";
+    }
+  }
+  return {
+    ...slot,
+    bookedCount,
+    status
+  };
+}
+function updateSlotsAvailability(slots, events) {
+  return slots.map((slot) => updateSlotAvailability(slot, events));
+}
+function canBookSlot(slot) {
+  if (slot.status === "blocked" || slot.status === "booked") {
+    return false;
+  }
+  if (slot.capacity !== void 0 && slot.bookedCount !== void 0) {
+    return slot.bookedCount < slot.capacity;
+  }
+  return slot.status === "available" || slot.status === "tentative";
+}
+function getSlotAtTime(slots, date, resourceId) {
+  return slots.find((slot) => {
+    const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+    const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+    const isInTimeRange = date >= slotStart && date < slotEnd;
+    if (resourceId !== void 0 && slot.resourceId !== void 0) {
+      return isInTimeRange && slot.resourceId === resourceId;
+    }
+    return isInTimeRange;
+  });
+}
+function getSlotsInTimeRange(slots, start, end, resourceId) {
+  return slots.filter((slot) => {
+    const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+    const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+    const overlaps = slotStart < end && slotEnd > start;
+    if (resourceId !== void 0 && slot.resourceId !== void 0) {
+      return overlaps && slot.resourceId === resourceId;
+    }
+    return overlaps;
+  });
+}
+function getAvailableSlots(slots) {
+  return slots.filter((slot) => slot.status === "available" || slot.status === "tentative");
+}
+function getSlotCapacityDisplay(slot) {
+  if (slot.capacity === void 0) return "";
+  const booked = slot.bookedCount ?? 0;
+  return `${booked}/${slot.capacity}`;
+}
+function getSlotById(slots, id) {
+  return slots.find((slot) => slot.id === id);
+}
+function createSlotFromTimeRange(start, end, resourceId, options) {
+  return {
+    id: `slot-${start.getTime()}-${end.getTime()}${resourceId ? `-${resourceId}` : ""}`,
+    start,
+    end,
+    resourceId,
+    status: "available",
+    ...options
+  };
+}
+function toSlotDate(value) {
+  return value instanceof Date ? value : new Date(value);
+}
+function getAppointmentSlotDisplayLabels(slot, options = {}) {
+  const start = toSlotDate(slot.start);
+  const end = toSlotDate(slot.end);
+  const formatter = createSchedulerDateFormatter(options);
+  const dateLabel = formatter.format(start, options.dateOptions ?? { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const timeRangeLabel = formatTimeRange(start, end, formatter.config.locale, options.timeFormat, formatter.config.timeZone);
+  const summaryLabel = options.includeDate === false ? timeRangeLabel : `${dateLabel}, ${timeRangeLabel}`;
+  const ariaLabel = `${slot.status ?? "available"} appointment slot, ${summaryLabel}`;
+  return {
+    dateLabel,
+    timeRangeLabel,
+    summaryLabel,
+    ariaLabel
+  };
+}
+function getAppointmentSlotOverlays(options, date, events, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId) {
+  if (!options.enabled || !options.showAvailability) return [];
+  const resource = resourceId !== void 0 ? { id: resourceId, title: "" } : void 0;
+  let slots = getSlotsForDay(options, date, resource, slotMinTime, slotMaxTime);
+  if (resourceId !== void 0) {
+    slots = slots.filter((slot) => slot.resourceId === resourceId || slot.resourceId === void 0);
+  }
+  slots = updateSlotsAvailability(slots, events);
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  const overlays = [];
+  for (const slot of slots) {
+    const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+    const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+    const slotStartMinutes = slotStart.getHours() * 60 + slotStart.getMinutes();
+    const slotEndMinutes = slotEnd.getHours() * 60 + slotEnd.getMinutes();
+    const clampedStart = Math.max(slotStartMinutes, slotMinMinutes);
+    const clampedEnd = Math.min(slotEndMinutes, slotMaxMinutes);
+    if (clampedStart >= clampedEnd) continue;
+    const top = minutesToPixels(clampedStart - slotMinMinutes, slotDuration, slotHeight);
+    const height = minutesToPixels(clampedEnd - clampedStart, slotDuration, slotHeight);
+    overlays.push({
+      slot,
+      top,
+      height,
+      status: slot.status,
+      capacityDisplay: options.showCapacity && slot.capacity !== void 0 ? getSlotCapacityDisplay(slot) : void 0,
+      displayMode: options.displayMode
+    });
+  }
+  return overlays;
+}
+function getAppointmentSlotIndicators(options, date, events, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId) {
+  if (!options.enabled || !options.showAvailability) return [];
+  const resource = resourceId !== void 0 ? { id: resourceId, title: "" } : void 0;
+  let slots = getSlotsForDay(options, date, resource, slotMinTime, slotMaxTime);
+  if (resourceId !== void 0) {
+    slots = slots.filter((slot) => slot.resourceId === resourceId || slot.resourceId === void 0);
+  }
+  slots = updateSlotsAvailability(slots, events);
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  const indicatorsByTimeSlot = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+    const slotStartMinutes = slotStart.getHours() * 60 + slotStart.getMinutes();
+    if (slotStartMinutes < slotMinMinutes || slotStartMinutes >= slotMaxMinutes) continue;
+    const timeSlotKey = Math.floor((slotStartMinutes - slotMinMinutes) / slotDuration) * slotDuration + slotMinMinutes;
+    if (!indicatorsByTimeSlot.has(timeSlotKey)) {
+      indicatorsByTimeSlot.set(timeSlotKey, {
+        timeSlotMinutes: timeSlotKey,
+        top: minutesToPixels(timeSlotKey - slotMinMinutes, slotDuration, slotHeight) + slotHeight / 2,
+        slots: [],
+        availableCount: 0,
+        bookedCount: 0,
+        blockedCount: 0,
+        tentativeCount: 0,
+        primaryStatus: "available"
+      });
+    }
+    const indicator = indicatorsByTimeSlot.get(timeSlotKey);
+    indicator.slots.push(slot);
+    switch (slot.status) {
+      case "available":
+        indicator.availableCount++;
+        break;
+      case "booked":
+        indicator.bookedCount++;
+        break;
+      case "blocked":
+        indicator.blockedCount++;
+        break;
+      case "tentative":
+        indicator.tentativeCount++;
+        break;
+    }
+  }
+  for (const indicator of indicatorsByTimeSlot.values()) {
+    if (indicator.availableCount > 0) {
+      indicator.primaryStatus = "available";
+    } else if (indicator.tentativeCount > 0) {
+      indicator.primaryStatus = "tentative";
+    } else if (indicator.blockedCount > 0) {
+      indicator.primaryStatus = "blocked";
+    } else {
+      indicator.primaryStatus = "booked";
+    }
+  }
+  return Array.from(indicatorsByTimeSlot.values()).sort((a, b) => a.timeSlotMinutes - b.timeSlotMinutes);
+}
+function getSlotOverlayClasses(overlay) {
+  const classes = ["p-scheduler-appointment-slot", `p-scheduler-appointment-slot-${overlay.status}`];
+  switch (overlay.displayMode) {
+    case "overlay":
+      classes.push("p-scheduler-appointment-slot-overlay");
+      break;
+    case "grid":
+      classes.push("p-scheduler-appointment-slot-grid");
+      break;
+    case "indicator":
+      classes.push("p-scheduler-appointment-slot-indicator");
+      break;
+  }
+  return classes;
+}
+function getSlotOverlayStyle(overlay) {
+  const style = {
+    position: "absolute",
+    top: `${overlay.top}px`,
+    zIndex: "0"
+  };
+  switch (overlay.displayMode) {
+    case "overlay":
+      style.left = "2px";
+      style.right = "2px";
+      style.height = `${overlay.height}px`;
+      break;
+    case "grid":
+      style.left = "4px";
+      style.right = "4px";
+      style.height = `${Math.max(overlay.height - 4, 20)}px`;
+      style.marginTop = "2px";
+      break;
+  }
+  return style;
+}
+
+export { DEFAULT_APPOINTMENT_SLOTS_OPTIONS, canBookSlot, createSlotFromTimeRange, generateAppointmentSlots, getAppointmentSlotDisplayLabels, getAppointmentSlotIndicators, getAppointmentSlotOverlays, getAvailableSlots, getSlotAtTime, getSlotById, getSlotCapacityDisplay, getSlotOverlayClasses, getSlotOverlayStyle, getSlotsForDay, getSlotsForTimeRange, getSlotsInTimeRange, normalizeAppointmentSlotsOptions, updateSlotAvailability, updateSlotsAvailability };

package/dist/chunk-QDMZBJDV.mjs

@@ -0,0 +1,251 @@
+// src/utils/timezone.ts
+var formatCache = /* @__PURE__ */ new Map();
+function getFormatter(timezone, options = {}) {
+  const key = `${timezone}-${JSON.stringify(options)}`;
+  let formatter = formatCache.get(key);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      ...options,
+      timeZone: timezone
+    });
+    formatCache.set(key, formatter);
+  }
+  return formatter;
+}
+function isValidTimezone(timezone) {
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timezone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getLocalTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function getTimezoneOffset(date, timezone) {
+  const targetDate = new Date(date.toLocaleString("en-US", { timeZone: timezone }));
+  const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+  return (utcDate.getTime() - targetDate.getTime()) / (60 * 1e3);
+}
+function getTimezoneOffsetString(date, timezone) {
+  const formatter = getFormatter(timezone, {
+    timeZoneName: "shortOffset"
+  });
+  const parts = formatter.formatToParts(date);
+  const tzPart = parts.find((p) => p.type === "timeZoneName");
+  if (tzPart) {
+    const match = tzPart.value.match(/GMT([+-]\d{1,2}(?::\d{2})?)?/);
+    if (match) {
+      return match[1] || "+0";
+    }
+  }
+  const offset = getTimezoneOffset(date, timezone);
+  const sign = offset <= 0 ? "+" : "-";
+  const hours = Math.floor(Math.abs(offset) / 60);
+  const minutes = Math.abs(offset) % 60;
+  return `${sign}${hours}${minutes > 0 ? ":" + String(minutes).padStart(2, "0") : ""}`;
+}
+function getTimezoneAbbreviation(date, timezone) {
+  const formatter = getFormatter(timezone, {
+    timeZoneName: "short"
+  });
+  const parts = formatter.formatToParts(date);
+  const tzPart = parts.find((p) => p.type === "timeZoneName");
+  return tzPart?.value || timezone;
+}
+function getTimezoneName(date, timezone, style = "long") {
+  const formatter = getFormatter(timezone, {
+    timeZoneName: style
+  });
+  const parts = formatter.formatToParts(date);
+  const tzPart = parts.find((p) => p.type === "timeZoneName");
+  return tzPart?.value || timezone;
+}
+function getTimezoneInfo(date, timezone) {
+  return {
+    id: timezone,
+    offset: getTimezoneOffset(date, timezone),
+    offsetString: getTimezoneOffsetString(date, timezone),
+    name: getTimezoneName(date, timezone),
+    abbreviation: getTimezoneAbbreviation(date, timezone)
+  };
+}
+function formatInTimezone(date, timezone, options = {}) {
+  return new Intl.DateTimeFormat("en-US", {
+    ...options,
+    timeZone: timezone
+  }).format(date);
+}
+function formatTimeInTimezone(date, timezone, locale = "en") {
+  return new Intl.DateTimeFormat(locale, {
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: timezone
+  }).format(date);
+}
+function formatDateInTimezone(date, timezone, locale = "en") {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    timeZone: timezone
+  }).format(date);
+}
+function formatDateTimeInTimezone(date, timezone, locale = "en") {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: timezone
+  }).format(date);
+}
+function toTimezone(date, fromTimezone, toTimezone2) {
+  const fromOffset = getTimezoneOffset(date, fromTimezone);
+  const toOffset = getTimezoneOffset(date, toTimezone2);
+  const diff = (fromOffset - toOffset) * 60 * 1e3;
+  return new Date(date.getTime() + diff);
+}
+function toUTC(date, timezone) {
+  return toTimezone(date, timezone, "UTC");
+}
+function fromUTC(date, timezone) {
+  return toTimezone(date, "UTC", timezone);
+}
+function toLocalTimezone(date, fromTimezone) {
+  return toTimezone(date, fromTimezone, getLocalTimezone());
+}
+function fromLocalTimezone(date, targetTimezone) {
+  return toTimezone(date, getLocalTimezone(), targetTimezone);
+}
+function getDatePartsInTimezone(date, timezone) {
+  const formatter = getFormatter(timezone, {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+    weekday: "short",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const getValue = (type) => {
+    const part = parts.find((p) => p.type === type);
+    return part ? parseInt(part.value, 10) : 0;
+  };
+  const weekdayPart = parts.find((p) => p.type === "weekday");
+  const weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const dayOfWeek = weekdayPart ? weekdays.indexOf(weekdayPart.value) : date.getDay();
+  return {
+    year: getValue("year"),
+    month: getValue("month") - 1,
+    day: getValue("day"),
+    // Some ICU/timezone combinations report midnight as hour 24 with hour12:false; normalize to 0.
+    hour: getValue("hour") % 24,
+    minute: getValue("minute"),
+    second: getValue("second"),
+    dayOfWeek: dayOfWeek >= 0 ? dayOfWeek : 0
+  };
+}
+function createDateInTimezone(timezone, year, month, day, hour = 0, minute = 0, second = 0) {
+  const utcGuess = Date.UTC(year, month, day, hour, minute, second);
+  const offset = getTimezoneOffset(new Date(utcGuess), timezone);
+  const adjusted = new Date(utcGuess + offset * 60 * 1e3);
+  const verifyOffset = getTimezoneOffset(adjusted, timezone);
+  if (verifyOffset !== offset) {
+    return new Date(utcGuess + verifyOffset * 60 * 1e3);
+  }
+  return adjusted;
+}
+function isSameDayInTimezone(d1, d2, timezone) {
+  const parts1 = getDatePartsInTimezone(d1, timezone);
+  const parts2 = getDatePartsInTimezone(d2, timezone);
+  return parts1.year === parts2.year && parts1.month === parts2.month && parts1.day === parts2.day;
+}
+function isTodayInTimezone(date, timezone) {
+  return isSameDayInTimezone(date, /* @__PURE__ */ new Date(), timezone);
+}
+function startOfDayInTimezone(date, timezone) {
+  const parts = getDatePartsInTimezone(date, timezone);
+  return createDateInTimezone(timezone, parts.year, parts.month, parts.day, 0, 0, 0);
+}
+function endOfDayInTimezone(date, timezone) {
+  const parts = getDatePartsInTimezone(date, timezone);
+  return createDateInTimezone(timezone, parts.year, parts.month, parts.day, 23, 59, 59);
+}
+function convertEventToDisplayTimezone(event, schedulerTimezone) {
+  const eventTz = event.timezone;
+  if (!eventTz || eventTz === schedulerTimezone) {
+    return event;
+  }
+  const newStart = toTimezone(event.start, eventTz, schedulerTimezone);
+  const newEnd = toTimezone(event.end, eventTz, schedulerTimezone);
+  const durationMinutes = Math.round((newEnd.getTime() - newStart.getTime()) / (1e3 * 60));
+  const startDay = new Date(newStart.getFullYear(), newStart.getMonth(), newStart.getDate());
+  const endDay = new Date(newEnd.getFullYear(), newEnd.getMonth(), newEnd.getDate());
+  const spanDays = Math.ceil((endDay.getTime() - startDay.getTime()) / (1e3 * 60 * 60 * 24)) + 1;
+  return {
+    ...event,
+    start: newStart,
+    end: newEnd,
+    durationMinutes,
+    isMultiDay: event.isMultiDay !== void 0 ? spanDays > 1 || !!event.isMultiDay : void 0,
+    spanDays: event.spanDays !== void 0 ? spanDays : void 0
+  };
+}
+function convertEventsToTimezone(events, schedulerTimezone) {
+  if (!schedulerTimezone) return events;
+  return events.map((event) => convertEventToDisplayTimezone(event, schedulerTimezone));
+}
+function getTimezoneDisplayLabel(timezone, displayTimezone) {
+  if (!timezone && !displayTimezone) return null;
+  const tz = displayTimezone || timezone;
+  if (!tz) return null;
+  if (tz === "UTC") return "UTC";
+  const now = /* @__PURE__ */ new Date();
+  return getTimezoneAbbreviation(now, tz);
+}
+var COMMON_TIMEZONES = [
+  "UTC",
+  "America/New_York",
+  "America/Chicago",
+  "America/Denver",
+  "America/Los_Angeles",
+  "America/Anchorage",
+  "Pacific/Honolulu",
+  "Europe/London",
+  "Europe/Paris",
+  "Europe/Berlin",
+  "Europe/Moscow",
+  "Asia/Dubai",
+  "Asia/Kolkata",
+  "Asia/Shanghai",
+  "Asia/Tokyo",
+  "Asia/Singapore",
+  "Australia/Sydney",
+  "Pacific/Auckland"
+];
+function getCommonTimezones() {
+  const now = /* @__PURE__ */ new Date();
+  return COMMON_TIMEZONES.map((tz) => getTimezoneInfo(now, tz));
+}
+function parseISOWithTimezone(isoString) {
+  const match = isoString.match(/^(.+?)(?:\[(.+?)\])?$/);
+  if (!match) {
+    return { date: new Date(isoString), timezone: null };
+  }
+  const dateString = match[1];
+  const timezone = match[2] || null;
+  return { date: new Date(dateString), timezone };
+}
+function toISOWithTimezone(date, timezone) {
+  const parts = getDatePartsInTimezone(date, timezone);
+  const offsetString = getTimezoneOffsetString(date, timezone);
+  const iso = `${parts.year}-${String(parts.month + 1).padStart(2, "0")}-${String(parts.day).padStart(2, "0")}T${String(parts.hour).padStart(2, "0")}:${String(parts.minute).padStart(2, "0")}:${String(parts.second).padStart(2, "0")}${offsetString}[${timezone}]`;
+  return iso;
+}
+
+export { COMMON_TIMEZONES, convertEventToDisplayTimezone, convertEventsToTimezone, createDateInTimezone, endOfDayInTimezone, formatDateInTimezone, formatDateTimeInTimezone, formatInTimezone, formatTimeInTimezone, fromLocalTimezone, fromUTC, getCommonTimezones, getDatePartsInTimezone, getLocalTimezone, getTimezoneAbbreviation, getTimezoneDisplayLabel, getTimezoneInfo, getTimezoneName, getTimezoneOffset, getTimezoneOffsetString, isSameDayInTimezone, isTodayInTimezone, isValidTimezone, parseISOWithTimezone, startOfDayInTimezone, toISOWithTimezone, toLocalTimezone, toTimezone, toUTC };