hron-ts 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1988 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HronError: () => HronError,
+  Schedule: () => Schedule,
+  Temporal: () => import_polyfill2.Temporal
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ast.ts
+function weekdayNumber(day) {
+  const map = {
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6,
+    sunday: 7
+  };
+  return map[day];
+}
+function cronDowNumber(day) {
+  const map = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6
+  };
+  return map[day];
+}
+function monthNumber(month) {
+  const map = {
+    jan: 1,
+    feb: 2,
+    mar: 3,
+    apr: 4,
+    may: 5,
+    jun: 6,
+    jul: 7,
+    aug: 8,
+    sep: 9,
+    oct: 10,
+    nov: 11,
+    dec: 12
+  };
+  return map[month];
+}
+function parseWeekday(s) {
+  const map = {
+    monday: "monday",
+    mon: "monday",
+    tuesday: "tuesday",
+    tue: "tuesday",
+    wednesday: "wednesday",
+    wed: "wednesday",
+    thursday: "thursday",
+    thu: "thursday",
+    friday: "friday",
+    fri: "friday",
+    saturday: "saturday",
+    sat: "saturday",
+    sunday: "sunday",
+    sun: "sunday"
+  };
+  return map[s.toLowerCase()] ?? null;
+}
+function parseMonthName(s) {
+  const map = {
+    january: "jan",
+    jan: "jan",
+    february: "feb",
+    feb: "feb",
+    march: "mar",
+    mar: "mar",
+    april: "apr",
+    apr: "apr",
+    may: "may",
+    june: "jun",
+    jun: "jun",
+    july: "jul",
+    jul: "jul",
+    august: "aug",
+    aug: "aug",
+    september: "sep",
+    sep: "sep",
+    october: "oct",
+    oct: "oct",
+    november: "nov",
+    nov: "nov",
+    december: "dec",
+    dec: "dec"
+  };
+  return map[s.toLowerCase()] ?? null;
+}
+function expandDaySpec(spec) {
+  if (spec.type === "single") {
+    return [spec.day];
+  }
+  const result = [];
+  for (let d = spec.start; d <= spec.end; d++) {
+    result.push(d);
+  }
+  return result;
+}
+function expandMonthTarget(target) {
+  if (target.type === "days") {
+    return target.specs.flatMap(expandDaySpec);
+  }
+  return [];
+}
+function ordinalToN(ord) {
+  const map = {
+    first: 1,
+    second: 2,
+    third: 3,
+    fourth: 4,
+    fifth: 5
+  };
+  return map[ord];
+}
+function newScheduleData(expr) {
+  return {
+    expr,
+    timezone: null,
+    except: [],
+    until: null,
+    anchor: null,
+    during: []
+  };
+}
+
+// src/error.ts
+var HronError = class _HronError extends Error {
+  kind;
+  span;
+  input;
+  suggestion;
+  constructor(kind, message, span, input, suggestion) {
+    super(message);
+    this.name = "HronError";
+    this.kind = kind;
+    this.span = span;
+    this.input = input;
+    this.suggestion = suggestion;
+  }
+  static lex(message, span, input) {
+    return new _HronError("lex", message, span, input);
+  }
+  static parse(message, span, input, suggestion) {
+    return new _HronError("parse", message, span, input, suggestion);
+  }
+  static eval(message) {
+    return new _HronError("eval", message);
+  }
+  static cron(message) {
+    return new _HronError("cron", message);
+  }
+  displayRich() {
+    if ((this.kind === "lex" || this.kind === "parse") && this.span && this.input) {
+      let out = `error: ${this.message}
+`;
+      out += `  ${this.input}
+`;
+      const padding = " ".repeat(this.span.start + 2);
+      const underline = "^".repeat(Math.max(this.span.end - this.span.start, 1));
+      out += padding + underline;
+      if (this.suggestion) {
+        out += ` try: "${this.suggestion}"`;
+      }
+      return out;
+    }
+    return `error: ${this.message}`;
+  }
+};
+
+// src/lexer.ts
+function tokenize(input) {
+  const lexer = new Lexer(input);
+  return lexer.tokenize();
+}
+var Lexer = class {
+  input;
+  pos;
+  afterIn;
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.afterIn = false;
+  }
+  tokenize() {
+    const tokens = [];
+    while (true) {
+      this.skipWhitespace();
+      if (this.pos >= this.input.length) break;
+      if (this.afterIn) {
+        this.afterIn = false;
+        tokens.push(this.lexTimezone());
+        continue;
+      }
+      const start = this.pos;
+      const ch = this.input[this.pos];
+      if (ch === ",") {
+        this.pos++;
+        tokens.push({ kind: { type: "comma" }, span: { start, end: this.pos } });
+        continue;
+      }
+      if (isDigit(ch)) {
+        tokens.push(this.lexNumberOrTimeOrDate());
+        continue;
+      }
+      if (isAlpha(ch)) {
+        tokens.push(this.lexWord());
+        continue;
+      }
+      throw HronError.lex(
+        `unexpected character '${ch}'`,
+        { start, end: start + 1 },
+        this.input
+      );
+    }
+    return tokens;
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && isWhitespace(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  lexTimezone() {
+    this.skipWhitespace();
+    const start = this.pos;
+    while (this.pos < this.input.length && !isWhitespace(this.input[this.pos])) {
+      this.pos++;
+    }
+    const tz = this.input.slice(start, this.pos);
+    if (tz.length === 0) {
+      throw HronError.lex(
+        "expected timezone after 'in'",
+        { start, end: start + 1 },
+        this.input
+      );
+    }
+    return { kind: { type: "timezone", tz }, span: { start, end: this.pos } };
+  }
+  lexNumberOrTimeOrDate() {
+    const start = this.pos;
+    const numStart = this.pos;
+    while (this.pos < this.input.length && isDigit(this.input[this.pos])) {
+      this.pos++;
+    }
+    const digits = this.input.slice(numStart, this.pos);
+    if (digits.length === 4 && this.pos < this.input.length && this.input[this.pos] === "-") {
+      const remaining = this.input.slice(start);
+      if (remaining.length >= 10 && remaining[4] === "-" && isDigit(remaining[5]) && isDigit(remaining[6]) && remaining[7] === "-" && isDigit(remaining[8]) && isDigit(remaining[9])) {
+        this.pos = start + 10;
+        return {
+          kind: { type: "isoDate", date: this.input.slice(start, this.pos) },
+          span: { start, end: this.pos }
+        };
+      }
+    }
+    if ((digits.length === 1 || digits.length === 2) && this.pos < this.input.length && this.input[this.pos] === ":") {
+      this.pos++;
+      const minStart = this.pos;
+      while (this.pos < this.input.length && isDigit(this.input[this.pos])) {
+        this.pos++;
+      }
+      const minDigits = this.input.slice(minStart, this.pos);
+      if (minDigits.length === 2) {
+        const hour = parseInt(digits, 10);
+        const minute = parseInt(minDigits, 10);
+        if (hour > 23 || minute > 59) {
+          throw HronError.lex(
+            "invalid time",
+            { start, end: this.pos },
+            this.input
+          );
+        }
+        return {
+          kind: { type: "time", hour, minute },
+          span: { start, end: this.pos }
+        };
+      }
+    }
+    const num = parseInt(digits, 10);
+    if (isNaN(num)) {
+      throw HronError.lex(
+        "invalid number",
+        { start, end: this.pos },
+        this.input
+      );
+    }
+    if (this.pos + 1 < this.input.length) {
+      const suffix = this.input.slice(this.pos, this.pos + 2).toLowerCase();
+      if (suffix === "st" || suffix === "nd" || suffix === "rd" || suffix === "th") {
+        this.pos += 2;
+        return {
+          kind: { type: "ordinalNumber", value: num },
+          span: { start, end: this.pos }
+        };
+      }
+    }
+    return {
+      kind: { type: "number", value: num },
+      span: { start, end: this.pos }
+    };
+  }
+  lexWord() {
+    const start = this.pos;
+    while (this.pos < this.input.length && (isAlphanumeric(this.input[this.pos]) || this.input[this.pos] === "_")) {
+      this.pos++;
+    }
+    const word = this.input.slice(start, this.pos).toLowerCase();
+    const span = { start, end: this.pos };
+    const kind = KEYWORD_MAP[word];
+    if (kind === void 0) {
+      throw HronError.lex(`unknown keyword '${word}'`, span, this.input);
+    }
+    if (kind.type === "in") {
+      this.afterIn = true;
+    }
+    return { kind, span };
+  }
+};
+var KEYWORD_MAP = {
+  every: { type: "every" },
+  on: { type: "on" },
+  at: { type: "at" },
+  from: { type: "from" },
+  to: { type: "to" },
+  in: { type: "in" },
+  of: { type: "of" },
+  the: { type: "the" },
+  last: { type: "last" },
+  except: { type: "except" },
+  until: { type: "until" },
+  starting: { type: "starting" },
+  during: { type: "during" },
+  year: { type: "year" },
+  day: { type: "day" },
+  weekday: { type: "weekday" },
+  weekdays: { type: "weekday" },
+  weekend: { type: "weekend" },
+  weekends: { type: "weekend" },
+  weeks: { type: "weeks" },
+  week: { type: "weeks" },
+  month: { type: "month" },
+  monday: { type: "dayName", name: "monday" },
+  mon: { type: "dayName", name: "monday" },
+  tuesday: { type: "dayName", name: "tuesday" },
+  tue: { type: "dayName", name: "tuesday" },
+  wednesday: { type: "dayName", name: "wednesday" },
+  wed: { type: "dayName", name: "wednesday" },
+  thursday: { type: "dayName", name: "thursday" },
+  thu: { type: "dayName", name: "thursday" },
+  friday: { type: "dayName", name: "friday" },
+  fri: { type: "dayName", name: "friday" },
+  saturday: { type: "dayName", name: "saturday" },
+  sat: { type: "dayName", name: "saturday" },
+  sunday: { type: "dayName", name: "sunday" },
+  sun: { type: "dayName", name: "sunday" },
+  january: { type: "monthName", name: "jan" },
+  jan: { type: "monthName", name: "jan" },
+  february: { type: "monthName", name: "feb" },
+  feb: { type: "monthName", name: "feb" },
+  march: { type: "monthName", name: "mar" },
+  mar: { type: "monthName", name: "mar" },
+  april: { type: "monthName", name: "apr" },
+  apr: { type: "monthName", name: "apr" },
+  may: { type: "monthName", name: "may" },
+  june: { type: "monthName", name: "jun" },
+  jun: { type: "monthName", name: "jun" },
+  july: { type: "monthName", name: "jul" },
+  jul: { type: "monthName", name: "jul" },
+  august: { type: "monthName", name: "aug" },
+  aug: { type: "monthName", name: "aug" },
+  september: { type: "monthName", name: "sep" },
+  sep: { type: "monthName", name: "sep" },
+  october: { type: "monthName", name: "oct" },
+  oct: { type: "monthName", name: "oct" },
+  november: { type: "monthName", name: "nov" },
+  nov: { type: "monthName", name: "nov" },
+  december: { type: "monthName", name: "dec" },
+  dec: { type: "monthName", name: "dec" },
+  first: { type: "ordinal", name: "first" },
+  second: { type: "ordinal", name: "second" },
+  third: { type: "ordinal", name: "third" },
+  fourth: { type: "ordinal", name: "fourth" },
+  fifth: { type: "ordinal", name: "fifth" },
+  min: { type: "intervalUnit", unit: "min" },
+  mins: { type: "intervalUnit", unit: "min" },
+  minute: { type: "intervalUnit", unit: "min" },
+  minutes: { type: "intervalUnit", unit: "min" },
+  hour: { type: "intervalUnit", unit: "hours" },
+  hours: { type: "intervalUnit", unit: "hours" },
+  hr: { type: "intervalUnit", unit: "hours" },
+  hrs: { type: "intervalUnit", unit: "hours" }
+};
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function isAlpha(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z";
+}
+function isAlphanumeric(ch) {
+  return isDigit(ch) || isAlpha(ch);
+}
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+
+// src/parser.ts
+var Parser = class {
+  tokens;
+  pos;
+  input;
+  constructor(tokens, input) {
+    this.tokens = tokens;
+    this.pos = 0;
+    this.input = input;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  peekKind() {
+    return this.tokens[this.pos]?.kind;
+  }
+  advance() {
+    const tok = this.tokens[this.pos];
+    if (tok) this.pos++;
+    return tok;
+  }
+  currentSpan() {
+    const tok = this.peek();
+    if (tok) return tok.span;
+    const last = this.tokens[this.tokens.length - 1];
+    if (last) return { start: last.span.end, end: last.span.end };
+    return { start: 0, end: 0 };
+  }
+  error(message, span) {
+    return HronError.parse(message, span, this.input);
+  }
+  errorAtEnd(message) {
+    const span = this.tokens.length > 0 ? {
+      start: this.tokens[this.tokens.length - 1].span.end,
+      end: this.tokens[this.tokens.length - 1].span.end
+    } : { start: 0, end: 0 };
+    return HronError.parse(message, span, this.input);
+  }
+  consumeKind(expected, check) {
+    const span = this.currentSpan();
+    const tok = this.peek();
+    if (tok && check(tok.kind)) {
+      this.pos++;
+      return tok;
+    }
+    if (tok) {
+      throw this.error(`expected ${expected}, got ${tok.kind.type}`, span);
+    }
+    throw this.errorAtEnd(`expected ${expected}`);
+  }
+  // --- Grammar productions ---
+  parseExpression() {
+    const span = this.currentSpan();
+    const kind = this.peekKind();
+    let expr;
+    if (kind?.type === "every") {
+      this.advance();
+      expr = this.parseEvery();
+    } else if (kind?.type === "on") {
+      this.advance();
+      expr = this.parseOn();
+    } else if (kind?.type === "ordinal" || kind?.type === "last") {
+      expr = this.parseOrdinalRepeat();
+    } else {
+      throw this.error(
+        "expected 'every', 'on', or an ordinal (first, second, ...)",
+        span
+      );
+    }
+    return this.parseTrailingClauses(expr);
+  }
+  parseTrailingClauses(expr) {
+    const schedule = newScheduleData(expr);
+    if (this.peekKind()?.type === "except") {
+      this.advance();
+      schedule.except = this.parseExceptionList();
+    }
+    if (this.peekKind()?.type === "until") {
+      this.advance();
+      schedule.until = this.parseUntilSpec();
+    }
+    if (this.peekKind()?.type === "starting") {
+      this.advance();
+      const k = this.peekKind();
+      if (k?.type === "isoDate") {
+        schedule.anchor = k.date;
+        this.advance();
+      } else {
+        throw this.error(
+          "expected ISO date (YYYY-MM-DD) after 'starting'",
+          this.currentSpan()
+        );
+      }
+    }
+    if (this.peekKind()?.type === "during") {
+      this.advance();
+      schedule.during = this.parseMonthList();
+    }
+    if (this.peekKind()?.type === "in") {
+      this.advance();
+      const k = this.peekKind();
+      if (k?.type === "timezone") {
+        schedule.timezone = k.tz;
+        this.advance();
+      } else {
+        throw this.error("expected timezone after 'in'", this.currentSpan());
+      }
+    }
+    return schedule;
+  }
+  parseExceptionList() {
+    const exceptions = [this.parseException()];
+    while (this.peekKind()?.type === "comma") {
+      this.advance();
+      exceptions.push(this.parseException());
+    }
+    return exceptions;
+  }
+  parseException() {
+    const k = this.peekKind();
+    if (k?.type === "isoDate") {
+      const date = k.date;
+      this.advance();
+      return { type: "iso", date };
+    }
+    if (k?.type === "monthName") {
+      const month = parseMonthName(
+        k.name
+      );
+      this.advance();
+      const day = this.parseDayNumber(
+        "expected day number after month name in exception"
+      );
+      return { type: "named", month, day };
+    }
+    throw this.error(
+      "expected ISO date or month-day in exception",
+      this.currentSpan()
+    );
+  }
+  parseUntilSpec() {
+    const k = this.peekKind();
+    if (k?.type === "isoDate") {
+      const date = k.date;
+      this.advance();
+      return { type: "iso", date };
+    }
+    if (k?.type === "monthName") {
+      const month = parseMonthName(
+        k.name
+      );
+      this.advance();
+      const day = this.parseDayNumber(
+        "expected day number after month name in until"
+      );
+      return { type: "named", month, day };
+    }
+    throw this.error(
+      "expected ISO date or month-day after 'until'",
+      this.currentSpan()
+    );
+  }
+  parseDayNumber(errorMsg) {
+    const k = this.peekKind();
+    if (k?.type === "number") {
+      const n = k.value;
+      this.advance();
+      return n;
+    }
+    if (k?.type === "ordinalNumber") {
+      const n = k.value;
+      this.advance();
+      return n;
+    }
+    throw this.error(errorMsg, this.currentSpan());
+  }
+  // After "every": dispatch
+  parseEvery() {
+    if (!this.peek()) throw this.errorAtEnd("expected repeater");
+    const k = this.peekKind();
+    if (k.type === "year") {
+      this.advance();
+      return this.parseYearRepeat();
+    }
+    if (k.type === "day") {
+      return this.parseDayRepeat({ type: "every" });
+    }
+    if (k.type === "weekday") {
+      this.advance();
+      return this.parseDayRepeat({ type: "weekday" });
+    }
+    if (k.type === "weekend") {
+      this.advance();
+      return this.parseDayRepeat({ type: "weekend" });
+    }
+    if (k.type === "dayName") {
+      const days = this.parseDayList();
+      return this.parseDayRepeat({ type: "days", days });
+    }
+    if (k.type === "month") {
+      this.advance();
+      return this.parseMonthRepeat();
+    }
+    if (k.type === "number") {
+      return this.parseNumberRepeat();
+    }
+    throw this.error(
+      "expected day, weekday, weekend, year, day name, month, or number after 'every'",
+      this.currentSpan()
+    );
+  }
+  parseDayRepeat(days) {
+    if (days.type === "every") {
+      this.consumeKind("'day'", (k) => k.type === "day");
+    }
+    this.consumeKind("'at'", (k) => k.type === "at");
+    const times = this.parseTimeList();
+    return { type: "dayRepeat", days, times };
+  }
+  parseNumberRepeat() {
+    const k = this.peekKind();
+    const num = k.value;
+    this.advance();
+    const next = this.peekKind();
+    if (next?.type === "weeks") {
+      this.advance();
+      return this.parseWeekRepeat(num);
+    }
+    if (next?.type === "intervalUnit") {
+      return this.parseIntervalRepeat(num);
+    }
+    throw this.error(
+      "expected 'weeks', 'min', 'minutes', 'hour', or 'hours' after number",
+      this.currentSpan()
+    );
+  }
+  parseIntervalRepeat(interval) {
+    const k = this.peekKind();
+    const unitStr = k.unit;
+    this.advance();
+    const unit = unitStr === "min" ? "min" : "hours";
+    this.consumeKind("'from'", (k2) => k2.type === "from");
+    const from = this.parseTime();
+    this.consumeKind("'to'", (k2) => k2.type === "to");
+    const to = this.parseTime();
+    let dayFilter = null;
+    if (this.peekKind()?.type === "on") {
+      this.advance();
+      dayFilter = this.parseDayTarget();
+    }
+    return { type: "intervalRepeat", interval, unit, from, to, dayFilter };
+  }
+  parseWeekRepeat(interval) {
+    this.consumeKind("'on'", (k) => k.type === "on");
+    const days = this.parseDayList();
+    this.consumeKind("'at'", (k) => k.type === "at");
+    const times = this.parseTimeList();
+    return { type: "weekRepeat", interval, days, times };
+  }
+  parseMonthRepeat() {
+    this.consumeKind("'on'", (k2) => k2.type === "on");
+    this.consumeKind("'the'", (k2) => k2.type === "the");
+    let target;
+    const k = this.peekKind();
+    if (k?.type === "last") {
+      this.advance();
+      const next = this.peekKind();
+      if (next?.type === "day") {
+        this.advance();
+        target = { type: "lastDay" };
+      } else if (next?.type === "weekday") {
+        this.advance();
+        target = { type: "lastWeekday" };
+      } else {
+        throw this.error(
+          "expected 'day' or 'weekday' after 'last'",
+          this.currentSpan()
+        );
+      }
+    } else if (k?.type === "ordinalNumber") {
+      const specs = this.parseOrdinalDayList();
+      target = { type: "days", specs };
+    } else {
+      throw this.error(
+        "expected ordinal day (1st, 15th) or 'last' after 'the'",
+        this.currentSpan()
+      );
+    }
+    this.consumeKind("'at'", (k2) => k2.type === "at");
+    const times = this.parseTimeList();
+    return { type: "monthRepeat", target, times };
+  }
+  parseOrdinalRepeat() {
+    const ordinal = this.parseOrdinalPosition();
+    const k = this.peekKind();
+    if (k?.type !== "dayName") {
+      throw this.error("expected day name after ordinal", this.currentSpan());
+    }
+    const day = parseWeekday(
+      k.name
+    );
+    this.advance();
+    this.consumeKind("'of'", (k2) => k2.type === "of");
+    this.consumeKind("'every'", (k2) => k2.type === "every");
+    this.consumeKind("'month'", (k2) => k2.type === "month");
+    this.consumeKind("'at'", (k2) => k2.type === "at");
+    const times = this.parseTimeList();
+    return { type: "ordinalRepeat", ordinal, day, times };
+  }
+  parseYearRepeat() {
+    this.consumeKind("'on'", (k2) => k2.type === "on");
+    let target;
+    const k = this.peekKind();
+    if (k?.type === "the") {
+      this.advance();
+      target = this.parseYearTargetAfterThe();
+    } else if (k?.type === "monthName") {
+      const month = parseMonthName(
+        k.name
+      );
+      this.advance();
+      const day = this.parseDayNumber(
+        "expected day number after month name"
+      );
+      target = { type: "date", month, day };
+    } else {
+      throw this.error(
+        "expected month name or 'the' after 'every year on'",
+        this.currentSpan()
+      );
+    }
+    this.consumeKind("'at'", (k2) => k2.type === "at");
+    const times = this.parseTimeList();
+    return { type: "yearRepeat", target, times };
+  }
+  parseYearTargetAfterThe() {
+    const k = this.peekKind();
+    if (k?.type === "last") {
+      this.advance();
+      const next = this.peekKind();
+      if (next?.type === "weekday") {
+        this.advance();
+        this.consumeKind("'of'", (k2) => k2.type === "of");
+        const month = this.parseMonthNameToken();
+        return { type: "lastWeekday", month };
+      }
+      if (next?.type === "dayName") {
+        const weekday = parseWeekday(
+          next.name
+        );
+        this.advance();
+        this.consumeKind("'of'", (k2) => k2.type === "of");
+        const month = this.parseMonthNameToken();
+        return { type: "ordinalWeekday", ordinal: "last", weekday, month };
+      }
+      throw this.error(
+        "expected 'weekday' or day name after 'last' in yearly expression",
+        this.currentSpan()
+      );
+    }
+    if (k?.type === "ordinal") {
+      const ordinal = this.parseOrdinalPosition();
+      const next = this.peekKind();
+      if (next?.type === "dayName") {
+        const weekday = parseWeekday(
+          next.name
+        );
+        this.advance();
+        this.consumeKind("'of'", (k2) => k2.type === "of");
+        const month = this.parseMonthNameToken();
+        return { type: "ordinalWeekday", ordinal, weekday, month };
+      }
+      throw this.error(
+        "expected day name after ordinal in yearly expression",
+        this.currentSpan()
+      );
+    }
+    if (k?.type === "ordinalNumber") {
+      const day = k.value;
+      this.advance();
+      this.consumeKind("'of'", (k2) => k2.type === "of");
+      const month = this.parseMonthNameToken();
+      return { type: "dayOfMonth", day, month };
+    }
+    throw this.error(
+      "expected ordinal, day number, or 'last' after 'the' in yearly expression",
+      this.currentSpan()
+    );
+  }
+  parseMonthNameToken() {
+    const k = this.peekKind();
+    if (k?.type === "monthName") {
+      const month = parseMonthName(
+        k.name
+      );
+      this.advance();
+      return month;
+    }
+    throw this.error("expected month name", this.currentSpan());
+  }
+  parseOrdinalPosition() {
+    const span = this.currentSpan();
+    const k = this.peekKind();
+    if (k?.type === "ordinal") {
+      const name = k.name;
+      this.advance();
+      return name;
+    }
+    if (k?.type === "last") {
+      this.advance();
+      return "last";
+    }
+    throw this.error(
+      "expected ordinal (first, second, third, fourth, fifth, last)",
+      span
+    );
+  }
+  parseOn() {
+    const date = this.parseDateTarget();
+    this.consumeKind("'at'", (k) => k.type === "at");
+    const times = this.parseTimeList();
+    return { type: "singleDate", date, times };
+  }
+  parseDateTarget() {
+    const k = this.peekKind();
+    if (k?.type === "isoDate") {
+      const date = k.date;
+      this.advance();
+      return { type: "iso", date };
+    }
+    if (k?.type === "monthName") {
+      const month = parseMonthName(
+        k.name
+      );
+      this.advance();
+      const day = this.parseDayNumber(
+        "expected day number after month name"
+      );
+      return { type: "named", month, day };
+    }
+    throw this.error(
+      "expected date (ISO date or month name)",
+      this.currentSpan()
+    );
+  }
+  parseDayTarget() {
+    const k = this.peekKind();
+    if (k?.type === "day") {
+      this.advance();
+      return { type: "every" };
+    }
+    if (k?.type === "weekday") {
+      this.advance();
+      return { type: "weekday" };
+    }
+    if (k?.type === "weekend") {
+      this.advance();
+      return { type: "weekend" };
+    }
+    if (k?.type === "dayName") {
+      const days = this.parseDayList();
+      return { type: "days", days };
+    }
+    throw this.error(
+      "expected 'day', 'weekday', 'weekend', or day name",
+      this.currentSpan()
+    );
+  }
+  parseDayList() {
+    const k = this.peekKind();
+    if (k?.type !== "dayName") {
+      throw this.error("expected day name", this.currentSpan());
+    }
+    const days = [
+      parseWeekday(k.name)
+    ];
+    this.advance();
+    while (this.peekKind()?.type === "comma") {
+      this.advance();
+      const next = this.peekKind();
+      if (next?.type !== "dayName") {
+        throw this.error("expected day name after ','", this.currentSpan());
+      }
+      days.push(
+        parseWeekday(
+          next.name
+        )
+      );
+      this.advance();
+    }
+    return days;
+  }
+  parseOrdinalDayList() {
+    const specs = [this.parseOrdinalDaySpec()];
+    while (this.peekKind()?.type === "comma") {
+      this.advance();
+      specs.push(this.parseOrdinalDaySpec());
+    }
+    return specs;
+  }
+  parseOrdinalDaySpec() {
+    const k = this.peekKind();
+    if (k?.type !== "ordinalNumber") {
+      throw this.error("expected ordinal day number", this.currentSpan());
+    }
+    const start = k.value;
+    this.advance();
+    if (this.peekKind()?.type === "to") {
+      this.advance();
+      const next = this.peekKind();
+      if (next?.type !== "ordinalNumber") {
+        throw this.error(
+          "expected ordinal day number after 'to'",
+          this.currentSpan()
+        );
+      }
+      const end = next.value;
+      this.advance();
+      return { type: "range", start, end };
+    }
+    return { type: "single", day: start };
+  }
+  parseMonthList() {
+    const months = [this.parseMonthNameToken()];
+    while (this.peekKind()?.type === "comma") {
+      this.advance();
+      months.push(this.parseMonthNameToken());
+    }
+    return months;
+  }
+  parseTimeList() {
+    const times = [this.parseTime()];
+    while (this.peekKind()?.type === "comma") {
+      this.advance();
+      times.push(this.parseTime());
+    }
+    return times;
+  }
+  parseTime() {
+    const span = this.currentSpan();
+    const k = this.peekKind();
+    if (k?.type === "time") {
+      const { hour, minute } = k;
+      this.advance();
+      return { hour, minute };
+    }
+    throw this.error("expected time (HH:MM)", span);
+  }
+};
+function parse(input) {
+  const tokens = tokenize(input);
+  if (tokens.length === 0) {
+    throw HronError.parse("empty expression", { start: 0, end: 0 }, input);
+  }
+  const parser = new Parser(tokens, input);
+  const schedule = parser.parseExpression();
+  if (parser.peek()) {
+    throw HronError.parse(
+      "unexpected tokens after expression",
+      parser.currentSpan(),
+      input
+    );
+  }
+  return schedule;
+}
+
+// src/display.ts
+function display(schedule) {
+  let out = displayExpr(schedule.expr);
+  if (schedule.except.length > 0) {
+    out += " except ";
+    out += schedule.except.map((exc) => {
+      if (exc.type === "named") return `${exc.month} ${exc.day}`;
+      return exc.date;
+    }).join(", ");
+  }
+  if (schedule.until) {
+    if (schedule.until.type === "iso") {
+      out += ` until ${schedule.until.date}`;
+    } else {
+      out += ` until ${schedule.until.month} ${schedule.until.day}`;
+    }
+  }
+  if (schedule.anchor) {
+    out += ` starting ${schedule.anchor}`;
+  }
+  if (schedule.during.length > 0) {
+    out += " during " + schedule.during.join(", ");
+  }
+  if (schedule.timezone) {
+    out += ` in ${schedule.timezone}`;
+  }
+  return out;
+}
+function displayExpr(expr) {
+  switch (expr.type) {
+    case "intervalRepeat": {
+      let out = `every ${expr.interval} ${unitDisplay(expr.interval, expr.unit)}`;
+      out += ` from ${formatTime(expr.from)} to ${formatTime(expr.to)}`;
+      if (expr.dayFilter) {
+        out += ` on ${displayDayFilter(expr.dayFilter)}`;
+      }
+      return out;
+    }
+    case "dayRepeat":
+      return `every ${displayDayFilter(expr.days)} at ${formatTimeList(expr.times)}`;
+    case "weekRepeat":
+      return `every ${expr.interval} weeks on ${formatDayList(expr.days)} at ${formatTimeList(expr.times)}`;
+    case "monthRepeat": {
+      let targetStr;
+      if (expr.target.type === "days") {
+        targetStr = formatOrdinalDaySpecs(expr.target.specs);
+      } else if (expr.target.type === "lastDay") {
+        targetStr = "last day";
+      } else {
+        targetStr = "last weekday";
+      }
+      return `every month on the ${targetStr} at ${formatTimeList(expr.times)}`;
+    }
+    case "ordinalRepeat":
+      return `${expr.ordinal} ${expr.day} of every month at ${formatTimeList(expr.times)}`;
+    case "singleDate": {
+      let dateStr;
+      if (expr.date.type === "named") {
+        dateStr = `${expr.date.month} ${expr.date.day}`;
+      } else {
+        dateStr = expr.date.date;
+      }
+      return `on ${dateStr} at ${formatTimeList(expr.times)}`;
+    }
+    case "yearRepeat": {
+      let targetStr;
+      if (expr.target.type === "date") {
+        targetStr = `${expr.target.month} ${expr.target.day}`;
+      } else if (expr.target.type === "ordinalWeekday") {
+        targetStr = `the ${expr.target.ordinal} ${expr.target.weekday} of ${expr.target.month}`;
+      } else if (expr.target.type === "dayOfMonth") {
+        targetStr = `the ${expr.target.day}${ordinalSuffix(expr.target.day)} of ${expr.target.month}`;
+      } else {
+        targetStr = `the last weekday of ${expr.target.month}`;
+      }
+      return `every year on ${targetStr} at ${formatTimeList(expr.times)}`;
+    }
+  }
+}
+function displayDayFilter(filter) {
+  switch (filter.type) {
+    case "every":
+      return "day";
+    case "weekday":
+      return "weekday";
+    case "weekend":
+      return "weekend";
+    case "days":
+      return formatDayList(filter.days);
+  }
+}
+function formatTime(t) {
+  return `${String(t.hour).padStart(2, "0")}:${String(t.minute).padStart(2, "0")}`;
+}
+function formatTimeList(times) {
+  return times.map(formatTime).join(", ");
+}
+function formatDayList(days) {
+  return days.join(", ");
+}
+function formatOrdinalDaySpecs(specs) {
+  return specs.map((spec) => {
+    if (spec.type === "single") {
+      return `${spec.day}${ordinalSuffix(spec.day)}`;
+    }
+    return `${spec.start}${ordinalSuffix(spec.start)} to ${spec.end}${ordinalSuffix(spec.end)}`;
+  }).join(", ");
+}
+function ordinalSuffix(n) {
+  const mod100 = n % 100;
+  if (mod100 >= 11 && mod100 <= 13) return "th";
+  switch (n % 10) {
+    case 1:
+      return "st";
+    case 2:
+      return "nd";
+    case 3:
+      return "rd";
+    default:
+      return "th";
+  }
+}
+function unitDisplay(interval, unit) {
+  if (unit === "min") {
+    return interval === 1 ? "minute" : "min";
+  }
+  return interval === 1 ? "hour" : "hours";
+}
+
+// src/eval.ts
+var import_polyfill = require("@js-temporal/polyfill");
+function resolveTz(tz) {
+  if (tz) return tz;
+  try {
+    return import_polyfill.Temporal.Now.timeZoneId();
+  } catch {
+    return "UTC";
+  }
+}
+function toPlainTime(tod) {
+  return import_polyfill.Temporal.PlainTime.from({ hour: tod.hour, minute: tod.minute });
+}
+function atTimeOnDate(date, time, tz) {
+  return date.toPlainDateTime(time).toZonedDateTime(tz, {
+    disambiguation: "compatible"
+  });
+}
+function weekdayNameToNumber(day) {
+  return weekdayNumber(day);
+}
+function matchesDayFilter(date, filter) {
+  const dow = date.dayOfWeek;
+  switch (filter.type) {
+    case "every":
+      return true;
+    case "weekday":
+      return dow >= 1 && dow <= 5;
+    case "weekend":
+      return dow === 6 || dow === 7;
+    case "days":
+      return filter.days.some((d) => weekdayNameToNumber(d) === dow);
+  }
+}
+function lastDayOfMonth(year, month) {
+  return import_polyfill.Temporal.PlainDate.from({ year, month, day: 1 }).add({ months: 1 }).subtract({ days: 1 });
+}
+function lastWeekdayOfMonth(year, month) {
+  let d = lastDayOfMonth(year, month);
+  while (d.dayOfWeek === 6 || d.dayOfWeek === 7) {
+    d = d.subtract({ days: 1 });
+  }
+  return d;
+}
+function nthWeekdayOfMonth(year, month, weekday, n) {
+  const targetDow = weekdayNameToNumber(weekday);
+  let d = import_polyfill.Temporal.PlainDate.from({ year, month, day: 1 });
+  while (d.dayOfWeek !== targetDow) {
+    d = d.add({ days: 1 });
+  }
+  for (let i = 1; i < n; i++) {
+    d = d.add({ days: 7 });
+  }
+  if (d.month !== month) return null;
+  return d;
+}
+function lastWeekdayInMonth(year, month, weekday) {
+  const targetDow = weekdayNameToNumber(weekday);
+  let d = lastDayOfMonth(year, month);
+  while (d.dayOfWeek !== targetDow) {
+    d = d.subtract({ days: 1 });
+  }
+  return d;
+}
+var EPOCH_MONDAY = import_polyfill.Temporal.PlainDate.from("1970-01-05");
+var MIDNIGHT = import_polyfill.Temporal.PlainTime.from({ hour: 0, minute: 0 });
+function weeksBetween(a, b) {
+  const days = a.until(b, { largestUnit: "days" }).days;
+  return Math.floor(days / 7);
+}
+function isExcepted(date, exceptions) {
+  for (const exc of exceptions) {
+    if (exc.type === "named") {
+      if (date.month === monthNumber(exc.month) && date.day === exc.day) {
+        return true;
+      }
+    } else {
+      const excDate = import_polyfill.Temporal.PlainDate.from(exc.date);
+      if (import_polyfill.Temporal.PlainDate.compare(date, excDate) === 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function parseExceptions(exceptions) {
+  const named = [];
+  const isoDates = [];
+  for (const exc of exceptions) {
+    if (exc.type === "named") {
+      named.push({ month: monthNumber(exc.month), day: exc.day });
+    } else {
+      isoDates.push(import_polyfill.Temporal.PlainDate.from(exc.date));
+    }
+  }
+  return { named, isoDates };
+}
+function isExceptedParsed(date, parsed) {
+  for (const n of parsed.named) {
+    if (date.month === n.month && date.day === n.day) return true;
+  }
+  for (const d of parsed.isoDates) {
+    if (import_polyfill.Temporal.PlainDate.compare(date, d) === 0) return true;
+  }
+  return false;
+}
+function matchesDuring(date, during) {
+  if (during.length === 0) return true;
+  return during.some((mn) => monthNumber(mn) === date.month);
+}
+function nextDuringMonth(date, during) {
+  const currentMonth = date.month;
+  const months = during.map((mn) => monthNumber(mn)).sort((a, b) => a - b);
+  for (const m of months) {
+    if (m > currentMonth) {
+      return import_polyfill.Temporal.PlainDate.from({ year: date.year, month: m, day: 1 });
+    }
+  }
+  return import_polyfill.Temporal.PlainDate.from({ year: date.year + 1, month: months[0], day: 1 });
+}
+function resolveUntil(until, now) {
+  if (until.type === "iso") {
+    return import_polyfill.Temporal.PlainDate.from(until.date);
+  }
+  const year = now.toPlainDate().year;
+  for (const y of [year, year + 1]) {
+    try {
+      const d = import_polyfill.Temporal.PlainDate.from({
+        year: y,
+        month: monthNumber(until.month),
+        day: until.day
+      }, { overflow: "reject" });
+      if (import_polyfill.Temporal.PlainDate.compare(d, now.toPlainDate()) >= 0) {
+        return d;
+      }
+    } catch {
+    }
+  }
+  return import_polyfill.Temporal.PlainDate.from({
+    year: year + 1,
+    month: monthNumber(until.month),
+    day: until.day
+  }, { overflow: "reject" });
+}
+function earliestFutureAtTimes(date, times, tz, now) {
+  let best = null;
+  for (const tod of times) {
+    const t = toPlainTime(tod);
+    const candidate = atTimeOnDate(date, t, tz);
+    if (import_polyfill.Temporal.ZonedDateTime.compare(candidate, now) > 0) {
+      if (best === null || import_polyfill.Temporal.ZonedDateTime.compare(candidate, best) < 0) {
+        best = candidate;
+      }
+    }
+  }
+  return best;
+}
+function nextFrom(schedule, now) {
+  const tz = resolveTz(schedule.timezone);
+  const untilDate = schedule.until ? resolveUntil(schedule.until, now) : null;
+  const parsedExceptions = parseExceptions(schedule.except);
+  const hasExceptions = schedule.except.length > 0;
+  const hasDuring = schedule.during.length > 0;
+  const needsTzConversion = untilDate !== null || hasDuring || hasExceptions;
+  let current = now;
+  for (let i = 0; i < 1e3; i++) {
+    const candidate = nextExpr(schedule.expr, tz, schedule.anchor, current);
+    if (candidate === null) return null;
+    const cDate = needsTzConversion ? candidate.withTimeZone(tz).toPlainDate() : null;
+    if (untilDate) {
+      if (import_polyfill.Temporal.PlainDate.compare(cDate, untilDate) > 0) {
+        return null;
+      }
+    }
+    if (hasDuring && !matchesDuring(cDate, schedule.during)) {
+      const skipTo = nextDuringMonth(cDate, schedule.during);
+      current = atTimeOnDate(skipTo, MIDNIGHT, tz).subtract({ seconds: 1 });
+      continue;
+    }
+    if (hasExceptions && isExceptedParsed(cDate, parsedExceptions)) {
+      const nextDay = cDate.add({ days: 1 });
+      current = atTimeOnDate(
+        nextDay,
+        MIDNIGHT,
+        tz
+      ).subtract({ seconds: 1 });
+      continue;
+    }
+    return candidate;
+  }
+  return null;
+}
+function nextExpr(expr, tz, anchor, now) {
+  switch (expr.type) {
+    case "dayRepeat":
+      return nextDayRepeat(expr.days, expr.times, tz, now);
+    case "intervalRepeat":
+      return nextIntervalRepeat(
+        expr.interval,
+        expr.unit,
+        expr.from,
+        expr.to,
+        expr.dayFilter,
+        tz,
+        now
+      );
+    case "weekRepeat":
+      return nextWeekRepeat(expr.interval, expr.days, expr.times, tz, anchor, now);
+    case "monthRepeat":
+      return nextMonthRepeat(expr.target, expr.times, tz, now);
+    case "ordinalRepeat":
+      return nextOrdinalRepeat(expr.ordinal, expr.day, expr.times, tz, now);
+    case "singleDate":
+      return nextSingleDate(expr.date, expr.times, tz, now);
+    case "yearRepeat":
+      return nextYearRepeat(expr.target, expr.times, tz, now);
+  }
+}
+function nextNFrom(schedule, now, n) {
+  const results = [];
+  let current = now;
+  for (let i = 0; i < n; i++) {
+    const next = nextFrom(schedule, current);
+    if (next === null) break;
+    current = next.add({ minutes: 1 });
+    results.push(next);
+  }
+  return results;
+}
+function matches(schedule, datetime) {
+  const tz = resolveTz(schedule.timezone);
+  const zdt = datetime.withTimeZone(tz);
+  const date = zdt.toPlainDate();
+  if (!matchesDuring(date, schedule.during)) return false;
+  if (isExcepted(date, schedule.except)) return false;
+  if (schedule.until) {
+    const untilDate = resolveUntil(schedule.until, datetime);
+    if (import_polyfill.Temporal.PlainDate.compare(date, untilDate) > 0) return false;
+  }
+  const timeMatches = (times) => times.some((tod) => zdt.hour === tod.hour && zdt.minute === tod.minute);
+  switch (schedule.expr.type) {
+    case "dayRepeat": {
+      if (!matchesDayFilter(date, schedule.expr.days)) return false;
+      return timeMatches(schedule.expr.times);
+    }
+    case "intervalRepeat": {
+      const { interval, unit, from, to, dayFilter } = schedule.expr;
+      if (dayFilter && !matchesDayFilter(date, dayFilter)) return false;
+      const fromMinutes = from.hour * 60 + from.minute;
+      const toMinutes = to.hour * 60 + to.minute;
+      const currentMinutes = zdt.hour * 60 + zdt.minute;
+      if (currentMinutes < fromMinutes || currentMinutes > toMinutes) return false;
+      const diff = currentMinutes - fromMinutes;
+      const step = unit === "min" ? interval : interval * 60;
+      return diff >= 0 && diff % step === 0;
+    }
+    case "weekRepeat": {
+      const { interval, days, times } = schedule.expr;
+      const dow = date.dayOfWeek;
+      if (!days.some((d) => weekdayNameToNumber(d) === dow)) return false;
+      if (!timeMatches(times)) return false;
+      const anchorDate = schedule.anchor ? import_polyfill.Temporal.PlainDate.from(schedule.anchor) : EPOCH_MONDAY;
+      const weeks = weeksBetween(anchorDate, date);
+      return weeks >= 0 && weeks % interval === 0;
+    }
+    case "monthRepeat": {
+      if (!timeMatches(schedule.expr.times)) return false;
+      const { target } = schedule.expr;
+      if (target.type === "days") {
+        const expanded = expandMonthTarget(target);
+        return expanded.includes(date.day);
+      }
+      if (target.type === "lastDay") {
+        const last = lastDayOfMonth(date.year, date.month);
+        return import_polyfill.Temporal.PlainDate.compare(date, last) === 0;
+      }
+      const lastWd = lastWeekdayOfMonth(date.year, date.month);
+      return import_polyfill.Temporal.PlainDate.compare(date, lastWd) === 0;
+    }
+    case "ordinalRepeat": {
+      if (!timeMatches(schedule.expr.times)) return false;
+      const { ordinal, day } = schedule.expr;
+      let targetDate;
+      if (ordinal === "last") {
+        targetDate = lastWeekdayInMonth(date.year, date.month, day);
+      } else {
+        targetDate = nthWeekdayOfMonth(
+          date.year,
+          date.month,
+          day,
+          ordinalToN(ordinal)
+        );
+      }
+      if (!targetDate) return false;
+      return import_polyfill.Temporal.PlainDate.compare(date, targetDate) === 0;
+    }
+    case "singleDate": {
+      if (!timeMatches(schedule.expr.times)) return false;
+      const { date: dateSpec } = schedule.expr;
+      if (dateSpec.type === "iso") {
+        const target = import_polyfill.Temporal.PlainDate.from(dateSpec.date);
+        return import_polyfill.Temporal.PlainDate.compare(date, target) === 0;
+      }
+      if (dateSpec.type === "named") {
+        return date.month === monthNumber(dateSpec.month) && date.day === dateSpec.day;
+      }
+      return false;
+    }
+    case "yearRepeat": {
+      if (!timeMatches(schedule.expr.times)) return false;
+      return matchesYearTarget(schedule.expr.target, date);
+    }
+  }
+}
+function matchesYearTarget(target, date) {
+  switch (target.type) {
+    case "date":
+      return date.month === monthNumber(target.month) && date.day === target.day;
+    case "ordinalWeekday": {
+      if (date.month !== monthNumber(target.month)) return false;
+      let targetDate;
+      if (target.ordinal === "last") {
+        targetDate = lastWeekdayInMonth(date.year, date.month, target.weekday);
+      } else {
+        targetDate = nthWeekdayOfMonth(
+          date.year,
+          date.month,
+          target.weekday,
+          ordinalToN(target.ordinal)
+        );
+      }
+      if (!targetDate) return false;
+      return import_polyfill.Temporal.PlainDate.compare(date, targetDate) === 0;
+    }
+    case "dayOfMonth":
+      return date.month === monthNumber(target.month) && date.day === target.day;
+    case "lastWeekday": {
+      if (date.month !== monthNumber(target.month)) return false;
+      const lwd = lastWeekdayOfMonth(date.year, date.month);
+      return import_polyfill.Temporal.PlainDate.compare(date, lwd) === 0;
+    }
+  }
+}
+function nextDayRepeat(days, times, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  let date = nowInTz.toPlainDate();
+  if (matchesDayFilter(date, days)) {
+    const candidate = earliestFutureAtTimes(date, times, tz, now);
+    if (candidate) return candidate;
+  }
+  for (let i = 0; i < 8; i++) {
+    date = date.add({ days: 1 });
+    if (matchesDayFilter(date, days)) {
+      const candidate = earliestFutureAtTimes(date, times, tz, now);
+      if (candidate) return candidate;
+    }
+  }
+  return null;
+}
+function nextIntervalRepeat(interval, unit, from, to, dayFilter, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  const stepMinutes = unit === "min" ? interval : interval * 60;
+  const fromMinutes = from.hour * 60 + from.minute;
+  const toMinutes = to.hour * 60 + to.minute;
+  let date = nowInTz.toPlainDate();
+  for (let d = 0; d < 400; d++) {
+    if (dayFilter && !matchesDayFilter(date, dayFilter)) {
+      date = date.add({ days: 1 });
+      continue;
+    }
+    const sameDay = import_polyfill.Temporal.PlainDate.compare(date, nowInTz.toPlainDate()) === 0;
+    const nowMinutes = sameDay ? nowInTz.hour * 60 + nowInTz.minute : -1;
+    let nextSlot;
+    if (nowMinutes < fromMinutes) {
+      nextSlot = fromMinutes;
+    } else {
+      const elapsed = nowMinutes - fromMinutes;
+      nextSlot = fromMinutes + (Math.floor(elapsed / stepMinutes) + 1) * stepMinutes;
+    }
+    if (nextSlot <= toMinutes) {
+      const h = Math.floor(nextSlot / 60);
+      const m = nextSlot % 60;
+      const t = import_polyfill.Temporal.PlainTime.from({ hour: h, minute: m });
+      const candidate = atTimeOnDate(date, t, tz);
+      if (import_polyfill.Temporal.ZonedDateTime.compare(candidate, now) > 0) {
+        return candidate;
+      }
+    }
+    date = date.add({ days: 1 });
+  }
+  return null;
+}
+function nextWeekRepeat(interval, days, times, tz, anchor, now) {
+  const nowInTz = now.withTimeZone(tz);
+  const anchorDate = anchor ? import_polyfill.Temporal.PlainDate.from(anchor) : EPOCH_MONDAY;
+  const date = nowInTz.toPlainDate();
+  const sortedDays = [...days].sort(
+    (a, b) => weekdayNameToNumber(a) - weekdayNameToNumber(b)
+  );
+  const dowOffset = date.dayOfWeek - 1;
+  let currentMonday = date.subtract({ days: dowOffset });
+  const anchorDowOffset = anchorDate.dayOfWeek - 1;
+  const anchorMonday = anchorDate.subtract({ days: anchorDowOffset });
+  for (let i = 0; i < 54; i++) {
+    const weeks = weeksBetween(anchorMonday, currentMonday);
+    if (weeks < 0) {
+      const skip = Math.ceil(-weeks / interval);
+      currentMonday = currentMonday.add({ days: skip * interval * 7 });
+      continue;
+    }
+    if (weeks % interval === 0) {
+      for (const wd of sortedDays) {
+        const dayOffset = weekdayNameToNumber(wd) - 1;
+        const targetDate = currentMonday.add({ days: dayOffset });
+        const candidate = earliestFutureAtTimes(targetDate, times, tz, now);
+        if (candidate) return candidate;
+      }
+    }
+    const remainder = weeks % interval;
+    const skipWeeks = remainder === 0 ? interval : interval - remainder;
+    currentMonday = currentMonday.add({ days: skipWeeks * 7 });
+  }
+  return null;
+}
+function nextMonthRepeat(target, times, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  let year = nowInTz.year;
+  let month = nowInTz.month;
+  for (let i = 0; i < 24; i++) {
+    const dateCandidates = [];
+    if (target.type === "days") {
+      const expanded = expandMonthTarget(target);
+      for (const dayNum of expanded) {
+        const last = lastDayOfMonth(year, month);
+        if (dayNum <= last.day) {
+          try {
+            dateCandidates.push(
+              import_polyfill.Temporal.PlainDate.from({ year, month, day: dayNum })
+            );
+          } catch {
+          }
+        }
+      }
+    } else if (target.type === "lastDay") {
+      dateCandidates.push(lastDayOfMonth(year, month));
+    } else {
+      dateCandidates.push(lastWeekdayOfMonth(year, month));
+    }
+    let best = null;
+    for (const date of dateCandidates) {
+      const candidate = earliestFutureAtTimes(date, times, tz, now);
+      if (candidate) {
+        if (best === null || import_polyfill.Temporal.ZonedDateTime.compare(candidate, best) < 0) {
+          best = candidate;
+        }
+      }
+    }
+    if (best) return best;
+    month++;
+    if (month > 12) {
+      month = 1;
+      year++;
+    }
+  }
+  return null;
+}
+function nextOrdinalRepeat(ordinal, day, times, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  let year = nowInTz.year;
+  let month = nowInTz.month;
+  for (let i = 0; i < 24; i++) {
+    let targetDate;
+    if (ordinal === "last") {
+      targetDate = lastWeekdayInMonth(year, month, day);
+    } else {
+      targetDate = nthWeekdayOfMonth(year, month, day, ordinalToN(ordinal));
+    }
+    if (targetDate) {
+      const candidate = earliestFutureAtTimes(targetDate, times, tz, now);
+      if (candidate) return candidate;
+    }
+    month++;
+    if (month > 12) {
+      month = 1;
+      year++;
+    }
+  }
+  return null;
+}
+function nextSingleDate(dateSpec, times, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  if (dateSpec.type === "iso") {
+    const date = import_polyfill.Temporal.PlainDate.from(dateSpec.date);
+    return earliestFutureAtTimes(date, times, tz, now);
+  }
+  if (dateSpec.type === "named") {
+    const startYear = nowInTz.year;
+    for (let y = 0; y < 8; y++) {
+      const year = startYear + y;
+      try {
+        const date = import_polyfill.Temporal.PlainDate.from({
+          year,
+          month: monthNumber(dateSpec.month),
+          day: dateSpec.day
+        }, { overflow: "reject" });
+        const candidate = earliestFutureAtTimes(date, times, tz, now);
+        if (candidate) return candidate;
+      } catch {
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function nextYearRepeat(target, times, tz, now) {
+  const nowInTz = now.withTimeZone(tz);
+  const startYear = nowInTz.year;
+  for (let y = 0; y < 8; y++) {
+    const year = startYear + y;
+    let targetDate = null;
+    switch (target.type) {
+      case "date":
+        try {
+          targetDate = import_polyfill.Temporal.PlainDate.from({
+            year,
+            month: monthNumber(target.month),
+            day: target.day
+          }, { overflow: "reject" });
+        } catch {
+          continue;
+        }
+        break;
+      case "ordinalWeekday":
+        if (target.ordinal === "last") {
+          targetDate = lastWeekdayInMonth(
+            year,
+            monthNumber(target.month),
+            target.weekday
+          );
+        } else {
+          targetDate = nthWeekdayOfMonth(
+            year,
+            monthNumber(target.month),
+            target.weekday,
+            ordinalToN(target.ordinal)
+          );
+        }
+        break;
+      case "dayOfMonth":
+        try {
+          targetDate = import_polyfill.Temporal.PlainDate.from({
+            year,
+            month: monthNumber(target.month),
+            day: target.day
+          }, { overflow: "reject" });
+        } catch {
+          continue;
+        }
+        break;
+      case "lastWeekday":
+        targetDate = lastWeekdayOfMonth(year, monthNumber(target.month));
+        break;
+    }
+    if (targetDate) {
+      const candidate = earliestFutureAtTimes(targetDate, times, tz, now);
+      if (candidate) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/cron.ts
+function toCron(schedule) {
+  if (schedule.except.length > 0) {
+    throw HronError.cron(
+      "not expressible as cron (except clauses not supported)"
+    );
+  }
+  if (schedule.until) {
+    throw HronError.cron(
+      "not expressible as cron (until clauses not supported)"
+    );
+  }
+  if (schedule.during.length > 0) {
+    throw HronError.cron(
+      "not expressible as cron (during clauses not supported)"
+    );
+  }
+  const expr = schedule.expr;
+  switch (expr.type) {
+    case "dayRepeat": {
+      if (expr.times.length !== 1) {
+        throw HronError.cron(
+          "not expressible as cron (multiple times not supported)"
+        );
+      }
+      const time = expr.times[0];
+      const dow = dayFilterToCronDow(expr.days);
+      return `${time.minute} ${time.hour} * * ${dow}`;
+    }
+    case "intervalRepeat": {
+      const fullDay = expr.from.hour === 0 && expr.from.minute === 0 && expr.to.hour === 23 && expr.to.minute === 59;
+      if (!fullDay) {
+        throw HronError.cron(
+          "not expressible as cron (partial-day interval windows not supported)"
+        );
+      }
+      if (expr.dayFilter) {
+        throw HronError.cron(
+          "not expressible as cron (interval with day filter not supported)"
+        );
+      }
+      if (expr.unit === "min") {
+        if (60 % expr.interval !== 0) {
+          throw HronError.cron(
+            `not expressible as cron (*/${expr.interval} breaks at hour boundaries)`
+          );
+        }
+        return `*/${expr.interval} * * * *`;
+      }
+      return `0 */${expr.interval} * * *`;
+    }
+    case "weekRepeat":
+      throw HronError.cron(
+        "not expressible as cron (multi-week intervals not supported)"
+      );
+    case "monthRepeat": {
+      if (expr.times.length !== 1) {
+        throw HronError.cron(
+          "not expressible as cron (multiple times not supported)"
+        );
+      }
+      const time = expr.times[0];
+      const { target } = expr;
+      if (target.type === "days") {
+        const expanded = target.specs.flatMap((s) => {
+          if (s.type === "single") return [s.day];
+          const r = [];
+          for (let d = s.start; d <= s.end; d++) r.push(d);
+          return r;
+        });
+        const dom = expanded.join(",");
+        return `${time.minute} ${time.hour} ${dom} * *`;
+      }
+      if (target.type === "lastDay") {
+        throw HronError.cron(
+          "not expressible as cron (last day of month not supported)"
+        );
+      }
+      throw HronError.cron(
+        "not expressible as cron (last weekday of month not supported)"
+      );
+    }
+    case "ordinalRepeat":
+      throw HronError.cron(
+        "not expressible as cron (ordinal weekday of month not supported)"
+      );
+    case "singleDate":
+      throw HronError.cron(
+        "not expressible as cron (single dates are not repeating)"
+      );
+    case "yearRepeat":
+      throw HronError.cron(
+        "not expressible as cron (yearly schedules not supported in 5-field cron)"
+      );
+  }
+}
+function dayFilterToCronDow(filter) {
+  switch (filter.type) {
+    case "every":
+      return "*";
+    case "weekday":
+      return "1-5";
+    case "weekend":
+      return "0,6";
+    case "days": {
+      const nums = filter.days.map((d) => cronDowNumber(d));
+      nums.sort((a, b) => a - b);
+      return nums.join(",");
+    }
+  }
+}
+function fromCron(cron) {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw HronError.cron(`expected 5 cron fields, got ${fields.length}`);
+  }
+  const [minuteField, hourField, domField, _monthField, dowField] = fields;
+  if (minuteField.startsWith("*/")) {
+    const interval = parseInt(minuteField.slice(2), 10);
+    if (isNaN(interval)) throw HronError.cron("invalid minute interval");
+    let fromHour = 0;
+    let toHour = 23;
+    if (hourField === "*") {
+    } else if (hourField.includes("-")) {
+      const [start, end] = hourField.split("-");
+      fromHour = parseInt(start, 10);
+      toHour = parseInt(end, 10);
+      if (isNaN(fromHour) || isNaN(toHour))
+        throw HronError.cron("invalid hour range");
+    } else {
+      const h = parseInt(hourField, 10);
+      if (isNaN(h)) throw HronError.cron("invalid hour");
+      fromHour = h;
+      toHour = h;
+    }
+    const dayFilter = dowField === "*" ? null : parseCronDow(dowField);
+    if (domField === "*") {
+      const expr2 = {
+        type: "intervalRepeat",
+        interval,
+        unit: "min",
+        from: { hour: fromHour, minute: 0 },
+        to: { hour: toHour, minute: toHour === 23 ? 59 : 0 },
+        dayFilter
+      };
+      return newScheduleData(expr2);
+    }
+  }
+  if (hourField.startsWith("*/") && minuteField === "0") {
+    const interval = parseInt(hourField.slice(2), 10);
+    if (isNaN(interval)) throw HronError.cron("invalid hour interval");
+    if (domField === "*" && dowField === "*") {
+      const expr2 = {
+        type: "intervalRepeat",
+        interval,
+        unit: "hours",
+        from: { hour: 0, minute: 0 },
+        to: { hour: 23, minute: 59 },
+        dayFilter: null
+      };
+      return newScheduleData(expr2);
+    }
+  }
+  const minute = parseInt(minuteField, 10);
+  if (isNaN(minute))
+    throw HronError.cron(`invalid minute field: ${minuteField}`);
+  const hour = parseInt(hourField, 10);
+  if (isNaN(hour)) throw HronError.cron(`invalid hour field: ${hourField}`);
+  const time = { hour, minute };
+  if (domField !== "*" && dowField === "*") {
+    if (domField.includes("-")) {
+      throw HronError.cron(`DOM ranges not supported: ${domField}`);
+    }
+    const dayNums = domField.split(",").map((s) => {
+      const n = parseInt(s, 10);
+      if (isNaN(n))
+        throw HronError.cron(`invalid DOM field: ${domField}`);
+      return n;
+    });
+    const specs = dayNums.map((d) => ({
+      type: "single",
+      day: d
+    }));
+    const expr2 = {
+      type: "monthRepeat",
+      target: { type: "days", specs },
+      times: [time]
+    };
+    return newScheduleData(expr2);
+  }
+  const days = parseCronDow(dowField);
+  const expr = {
+    type: "dayRepeat",
+    days,
+    times: [time]
+  };
+  return newScheduleData(expr);
+}
+function parseCronDow(field) {
+  if (field === "*") return { type: "every" };
+  if (field === "1-5") return { type: "weekday" };
+  if (field === "0,6" || field === "6,0") return { type: "weekend" };
+  if (field.includes("-")) {
+    throw HronError.cron(`DOW ranges not supported: ${field}`);
+  }
+  const nums = field.split(",").map((s) => {
+    const n = parseInt(s, 10);
+    if (isNaN(n)) throw HronError.cron(`invalid DOW field: ${field}`);
+    return n;
+  });
+  const days = nums.map((n) => cronDowToWeekday(n));
+  return { type: "days", days };
+}
+function cronDowToWeekday(n) {
+  const map = {
+    0: "sunday",
+    1: "monday",
+    2: "tuesday",
+    3: "wednesday",
+    4: "thursday",
+    5: "friday",
+    6: "saturday",
+    7: "sunday"
+  };
+  const result = map[n];
+  if (!result) throw HronError.cron(`invalid DOW number: ${n}`);
+  return result;
+}
+
+// src/index.ts
+var import_polyfill2 = require("@js-temporal/polyfill");
+var Schedule = class _Schedule {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  /** Parse an hron expression string. */
+  static parse(input) {
+    return new _Schedule(parse(input));
+  }
+  /** Convert a 5-field cron expression to a Schedule. */
+  static fromCron(cronExpr) {
+    return new _Schedule(fromCron(cronExpr));
+  }
+  /** Check if an input string is a valid hron expression. */
+  static validate(input) {
+    try {
+      parse(input);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Compute the next occurrence after `now`. */
+  nextFrom(now) {
+    return nextFrom(this.data, now);
+  }
+  /** Compute the next `n` occurrences after `now`. */
+  nextNFrom(now, n) {
+    return nextNFrom(this.data, now, n);
+  }
+  /** Check if a datetime matches this schedule. */
+  matches(datetime) {
+    return matches(this.data, datetime);
+  }
+  /** Convert this schedule to a 5-field cron expression. */
+  toCron() {
+    return toCron(this.data);
+  }
+  /** Render as canonical string (roundtrip-safe). */
+  toString() {
+    return display(this.data);
+  }
+  /** Get the timezone, if specified. */
+  get timezone() {
+    return this.data.timezone;
+  }
+  /** Get the underlying schedule expression. */
+  get expression() {
+    return this.data.expr;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HronError,
+  Schedule,
+  Temporal
+});
+//# sourceMappingURL=index.cjs.map