@bryanhu/codexly 0.18.0 → 0.20.0

package/dist/scheduled-task-recurrence-worker.js

@@ -0,0 +1,2969 @@
+import { createRequire } from 'node:module';
+import { scheduled_task_wall_time_exports } from './chunk-GT7XTSEG.js';
+import { __export } from './chunk-K6J42667.js';
+import { workerData, parentPort } from 'worker_threads';
+
+createRequire(import.meta.url);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  ALL_WEEKDAYS: () => ALL_WEEKDAYS,
+  Frequency: () => Frequency,
+  RRule: () => RRule,
+  RRuleSet: () => RRuleSet,
+  Weekday: () => Weekday,
+  datetime: () => datetime,
+  rrulestr: () => rrulestr
+});
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/weekday.js
+var ALL_WEEKDAYS = [
+  "MO",
+  "TU",
+  "WE",
+  "TH",
+  "FR",
+  "SA",
+  "SU"
+];
+var Weekday = (
+  /** @class */
+  (function() {
+    function Weekday2(weekday, n) {
+      if (n === 0)
+        throw new Error("Can't create weekday with n == 0");
+      this.weekday = weekday;
+      this.n = n;
+    }
+    Weekday2.fromStr = function(str) {
+      return new Weekday2(ALL_WEEKDAYS.indexOf(str));
+    };
+    Weekday2.prototype.nth = function(n) {
+      return this.n === n ? this : new Weekday2(this.weekday, n);
+    };
+    Weekday2.prototype.equals = function(other) {
+      return this.weekday === other.weekday && this.n === other.n;
+    };
+    Weekday2.prototype.toString = function() {
+      var s = ALL_WEEKDAYS[this.weekday];
+      if (this.n)
+        s = (this.n > 0 ? "+" : "") + String(this.n) + s;
+      return s;
+    };
+    Weekday2.prototype.getJsWeekday = function() {
+      return this.weekday === 6 ? 0 : this.weekday + 1;
+    };
+    return Weekday2;
+  })()
+);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/helpers.js
+var isPresent = function(value) {
+  return value !== null && value !== void 0;
+};
+var isNumber = function(value) {
+  return typeof value === "number";
+};
+var isWeekdayStr = function(value) {
+  return typeof value === "string" && ALL_WEEKDAYS.includes(value);
+};
+var isArray = Array.isArray;
+var range = function(start, end) {
+  if (end === void 0) {
+    end = start;
+  }
+  if (arguments.length === 1) {
+    end = start;
+    start = 0;
+  }
+  var rang = [];
+  for (var i = start; i < end; i++)
+    rang.push(i);
+  return rang;
+};
+var repeat = function(value, times) {
+  var i = 0;
+  var array = [];
+  if (isArray(value)) {
+    for (; i < times; i++)
+      array[i] = [].concat(value);
+  } else {
+    for (; i < times; i++)
+      array[i] = value;
+  }
+  return array;
+};
+var toArray = function(item) {
+  if (isArray(item)) {
+    return item;
+  }
+  return [item];
+};
+function padStart(item, targetLength, padString) {
+  if (padString === void 0) {
+    padString = " ";
+  }
+  var str = String(item);
+  targetLength = targetLength >> 0;
+  if (str.length > targetLength) {
+    return String(str);
+  }
+  targetLength = targetLength - str.length;
+  if (targetLength > padString.length) {
+    padString += repeat(padString, targetLength / padString.length);
+  }
+  return padString.slice(0, targetLength) + String(str);
+}
+var split = function(str, sep, num) {
+  var splits = str.split(sep);
+  return num ? splits.slice(0, num).concat([splits.slice(num).join(sep)]) : splits;
+};
+var pymod = function(a, b) {
+  var r = a % b;
+  return r * b < 0 ? r + b : r;
+};
+var divmod = function(a, b) {
+  return { div: Math.floor(a / b), mod: pymod(a, b) };
+};
+var empty = function(obj) {
+  return !isPresent(obj) || obj.length === 0;
+};
+var notEmpty = function(obj) {
+  return !empty(obj);
+};
+var includes = function(arr, val) {
+  return notEmpty(arr) && arr.indexOf(val) !== -1;
+};
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/dateutil.js
+var datetime = function(y, m, d, h, i, s) {
+  if (h === void 0) {
+    h = 0;
+  }
+  if (i === void 0) {
+    i = 0;
+  }
+  if (s === void 0) {
+    s = 0;
+  }
+  return new Date(Date.UTC(y, m - 1, d, h, i, s));
+};
+var MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var ONE_DAY = 1e3 * 60 * 60 * 24;
+var MAXYEAR = 9999;
+var ORDINAL_BASE = datetime(1970, 1, 1);
+var PY_WEEKDAYS = [6, 0, 1, 2, 3, 4, 5];
+var isLeapYear = function(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
+var isDate = function(value) {
+  return value instanceof Date;
+};
+var isValidDate = function(value) {
+  return isDate(value) && !isNaN(value.getTime());
+};
+var daysBetween = function(date1, date2) {
+  var date1ms = date1.getTime();
+  var date2ms = date2.getTime();
+  var differencems = date1ms - date2ms;
+  return Math.round(differencems / ONE_DAY);
+};
+var toOrdinal = function(date) {
+  return daysBetween(date, ORDINAL_BASE);
+};
+var fromOrdinal = function(ordinal) {
+  return new Date(ORDINAL_BASE.getTime() + ordinal * ONE_DAY);
+};
+var getMonthDays = function(date) {
+  var month = date.getUTCMonth();
+  return month === 1 && isLeapYear(date.getUTCFullYear()) ? 29 : MONTH_DAYS[month];
+};
+var getWeekday = function(date) {
+  return PY_WEEKDAYS[date.getUTCDay()];
+};
+var monthRange = function(year, month) {
+  var date = datetime(year, month + 1, 1);
+  return [getWeekday(date), getMonthDays(date)];
+};
+var combine = function(date, time) {
+  time = time || date;
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds()));
+};
+var clone = function(date) {
+  var dolly = new Date(date.getTime());
+  return dolly;
+};
+var cloneDates = function(dates) {
+  var clones = [];
+  for (var i = 0; i < dates.length; i++) {
+    clones.push(clone(dates[i]));
+  }
+  return clones;
+};
+var sort = function(dates) {
+  dates.sort(function(a, b) {
+    return a.getTime() - b.getTime();
+  });
+};
+var timeToUntilString = function(time, utc) {
+  if (utc === void 0) {
+    utc = true;
+  }
+  var date = new Date(time);
+  return [
+    padStart(date.getUTCFullYear().toString(), 4, "0"),
+    padStart(date.getUTCMonth() + 1, 2, "0"),
+    padStart(date.getUTCDate(), 2, "0"),
+    "T",
+    padStart(date.getUTCHours(), 2, "0"),
+    padStart(date.getUTCMinutes(), 2, "0"),
+    padStart(date.getUTCSeconds(), 2, "0"),
+    utc ? "Z" : ""
+  ].join("");
+};
+var untilStringToDate = function(until) {
+  var re = /^(\d{4})(\d{2})(\d{2})(T(\d{2})(\d{2})(\d{2})Z?)?$/;
+  var bits = re.exec(until);
+  if (!bits)
+    throw new Error("Invalid UNTIL value: ".concat(until));
+  return new Date(Date.UTC(parseInt(bits[1], 10), parseInt(bits[2], 10) - 1, parseInt(bits[3], 10), parseInt(bits[5], 10) || 0, parseInt(bits[6], 10) || 0, parseInt(bits[7], 10) || 0));
+};
+var dateTZtoISO8601 = function(date, timeZone) {
+  var dateStr = date.toLocaleString("sv-SE", { timeZone });
+  return dateStr.replace(" ", "T") + "Z";
+};
+var dateInTimeZone = function(date, timeZone) {
+  var localTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  var dateInLocalTZ = new Date(dateTZtoISO8601(date, localTimeZone));
+  var dateInTargetTZ = new Date(dateTZtoISO8601(date, timeZone !== null && timeZone !== void 0 ? timeZone : "UTC"));
+  var tzOffset = dateInTargetTZ.getTime() - dateInLocalTZ.getTime();
+  return new Date(date.getTime() - tzOffset);
+};
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterresult.js
+var IterResult = (
+  /** @class */
+  (function() {
+    function IterResult2(method, args) {
+      this.minDate = null;
+      this.maxDate = null;
+      this._result = [];
+      this.total = 0;
+      this.method = method;
+      this.args = args;
+      if (method === "between") {
+        this.maxDate = args.inc ? args.before : new Date(args.before.getTime() - 1);
+        this.minDate = args.inc ? args.after : new Date(args.after.getTime() + 1);
+      } else if (method === "before") {
+        this.maxDate = args.inc ? args.dt : new Date(args.dt.getTime() - 1);
+      } else if (method === "after") {
+        this.minDate = args.inc ? args.dt : new Date(args.dt.getTime() + 1);
+      }
+    }
+    IterResult2.prototype.accept = function(date) {
+      ++this.total;
+      var tooEarly = this.minDate && date < this.minDate;
+      var tooLate = this.maxDate && date > this.maxDate;
+      if (this.method === "between") {
+        if (tooEarly)
+          return true;
+        if (tooLate)
+          return false;
+      } else if (this.method === "before") {
+        if (tooLate)
+          return false;
+      } else if (this.method === "after") {
+        if (tooEarly)
+          return true;
+        this.add(date);
+        return false;
+      }
+      return this.add(date);
+    };
+    IterResult2.prototype.add = function(date) {
+      this._result.push(date);
+      return true;
+    };
+    IterResult2.prototype.getValue = function() {
+      var res = this._result;
+      switch (this.method) {
+        case "all":
+        case "between":
+          return res;
+        case "before":
+        case "after":
+        default:
+          return res.length ? res[res.length - 1] : null;
+      }
+    };
+    IterResult2.prototype.clone = function() {
+      return new IterResult2(this.method, this.args);
+    };
+    return IterResult2;
+  })()
+);
+var iterresult_default = IterResult;
+
+// node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __spreadArray(to, from, pack) {
+  for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/callbackiterresult.js
+var CallbackIterResult = (
+  /** @class */
+  (function(_super) {
+    __extends(CallbackIterResult2, _super);
+    function CallbackIterResult2(method, args, iterator) {
+      var _this = _super.call(this, method, args) || this;
+      _this.iterator = iterator;
+      return _this;
+    }
+    CallbackIterResult2.prototype.add = function(date) {
+      if (this.iterator(date, this._result.length)) {
+        this._result.push(date);
+        return true;
+      }
+      return false;
+    };
+    return CallbackIterResult2;
+  })(iterresult_default)
+);
+var callbackiterresult_default = CallbackIterResult;
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/i18n.js
+var ENGLISH = {
+  dayNames: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ],
+  monthNames: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ],
+  tokens: {
+    SKIP: /^[ \r\n\t]+|^\.$/,
+    number: /^[1-9][0-9]*/,
+    numberAsText: /^(one|two|three)/i,
+    every: /^every/i,
+    "day(s)": /^days?/i,
+    "weekday(s)": /^weekdays?/i,
+    "week(s)": /^weeks?/i,
+    "hour(s)": /^hours?/i,
+    "minute(s)": /^minutes?/i,
+    "month(s)": /^months?/i,
+    "year(s)": /^years?/i,
+    on: /^(on|in)/i,
+    at: /^(at)/i,
+    the: /^the/i,
+    first: /^first/i,
+    second: /^second/i,
+    third: /^third/i,
+    nth: /^([1-9][0-9]*)(\.|th|nd|rd|st)/i,
+    last: /^last/i,
+    for: /^for/i,
+    "time(s)": /^times?/i,
+    until: /^(un)?til/i,
+    monday: /^mo(n(day)?)?/i,
+    tuesday: /^tu(e(s(day)?)?)?/i,
+    wednesday: /^we(d(n(esday)?)?)?/i,
+    thursday: /^th(u(r(sday)?)?)?/i,
+    friday: /^fr(i(day)?)?/i,
+    saturday: /^sa(t(urday)?)?/i,
+    sunday: /^su(n(day)?)?/i,
+    january: /^jan(uary)?/i,
+    february: /^feb(ruary)?/i,
+    march: /^mar(ch)?/i,
+    april: /^apr(il)?/i,
+    may: /^may/i,
+    june: /^june?/i,
+    july: /^july?/i,
+    august: /^aug(ust)?/i,
+    september: /^sep(t(ember)?)?/i,
+    october: /^oct(ober)?/i,
+    november: /^nov(ember)?/i,
+    december: /^dec(ember)?/i,
+    comma: /^(,\s*|(and|or)\s*)+/i
+  }
+};
+var i18n_default = ENGLISH;
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/totext.js
+var contains = function(arr, val) {
+  return arr.indexOf(val) !== -1;
+};
+var defaultGetText = function(id) {
+  return id.toString();
+};
+var defaultDateFormatter = function(year, month, day) {
+  return "".concat(month, " ").concat(day, ", ").concat(year);
+};
+var ToText = (
+  /** @class */
+  (function() {
+    function ToText2(rrule, gettext, language, dateFormatter) {
+      if (gettext === void 0) {
+        gettext = defaultGetText;
+      }
+      if (language === void 0) {
+        language = i18n_default;
+      }
+      if (dateFormatter === void 0) {
+        dateFormatter = defaultDateFormatter;
+      }
+      this.text = [];
+      this.language = language || i18n_default;
+      this.gettext = gettext;
+      this.dateFormatter = dateFormatter;
+      this.rrule = rrule;
+      this.options = rrule.options;
+      this.origOptions = rrule.origOptions;
+      if (this.origOptions.bymonthday) {
+        var bymonthday = [].concat(this.options.bymonthday);
+        var bynmonthday = [].concat(this.options.bynmonthday);
+        bymonthday.sort(function(a, b) {
+          return a - b;
+        });
+        bynmonthday.sort(function(a, b) {
+          return b - a;
+        });
+        this.bymonthday = bymonthday.concat(bynmonthday);
+        if (!this.bymonthday.length)
+          this.bymonthday = null;
+      }
+      if (isPresent(this.origOptions.byweekday)) {
+        var byweekday = !isArray(this.origOptions.byweekday) ? [this.origOptions.byweekday] : this.origOptions.byweekday;
+        var days = String(byweekday);
+        this.byweekday = {
+          allWeeks: byweekday.filter(function(weekday) {
+            return !weekday.n;
+          }),
+          someWeeks: byweekday.filter(function(weekday) {
+            return Boolean(weekday.n);
+          }),
+          isWeekdays: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") === -1 && days.indexOf("SU") === -1,
+          isEveryDay: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") !== -1 && days.indexOf("SU") !== -1
+        };
+        var sortWeekDays = function(a, b) {
+          return a.weekday - b.weekday;
+        };
+        this.byweekday.allWeeks.sort(sortWeekDays);
+        this.byweekday.someWeeks.sort(sortWeekDays);
+        if (!this.byweekday.allWeeks.length)
+          this.byweekday.allWeeks = null;
+        if (!this.byweekday.someWeeks.length)
+          this.byweekday.someWeeks = null;
+      } else {
+        this.byweekday = null;
+      }
+    }
+    ToText2.isFullyConvertible = function(rrule) {
+      var canConvert = true;
+      if (!(rrule.options.freq in ToText2.IMPLEMENTED))
+        return false;
+      if (rrule.origOptions.until && rrule.origOptions.count)
+        return false;
+      for (var key in rrule.origOptions) {
+        if (contains(["dtstart", "tzid", "wkst", "freq"], key))
+          return true;
+        if (!contains(ToText2.IMPLEMENTED[rrule.options.freq], key))
+          return false;
+      }
+      return canConvert;
+    };
+    ToText2.prototype.isFullyConvertible = function() {
+      return ToText2.isFullyConvertible(this.rrule);
+    };
+    ToText2.prototype.toString = function() {
+      var gettext = this.gettext;
+      if (!(this.options.freq in ToText2.IMPLEMENTED)) {
+        return gettext("RRule error: Unable to fully convert this rrule to text");
+      }
+      this.text = [gettext("every")];
+      this[RRule.FREQUENCIES[this.options.freq]]();
+      if (this.options.until) {
+        this.add(gettext("until"));
+        var until = this.options.until;
+        this.add(this.dateFormatter(until.getUTCFullYear(), this.language.monthNames[until.getUTCMonth()], until.getUTCDate()));
+      } else if (this.options.count) {
+        this.add(gettext("for")).add(this.options.count.toString()).add(this.plural(this.options.count) ? gettext("times") : gettext("time"));
+      }
+      if (!this.isFullyConvertible())
+        this.add(gettext("(~ approximate)"));
+      return this.text.join("");
+    };
+    ToText2.prototype.HOURLY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      this.add(this.plural(this.options.interval) ? gettext("hours") : gettext("hour"));
+    };
+    ToText2.prototype.MINUTELY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      this.add(this.plural(this.options.interval) ? gettext("minutes") : gettext("minute"));
+    };
+    ToText2.prototype.DAILY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      if (this.byweekday && this.byweekday.isWeekdays) {
+        this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+      } else {
+        this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+      }
+      if (this.origOptions.bymonth) {
+        this.add(gettext("in"));
+        this._bymonth();
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday) {
+        this._byweekday();
+      } else if (this.origOptions.byhour) {
+        this._byhour();
+      }
+    };
+    ToText2.prototype.WEEKLY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1) {
+        this.add(this.options.interval.toString()).add(this.plural(this.options.interval) ? gettext("weeks") : gettext("week"));
+      }
+      if (this.byweekday && this.byweekday.isWeekdays) {
+        if (this.options.interval === 1) {
+          this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+        } else {
+          this.add(gettext("on")).add(gettext("weekdays"));
+        }
+      } else if (this.byweekday && this.byweekday.isEveryDay) {
+        this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+      } else {
+        if (this.options.interval === 1)
+          this.add(gettext("week"));
+        if (this.origOptions.bymonth) {
+          this.add(gettext("in"));
+          this._bymonth();
+        }
+        if (this.bymonthday) {
+          this._bymonthday();
+        } else if (this.byweekday) {
+          this._byweekday();
+        }
+        if (this.origOptions.byhour) {
+          this._byhour();
+        }
+      }
+    };
+    ToText2.prototype.MONTHLY = function() {
+      var gettext = this.gettext;
+      if (this.origOptions.bymonth) {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString()).add(gettext("months"));
+          if (this.plural(this.options.interval))
+            this.add(gettext("in"));
+        }
+        this._bymonth();
+      } else {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+        }
+        this.add(this.plural(this.options.interval) ? gettext("months") : gettext("month"));
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday && this.byweekday.isWeekdays) {
+        this.add(gettext("on")).add(gettext("weekdays"));
+      } else if (this.byweekday) {
+        this._byweekday();
+      }
+    };
+    ToText2.prototype.YEARLY = function() {
+      var gettext = this.gettext;
+      if (this.origOptions.bymonth) {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+          this.add(gettext("years"));
+        }
+        this._bymonth();
+      } else {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+        }
+        this.add(this.plural(this.options.interval) ? gettext("years") : gettext("year"));
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday) {
+        this._byweekday();
+      }
+      if (this.options.byyearday) {
+        this.add(gettext("on the")).add(this.list(this.options.byyearday, this.nth, gettext("and"))).add(gettext("day"));
+      }
+      if (this.options.byweekno) {
+        this.add(gettext("in")).add(this.plural(this.options.byweekno.length) ? gettext("weeks") : gettext("week")).add(this.list(this.options.byweekno, void 0, gettext("and")));
+      }
+    };
+    ToText2.prototype._bymonthday = function() {
+      var gettext = this.gettext;
+      if (this.byweekday && this.byweekday.allWeeks) {
+        this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext, gettext("or"))).add(gettext("the")).add(this.list(this.bymonthday, this.nth, gettext("or")));
+      } else {
+        this.add(gettext("on the")).add(this.list(this.bymonthday, this.nth, gettext("and")));
+      }
+    };
+    ToText2.prototype._byweekday = function() {
+      var gettext = this.gettext;
+      if (this.byweekday.allWeeks && !this.byweekday.isWeekdays) {
+        this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext));
+      }
+      if (this.byweekday.someWeeks) {
+        if (this.byweekday.allWeeks)
+          this.add(gettext("and"));
+        this.add(gettext("on the")).add(this.list(this.byweekday.someWeeks, this.weekdaytext, gettext("and")));
+      }
+    };
+    ToText2.prototype._byhour = function() {
+      var gettext = this.gettext;
+      this.add(gettext("at")).add(this.list(this.origOptions.byhour, void 0, gettext("and")));
+    };
+    ToText2.prototype._bymonth = function() {
+      this.add(this.list(this.options.bymonth, this.monthtext, this.gettext("and")));
+    };
+    ToText2.prototype.nth = function(n) {
+      n = parseInt(n.toString(), 10);
+      var nth;
+      var gettext = this.gettext;
+      if (n === -1)
+        return gettext("last");
+      var npos = Math.abs(n);
+      switch (npos) {
+        case 1:
+        case 21:
+        case 31:
+          nth = npos + gettext("st");
+          break;
+        case 2:
+        case 22:
+          nth = npos + gettext("nd");
+          break;
+        case 3:
+        case 23:
+          nth = npos + gettext("rd");
+          break;
+        default:
+          nth = npos + gettext("th");
+      }
+      return n < 0 ? nth + " " + gettext("last") : nth;
+    };
+    ToText2.prototype.monthtext = function(m) {
+      return this.language.monthNames[m - 1];
+    };
+    ToText2.prototype.weekdaytext = function(wday) {
+      var weekday = isNumber(wday) ? (wday + 1) % 7 : wday.getJsWeekday();
+      return (wday.n ? this.nth(wday.n) + " " : "") + this.language.dayNames[weekday];
+    };
+    ToText2.prototype.plural = function(n) {
+      return n % 100 !== 1;
+    };
+    ToText2.prototype.add = function(s) {
+      this.text.push(" ");
+      this.text.push(s);
+      return this;
+    };
+    ToText2.prototype.list = function(arr, callback, finalDelim, delim) {
+      var _this = this;
+      if (delim === void 0) {
+        delim = ",";
+      }
+      if (!isArray(arr)) {
+        arr = [arr];
+      }
+      var delimJoin = function(array, delimiter, finalDelimiter) {
+        var list = "";
+        for (var i = 0; i < array.length; i++) {
+          if (i !== 0) {
+            if (i === array.length - 1) {
+              list += " " + finalDelimiter + " ";
+            } else {
+              list += delimiter + " ";
+            }
+          }
+          list += array[i];
+        }
+        return list;
+      };
+      callback = callback || function(o) {
+        return o.toString();
+      };
+      var realCallback = function(arg) {
+        return callback && callback.call(_this, arg);
+      };
+      if (finalDelim) {
+        return delimJoin(arr.map(realCallback), delim, finalDelim);
+      } else {
+        return arr.map(realCallback).join(delim + " ");
+      }
+    };
+    return ToText2;
+  })()
+);
+var totext_default = ToText;
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/parsetext.js
+var Parser = (
+  /** @class */
+  (function() {
+    function Parser2(rules) {
+      this.done = true;
+      this.rules = rules;
+    }
+    Parser2.prototype.start = function(text) {
+      this.text = text;
+      this.done = false;
+      return this.nextSymbol();
+    };
+    Parser2.prototype.isDone = function() {
+      return this.done && this.symbol === null;
+    };
+    Parser2.prototype.nextSymbol = function() {
+      var best;
+      var bestSymbol;
+      this.symbol = null;
+      this.value = null;
+      do {
+        if (this.done)
+          return false;
+        var rule = void 0;
+        best = null;
+        for (var name_1 in this.rules) {
+          rule = this.rules[name_1];
+          var match = rule.exec(this.text);
+          if (match) {
+            if (best === null || match[0].length > best[0].length) {
+              best = match;
+              bestSymbol = name_1;
+            }
+          }
+        }
+        if (best != null) {
+          this.text = this.text.substr(best[0].length);
+          if (this.text === "")
+            this.done = true;
+        }
+        if (best == null) {
+          this.done = true;
+          this.symbol = null;
+          this.value = null;
+          return;
+        }
+      } while (bestSymbol === "SKIP");
+      this.symbol = bestSymbol;
+      this.value = best;
+      return true;
+    };
+    Parser2.prototype.accept = function(name) {
+      if (this.symbol === name) {
+        if (this.value) {
+          var v = this.value;
+          this.nextSymbol();
+          return v;
+        }
+        this.nextSymbol();
+        return true;
+      }
+      return false;
+    };
+    Parser2.prototype.acceptNumber = function() {
+      return this.accept("number");
+    };
+    Parser2.prototype.expect = function(name) {
+      if (this.accept(name))
+        return true;
+      throw new Error("expected " + name + " but found " + this.symbol);
+    };
+    return Parser2;
+  })()
+);
+function parseText(text, language) {
+  if (language === void 0) {
+    language = i18n_default;
+  }
+  var options = {};
+  var ttr = new Parser(language.tokens);
+  if (!ttr.start(text))
+    return null;
+  S();
+  return options;
+  function S() {
+    ttr.expect("every");
+    var n = ttr.acceptNumber();
+    if (n)
+      options.interval = parseInt(n[0], 10);
+    if (ttr.isDone())
+      throw new Error("Unexpected end");
+    switch (ttr.symbol) {
+      case "day(s)":
+        options.freq = RRule.DAILY;
+        if (ttr.nextSymbol()) {
+          AT();
+          F();
+        }
+        break;
+      // FIXME Note: every 2 weekdays != every two weeks on weekdays.
+      // DAILY on weekdays is not a valid rule
+      case "weekday(s)":
+        options.freq = RRule.WEEKLY;
+        options.byweekday = [RRule.MO, RRule.TU, RRule.WE, RRule.TH, RRule.FR];
+        ttr.nextSymbol();
+        AT();
+        F();
+        break;
+      case "week(s)":
+        options.freq = RRule.WEEKLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          AT();
+          F();
+        }
+        break;
+      case "hour(s)":
+        options.freq = RRule.HOURLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F();
+        }
+        break;
+      case "minute(s)":
+        options.freq = RRule.MINUTELY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F();
+        }
+        break;
+      case "month(s)":
+        options.freq = RRule.MONTHLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F();
+        }
+        break;
+      case "year(s)":
+        options.freq = RRule.YEARLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F();
+        }
+        break;
+      case "monday":
+      case "tuesday":
+      case "wednesday":
+      case "thursday":
+      case "friday":
+      case "saturday":
+      case "sunday":
+        options.freq = RRule.WEEKLY;
+        var key = ttr.symbol.substr(0, 2).toUpperCase();
+        options.byweekday = [RRule[key]];
+        if (!ttr.nextSymbol())
+          return;
+        while (ttr.accept("comma")) {
+          if (ttr.isDone())
+            throw new Error("Unexpected end");
+          var wkd = decodeWKD();
+          if (!wkd) {
+            throw new Error("Unexpected symbol " + ttr.symbol + ", expected weekday");
+          }
+          options.byweekday.push(RRule[wkd]);
+          ttr.nextSymbol();
+        }
+        AT();
+        MDAYs();
+        F();
+        break;
+      case "january":
+      case "february":
+      case "march":
+      case "april":
+      case "may":
+      case "june":
+      case "july":
+      case "august":
+      case "september":
+      case "october":
+      case "november":
+      case "december":
+        options.freq = RRule.YEARLY;
+        options.bymonth = [decodeM()];
+        if (!ttr.nextSymbol())
+          return;
+        while (ttr.accept("comma")) {
+          if (ttr.isDone())
+            throw new Error("Unexpected end");
+          var m = decodeM();
+          if (!m) {
+            throw new Error("Unexpected symbol " + ttr.symbol + ", expected month");
+          }
+          options.bymonth.push(m);
+          ttr.nextSymbol();
+        }
+        ON();
+        F();
+        break;
+      default:
+        throw new Error("Unknown symbol");
+    }
+  }
+  function ON() {
+    var on = ttr.accept("on");
+    var the = ttr.accept("the");
+    if (!(on || the))
+      return;
+    do {
+      var nth = decodeNTH();
+      var wkd = decodeWKD();
+      var m = decodeM();
+      if (nth) {
+        if (wkd) {
+          ttr.nextSymbol();
+          if (!options.byweekday)
+            options.byweekday = [];
+          options.byweekday.push(RRule[wkd].nth(nth));
+        } else {
+          if (!options.bymonthday)
+            options.bymonthday = [];
+          options.bymonthday.push(nth);
+          ttr.accept("day(s)");
+        }
+      } else if (wkd) {
+        ttr.nextSymbol();
+        if (!options.byweekday)
+          options.byweekday = [];
+        options.byweekday.push(RRule[wkd]);
+      } else if (ttr.symbol === "weekday(s)") {
+        ttr.nextSymbol();
+        if (!options.byweekday) {
+          options.byweekday = [RRule.MO, RRule.TU, RRule.WE, RRule.TH, RRule.FR];
+        }
+      } else if (ttr.symbol === "week(s)") {
+        ttr.nextSymbol();
+        var n = ttr.acceptNumber();
+        if (!n) {
+          throw new Error("Unexpected symbol " + ttr.symbol + ", expected week number");
+        }
+        options.byweekno = [parseInt(n[0], 10)];
+        while (ttr.accept("comma")) {
+          n = ttr.acceptNumber();
+          if (!n) {
+            throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+          }
+          options.byweekno.push(parseInt(n[0], 10));
+        }
+      } else if (m) {
+        ttr.nextSymbol();
+        if (!options.bymonth)
+          options.bymonth = [];
+        options.bymonth.push(m);
+      } else {
+        return;
+      }
+    } while (ttr.accept("comma") || ttr.accept("the") || ttr.accept("on"));
+  }
+  function AT() {
+    var at = ttr.accept("at");
+    if (!at)
+      return;
+    do {
+      var n = ttr.acceptNumber();
+      if (!n) {
+        throw new Error("Unexpected symbol " + ttr.symbol + ", expected hour");
+      }
+      options.byhour = [parseInt(n[0], 10)];
+      while (ttr.accept("comma")) {
+        n = ttr.acceptNumber();
+        if (!n) {
+          throw new Error("Unexpected symbol " + ttr.symbol + "; expected hour");
+        }
+        options.byhour.push(parseInt(n[0], 10));
+      }
+    } while (ttr.accept("comma") || ttr.accept("at"));
+  }
+  function decodeM() {
+    switch (ttr.symbol) {
+      case "january":
+        return 1;
+      case "february":
+        return 2;
+      case "march":
+        return 3;
+      case "april":
+        return 4;
+      case "may":
+        return 5;
+      case "june":
+        return 6;
+      case "july":
+        return 7;
+      case "august":
+        return 8;
+      case "september":
+        return 9;
+      case "october":
+        return 10;
+      case "november":
+        return 11;
+      case "december":
+        return 12;
+      default:
+        return false;
+    }
+  }
+  function decodeWKD() {
+    switch (ttr.symbol) {
+      case "monday":
+      case "tuesday":
+      case "wednesday":
+      case "thursday":
+      case "friday":
+      case "saturday":
+      case "sunday":
+        return ttr.symbol.substr(0, 2).toUpperCase();
+      default:
+        return false;
+    }
+  }
+  function decodeNTH() {
+    switch (ttr.symbol) {
+      case "last":
+        ttr.nextSymbol();
+        return -1;
+      case "first":
+        ttr.nextSymbol();
+        return 1;
+      case "second":
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -2 : 2;
+      case "third":
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -3 : 3;
+      case "nth":
+        var v = parseInt(ttr.value[1], 10);
+        if (v < -366 || v > 366)
+          throw new Error("Nth out of range: " + v);
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -v : v;
+      default:
+        return false;
+    }
+  }
+  function MDAYs() {
+    ttr.accept("on");
+    ttr.accept("the");
+    var nth = decodeNTH();
+    if (!nth)
+      return;
+    options.bymonthday = [nth];
+    ttr.nextSymbol();
+    while (ttr.accept("comma")) {
+      nth = decodeNTH();
+      if (!nth) {
+        throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+      }
+      options.bymonthday.push(nth);
+      ttr.nextSymbol();
+    }
+  }
+  function F() {
+    if (ttr.symbol === "until") {
+      var date = Date.parse(ttr.text);
+      if (!date)
+        throw new Error("Cannot parse until date:" + ttr.text);
+      options.until = new Date(date);
+    } else if (ttr.accept("for")) {
+      options.count = parseInt(ttr.value[0], 10);
+      ttr.expect("number");
+    }
+  }
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/types.js
+var Frequency;
+(function(Frequency2) {
+  Frequency2[Frequency2["YEARLY"] = 0] = "YEARLY";
+  Frequency2[Frequency2["MONTHLY"] = 1] = "MONTHLY";
+  Frequency2[Frequency2["WEEKLY"] = 2] = "WEEKLY";
+  Frequency2[Frequency2["DAILY"] = 3] = "DAILY";
+  Frequency2[Frequency2["HOURLY"] = 4] = "HOURLY";
+  Frequency2[Frequency2["MINUTELY"] = 5] = "MINUTELY";
+  Frequency2[Frequency2["SECONDLY"] = 6] = "SECONDLY";
+})(Frequency || (Frequency = {}));
+function freqIsDailyOrGreater(freq) {
+  return freq < Frequency.HOURLY;
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/index.js
+var fromText = function(text, language) {
+  if (language === void 0) {
+    language = i18n_default;
+  }
+  return new RRule(parseText(text, language) || void 0);
+};
+var common = [
+  "count",
+  "until",
+  "interval",
+  "byweekday",
+  "bymonthday",
+  "bymonth"
+];
+totext_default.IMPLEMENTED = [];
+totext_default.IMPLEMENTED[Frequency.HOURLY] = common;
+totext_default.IMPLEMENTED[Frequency.MINUTELY] = common;
+totext_default.IMPLEMENTED[Frequency.DAILY] = ["byhour"].concat(common);
+totext_default.IMPLEMENTED[Frequency.WEEKLY] = common;
+totext_default.IMPLEMENTED[Frequency.MONTHLY] = common;
+totext_default.IMPLEMENTED[Frequency.YEARLY] = ["byweekno", "byyearday"].concat(common);
+var toText = function(rrule, gettext, language, dateFormatter) {
+  return new totext_default(rrule, gettext, language, dateFormatter).toString();
+};
+var isFullyConvertible = totext_default.isFullyConvertible;
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/datetime.js
+var Time = (
+  /** @class */
+  (function() {
+    function Time2(hour, minute, second, millisecond) {
+      this.hour = hour;
+      this.minute = minute;
+      this.second = second;
+      this.millisecond = millisecond || 0;
+    }
+    Time2.prototype.getHours = function() {
+      return this.hour;
+    };
+    Time2.prototype.getMinutes = function() {
+      return this.minute;
+    };
+    Time2.prototype.getSeconds = function() {
+      return this.second;
+    };
+    Time2.prototype.getMilliseconds = function() {
+      return this.millisecond;
+    };
+    Time2.prototype.getTime = function() {
+      return (this.hour * 60 * 60 + this.minute * 60 + this.second) * 1e3 + this.millisecond;
+    };
+    return Time2;
+  })()
+);
+var DateTime = (
+  /** @class */
+  (function(_super) {
+    __extends(DateTime2, _super);
+    function DateTime2(year, month, day, hour, minute, second, millisecond) {
+      var _this = _super.call(this, hour, minute, second, millisecond) || this;
+      _this.year = year;
+      _this.month = month;
+      _this.day = day;
+      return _this;
+    }
+    DateTime2.fromDate = function(date) {
+      return new this(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.valueOf() % 1e3);
+    };
+    DateTime2.prototype.getWeekday = function() {
+      return getWeekday(new Date(this.getTime()));
+    };
+    DateTime2.prototype.getTime = function() {
+      return new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond)).getTime();
+    };
+    DateTime2.prototype.getDay = function() {
+      return this.day;
+    };
+    DateTime2.prototype.getMonth = function() {
+      return this.month;
+    };
+    DateTime2.prototype.getYear = function() {
+      return this.year;
+    };
+    DateTime2.prototype.addYears = function(years) {
+      this.year += years;
+    };
+    DateTime2.prototype.addMonths = function(months) {
+      this.month += months;
+      if (this.month > 12) {
+        var yearDiv = Math.floor(this.month / 12);
+        var monthMod = pymod(this.month, 12);
+        this.month = monthMod;
+        this.year += yearDiv;
+        if (this.month === 0) {
+          this.month = 12;
+          --this.year;
+        }
+      }
+    };
+    DateTime2.prototype.addWeekly = function(days, wkst) {
+      if (wkst > this.getWeekday()) {
+        this.day += -(this.getWeekday() + 1 + (6 - wkst)) + days * 7;
+      } else {
+        this.day += -(this.getWeekday() - wkst) + days * 7;
+      }
+      this.fixDay();
+    };
+    DateTime2.prototype.addDaily = function(days) {
+      this.day += days;
+      this.fixDay();
+    };
+    DateTime2.prototype.addHours = function(hours, filtered, byhour) {
+      if (filtered) {
+        this.hour += Math.floor((23 - this.hour) / hours) * hours;
+      }
+      for (; ; ) {
+        this.hour += hours;
+        var _a = divmod(this.hour, 24), dayDiv = _a.div, hourMod = _a.mod;
+        if (dayDiv) {
+          this.hour = hourMod;
+          this.addDaily(dayDiv);
+        }
+        if (empty(byhour) || includes(byhour, this.hour))
+          break;
+      }
+    };
+    DateTime2.prototype.addMinutes = function(minutes, filtered, byhour, byminute) {
+      if (filtered) {
+        this.minute += Math.floor((1439 - (this.hour * 60 + this.minute)) / minutes) * minutes;
+      }
+      for (; ; ) {
+        this.minute += minutes;
+        var _a = divmod(this.minute, 60), hourDiv = _a.div, minuteMod = _a.mod;
+        if (hourDiv) {
+          this.minute = minuteMod;
+          this.addHours(hourDiv, false, byhour);
+        }
+        if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute))) {
+          break;
+        }
+      }
+    };
+    DateTime2.prototype.addSeconds = function(seconds, filtered, byhour, byminute, bysecond) {
+      if (filtered) {
+        this.second += Math.floor((86399 - (this.hour * 3600 + this.minute * 60 + this.second)) / seconds) * seconds;
+      }
+      for (; ; ) {
+        this.second += seconds;
+        var _a = divmod(this.second, 60), minuteDiv = _a.div, secondMod = _a.mod;
+        if (minuteDiv) {
+          this.second = secondMod;
+          this.addMinutes(minuteDiv, false, byhour, byminute);
+        }
+        if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute)) && (empty(bysecond) || includes(bysecond, this.second))) {
+          break;
+        }
+      }
+    };
+    DateTime2.prototype.fixDay = function() {
+      if (this.day <= 28) {
+        return;
+      }
+      var daysinmonth = monthRange(this.year, this.month - 1)[1];
+      if (this.day <= daysinmonth) {
+        return;
+      }
+      while (this.day > daysinmonth) {
+        this.day -= daysinmonth;
+        ++this.month;
+        if (this.month === 13) {
+          this.month = 1;
+          ++this.year;
+          if (this.year > MAXYEAR) {
+            return;
+          }
+        }
+        daysinmonth = monthRange(this.year, this.month - 1)[1];
+      }
+    };
+    DateTime2.prototype.add = function(options, filtered) {
+      var freq = options.freq, interval = options.interval, wkst = options.wkst, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+      switch (freq) {
+        case Frequency.YEARLY:
+          return this.addYears(interval);
+        case Frequency.MONTHLY:
+          return this.addMonths(interval);
+        case Frequency.WEEKLY:
+          return this.addWeekly(interval, wkst);
+        case Frequency.DAILY:
+          return this.addDaily(interval);
+        case Frequency.HOURLY:
+          return this.addHours(interval, filtered, byhour);
+        case Frequency.MINUTELY:
+          return this.addMinutes(interval, filtered, byhour, byminute);
+        case Frequency.SECONDLY:
+          return this.addSeconds(interval, filtered, byhour, byminute, bysecond);
+      }
+    };
+    return DateTime2;
+  })(Time)
+);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/parseoptions.js
+function initializeOptions(options) {
+  var invalid = [];
+  var keys = Object.keys(options);
+  for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+    var key = keys_1[_i];
+    if (!includes(defaultKeys, key))
+      invalid.push(key);
+    if (isDate(options[key]) && !isValidDate(options[key])) {
+      invalid.push(key);
+    }
+  }
+  if (invalid.length) {
+    throw new Error("Invalid options: " + invalid.join(", "));
+  }
+  return __assign({}, options);
+}
+function parseOptions(options) {
+  var opts = __assign(__assign({}, DEFAULT_OPTIONS), initializeOptions(options));
+  if (isPresent(opts.byeaster))
+    opts.freq = RRule.YEARLY;
+  if (!(isPresent(opts.freq) && RRule.FREQUENCIES[opts.freq])) {
+    throw new Error("Invalid frequency: ".concat(opts.freq, " ").concat(options.freq));
+  }
+  if (!opts.dtstart)
+    opts.dtstart = new Date((/* @__PURE__ */ new Date()).setMilliseconds(0));
+  if (!isPresent(opts.wkst)) {
+    opts.wkst = RRule.MO.weekday;
+  } else if (isNumber(opts.wkst)) ; else {
+    opts.wkst = opts.wkst.weekday;
+  }
+  if (isPresent(opts.bysetpos)) {
+    if (isNumber(opts.bysetpos))
+      opts.bysetpos = [opts.bysetpos];
+    for (var i = 0; i < opts.bysetpos.length; i++) {
+      var v = opts.bysetpos[i];
+      if (v === 0 || !(v >= -366 && v <= 366)) {
+        throw new Error("bysetpos must be between 1 and 366, or between -366 and -1");
+      }
+    }
+  }
+  if (!(Boolean(opts.byweekno) || notEmpty(opts.byweekno) || notEmpty(opts.byyearday) || Boolean(opts.bymonthday) || notEmpty(opts.bymonthday) || isPresent(opts.byweekday) || isPresent(opts.byeaster))) {
+    switch (opts.freq) {
+      case RRule.YEARLY:
+        if (!opts.bymonth)
+          opts.bymonth = opts.dtstart.getUTCMonth() + 1;
+        opts.bymonthday = opts.dtstart.getUTCDate();
+        break;
+      case RRule.MONTHLY:
+        opts.bymonthday = opts.dtstart.getUTCDate();
+        break;
+      case RRule.WEEKLY:
+        opts.byweekday = [getWeekday(opts.dtstart)];
+        break;
+    }
+  }
+  if (isPresent(opts.bymonth) && !isArray(opts.bymonth)) {
+    opts.bymonth = [opts.bymonth];
+  }
+  if (isPresent(opts.byyearday) && !isArray(opts.byyearday) && isNumber(opts.byyearday)) {
+    opts.byyearday = [opts.byyearday];
+  }
+  if (!isPresent(opts.bymonthday)) {
+    opts.bymonthday = [];
+    opts.bynmonthday = [];
+  } else if (isArray(opts.bymonthday)) {
+    var bymonthday = [];
+    var bynmonthday = [];
+    for (var i = 0; i < opts.bymonthday.length; i++) {
+      var v = opts.bymonthday[i];
+      if (v > 0) {
+        bymonthday.push(v);
+      } else if (v < 0) {
+        bynmonthday.push(v);
+      }
+    }
+    opts.bymonthday = bymonthday;
+    opts.bynmonthday = bynmonthday;
+  } else if (opts.bymonthday < 0) {
+    opts.bynmonthday = [opts.bymonthday];
+    opts.bymonthday = [];
+  } else {
+    opts.bynmonthday = [];
+    opts.bymonthday = [opts.bymonthday];
+  }
+  if (isPresent(opts.byweekno) && !isArray(opts.byweekno)) {
+    opts.byweekno = [opts.byweekno];
+  }
+  if (!isPresent(opts.byweekday)) {
+    opts.bynweekday = null;
+  } else if (isNumber(opts.byweekday)) {
+    opts.byweekday = [opts.byweekday];
+    opts.bynweekday = null;
+  } else if (isWeekdayStr(opts.byweekday)) {
+    opts.byweekday = [Weekday.fromStr(opts.byweekday).weekday];
+    opts.bynweekday = null;
+  } else if (opts.byweekday instanceof Weekday) {
+    if (!opts.byweekday.n || opts.freq > RRule.MONTHLY) {
+      opts.byweekday = [opts.byweekday.weekday];
+      opts.bynweekday = null;
+    } else {
+      opts.bynweekday = [[opts.byweekday.weekday, opts.byweekday.n]];
+      opts.byweekday = null;
+    }
+  } else {
+    var byweekday = [];
+    var bynweekday = [];
+    for (var i = 0; i < opts.byweekday.length; i++) {
+      var wday = opts.byweekday[i];
+      if (isNumber(wday)) {
+        byweekday.push(wday);
+        continue;
+      } else if (isWeekdayStr(wday)) {
+        byweekday.push(Weekday.fromStr(wday).weekday);
+        continue;
+      }
+      if (!wday.n || opts.freq > RRule.MONTHLY) {
+        byweekday.push(wday.weekday);
+      } else {
+        bynweekday.push([wday.weekday, wday.n]);
+      }
+    }
+    opts.byweekday = notEmpty(byweekday) ? byweekday : null;
+    opts.bynweekday = notEmpty(bynweekday) ? bynweekday : null;
+  }
+  if (!isPresent(opts.byhour)) {
+    opts.byhour = opts.freq < RRule.HOURLY ? [opts.dtstart.getUTCHours()] : null;
+  } else if (isNumber(opts.byhour)) {
+    opts.byhour = [opts.byhour];
+  }
+  if (!isPresent(opts.byminute)) {
+    opts.byminute = opts.freq < RRule.MINUTELY ? [opts.dtstart.getUTCMinutes()] : null;
+  } else if (isNumber(opts.byminute)) {
+    opts.byminute = [opts.byminute];
+  }
+  if (!isPresent(opts.bysecond)) {
+    opts.bysecond = opts.freq < RRule.SECONDLY ? [opts.dtstart.getUTCSeconds()] : null;
+  } else if (isNumber(opts.bysecond)) {
+    opts.bysecond = [opts.bysecond];
+  }
+  return { parsedOptions: opts };
+}
+function buildTimeset(opts) {
+  var millisecondModulo = opts.dtstart.getTime() % 1e3;
+  if (!freqIsDailyOrGreater(opts.freq)) {
+    return [];
+  }
+  var timeset = [];
+  opts.byhour.forEach(function(hour) {
+    opts.byminute.forEach(function(minute) {
+      opts.bysecond.forEach(function(second) {
+        timeset.push(new Time(hour, minute, second, millisecondModulo));
+      });
+    });
+  });
+  return timeset;
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/parsestring.js
+function parseString(rfcString) {
+  var options = rfcString.split("\n").map(parseLine).filter(function(x) {
+    return x !== null;
+  });
+  return __assign(__assign({}, options[0]), options[1]);
+}
+function parseDtstart(line) {
+  var options = {};
+  var dtstartWithZone = /DTSTART(?:;TZID=([^:=]+?))?(?::|=)([^;\s]+)/i.exec(line);
+  if (!dtstartWithZone) {
+    return options;
+  }
+  var tzid = dtstartWithZone[1], dtstart = dtstartWithZone[2];
+  if (tzid) {
+    options.tzid = tzid;
+  }
+  options.dtstart = untilStringToDate(dtstart);
+  return options;
+}
+function parseLine(rfcString) {
+  rfcString = rfcString.replace(/^\s+|\s+$/, "");
+  if (!rfcString.length)
+    return null;
+  var header = /^([A-Z]+?)[:;]/.exec(rfcString.toUpperCase());
+  if (!header) {
+    return parseRrule(rfcString);
+  }
+  var key = header[1];
+  switch (key.toUpperCase()) {
+    case "RRULE":
+    case "EXRULE":
+      return parseRrule(rfcString);
+    case "DTSTART":
+      return parseDtstart(rfcString);
+    default:
+      throw new Error("Unsupported RFC prop ".concat(key, " in ").concat(rfcString));
+  }
+}
+function parseRrule(line) {
+  var strippedLine = line.replace(/^RRULE:/i, "");
+  var options = parseDtstart(strippedLine);
+  var attrs = line.replace(/^(?:RRULE|EXRULE):/i, "").split(";");
+  attrs.forEach(function(attr) {
+    var _a = attr.split("="), key = _a[0], value = _a[1];
+    switch (key.toUpperCase()) {
+      case "FREQ":
+        options.freq = Frequency[value.toUpperCase()];
+        break;
+      case "WKST":
+        options.wkst = Days[value.toUpperCase()];
+        break;
+      case "COUNT":
+      case "INTERVAL":
+      case "BYSETPOS":
+      case "BYMONTH":
+      case "BYMONTHDAY":
+      case "BYYEARDAY":
+      case "BYWEEKNO":
+      case "BYHOUR":
+      case "BYMINUTE":
+      case "BYSECOND":
+        var num = parseNumber(value);
+        var optionKey = key.toLowerCase();
+        options[optionKey] = num;
+        break;
+      case "BYWEEKDAY":
+      case "BYDAY":
+        options.byweekday = parseWeekday(value);
+        break;
+      case "DTSTART":
+      case "TZID":
+        var dtstart = parseDtstart(line);
+        options.tzid = dtstart.tzid;
+        options.dtstart = dtstart.dtstart;
+        break;
+      case "UNTIL":
+        options.until = untilStringToDate(value);
+        break;
+      case "BYEASTER":
+        options.byeaster = Number(value);
+        break;
+      default:
+        throw new Error("Unknown RRULE property '" + key + "'");
+    }
+  });
+  return options;
+}
+function parseNumber(value) {
+  if (value.indexOf(",") !== -1) {
+    var values = value.split(",");
+    return values.map(parseIndividualNumber);
+  }
+  return parseIndividualNumber(value);
+}
+function parseIndividualNumber(value) {
+  if (/^[+-]?\d+$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+function parseWeekday(value) {
+  var days = value.split(",");
+  return days.map(function(day) {
+    if (day.length === 2) {
+      return Days[day];
+    }
+    var parts = day.match(/^([+-]?\d{1,2})([A-Z]{2})$/);
+    if (!parts || parts.length < 3) {
+      throw new SyntaxError("Invalid weekday string: ".concat(day));
+    }
+    var n = Number(parts[1]);
+    var wdaypart = parts[2];
+    var wday = Days[wdaypart].weekday;
+    return new Weekday(wday, n);
+  });
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/datewithzone.js
+var DateWithZone = (
+  /** @class */
+  (function() {
+    function DateWithZone2(date, tzid) {
+      if (isNaN(date.getTime())) {
+        throw new RangeError("Invalid date passed to DateWithZone");
+      }
+      this.date = date;
+      this.tzid = tzid;
+    }
+    Object.defineProperty(DateWithZone2.prototype, "isUTC", {
+      get: function() {
+        return !this.tzid || this.tzid.toUpperCase() === "UTC";
+      },
+      enumerable: false,
+      configurable: true
+    });
+    DateWithZone2.prototype.toString = function() {
+      var datestr = timeToUntilString(this.date.getTime(), this.isUTC);
+      if (!this.isUTC) {
+        return ";TZID=".concat(this.tzid, ":").concat(datestr);
+      }
+      return ":".concat(datestr);
+    };
+    DateWithZone2.prototype.getTime = function() {
+      return this.date.getTime();
+    };
+    DateWithZone2.prototype.rezonedDate = function() {
+      if (this.isUTC) {
+        return this.date;
+      }
+      return dateInTimeZone(this.date, this.tzid);
+    };
+    return DateWithZone2;
+  })()
+);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/optionstostring.js
+function optionsToString(options) {
+  var rrule = [];
+  var dtstart = "";
+  var keys = Object.keys(options);
+  var defaultKeys2 = Object.keys(DEFAULT_OPTIONS);
+  for (var i = 0; i < keys.length; i++) {
+    if (keys[i] === "tzid")
+      continue;
+    if (!includes(defaultKeys2, keys[i]))
+      continue;
+    var key = keys[i].toUpperCase();
+    var value = options[keys[i]];
+    var outValue = "";
+    if (!isPresent(value) || isArray(value) && !value.length)
+      continue;
+    switch (key) {
+      case "FREQ":
+        outValue = RRule.FREQUENCIES[options.freq];
+        break;
+      case "WKST":
+        if (isNumber(value)) {
+          outValue = new Weekday(value).toString();
+        } else {
+          outValue = value.toString();
+        }
+        break;
+      case "BYWEEKDAY":
+        key = "BYDAY";
+        outValue = toArray(value).map(function(wday) {
+          if (wday instanceof Weekday) {
+            return wday;
+          }
+          if (isArray(wday)) {
+            return new Weekday(wday[0], wday[1]);
+          }
+          return new Weekday(wday);
+        }).toString();
+        break;
+      case "DTSTART":
+        dtstart = buildDtstart(value, options.tzid);
+        break;
+      case "UNTIL":
+        outValue = timeToUntilString(value, !options.tzid);
+        break;
+      default:
+        if (isArray(value)) {
+          var strValues = [];
+          for (var j = 0; j < value.length; j++) {
+            strValues[j] = String(value[j]);
+          }
+          outValue = strValues.toString();
+        } else {
+          outValue = String(value);
+        }
+    }
+    if (outValue) {
+      rrule.push([key, outValue]);
+    }
+  }
+  var rules = rrule.map(function(_a) {
+    var key2 = _a[0], value2 = _a[1];
+    return "".concat(key2, "=").concat(value2.toString());
+  }).join(";");
+  var ruleString = "";
+  if (rules !== "") {
+    ruleString = "RRULE:".concat(rules);
+  }
+  return [dtstart, ruleString].filter(function(x) {
+    return !!x;
+  }).join("\n");
+}
+function buildDtstart(dtstart, tzid) {
+  if (!dtstart) {
+    return "";
+  }
+  return "DTSTART" + new DateWithZone(new Date(dtstart), tzid).toString();
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/cache.js
+function argsMatch(left, right) {
+  if (Array.isArray(left)) {
+    if (!Array.isArray(right))
+      return false;
+    if (left.length !== right.length)
+      return false;
+    return left.every(function(date, i) {
+      return date.getTime() === right[i].getTime();
+    });
+  }
+  if (left instanceof Date) {
+    return right instanceof Date && left.getTime() === right.getTime();
+  }
+  return left === right;
+}
+var Cache = (
+  /** @class */
+  (function() {
+    function Cache2() {
+      this.all = false;
+      this.before = [];
+      this.after = [];
+      this.between = [];
+    }
+    Cache2.prototype._cacheAdd = function(what, value, args) {
+      if (value) {
+        value = value instanceof Date ? clone(value) : cloneDates(value);
+      }
+      if (what === "all") {
+        this.all = value;
+      } else {
+        args._value = value;
+        this[what].push(args);
+      }
+    };
+    Cache2.prototype._cacheGet = function(what, args) {
+      var cached = false;
+      var argsKeys = args ? Object.keys(args) : [];
+      var findCacheDiff = function(item2) {
+        for (var i2 = 0; i2 < argsKeys.length; i2++) {
+          var key = argsKeys[i2];
+          if (!argsMatch(args[key], item2[key])) {
+            return true;
+          }
+        }
+        return false;
+      };
+      var cachedObject = this[what];
+      if (what === "all") {
+        cached = this.all;
+      } else if (isArray(cachedObject)) {
+        for (var i = 0; i < cachedObject.length; i++) {
+          var item = cachedObject[i];
+          if (argsKeys.length && findCacheDiff(item))
+            continue;
+          cached = item._value;
+          break;
+        }
+      }
+      if (!cached && this.all) {
+        var iterResult = new iterresult_default(what, args);
+        for (var i = 0; i < this.all.length; i++) {
+          if (!iterResult.accept(this.all[i]))
+            break;
+        }
+        cached = iterResult.getValue();
+        this._cacheAdd(what, cached, args);
+      }
+      return isArray(cached) ? cloneDates(cached) : cached instanceof Date ? clone(cached) : cached;
+    };
+    return Cache2;
+  })()
+);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/masks.js
+var M365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 28), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7));
+var M366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 29), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7));
+var M28 = range(1, 29);
+var M29 = range(1, 30);
+var M30 = range(1, 31);
+var M31 = range(1, 32);
+var MDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M29, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7));
+var MDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M28, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7));
+var NM28 = range(-28, 0);
+var NM29 = range(-29, 0);
+var NM30 = range(-30, 0);
+var NM31 = range(-31, 0);
+var NMDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM29, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7));
+var NMDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM28, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7));
+var M366RANGE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366];
+var M365RANGE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365];
+var WDAYMASK = (function() {
+  var wdaymask = [];
+  for (var i = 0; i < 55; i++)
+    wdaymask = wdaymask.concat(range(7));
+  return wdaymask;
+})();
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/yearinfo.js
+function rebuildYear(year, options) {
+  var firstyday = datetime(year, 1, 1);
+  var yearlen = isLeapYear(year) ? 366 : 365;
+  var nextyearlen = isLeapYear(year + 1) ? 366 : 365;
+  var yearordinal = toOrdinal(firstyday);
+  var yearweekday = getWeekday(firstyday);
+  var result = __assign(__assign({ yearlen, nextyearlen, yearordinal, yearweekday }, baseYearMasks(year)), { wnomask: null });
+  if (empty(options.byweekno)) {
+    return result;
+  }
+  result.wnomask = repeat(0, yearlen + 7);
+  var firstwkst;
+  var wyearlen;
+  var no1wkst = firstwkst = pymod(7 - yearweekday + options.wkst, 7);
+  if (no1wkst >= 4) {
+    no1wkst = 0;
+    wyearlen = result.yearlen + pymod(yearweekday - options.wkst, 7);
+  } else {
+    wyearlen = yearlen - no1wkst;
+  }
+  var div = Math.floor(wyearlen / 7);
+  var mod = pymod(wyearlen, 7);
+  var numweeks = Math.floor(div + mod / 4);
+  for (var j = 0; j < options.byweekno.length; j++) {
+    var n = options.byweekno[j];
+    if (n < 0) {
+      n += numweeks + 1;
+    }
+    if (!(n > 0 && n <= numweeks)) {
+      continue;
+    }
+    var i = void 0;
+    if (n > 1) {
+      i = no1wkst + (n - 1) * 7;
+      if (no1wkst !== firstwkst) {
+        i -= 7 - firstwkst;
+      }
+    } else {
+      i = no1wkst;
+    }
+    for (var k = 0; k < 7; k++) {
+      result.wnomask[i] = 1;
+      i++;
+      if (result.wdaymask[i] === options.wkst)
+        break;
+    }
+  }
+  if (includes(options.byweekno, 1)) {
+    var i = no1wkst + numweeks * 7;
+    if (no1wkst !== firstwkst)
+      i -= 7 - firstwkst;
+    if (i < yearlen) {
+      for (var j = 0; j < 7; j++) {
+        result.wnomask[i] = 1;
+        i += 1;
+        if (result.wdaymask[i] === options.wkst)
+          break;
+      }
+    }
+  }
+  if (no1wkst) {
+    var lnumweeks = void 0;
+    if (!includes(options.byweekno, -1)) {
+      var lyearweekday = getWeekday(datetime(year - 1, 1, 1));
+      var lno1wkst = pymod(7 - lyearweekday.valueOf() + options.wkst, 7);
+      var lyearlen = isLeapYear(year - 1) ? 366 : 365;
+      var weekst = void 0;
+      if (lno1wkst >= 4) {
+        lno1wkst = 0;
+        weekst = lyearlen + pymod(lyearweekday - options.wkst, 7);
+      } else {
+        weekst = yearlen - no1wkst;
+      }
+      lnumweeks = Math.floor(52 + pymod(weekst, 7) / 4);
+    } else {
+      lnumweeks = -1;
+    }
+    if (includes(options.byweekno, lnumweeks)) {
+      for (var i = 0; i < no1wkst; i++)
+        result.wnomask[i] = 1;
+    }
+  }
+  return result;
+}
+function baseYearMasks(year) {
+  var yearlen = isLeapYear(year) ? 366 : 365;
+  var firstyday = datetime(year, 1, 1);
+  var wday = getWeekday(firstyday);
+  if (yearlen === 365) {
+    return {
+      mmask: M365MASK,
+      mdaymask: MDAY365MASK,
+      nmdaymask: NMDAY365MASK,
+      wdaymask: WDAYMASK.slice(wday),
+      mrange: M365RANGE
+    };
+  }
+  return {
+    mmask: M366MASK,
+    mdaymask: MDAY366MASK,
+    nmdaymask: NMDAY366MASK,
+    wdaymask: WDAYMASK.slice(wday),
+    mrange: M366RANGE
+  };
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/monthinfo.js
+function rebuildMonth(year, month, yearlen, mrange, wdaymask, options) {
+  var result = {
+    lastyear: year,
+    lastmonth: month,
+    nwdaymask: []
+  };
+  var ranges = [];
+  if (options.freq === RRule.YEARLY) {
+    if (empty(options.bymonth)) {
+      ranges = [[0, yearlen]];
+    } else {
+      for (var j = 0; j < options.bymonth.length; j++) {
+        month = options.bymonth[j];
+        ranges.push(mrange.slice(month - 1, month + 1));
+      }
+    }
+  } else if (options.freq === RRule.MONTHLY) {
+    ranges = [mrange.slice(month - 1, month + 1)];
+  }
+  if (empty(ranges)) {
+    return result;
+  }
+  result.nwdaymask = repeat(0, yearlen);
+  for (var j = 0; j < ranges.length; j++) {
+    var rang = ranges[j];
+    var first = rang[0];
+    var last = rang[1] - 1;
+    for (var k = 0; k < options.bynweekday.length; k++) {
+      var i = void 0;
+      var _a = options.bynweekday[k], wday = _a[0], n = _a[1];
+      if (n < 0) {
+        i = last + (n + 1) * 7;
+        i -= pymod(wdaymask[i] - wday, 7);
+      } else {
+        i = first + (n - 1) * 7;
+        i += pymod(7 - wdaymask[i] + wday, 7);
+      }
+      if (first <= i && i <= last)
+        result.nwdaymask[i] = 1;
+    }
+  }
+  return result;
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/easter.js
+function easter(y, offset) {
+  if (offset === void 0) {
+    offset = 0;
+  }
+  var a = y % 19;
+  var b = Math.floor(y / 100);
+  var c = y % 100;
+  var d = Math.floor(b / 4);
+  var e = b % 4;
+  var f = Math.floor((b + 8) / 25);
+  var g = Math.floor((b - f + 1) / 3);
+  var h = Math.floor(19 * a + b - d - g + 15) % 30;
+  var i = Math.floor(c / 4);
+  var k = c % 4;
+  var l = Math.floor(32 + 2 * e + 2 * i - h - k) % 7;
+  var m = Math.floor((a + 11 * h + 22 * l) / 451);
+  var month = Math.floor((h + l - 7 * m + 114) / 31);
+  var day = (h + l - 7 * m + 114) % 31 + 1;
+  var date = Date.UTC(y, month - 1, day + offset);
+  var yearStart = Date.UTC(y, 0, 1);
+  return [Math.ceil((date - yearStart) / (1e3 * 60 * 60 * 24))];
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/index.js
+var Iterinfo = (
+  /** @class */
+  (function() {
+    function Iterinfo2(options) {
+      this.options = options;
+    }
+    Iterinfo2.prototype.rebuild = function(year, month) {
+      var options = this.options;
+      if (year !== this.lastyear) {
+        this.yearinfo = rebuildYear(year, options);
+      }
+      if (notEmpty(options.bynweekday) && (month !== this.lastmonth || year !== this.lastyear)) {
+        var _a = this.yearinfo, yearlen = _a.yearlen, mrange = _a.mrange, wdaymask = _a.wdaymask;
+        this.monthinfo = rebuildMonth(year, month, yearlen, mrange, wdaymask, options);
+      }
+      if (isPresent(options.byeaster)) {
+        this.eastermask = easter(year, options.byeaster);
+      }
+    };
+    Object.defineProperty(Iterinfo2.prototype, "lastyear", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.lastyear : null;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "lastmonth", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.lastmonth : null;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "yearlen", {
+      get: function() {
+        return this.yearinfo.yearlen;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "yearordinal", {
+      get: function() {
+        return this.yearinfo.yearordinal;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mrange", {
+      get: function() {
+        return this.yearinfo.mrange;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "wdaymask", {
+      get: function() {
+        return this.yearinfo.wdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mmask", {
+      get: function() {
+        return this.yearinfo.mmask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "wnomask", {
+      get: function() {
+        return this.yearinfo.wnomask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nwdaymask", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.nwdaymask : [];
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nextyearlen", {
+      get: function() {
+        return this.yearinfo.nextyearlen;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mdaymask", {
+      get: function() {
+        return this.yearinfo.mdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nmdaymask", {
+      get: function() {
+        return this.yearinfo.nmdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Iterinfo2.prototype.ydayset = function() {
+      return [range(this.yearlen), 0, this.yearlen];
+    };
+    Iterinfo2.prototype.mdayset = function(_, month) {
+      var start = this.mrange[month - 1];
+      var end = this.mrange[month];
+      var set = repeat(null, this.yearlen);
+      for (var i = start; i < end; i++)
+        set[i] = i;
+      return [set, start, end];
+    };
+    Iterinfo2.prototype.wdayset = function(year, month, day) {
+      var set = repeat(null, this.yearlen + 7);
+      var i = toOrdinal(datetime(year, month, day)) - this.yearordinal;
+      var start = i;
+      for (var j = 0; j < 7; j++) {
+        set[i] = i;
+        ++i;
+        if (this.wdaymask[i] === this.options.wkst)
+          break;
+      }
+      return [set, start, i];
+    };
+    Iterinfo2.prototype.ddayset = function(year, month, day) {
+      var set = repeat(null, this.yearlen);
+      var i = toOrdinal(datetime(year, month, day)) - this.yearordinal;
+      set[i] = i;
+      return [set, i, i + 1];
+    };
+    Iterinfo2.prototype.htimeset = function(hour, _, second, millisecond) {
+      var _this = this;
+      var set = [];
+      this.options.byminute.forEach(function(minute) {
+        set = set.concat(_this.mtimeset(hour, minute, second, millisecond));
+      });
+      sort(set);
+      return set;
+    };
+    Iterinfo2.prototype.mtimeset = function(hour, minute, _, millisecond) {
+      var set = this.options.bysecond.map(function(second) {
+        return new Time(hour, minute, second, millisecond);
+      });
+      sort(set);
+      return set;
+    };
+    Iterinfo2.prototype.stimeset = function(hour, minute, second, millisecond) {
+      return [new Time(hour, minute, second, millisecond)];
+    };
+    Iterinfo2.prototype.getdayset = function(freq) {
+      switch (freq) {
+        case Frequency.YEARLY:
+          return this.ydayset.bind(this);
+        case Frequency.MONTHLY:
+          return this.mdayset.bind(this);
+        case Frequency.WEEKLY:
+          return this.wdayset.bind(this);
+        case Frequency.DAILY:
+          return this.ddayset.bind(this);
+        default:
+          return this.ddayset.bind(this);
+      }
+    };
+    Iterinfo2.prototype.gettimeset = function(freq) {
+      switch (freq) {
+        case Frequency.HOURLY:
+          return this.htimeset.bind(this);
+        case Frequency.MINUTELY:
+          return this.mtimeset.bind(this);
+        case Frequency.SECONDLY:
+          return this.stimeset.bind(this);
+      }
+    };
+    return Iterinfo2;
+  })()
+);
+var iterinfo_default = Iterinfo;
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iter/poslist.js
+function buildPoslist(bysetpos, timeset, start, end, ii, dayset) {
+  var poslist = [];
+  for (var j = 0; j < bysetpos.length; j++) {
+    var daypos = void 0;
+    var timepos = void 0;
+    var pos = bysetpos[j];
+    if (pos < 0) {
+      daypos = Math.floor(pos / timeset.length);
+      timepos = pymod(pos, timeset.length);
+    } else {
+      daypos = Math.floor((pos - 1) / timeset.length);
+      timepos = pymod(pos - 1, timeset.length);
+    }
+    var tmp = [];
+    for (var k = start; k < end; k++) {
+      var val = dayset[k];
+      if (!isPresent(val))
+        continue;
+      tmp.push(val);
+    }
+    var i = void 0;
+    if (daypos < 0) {
+      i = tmp.slice(daypos)[0];
+    } else {
+      i = tmp[daypos];
+    }
+    var time = timeset[timepos];
+    var date = fromOrdinal(ii.yearordinal + i);
+    var res = combine(date, time);
+    if (!includes(poslist, res))
+      poslist.push(res);
+  }
+  sort(poslist);
+  return poslist;
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iter/index.js
+function iter(iterResult, options) {
+  var dtstart = options.dtstart, freq = options.freq, interval = options.interval, until = options.until, bysetpos = options.bysetpos;
+  var count = options.count;
+  if (count === 0 || interval === 0) {
+    return emitResult(iterResult);
+  }
+  var counterDate = DateTime.fromDate(dtstart);
+  var ii = new iterinfo_default(options);
+  ii.rebuild(counterDate.year, counterDate.month);
+  var timeset = makeTimeset(ii, counterDate, options);
+  for (; ; ) {
+    var _a = ii.getdayset(freq)(counterDate.year, counterDate.month, counterDate.day), dayset = _a[0], start = _a[1], end = _a[2];
+    var filtered = removeFilteredDays(dayset, start, end, ii, options);
+    if (notEmpty(bysetpos)) {
+      var poslist = buildPoslist(bysetpos, timeset, start, end, ii, dayset);
+      for (var j = 0; j < poslist.length; j++) {
+        var res = poslist[j];
+        if (until && res > until) {
+          return emitResult(iterResult);
+        }
+        if (res >= dtstart) {
+          var rezonedDate = rezoneIfNeeded(res, options);
+          if (!iterResult.accept(rezonedDate)) {
+            return emitResult(iterResult);
+          }
+          if (count) {
+            --count;
+            if (!count) {
+              return emitResult(iterResult);
+            }
+          }
+        }
+      }
+    } else {
+      for (var j = start; j < end; j++) {
+        var currentDay = dayset[j];
+        if (!isPresent(currentDay)) {
+          continue;
+        }
+        var date = fromOrdinal(ii.yearordinal + currentDay);
+        for (var k = 0; k < timeset.length; k++) {
+          var time = timeset[k];
+          var res = combine(date, time);
+          if (until && res > until) {
+            return emitResult(iterResult);
+          }
+          if (res >= dtstart) {
+            var rezonedDate = rezoneIfNeeded(res, options);
+            if (!iterResult.accept(rezonedDate)) {
+              return emitResult(iterResult);
+            }
+            if (count) {
+              --count;
+              if (!count) {
+                return emitResult(iterResult);
+              }
+            }
+          }
+        }
+      }
+    }
+    if (options.interval === 0) {
+      return emitResult(iterResult);
+    }
+    counterDate.add(options, filtered);
+    if (counterDate.year > MAXYEAR) {
+      return emitResult(iterResult);
+    }
+    if (!freqIsDailyOrGreater(freq)) {
+      timeset = ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, 0);
+    }
+    ii.rebuild(counterDate.year, counterDate.month);
+  }
+}
+function isFiltered(ii, currentDay, options) {
+  var bymonth = options.bymonth, byweekno = options.byweekno, byweekday = options.byweekday, byeaster = options.byeaster, bymonthday = options.bymonthday, bynmonthday = options.bynmonthday, byyearday = options.byyearday;
+  return notEmpty(bymonth) && !includes(bymonth, ii.mmask[currentDay]) || notEmpty(byweekno) && !ii.wnomask[currentDay] || notEmpty(byweekday) && !includes(byweekday, ii.wdaymask[currentDay]) || notEmpty(ii.nwdaymask) && !ii.nwdaymask[currentDay] || byeaster !== null && !includes(ii.eastermask, currentDay) || (notEmpty(bymonthday) || notEmpty(bynmonthday)) && !includes(bymonthday, ii.mdaymask[currentDay]) && !includes(bynmonthday, ii.nmdaymask[currentDay]) || notEmpty(byyearday) && (currentDay < ii.yearlen && !includes(byyearday, currentDay + 1) && !includes(byyearday, -ii.yearlen + currentDay) || currentDay >= ii.yearlen && !includes(byyearday, currentDay + 1 - ii.yearlen) && !includes(byyearday, -ii.nextyearlen + currentDay - ii.yearlen));
+}
+function rezoneIfNeeded(date, options) {
+  return new DateWithZone(date, options.tzid).rezonedDate();
+}
+function emitResult(iterResult) {
+  return iterResult.getValue();
+}
+function removeFilteredDays(dayset, start, end, ii, options) {
+  var filtered = false;
+  for (var dayCounter = start; dayCounter < end; dayCounter++) {
+    var currentDay = dayset[dayCounter];
+    filtered = isFiltered(ii, currentDay, options);
+    if (filtered)
+      dayset[currentDay] = null;
+  }
+  return filtered;
+}
+function makeTimeset(ii, counterDate, options) {
+  var freq = options.freq, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+  if (freqIsDailyOrGreater(freq)) {
+    return buildTimeset(options);
+  }
+  if (freq >= RRule.HOURLY && notEmpty(byhour) && !includes(byhour, counterDate.hour) || freq >= RRule.MINUTELY && notEmpty(byminute) && !includes(byminute, counterDate.minute) || freq >= RRule.SECONDLY && notEmpty(bysecond) && !includes(bysecond, counterDate.second)) {
+    return [];
+  }
+  return ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, counterDate.millisecond);
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rrule.js
+var Days = {
+  MO: new Weekday(0),
+  TU: new Weekday(1),
+  WE: new Weekday(2),
+  TH: new Weekday(3),
+  FR: new Weekday(4),
+  SA: new Weekday(5),
+  SU: new Weekday(6)
+};
+var DEFAULT_OPTIONS = {
+  freq: Frequency.YEARLY,
+  dtstart: null,
+  interval: 1,
+  wkst: Days.MO,
+  count: null,
+  until: null,
+  tzid: null,
+  bysetpos: null,
+  bymonth: null,
+  bymonthday: null,
+  bynmonthday: null,
+  byyearday: null,
+  byweekno: null,
+  byweekday: null,
+  bynweekday: null,
+  byhour: null,
+  byminute: null,
+  bysecond: null,
+  byeaster: null
+};
+var defaultKeys = Object.keys(DEFAULT_OPTIONS);
+var RRule = (
+  /** @class */
+  (function() {
+    function RRule3(options, noCache) {
+      if (options === void 0) {
+        options = {};
+      }
+      if (noCache === void 0) {
+        noCache = false;
+      }
+      this._cache = noCache ? null : new Cache();
+      this.origOptions = initializeOptions(options);
+      var parsedOptions = parseOptions(options).parsedOptions;
+      this.options = parsedOptions;
+    }
+    RRule3.parseText = function(text, language) {
+      return parseText(text, language);
+    };
+    RRule3.fromText = function(text, language) {
+      return fromText(text, language);
+    };
+    RRule3.fromString = function(str) {
+      return new RRule3(RRule3.parseString(str) || void 0);
+    };
+    RRule3.prototype._iter = function(iterResult) {
+      return iter(iterResult, this.options);
+    };
+    RRule3.prototype._cacheGet = function(what, args) {
+      if (!this._cache)
+        return false;
+      return this._cache._cacheGet(what, args);
+    };
+    RRule3.prototype._cacheAdd = function(what, value, args) {
+      if (!this._cache)
+        return;
+      return this._cache._cacheAdd(what, value, args);
+    };
+    RRule3.prototype.all = function(iterator) {
+      if (iterator) {
+        return this._iter(new callbackiterresult_default("all", {}, iterator));
+      }
+      var result = this._cacheGet("all");
+      if (result === false) {
+        result = this._iter(new iterresult_default("all", {}));
+        this._cacheAdd("all", result);
+      }
+      return result;
+    };
+    RRule3.prototype.between = function(after, before, inc, iterator) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(after) || !isValidDate(before)) {
+        throw new Error("Invalid date passed in to RRule.between");
+      }
+      var args = {
+        before,
+        after,
+        inc
+      };
+      if (iterator) {
+        return this._iter(new callbackiterresult_default("between", args, iterator));
+      }
+      var result = this._cacheGet("between", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("between", args));
+        this._cacheAdd("between", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.before = function(dt, inc) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(dt)) {
+        throw new Error("Invalid date passed in to RRule.before");
+      }
+      var args = { dt, inc };
+      var result = this._cacheGet("before", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("before", args));
+        this._cacheAdd("before", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.after = function(dt, inc) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(dt)) {
+        throw new Error("Invalid date passed in to RRule.after");
+      }
+      var args = { dt, inc };
+      var result = this._cacheGet("after", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("after", args));
+        this._cacheAdd("after", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.count = function() {
+      return this.all().length;
+    };
+    RRule3.prototype.toString = function() {
+      return optionsToString(this.origOptions);
+    };
+    RRule3.prototype.toText = function(gettext, language, dateFormatter) {
+      return toText(this, gettext, language, dateFormatter);
+    };
+    RRule3.prototype.isFullyConvertibleToText = function() {
+      return isFullyConvertible(this);
+    };
+    RRule3.prototype.clone = function() {
+      return new RRule3(this.origOptions);
+    };
+    RRule3.FREQUENCIES = [
+      "YEARLY",
+      "MONTHLY",
+      "WEEKLY",
+      "DAILY",
+      "HOURLY",
+      "MINUTELY",
+      "SECONDLY"
+    ];
+    RRule3.YEARLY = Frequency.YEARLY;
+    RRule3.MONTHLY = Frequency.MONTHLY;
+    RRule3.WEEKLY = Frequency.WEEKLY;
+    RRule3.DAILY = Frequency.DAILY;
+    RRule3.HOURLY = Frequency.HOURLY;
+    RRule3.MINUTELY = Frequency.MINUTELY;
+    RRule3.SECONDLY = Frequency.SECONDLY;
+    RRule3.MO = Days.MO;
+    RRule3.TU = Days.TU;
+    RRule3.WE = Days.WE;
+    RRule3.TH = Days.TH;
+    RRule3.FR = Days.FR;
+    RRule3.SA = Days.SA;
+    RRule3.SU = Days.SU;
+    RRule3.parseString = parseString;
+    RRule3.optionsToString = optionsToString;
+    return RRule3;
+  })()
+);
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterset.js
+function iterSet(iterResult, _rrule, _exrule, _rdate, _exdate, tzid) {
+  var _exdateHash = {};
+  var _accept = iterResult.accept;
+  function evalExdate(after, before) {
+    _exrule.forEach(function(rrule) {
+      rrule.between(after, before, true).forEach(function(date) {
+        _exdateHash[Number(date)] = true;
+      });
+    });
+  }
+  _exdate.forEach(function(date) {
+    var zonedDate2 = new DateWithZone(date, tzid).rezonedDate();
+    _exdateHash[Number(zonedDate2)] = true;
+  });
+  iterResult.accept = function(date) {
+    var dt = Number(date);
+    if (isNaN(dt))
+      return _accept.call(this, date);
+    if (!_exdateHash[dt]) {
+      evalExdate(new Date(dt - 1), new Date(dt + 1));
+      if (!_exdateHash[dt]) {
+        _exdateHash[dt] = true;
+        return _accept.call(this, date);
+      }
+    }
+    return true;
+  };
+  if (iterResult.method === "between") {
+    evalExdate(iterResult.args.after, iterResult.args.before);
+    iterResult.accept = function(date) {
+      var dt = Number(date);
+      if (!_exdateHash[dt]) {
+        _exdateHash[dt] = true;
+        return _accept.call(this, date);
+      }
+      return true;
+    };
+  }
+  for (var i = 0; i < _rdate.length; i++) {
+    var zonedDate = new DateWithZone(_rdate[i], tzid).rezonedDate();
+    if (!iterResult.accept(new Date(zonedDate.getTime())))
+      break;
+  }
+  _rrule.forEach(function(rrule) {
+    iter(iterResult, rrule.options);
+  });
+  var res = iterResult._result;
+  sort(res);
+  switch (iterResult.method) {
+    case "all":
+    case "between":
+      return res;
+    case "before":
+      return res.length && res[res.length - 1] || null;
+    case "after":
+    default:
+      return res.length && res[0] || null;
+  }
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rrulestr.js
+var DEFAULT_OPTIONS2 = {
+  dtstart: null,
+  cache: false,
+  unfold: false,
+  forceset: false,
+  compatible: false,
+  tzid: null
+};
+function parseInput(s, options) {
+  var rrulevals = [];
+  var rdatevals = [];
+  var exrulevals = [];
+  var exdatevals = [];
+  var parsedDtstart = parseDtstart(s);
+  var dtstart = parsedDtstart.dtstart;
+  var tzid = parsedDtstart.tzid;
+  var lines = splitIntoLines(s, options.unfold);
+  lines.forEach(function(line) {
+    var _a;
+    if (!line)
+      return;
+    var _b = breakDownLine(line), name = _b.name, parms = _b.parms, value = _b.value;
+    switch (name.toUpperCase()) {
+      case "RRULE":
+        if (parms.length) {
+          throw new Error("unsupported RRULE parm: ".concat(parms.join(",")));
+        }
+        rrulevals.push(parseString(line));
+        break;
+      case "RDATE":
+        var _c = (_a = /RDATE(?:;TZID=([^:=]+))?/i.exec(line)) !== null && _a !== void 0 ? _a : [], rdateTzid = _c[1];
+        if (rdateTzid && !tzid) {
+          tzid = rdateTzid;
+        }
+        rdatevals = rdatevals.concat(parseRDate(value, parms));
+        break;
+      case "EXRULE":
+        if (parms.length) {
+          throw new Error("unsupported EXRULE parm: ".concat(parms.join(",")));
+        }
+        exrulevals.push(parseString(value));
+        break;
+      case "EXDATE":
+        exdatevals = exdatevals.concat(parseRDate(value, parms));
+        break;
+      case "DTSTART":
+        break;
+      default:
+        throw new Error("unsupported property: " + name);
+    }
+  });
+  return {
+    dtstart,
+    tzid,
+    rrulevals,
+    rdatevals,
+    exrulevals,
+    exdatevals
+  };
+}
+function buildRule(s, options) {
+  var _a = parseInput(s, options), rrulevals = _a.rrulevals, rdatevals = _a.rdatevals, exrulevals = _a.exrulevals, exdatevals = _a.exdatevals, dtstart = _a.dtstart, tzid = _a.tzid;
+  var noCache = options.cache === false;
+  if (options.compatible) {
+    options.forceset = true;
+    options.unfold = true;
+  }
+  if (options.forceset || rrulevals.length > 1 || rdatevals.length || exrulevals.length || exdatevals.length) {
+    var rset_1 = new RRuleSet(noCache);
+    rset_1.dtstart(dtstart);
+    rset_1.tzid(tzid || void 0);
+    rrulevals.forEach(function(val2) {
+      rset_1.rrule(new RRule(groomRruleOptions(val2, dtstart, tzid), noCache));
+    });
+    rdatevals.forEach(function(date) {
+      rset_1.rdate(date);
+    });
+    exrulevals.forEach(function(val2) {
+      rset_1.exrule(new RRule(groomRruleOptions(val2, dtstart, tzid), noCache));
+    });
+    exdatevals.forEach(function(date) {
+      rset_1.exdate(date);
+    });
+    if (options.compatible && options.dtstart)
+      rset_1.rdate(dtstart);
+    return rset_1;
+  }
+  var val = rrulevals[0] || {};
+  return new RRule(groomRruleOptions(val, val.dtstart || options.dtstart || dtstart, val.tzid || options.tzid || tzid), noCache);
+}
+function rrulestr(s, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return buildRule(s, initializeOptions2(options));
+}
+function groomRruleOptions(val, dtstart, tzid) {
+  return __assign(__assign({}, val), { dtstart, tzid });
+}
+function initializeOptions2(options) {
+  var invalid = [];
+  var keys = Object.keys(options);
+  var defaultKeys2 = Object.keys(DEFAULT_OPTIONS2);
+  keys.forEach(function(key) {
+    if (!includes(defaultKeys2, key))
+      invalid.push(key);
+  });
+  if (invalid.length) {
+    throw new Error("Invalid options: " + invalid.join(", "));
+  }
+  return __assign(__assign({}, DEFAULT_OPTIONS2), options);
+}
+function extractName(line) {
+  if (line.indexOf(":") === -1) {
+    return {
+      name: "RRULE",
+      value: line
+    };
+  }
+  var _a = split(line, ":", 1), name = _a[0], value = _a[1];
+  return {
+    name,
+    value
+  };
+}
+function breakDownLine(line) {
+  var _a = extractName(line), name = _a.name, value = _a.value;
+  var parms = name.split(";");
+  if (!parms)
+    throw new Error("empty property name");
+  return {
+    name: parms[0].toUpperCase(),
+    parms: parms.slice(1),
+    value
+  };
+}
+function splitIntoLines(s, unfold) {
+  if (unfold === void 0) {
+    unfold = false;
+  }
+  s = s && s.trim();
+  if (!s)
+    throw new Error("Invalid empty string");
+  if (!unfold) {
+    return s.split(/\s/);
+  }
+  var lines = s.split("\n");
+  var i = 0;
+  while (i < lines.length) {
+    var line = lines[i] = lines[i].replace(/\s+$/g, "");
+    if (!line) {
+      lines.splice(i, 1);
+    } else if (i > 0 && line[0] === " ") {
+      lines[i - 1] += line.slice(1);
+      lines.splice(i, 1);
+    } else {
+      i += 1;
+    }
+  }
+  return lines;
+}
+function validateDateParm(parms) {
+  parms.forEach(function(parm) {
+    if (!/(VALUE=DATE(-TIME)?)|(TZID=)/.test(parm)) {
+      throw new Error("unsupported RDATE/EXDATE parm: " + parm);
+    }
+  });
+}
+function parseRDate(rdateval, parms) {
+  validateDateParm(parms);
+  return rdateval.split(",").map(function(datestr) {
+    return untilStringToDate(datestr);
+  });
+}
+
+// node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rruleset.js
+function createGetterSetter(fieldName) {
+  var _this = this;
+  return function(field) {
+    if (field !== void 0) {
+      _this["_".concat(fieldName)] = field;
+    }
+    if (_this["_".concat(fieldName)] !== void 0) {
+      return _this["_".concat(fieldName)];
+    }
+    for (var i = 0; i < _this._rrule.length; i++) {
+      var field_1 = _this._rrule[i].origOptions[fieldName];
+      if (field_1) {
+        return field_1;
+      }
+    }
+  };
+}
+var RRuleSet = (
+  /** @class */
+  (function(_super) {
+    __extends(RRuleSet2, _super);
+    function RRuleSet2(noCache) {
+      if (noCache === void 0) {
+        noCache = false;
+      }
+      var _this = _super.call(this, {}, noCache) || this;
+      _this.dtstart = createGetterSetter.apply(_this, ["dtstart"]);
+      _this.tzid = createGetterSetter.apply(_this, ["tzid"]);
+      _this._rrule = [];
+      _this._rdate = [];
+      _this._exrule = [];
+      _this._exdate = [];
+      return _this;
+    }
+    RRuleSet2.prototype._iter = function(iterResult) {
+      return iterSet(iterResult, this._rrule, this._exrule, this._rdate, this._exdate, this.tzid());
+    };
+    RRuleSet2.prototype.rrule = function(rrule) {
+      _addRule(rrule, this._rrule);
+    };
+    RRuleSet2.prototype.exrule = function(rrule) {
+      _addRule(rrule, this._exrule);
+    };
+    RRuleSet2.prototype.rdate = function(date) {
+      _addDate(date, this._rdate);
+    };
+    RRuleSet2.prototype.exdate = function(date) {
+      _addDate(date, this._exdate);
+    };
+    RRuleSet2.prototype.rrules = function() {
+      return this._rrule.map(function(e) {
+        return rrulestr(e.toString());
+      });
+    };
+    RRuleSet2.prototype.exrules = function() {
+      return this._exrule.map(function(e) {
+        return rrulestr(e.toString());
+      });
+    };
+    RRuleSet2.prototype.rdates = function() {
+      return this._rdate.map(function(e) {
+        return new Date(e.getTime());
+      });
+    };
+    RRuleSet2.prototype.exdates = function() {
+      return this._exdate.map(function(e) {
+        return new Date(e.getTime());
+      });
+    };
+    RRuleSet2.prototype.valueOf = function() {
+      var result = [];
+      if (!this._rrule.length && this._dtstart) {
+        result = result.concat(optionsToString({ dtstart: this._dtstart }));
+      }
+      this._rrule.forEach(function(rrule) {
+        result = result.concat(rrule.toString().split("\n"));
+      });
+      this._exrule.forEach(function(exrule) {
+        result = result.concat(exrule.toString().split("\n").map(function(line) {
+          return line.replace(/^RRULE:/, "EXRULE:");
+        }).filter(function(line) {
+          return !/^DTSTART/.test(line);
+        }));
+      });
+      if (this._rdate.length) {
+        result.push(rdatesToString("RDATE", this._rdate, this.tzid()));
+      }
+      if (this._exdate.length) {
+        result.push(rdatesToString("EXDATE", this._exdate, this.tzid()));
+      }
+      return result;
+    };
+    RRuleSet2.prototype.toString = function() {
+      return this.valueOf().join("\n");
+    };
+    RRuleSet2.prototype.clone = function() {
+      var rrs = new RRuleSet2(!!this._cache);
+      this._rrule.forEach(function(rule) {
+        return rrs.rrule(rule.clone());
+      });
+      this._exrule.forEach(function(rule) {
+        return rrs.exrule(rule.clone());
+      });
+      this._rdate.forEach(function(date) {
+        return rrs.rdate(new Date(date.getTime()));
+      });
+      this._exdate.forEach(function(date) {
+        return rrs.exdate(new Date(date.getTime()));
+      });
+      return rrs;
+    };
+    return RRuleSet2;
+  })(RRule)
+);
+function _addRule(rrule, collection) {
+  if (!(rrule instanceof RRule)) {
+    throw new TypeError(String(rrule) + " is not RRule instance");
+  }
+  if (!includes(collection.map(String), String(rrule))) {
+    collection.push(rrule);
+  }
+}
+function _addDate(date, collection) {
+  if (!(date instanceof Date)) {
+    throw new TypeError(String(date) + " is not Date instance");
+  }
+  if (!includes(collection.map(Number), Number(date))) {
+    collection.push(date);
+    sort(collection);
+  }
+}
+function rdatesToString(param, rdates, tzid) {
+  var isUTC = !tzid || tzid.toUpperCase() === "UTC";
+  var header = isUTC ? "".concat(param, ":") : "".concat(param, ";TZID=").concat(tzid, ":");
+  var dateString = rdates.map(function(rdate) {
+    return timeToUntilString(rdate.valueOf(), isUTC);
+  }).join(",");
+  return "".concat(header).concat(dateString);
+}
+
+// packages/server/src/scheduled-task-recurrence-engine.ts
+function normalizeModule(module) {
+  return "default" in module ? module.default : module;
+}
+var { RRule: RRule2, rrulestr: rrulestr2 } = normalizeModule(esm_exports);
+var MIN_RECURRENCE_MS = 6e4;
+function previewScheduledTask(schedule, afterUnixMs, limit, { wallTimeToUnix, zonedDateTime }) {
+  if (schedule.type === "once") return schedule.atUnixMs > afterUnixMs ? [schedule.atUnixMs] : [];
+  const normalized = schedule.rrule.trim().replace(/^RRULE:/u, "");
+  if (normalized === "" || /[\r\n]/u.test(normalized))
+    throw new Error("Scheduled task RRULE is invalid");
+  const start = zonedDateTime(schedule.startAtUnixMs, schedule.timezone).replace(/[-:]/gu, "");
+  const rule = rrulestr2(`DTSTART:${start}Z
+RRULE:${normalized}`, { cache: false });
+  const until = rule.options.until?.getTime();
+  const count = rule.options.count;
+  if (!Number.isInteger(rule.options.interval) || rule.options.interval < 1)
+    throw new Error("Scheduled task interval must be a positive integer");
+  if (count !== null && (!Number.isInteger(count) || count < 1 || count > 1e4))
+    throw new Error("Scheduled task count must be between 1 and 10000");
+  if (until !== void 0) {
+    rule.options.until = /* @__PURE__ */ new Date(`${zonedDateTime(until, schedule.timezone)}Z`);
+  }
+  const first = rule.all((_date, index) => index < 2);
+  if (first[0] !== void 0 && first[1] !== void 0 && first[1].getTime() - first[0].getTime() < MIN_RECURRENCE_MS) {
+    throw new Error("Scheduled task recurrence must be at least one minute");
+  }
+  if (until !== void 0 && until <= afterUnixMs) return [];
+  const dates = [];
+  const afterWall = Date.parse(`${zonedDateTime(afterUnixMs, schedule.timezone)}Z`);
+  const lower = new Date(afterWall - 2 * 864e5);
+  if (count === null) {
+    const unit = rule.options.freq === RRule2.HOURLY ? 36e5 : rule.options.freq === RRule2.DAILY ? 864e5 : rule.options.freq === RRule2.WEEKLY ? 7 * 864e5 : void 0;
+    if (unit !== void 0) {
+      const step = unit * rule.options.interval;
+      const anchor = rule.options.dtstart.getTime();
+      const cycles = Math.max(0, Math.floor((lower.getTime() - anchor) / step));
+      rule.options.dtstart = new Date(anchor + cycles * step);
+    }
+  }
+  if (count !== null) {
+    rule.options.count = null;
+  }
+  let occurrences = 0;
+  const accept = (date) => {
+    const unixMs = wallTimeToUnix(date.toISOString().slice(0, 19), schedule.timezone);
+    if (unixMs === void 0) return true;
+    if (unixMs < schedule.startAtUnixMs) return true;
+    if (until !== void 0 && unixMs > until) return false;
+    occurrences += 1;
+    if (unixMs > afterUnixMs) dates.push(unixMs);
+    return dates.length < Math.min(limit, 5) && (count === null || occurrences < count);
+  };
+  if (count !== null) {
+    rule.between(rule.options.dtstart, /* @__PURE__ */ new Date("9999-12-31T23:59:59Z"), true, accept);
+  } else {
+    rule.between(lower, /* @__PURE__ */ new Date("9999-12-31T23:59:59Z"), true, accept);
+  }
+  return dates;
+}
+
+// packages/server/src/scheduled-task-recurrence-worker.js
+try {
+  const { schedule, afterUnixMs, limit } = workerData;
+  parentPort.postMessage({ dates: previewScheduledTask(schedule, afterUnixMs, limit, scheduled_task_wall_time_exports) });
+} catch (error) {
+  parentPort.postMessage({ error: error instanceof Error ? error.message : String(error) });
+}