@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-FIBAZFC4.mjs

@@ -0,0 +1,871 @@
+import { createSchedulerDateFormatter } from './chunk-TNKJPFGI.mjs';
+
+// src/event/recurrence.ts
+var WEEKDAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+var WEEKDAY_REVERSE = {
+  0: "SU",
+  1: "MO",
+  2: "TU",
+  3: "WE",
+  4: "TH",
+  5: "FR",
+  6: "SA"
+};
+function getDisplayConfigView(displayConfig) {
+  return displayConfig && "view" in displayConfig ? displayConfig.view : void 0;
+}
+function createRecurrenceDescriptionFormatter(localeOrOptions = "en", displayOptions = {}) {
+  const directOptions = typeof localeOrOptions === "string" ? displayOptions : localeOrOptions;
+  const displayConfig = directOptions.calendarDisplayConfig;
+  const formatter = createSchedulerDateFormatter({
+    locale: directOptions.locale ?? displayConfig?.locale ?? (typeof localeOrOptions === "string" ? localeOrOptions : "en"),
+    calendar: directOptions.calendar ?? displayConfig?.calendar,
+    numberingSystem: directOptions.numberingSystem ?? displayConfig?.numberingSystem,
+    timeZone: directOptions.timeZone ?? displayConfig?.timeZone,
+    view: directOptions.view ?? getDisplayConfigView(displayConfig)
+  });
+  return {
+    formatter,
+    formatNumber: (value) => formatter.formatNumber(value)
+  };
+}
+function getWeekdayDisplayDate(weekday) {
+  const weekdayIndex = WEEKDAY_MAP[weekday];
+  return new Date(2024, 0, weekdayIndex === 0 ? 7 : weekdayIndex, 12);
+}
+function getMonthDisplayDate(month) {
+  return new Date(2024, month - 1, 1, 12);
+}
+function formatWeekdayName(weekday, formatter) {
+  return formatter.formatWeekday(getWeekdayDisplayDate(weekday), "long");
+}
+function formatMonthName(month, formatter) {
+  return formatter.formatMonth(getMonthDisplayDate(month), "long");
+}
+function formatNumberList(values, formatNumber) {
+  return values.map((value) => formatNumber(value)).join(", ");
+}
+function parseRRule(rruleString) {
+  if (!rruleString || typeof rruleString !== "string") return null;
+  const cleaned = rruleString.replace(/^RRULE:/i, "").trim();
+  const parts = cleaned.split(";");
+  const options = {};
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (!key || !value) continue;
+    const upperKey = key.toUpperCase();
+    switch (upperKey) {
+      case "FREQ":
+        options.freq = value.toUpperCase();
+        break;
+      case "INTERVAL":
+        options.interval = parseInt(value, 10);
+        break;
+      case "COUNT":
+        options.count = parseInt(value, 10);
+        break;
+      case "UNTIL":
+        options.until = parseRRuleDate(value);
+        break;
+      case "BYDAY":
+        options.byday = value.split(",").map((d) => d.toUpperCase());
+        break;
+      case "BYMONTHDAY":
+        options.bymonthday = value.split(",").map((d) => parseInt(d, 10));
+        break;
+      case "BYMONTH":
+        options.bymonth = value.split(",").map((m) => parseInt(m, 10));
+        break;
+      case "BYWEEKNO":
+        options.byweekno = value.split(",").map((w) => parseInt(w, 10));
+        break;
+      case "BYYEARDAY":
+        options.byyearday = value.split(",").map((d) => parseInt(d, 10));
+        break;
+      case "BYHOUR":
+        options.byhour = value.split(",").map((h) => parseInt(h, 10));
+        break;
+      case "BYMINUTE":
+        options.byminute = value.split(",").map((m) => parseInt(m, 10));
+        break;
+      case "BYSECOND":
+        options.bysecond = value.split(",").map((s) => parseInt(s, 10));
+        break;
+      case "BYSETPOS":
+        options.bysetpos = value.split(",").map((p) => parseInt(p, 10));
+        break;
+      case "WKST":
+        options.wkst = value.toUpperCase();
+        break;
+    }
+  }
+  if (!options.freq) return null;
+  return options;
+}
+function serializeRRule(options) {
+  const parts = [];
+  parts.push(`FREQ=${options.freq}`);
+  if (options.interval && options.interval > 1) {
+    parts.push(`INTERVAL=${options.interval}`);
+  }
+  if (options.count !== void 0) {
+    parts.push(`COUNT=${options.count}`);
+  }
+  if (options.until) {
+    parts.push(`UNTIL=${formatRRuleDate(options.until)}`);
+  }
+  if (options.byday && options.byday.length > 0) {
+    parts.push(`BYDAY=${options.byday.join(",")}`);
+  }
+  if (options.bymonthday && options.bymonthday.length > 0) {
+    parts.push(`BYMONTHDAY=${options.bymonthday.join(",")}`);
+  }
+  if (options.bymonth && options.bymonth.length > 0) {
+    parts.push(`BYMONTH=${options.bymonth.join(",")}`);
+  }
+  if (options.byweekno && options.byweekno.length > 0) {
+    parts.push(`BYWEEKNO=${options.byweekno.join(",")}`);
+  }
+  if (options.byyearday && options.byyearday.length > 0) {
+    parts.push(`BYYEARDAY=${options.byyearday.join(",")}`);
+  }
+  if (options.byhour && options.byhour.length > 0) {
+    parts.push(`BYHOUR=${options.byhour.join(",")}`);
+  }
+  if (options.byminute && options.byminute.length > 0) {
+    parts.push(`BYMINUTE=${options.byminute.join(",")}`);
+  }
+  if (options.bysecond && options.bysecond.length > 0) {
+    parts.push(`BYSECOND=${options.bysecond.join(",")}`);
+  }
+  if (options.bysetpos && options.bysetpos.length > 0) {
+    parts.push(`BYSETPOS=${options.bysetpos.join(",")}`);
+  }
+  if (options.wkst) {
+    parts.push(`WKST=${options.wkst}`);
+  }
+  return parts.join(";");
+}
+function parseRRuleDate(dateStr) {
+  if (dateStr.length === 8) {
+    const year = parseInt(dateStr.slice(0, 4), 10);
+    const month = parseInt(dateStr.slice(4, 6), 10) - 1;
+    const day = parseInt(dateStr.slice(6, 8), 10);
+    return new Date(year, month, day);
+  }
+  if (dateStr.includes("T")) {
+    const datePart = dateStr.slice(0, 8);
+    const timePart = dateStr.slice(9, 15);
+    const year = parseInt(datePart.slice(0, 4), 10);
+    const month = parseInt(datePart.slice(4, 6), 10) - 1;
+    const day = parseInt(datePart.slice(6, 8), 10);
+    const hour = parseInt(timePart.slice(0, 2), 10);
+    const minute = parseInt(timePart.slice(2, 4), 10);
+    const second = parseInt(timePart.slice(4, 6), 10);
+    if (dateStr.endsWith("Z")) {
+      return new Date(Date.UTC(year, month, day, hour, minute, second));
+    }
+    return new Date(year, month, day, hour, minute, second);
+  }
+  return new Date(dateStr);
+}
+function formatRRuleDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addMonths(date, months) {
+  const result = new Date(date);
+  const targetMonth = result.getMonth() + months;
+  result.setMonth(targetMonth);
+  if (result.getMonth() !== (targetMonth % 12 + 12) % 12) {
+    result.setDate(0);
+  }
+  return result;
+}
+function addYears(date, years) {
+  const result = new Date(date);
+  result.setFullYear(result.getFullYear() + years);
+  return result;
+}
+function getDaysInMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
+function getDaysInYear(year) {
+  return isLeapYear(year) ? 366 : 365;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function getDateFromYearDay(year, yearDay) {
+  const daysInYear = getDaysInYear(year);
+  let actualDay = yearDay;
+  if (yearDay < 0) {
+    actualDay = daysInYear + yearDay + 1;
+  }
+  if (actualDay < 1 || actualDay > daysInYear) {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  const date = new Date(year, 0, actualDay);
+  return date;
+}
+function getWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+function getDatesByWeekNumber(year, weekNumbers, wkst) {
+  const dates = [];
+  for (const weekNo of weekNumbers) {
+    let actualWeek = weekNo;
+    if (weekNo < 0) {
+      const lastWeek = getWeekNumber(new Date(year, 11, 28));
+      actualWeek = lastWeek + weekNo + 1;
+    }
+    if (actualWeek < 1 || actualWeek > 53) continue;
+    const jan4 = new Date(year, 0, 4);
+    const jan4Day = jan4.getDay() || 7;
+    const week1Start = new Date(year, 0, 4 - jan4Day + wkst);
+    if (week1Start.getDay() !== wkst) {
+      week1Start.setDate(week1Start.getDate() - 7);
+    }
+    const targetWeekStart = new Date(week1Start);
+    targetWeekStart.setDate(targetWeekStart.getDate() + (actualWeek - 1) * 7);
+    for (let i = 0; i < 7; i++) {
+      const dayInWeek = new Date(targetWeekStart);
+      dayInWeek.setDate(dayInWeek.getDate() + i);
+      if (dayInWeek.getFullYear() === year) {
+        dates.push(dayInWeek);
+      }
+    }
+  }
+  return dates;
+}
+function getWeekdayOfMonth(date, weekday, position) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const daysInMonth = getDaysInMonth(year, month);
+  if (position > 0) {
+    let count = 0;
+    for (let day = 1; day <= daysInMonth; day++) {
+      const d = new Date(year, month, day);
+      if (d.getDay() === weekday) {
+        count++;
+        if (count === position) return d;
+      }
+    }
+  } else if (position < 0) {
+    let count = 0;
+    for (let day = daysInMonth; day >= 1; day--) {
+      const d = new Date(year, month, day);
+      if (d.getDay() === weekday) {
+        count--;
+        if (count === position) return d;
+      }
+    }
+  }
+  return null;
+}
+function parsePositionalWeekday(byday) {
+  const match = byday.match(/^(-?\d+)?([A-Z]{2})$/);
+  if (!match) return null;
+  const position = match[1] ? parseInt(match[1], 10) : void 0;
+  const weekday = match[2];
+  return { weekday, position };
+}
+function expandRRule(event, rangeStart, rangeEnd, maxOccurrences = 365) {
+  const rrule = typeof event.rrule === "string" ? parseRRule(event.rrule) : event.rrule;
+  if (!rrule) return [];
+  const eventStart = typeof event.start === "string" ? new Date(event.start) : new Date(event.start);
+  let eventEnd;
+  if (event.end) {
+    eventEnd = typeof event.end === "string" ? new Date(event.end) : new Date(event.end);
+  } else if (event.duration) {
+    eventEnd = new Date(eventStart.getTime() + event.duration * 60 * 1e3);
+  } else if (event.allDay) {
+    eventEnd = new Date(eventStart);
+    eventEnd.setHours(23, 59, 59, 999);
+  } else {
+    eventEnd = new Date(eventStart.getTime() + 60 * 60 * 1e3);
+  }
+  const duration = eventEnd.getTime() - eventStart.getTime();
+  const exdates = /* @__PURE__ */ new Set();
+  if (event.exdate) {
+    for (const exd of event.exdate) {
+      const d = typeof exd === "string" ? new Date(exd) : exd;
+      exdates.add(dateToKey(d));
+    }
+  }
+  const interval = rrule.interval || 1;
+  const until = rrule.until ? typeof rrule.until === "string" ? new Date(rrule.until) : rrule.until : null;
+  const count = rrule.count;
+  const wkst = rrule.wkst ? WEEKDAY_MAP[rrule.wkst] : 1;
+  const occurrences = [];
+  let current = new Date(eventStart);
+  let totalCount = 0;
+  const effectiveEnd = until && until < rangeEnd ? until : rangeEnd;
+  while (current <= effectiveEnd && totalCount < maxOccurrences) {
+    if (count !== void 0 && totalCount >= count) break;
+    const matchingDates = getMatchingDatesForFrequency(current, rrule, eventStart, wkst);
+    for (const date of matchingDates) {
+      if (count !== void 0 && totalCount >= count) break;
+      if (date > effectiveEnd) continue;
+      if (date < eventStart) continue;
+      const dateKey = dateToKey(date);
+      if (exdates.has(dateKey)) continue;
+      const occurrenceEnd = new Date(date.getTime() + duration);
+      if (occurrenceEnd >= rangeStart && date <= rangeEnd) {
+        occurrences.push(new Date(date));
+      }
+      totalCount++;
+    }
+    current = advanceToNextPeriod(current, rrule.freq, interval);
+  }
+  return occurrences.map((occStart) => {
+    const occEnd = new Date(occStart.getTime() + duration);
+    return {
+      id: `${event.id}_${occStart.getTime()}`,
+      originalId: event.id,
+      title: event.title,
+      start: occStart,
+      end: occEnd,
+      allDay: event.allDay,
+      color: event.color,
+      textColor: event.textColor,
+      className: event.className,
+      editable: event.editable,
+      draggable: event.draggable,
+      resizable: event.resizable,
+      metadata: event.metadata,
+      isRecurring: true,
+      recurringEventId: event.id,
+      recurrenceId: occStart,
+      originalStart: occStart,
+      timezone: event.timezone,
+      resourceId: event.resourceId,
+      resourceIds: event.resourceIds,
+      categoryId: event.categoryId,
+      categoryIds: event.categoryIds
+    };
+  });
+}
+function dateToKey(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function expandRecurringSeries(series, rangeStart, rangeEnd, maxOccurrences = 365) {
+  const rrule = typeof series.rrule === "string" ? parseRRule(series.rrule) : series.rrule;
+  if (!rrule) return [];
+  const seriesStart = typeof series.start === "string" ? new Date(series.start) : new Date(series.start);
+  let seriesEnd;
+  if (series.end) {
+    seriesEnd = typeof series.end === "string" ? new Date(series.end) : new Date(series.end);
+  } else if (series.duration) {
+    seriesEnd = new Date(seriesStart.getTime() + series.duration * 60 * 1e3);
+  } else if (series.allDay) {
+    seriesEnd = new Date(seriesStart);
+    seriesEnd.setHours(23, 59, 59, 999);
+  } else {
+    seriesEnd = new Date(seriesStart.getTime() + 60 * 60 * 1e3);
+  }
+  const duration = seriesEnd.getTime() - seriesStart.getTime();
+  const exdates = /* @__PURE__ */ new Set();
+  if (series.exdate) {
+    for (const exd of series.exdate) {
+      const d = typeof exd === "string" ? new Date(exd) : exd;
+      exdates.add(dateToKey(d));
+    }
+  }
+  const exceptionsMap = /* @__PURE__ */ new Map();
+  if (series.exceptions) {
+    for (const exc of series.exceptions) {
+      const d = typeof exc.originalStart === "string" ? new Date(exc.originalStart) : exc.originalStart;
+      exceptionsMap.set(dateToKey(d), exc);
+    }
+  }
+  const rdates = [];
+  if (series.rdate) {
+    for (const rd of series.rdate) {
+      const d = typeof rd === "string" ? new Date(rd) : rd;
+      if (d >= rangeStart && d <= rangeEnd && !exdates.has(dateToKey(d))) {
+        rdates.push(d);
+      }
+    }
+  }
+  const interval = rrule.interval || 1;
+  const until = rrule.until ? typeof rrule.until === "string" ? new Date(rrule.until) : rrule.until : null;
+  const count = rrule.count;
+  const wkst = rrule.wkst ? WEEKDAY_MAP[rrule.wkst] : 1;
+  const occurrences = [];
+  let current = new Date(seriesStart);
+  let totalCount = 0;
+  const effectiveEnd = until && until < rangeEnd ? until : rangeEnd;
+  while (current <= effectiveEnd && totalCount < maxOccurrences) {
+    if (count !== void 0 && totalCount >= count) break;
+    const matchingDates = getMatchingDatesForFrequency(current, rrule, seriesStart, wkst);
+    for (const date of matchingDates) {
+      if (count !== void 0 && totalCount >= count) break;
+      if (date > effectiveEnd) continue;
+      if (date < seriesStart) continue;
+      const dateKey = dateToKey(date);
+      if (exdates.has(dateKey)) continue;
+      const occurrenceEnd = new Date(date.getTime() + duration);
+      if (occurrenceEnd >= rangeStart && date <= rangeEnd) {
+        occurrences.push(new Date(date));
+      }
+      totalCount++;
+    }
+    current = advanceToNextPeriod(current, rrule.freq, interval);
+  }
+  for (const rdate of rdates) {
+    const dateKey = dateToKey(rdate);
+    const alreadyExists = occurrences.some((occ) => dateToKey(occ) === dateKey);
+    if (!alreadyExists) {
+      occurrences.push(rdate);
+    }
+  }
+  occurrences.sort((a, b) => a.getTime() - b.getTime());
+  return occurrences.map((occStart) => {
+    const dateKey = dateToKey(occStart);
+    const exception = exceptionsMap.get(dateKey);
+    if (exception && exception.event) {
+      const excEvent = exception.event;
+      const excStart = excEvent.start ? typeof excEvent.start === "string" ? new Date(excEvent.start) : new Date(excEvent.start) : occStart;
+      let excEnd;
+      if (excEvent.end) {
+        excEnd = typeof excEvent.end === "string" ? new Date(excEvent.end) : new Date(excEvent.end);
+      } else if (excEvent.duration) {
+        excEnd = new Date(excStart.getTime() + excEvent.duration * 60 * 1e3);
+      } else {
+        excEnd = new Date(excStart.getTime() + duration);
+      }
+      return {
+        id: `${series.id}_${occStart.getTime()}`,
+        originalId: series.id,
+        title: excEvent.title ?? series.title,
+        start: excStart,
+        end: excEnd,
+        allDay: excEvent.allDay ?? series.allDay,
+        color: excEvent.color ?? series.color,
+        textColor: excEvent.textColor ?? series.textColor,
+        className: excEvent.className ?? series.className,
+        editable: excEvent.editable ?? series.editable,
+        draggable: excEvent.draggable ?? series.draggable,
+        resizable: excEvent.resizable ?? series.resizable,
+        metadata: { ...series.metadata, ...excEvent.metadata },
+        isRecurring: true,
+        recurringEventId: series.id,
+        recurrenceId: exception.recurrenceId,
+        isException: true,
+        originalStart: occStart,
+        timezone: excEvent.timezone ?? series.timezone,
+        resourceId: excEvent.resourceId ?? series.resourceId,
+        resourceIds: excEvent.resourceIds ?? series.resourceIds,
+        categoryId: excEvent.categoryId ?? series.categoryId,
+        categoryIds: excEvent.categoryIds ?? series.categoryIds
+      };
+    }
+    const occEnd = new Date(occStart.getTime() + duration);
+    return {
+      id: `${series.id}_${occStart.getTime()}`,
+      originalId: series.id,
+      title: series.title,
+      start: occStart,
+      end: occEnd,
+      allDay: series.allDay,
+      color: series.color,
+      textColor: series.textColor,
+      className: series.className,
+      editable: series.editable,
+      draggable: series.draggable,
+      resizable: series.resizable,
+      metadata: series.metadata,
+      isRecurring: true,
+      recurringEventId: series.id,
+      originalStart: occStart,
+      timezone: series.timezone,
+      resourceId: series.resourceId,
+      resourceIds: series.resourceIds,
+      categoryId: series.categoryId,
+      categoryIds: series.categoryIds
+    };
+  });
+}
+function getMatchingDatesForFrequency(current, rrule, eventStart, wkst) {
+  const dates = [];
+  const { freq, byday, bymonthday, bymonth, byweekno, byyearday, byhour, byminute, bysecond, bysetpos } = rrule;
+  switch (freq) {
+    case "DAILY": {
+      if (bymonth && bymonth.length > 0) {
+        if (!bymonth.includes(current.getMonth() + 1)) return [];
+      }
+      dates.push(new Date(current));
+      break;
+    }
+    case "WEEKLY": {
+      if (byday && byday.length > 0) {
+        const weekStart = getWeekStart(current, wkst);
+        for (let i = 0; i < 7; i++) {
+          const dayDate = addDays(weekStart, i);
+          const dayName = WEEKDAY_REVERSE[dayDate.getDay()];
+          if (byday.includes(dayName)) {
+            const occurrence = new Date(dayDate);
+            occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+            dates.push(occurrence);
+          }
+        }
+      } else {
+        dates.push(new Date(current));
+      }
+      break;
+    }
+    case "MONTHLY": {
+      if (bymonth && bymonth.length > 0) {
+        if (!bymonth.includes(current.getMonth() + 1)) return [];
+      }
+      if (byday && byday.length > 0) {
+        for (const day of byday) {
+          const parsed = parsePositionalWeekday(day);
+          if (!parsed) continue;
+          const weekday = WEEKDAY_MAP[parsed.weekday];
+          if (parsed.position !== void 0) {
+            const matchDate = getWeekdayOfMonth(current, weekday, parsed.position);
+            if (matchDate) {
+              matchDate.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+              dates.push(matchDate);
+            }
+          } else {
+            const daysInMonth = getDaysInMonth(current.getFullYear(), current.getMonth());
+            for (let d = 1; d <= daysInMonth; d++) {
+              const testDate = new Date(current.getFullYear(), current.getMonth(), d);
+              if (testDate.getDay() === weekday) {
+                testDate.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+                dates.push(testDate);
+              }
+            }
+          }
+        }
+      } else if (bymonthday && bymonthday.length > 0) {
+        const daysInMonth = getDaysInMonth(current.getFullYear(), current.getMonth());
+        for (const day of bymonthday) {
+          let actualDay = day;
+          if (day < 0) {
+            actualDay = daysInMonth + day + 1;
+          }
+          if (actualDay >= 1 && actualDay <= daysInMonth) {
+            const occurrence = new Date(current.getFullYear(), current.getMonth(), actualDay);
+            occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+            dates.push(occurrence);
+          }
+        }
+      } else {
+        const dayOfMonth = eventStart.getDate();
+        const daysInMonth = getDaysInMonth(current.getFullYear(), current.getMonth());
+        const actualDay = Math.min(dayOfMonth, daysInMonth);
+        const occurrence = new Date(current.getFullYear(), current.getMonth(), actualDay);
+        occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+        dates.push(occurrence);
+      }
+      break;
+    }
+    case "YEARLY": {
+      const year = current.getFullYear();
+      if (byyearday && byyearday.length > 0) {
+        for (const yearDay of byyearday) {
+          const occurrence = getDateFromYearDay(year, yearDay);
+          if (!isNaN(occurrence.getTime())) {
+            if (bymonth && bymonth.length > 0 && !bymonth.includes(occurrence.getMonth() + 1)) {
+              continue;
+            }
+            occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+            dates.push(occurrence);
+          }
+        }
+      } else if (byweekno && byweekno.length > 0) {
+        const weekDates = getDatesByWeekNumber(year, byweekno, wkst);
+        for (const weekDate of weekDates) {
+          if (byday && byday.length > 0) {
+            const dayName = WEEKDAY_REVERSE[weekDate.getDay()];
+            if (!byday.includes(dayName)) continue;
+          }
+          if (bymonth && bymonth.length > 0 && !bymonth.includes(weekDate.getMonth() + 1)) {
+            continue;
+          }
+          const occurrence = new Date(weekDate);
+          occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+          dates.push(occurrence);
+        }
+      } else if (bymonth && bymonth.length > 0) {
+        for (const month of bymonth) {
+          const testMonth = month - 1;
+          if (byday && byday.length > 0) {
+            for (const day of byday) {
+              const parsed = parsePositionalWeekday(day);
+              if (!parsed) continue;
+              const weekday = WEEKDAY_MAP[parsed.weekday];
+              if (parsed.position !== void 0) {
+                const testDate = new Date(year, testMonth, 1);
+                const matchDate = getWeekdayOfMonth(testDate, weekday, parsed.position);
+                if (matchDate) {
+                  matchDate.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+                  dates.push(matchDate);
+                }
+              }
+            }
+          } else if (bymonthday && bymonthday.length > 0) {
+            for (const day of bymonthday) {
+              const daysInMonth = getDaysInMonth(year, testMonth);
+              let actualDay = day;
+              if (day < 0) {
+                actualDay = daysInMonth + day + 1;
+              }
+              if (actualDay >= 1 && actualDay <= daysInMonth) {
+                const occurrence = new Date(year, testMonth, actualDay);
+                occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+                dates.push(occurrence);
+              }
+            }
+          } else {
+            const dayOfMonth = eventStart.getDate();
+            const daysInMonth = getDaysInMonth(year, testMonth);
+            const actualDay = Math.min(dayOfMonth, daysInMonth);
+            const occurrence = new Date(year, testMonth, actualDay);
+            occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+            dates.push(occurrence);
+          }
+        }
+      } else {
+        const occurrence = new Date(year, eventStart.getMonth(), eventStart.getDate());
+        occurrence.setHours(eventStart.getHours(), eventStart.getMinutes(), eventStart.getSeconds(), eventStart.getMilliseconds());
+        dates.push(occurrence);
+      }
+      break;
+    }
+  }
+  if (bysetpos && bysetpos.length > 0 && dates.length > 0) {
+    dates.sort((a, b) => a.getTime() - b.getTime());
+    const filtered = [];
+    for (const pos of bysetpos) {
+      let index;
+      if (pos > 0) {
+        index = pos - 1;
+      } else {
+        index = dates.length + pos;
+      }
+      if (index >= 0 && index < dates.length) {
+        filtered.push(dates[index]);
+      }
+    }
+    return applyTimeFilters(filtered, byhour, byminute, bysecond);
+  }
+  return applyTimeFilters(dates, byhour, byminute, bysecond);
+}
+function applyTimeFilters(dates, byhour, byminute, bysecond) {
+  if ((!byhour || byhour.length === 0) && (!byminute || byminute.length === 0) && (!bysecond || bysecond.length === 0)) {
+    return dates;
+  }
+  const result = [];
+  const hours = byhour && byhour.length > 0 ? byhour : [dates[0]?.getHours() ?? 0];
+  const minutes = byminute && byminute.length > 0 ? byminute : [dates[0]?.getMinutes() ?? 0];
+  const seconds = bysecond && bysecond.length > 0 ? bysecond : [dates[0]?.getSeconds() ?? 0];
+  for (const date of dates) {
+    for (const hour of hours) {
+      for (const minute of minutes) {
+        for (const second of seconds) {
+          const occurrence = new Date(date);
+          occurrence.setHours(hour, minute, second, 0);
+          result.push(occurrence);
+        }
+      }
+    }
+  }
+  return result;
+}
+function getWeekStart(date, wkst) {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = (day - wkst + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function advanceToNextPeriod(date, freq, interval) {
+  switch (freq) {
+    case "DAILY":
+      return addDays(date, interval);
+    case "WEEKLY":
+      return addDays(date, 7 * interval);
+    case "MONTHLY":
+      return addMonths(date, interval);
+    case "YEARLY":
+      return addYears(date, interval);
+    default:
+      return addDays(date, 1);
+  }
+}
+function createRRule(options) {
+  return {
+    freq: options.freq,
+    interval: options.interval || 1,
+    count: options.count,
+    until: options.until,
+    byday: options.byday,
+    bymonthday: options.bymonthday,
+    bymonth: options.bymonth,
+    byweekno: options.byweekno,
+    byyearday: options.byyearday,
+    byhour: options.byhour,
+    byminute: options.byminute,
+    bysecond: options.bysecond,
+    bysetpos: options.bysetpos,
+    wkst: options.wkst || "MO"
+  };
+}
+function daily(interval = 1) {
+  return createRRule({ freq: "DAILY", interval });
+}
+function weekly(interval = 1, weekdays2) {
+  return createRRule({ freq: "WEEKLY", interval, byday: weekdays2 });
+}
+function monthly(interval = 1, options) {
+  return createRRule({
+    freq: "MONTHLY",
+    interval,
+    bymonthday: options?.bymonthday,
+    byday: options?.byday
+  });
+}
+function yearly(interval = 1, options) {
+  return createRRule({
+    freq: "YEARLY",
+    interval,
+    bymonth: options?.bymonth,
+    bymonthday: options?.bymonthday
+  });
+}
+function weekdays() {
+  return weekly(1, ["MO", "TU", "WE", "TH", "FR"]);
+}
+function everyNthWeekday(n, weekday) {
+  return createRRule({
+    freq: "MONTHLY",
+    byday: [`${n}${weekday}`]
+  });
+}
+function lastWeekdayOfMonth(weekday) {
+  return createRRule({
+    freq: "MONTHLY",
+    byday: [`-1${weekday}`]
+  });
+}
+function describeRRule(rrule, localeOrOptions = "en", displayOptions) {
+  const options = typeof rrule === "string" ? parseRRule(rrule) : rrule;
+  if (!options) return "";
+  const interval = options.interval || 1;
+  const { formatter, formatNumber } = createRecurrenceDescriptionFormatter(localeOrOptions, displayOptions);
+  const formattedInterval = formatNumber(interval);
+  const parts = [];
+  switch (options.freq) {
+    case "DAILY":
+      parts.push(interval === 1 ? "Daily" : `Every ${formattedInterval} days`);
+      break;
+    case "WEEKLY":
+      if (options.byday && options.byday.length > 0) {
+        const dayNames = options.byday.map((d) => formatWeekdayName(d, formatter));
+        if (interval === 1) {
+          parts.push(`Weekly on ${dayNames.join(", ")}`);
+        } else {
+          parts.push(`Every ${formattedInterval} weeks on ${dayNames.join(", ")}`);
+        }
+      } else {
+        parts.push(interval === 1 ? "Weekly" : `Every ${formattedInterval} weeks`);
+      }
+      break;
+    case "MONTHLY":
+      if (options.byday && options.byday.length > 0) {
+        const descriptions = options.byday.map((d) => {
+          const parsed = parsePositionalWeekday(d);
+          if (!parsed) return d;
+          const dayName = formatWeekdayName(parsed.weekday, formatter);
+          if (parsed.position === 1) return `first ${dayName}`;
+          if (parsed.position === 2) return `second ${dayName}`;
+          if (parsed.position === 3) return `third ${dayName}`;
+          if (parsed.position === 4) return `fourth ${dayName}`;
+          if (parsed.position === -1) return `last ${dayName}`;
+          return dayName;
+        });
+        parts.push(interval === 1 ? `Monthly on the ${descriptions.join(", ")}` : `Every ${formattedInterval} months on the ${descriptions.join(", ")}`);
+      } else if (options.bymonthday && options.bymonthday.length > 0) {
+        const days = formatNumberList(options.bymonthday, formatNumber);
+        parts.push(interval === 1 ? `Monthly on day ${days}` : `Every ${formattedInterval} months on day ${days}`);
+      } else {
+        parts.push(interval === 1 ? "Monthly" : `Every ${formattedInterval} months`);
+      }
+      break;
+    case "YEARLY": {
+      let yearlyDesc = interval === 1 ? "Yearly" : `Every ${formattedInterval} years`;
+      if (options.byyearday && options.byyearday.length > 0) {
+        const dayDescs = options.byyearday.map((d) => d < 0 ? `${formatNumber(d)} from end` : `day ${formatNumber(d)}`);
+        yearlyDesc += ` on ${dayDescs.join(", ")}`;
+      } else if (options.byweekno && options.byweekno.length > 0) {
+        const weekDescs = options.byweekno.map((w) => w < 0 ? `${formatNumber(w)} from end` : `week ${formatNumber(w)}`);
+        yearlyDesc += ` in ${weekDescs.join(", ")}`;
+        if (options.byday && options.byday.length > 0) {
+          const dayNames = options.byday.map((d) => formatWeekdayName(d, formatter));
+          yearlyDesc += ` on ${dayNames.join(", ")}`;
+        }
+      } else if (options.bymonth && options.bymonth.length > 0) {
+        const monthNames = options.bymonth.map((m) => formatMonthName(m, formatter));
+        yearlyDesc += ` in ${monthNames.join(", ")}`;
+        if (options.byday && options.byday.length > 0) {
+          const descriptions = options.byday.map((d) => {
+            const parsed = parsePositionalWeekday(d);
+            if (!parsed) return d;
+            const dayName = formatWeekdayName(parsed.weekday, formatter);
+            if (parsed.position === 1) return `first ${dayName}`;
+            if (parsed.position === 2) return `second ${dayName}`;
+            if (parsed.position === 3) return `third ${dayName}`;
+            if (parsed.position === 4) return `fourth ${dayName}`;
+            if (parsed.position === -1) return `last ${dayName}`;
+            return dayName;
+          });
+          yearlyDesc += ` on the ${descriptions.join(", ")}`;
+        } else if (options.bymonthday && options.bymonthday.length > 0) {
+          yearlyDesc += ` on day ${formatNumberList(options.bymonthday, formatNumber)}`;
+        }
+      }
+      parts.push(yearlyDesc);
+      break;
+    }
+  }
+  if (options.byhour && options.byhour.length > 0) {
+    const hourDescs = options.byhour.map((h) => `${formatNumber(h)}:00`);
+    parts.push(`at ${hourDescs.join(", ")}`);
+  }
+  if (options.count) {
+    parts.push(`${formatNumber(options.count)} times`);
+  } else if (options.until) {
+    const untilDate = typeof options.until === "string" ? new Date(options.until) : options.until;
+    const formatted = formatter.format(untilDate, { dateStyle: "medium" });
+    parts.push(`until ${formatted}`);
+  }
+  return parts.join(", ");
+}
+
+export { createRRule, daily, describeRRule, everyNthWeekday, expandRRule, expandRecurringSeries, lastWeekdayOfMonth, monthly, parseRRule, serializeRRule, weekdays, weekly, yearly };