temporal-workdays 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -32,232 +32,906 @@ function daysInMonth(year, month) {
   if (month === 2) return isLeapYear(year) ? 29 : 28;
   return month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
 }
+function floorDiv(a, b) {
+  const q = a / b;
+  return a % b < 0n ? q - 1n : q;
+}
 
-// src/index.ts
-var MAX_SCAN_DAYS = 366 * 20;
-var DATE_RE = /^([+-]?\d{4,6})-(\d{2})-(\d{2})$/;
-var MONTH_DAY_RE = /^(?:--)?(\d{2})-(\d{2})$/;
-function checkDay(year, month, day, source) {
-  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
-    throw new RangeError(`temporal-workdays: invalid date ${JSON.stringify(String(source))}`);
+// src/errors.ts
+var PREFIX = "temporal-workdays: ";
+function rangeError(message) {
+  return new RangeError(PREFIX + message);
+}
+function typeError(message) {
+  return new TypeError(PREFIX + message);
+}
+function describe(value) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "undefined":
+      return String(value);
+    case "symbol":
+      return value.toString();
+    case "function":
+      return "a function";
+    case "object":
+      return value === null ? "null" : Object.prototype.toString.call(value);
+  }
+}
+
+// src/temporal.ts
+function hasBrand(value, brand) {
+  return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === `[object ${brand}]`;
+}
+function isPlainDate(value) {
+  return hasBrand(value, "Temporal.PlainDate");
+}
+function isPlainDateTime(value) {
+  return hasBrand(value, "Temporal.PlainDateTime");
+}
+function isZonedDateTime(value) {
+  return hasBrand(value, "Temporal.ZonedDateTime");
+}
+function toPlainDate(date) {
+  if (isPlainDate(date)) return date;
+  if (isPlainDateTime(date) || isZonedDateTime(date)) {
+    return date.toPlainDate();
   }
+  throw typeError(`expected a Temporal.PlainDate, PlainDateTime or ZonedDateTime, got ${describe(date)}`);
+}
+function toIso(value) {
+  return value.calendarId === "iso8601" ? value : value.withCalendar("iso8601");
+}
+function withCalendarId(value, calendarId) {
+  return calendarId === "iso8601" ? value : value.withCalendar(calendarId);
+}
+function toIsoDate(date) {
+  return toIso(date);
 }
-function epochDayOfPlainDate(date) {
-  const iso = date.calendarId === "iso8601" ? date : date.withCalendar("iso8601");
+function epochDayOf(date) {
+  const iso = toIsoDate(date);
   return epochDayFromIso(iso.year, iso.month, iso.day);
 }
-function isTemporalLike(value, tag) {
-  return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === `[object ${tag}]`;
+var DateFactory = class {
+  #iso;
+  #epochDay;
+  constructor(reference) {
+    this.#iso = toIsoDate(reference);
+    this.#epochDay = epochDayFromIso(this.#iso.year, this.#iso.month, this.#iso.day);
+  }
+  get epochDay() {
+    return this.#epochDay;
+  }
+  at(epochDay) {
+    return epochDay === this.#epochDay ? this.#iso : this.#iso.add({ days: epochDay - this.#epochDay });
+  }
+};
+
+// src/day-calendar.ts
+var MAX_SCAN_DAYS = 366 * 20;
+var DATE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})$/;
+var MONTH_DAY_RE = /^(?:--)?(\d{2})-(\d{2})$/;
+var OPTION_KEYS = /* @__PURE__ */ new Set([
+  "weekend",
+  "holidays",
+  "extraWorkdays",
+  "hours",
+  "specialHours"
+]);
+function checkDate(year, month, day, source) {
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
+    throw rangeError(`invalid date ${describe(source)}`);
+  }
 }
-function parseSingleDate(value) {
+function parseDate(value) {
   if (typeof value === "string") {
     const m = DATE_RE.exec(value);
-    if (!m) throw new RangeError(`temporal-workdays: expected "YYYY-MM-DD", got ${JSON.stringify(value)}`);
-    const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
-    checkDay(y, mo, d, value);
-    return epochDayFromIso(y, mo, d);
+    if (!m) throw rangeError(`expected a "YYYY-MM-DD" date, got ${describe(value)}`);
+    const [year, month, day] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    checkDate(year, month, day, value);
+    return epochDayFromIso(year, month, day);
+  }
+  if (isPlainDate(value)) return epochDayOf(value);
+  throw typeError(`expected a "YYYY-MM-DD" string or Temporal.PlainDate, got ${describe(value)}`);
+}
+function addHoliday(entry, dates, annual) {
+  if (typeof entry === "string") {
+    const md = MONTH_DAY_RE.exec(entry);
+    if (md) {
+      const [month, day] = [Number(md[1]), Number(md[2])];
+      checkDate(2e3, month, day, entry);
+      annual.add(month * 100 + day);
+      return;
+    }
+  } else if (hasBrand(entry, "Temporal.PlainMonthDay")) {
+    const pmd = entry;
+    if (pmd.calendarId !== "iso8601") {
+      throw rangeError("Temporal.PlainMonthDay holidays must use the iso8601 calendar");
+    }
+    annual.add(Number(pmd.monthCode.slice(1)) * 100 + pmd.day);
+    return;
+  }
+  dates.add(parseDate(entry));
+}
+function isIterable(value) {
+  return typeof value === "object" && value !== null && typeof value[Symbol.iterator] === "function";
+}
+function checkOptionKeys(options, allowed) {
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) throw typeError(`unknown option ${JSON.stringify(key)}`);
+  }
+}
+function checkOptionsObject(options) {
+  if (options !== void 0 && (typeof options !== "object" || options === null)) {
+    throw typeError(`options must be an object, got ${describe(options)}`);
   }
-  if (isTemporalLike(value, "Temporal.PlainDate")) return epochDayOfPlainDate(value);
-  throw new TypeError(`temporal-workdays: expected a "YYYY-MM-DD" string or Temporal.PlainDate, got ${String(value)}`);
 }
-function compile(options) {
-  const weekendDays = options?.weekend ?? [6, 7];
+function compileDayCalendar(options = {}) {
+  checkOptionsObject(options);
+  checkOptionKeys(options, OPTION_KEYS);
   const weekend = new Array(8).fill(false);
+  const weekendDays = options.weekend ?? [6, 7];
+  if (!isIterable(weekendDays)) throw typeError(`weekend must be an array of days, got ${describe(weekendDays)}`);
   for (const d of weekendDays) {
     if (!Number.isInteger(d) || d < 1 || d > 7) {
-      throw new RangeError(`temporal-workdays: weekend days must be integers 1 (Mon) \u2013 7 (Sun), got ${String(d)}`);
+      throw rangeError(`weekend days must be integers 1 (Mon) \u2013 7 (Sun), got ${describe(d)}`);
     }
     weekend[d] = true;
   }
   const dates = /* @__PURE__ */ new Set();
   const annual = /* @__PURE__ */ new Set();
   let predicate;
-  const holidays = options?.holidays;
+  const holidays = options.holidays;
   if (typeof holidays === "function") {
     predicate = holidays;
-  } else if (holidays != null) {
-    for (const h of holidays) {
-      if (typeof h === "string") {
-        const md = MONTH_DAY_RE.exec(h);
-        if (md) {
-          const [mo, d] = [Number(md[1]), Number(md[2])];
-          checkDay(2e3, mo, d, h);
-          annual.add(mo * 100 + d);
-          continue;
-        }
-        dates.add(parseSingleDate(h));
-      } else if (isTemporalLike(h, "Temporal.PlainMonthDay")) {
-        const pmd = h;
-        if (pmd.calendarId !== "iso8601") {
-          throw new RangeError("temporal-workdays: Temporal.PlainMonthDay holidays must use the iso8601 calendar");
-        }
-        annual.add(Number(pmd.monthCode.slice(1)) * 100 + pmd.day);
-      } else {
-        dates.add(parseSingleDate(h));
-      }
-    }
+  } else if (holidays !== void 0) {
+    if (!isIterable(holidays)) throw typeError(`holidays must be an array or a function, got ${describe(holidays)}`);
+    for (const entry of holidays) addHoliday(entry, dates, annual);
   }
   const extra = /* @__PURE__ */ new Set();
-  if (options?.extraWorkdays != null) {
-    for (const e of options.extraWorkdays) extra.add(parseSingleDate(e));
+  const extraWorkdays = options.extraWorkdays;
+  if (extraWorkdays !== void 0) {
+    if (!isIterable(extraWorkdays)) throw typeError(`extraWorkdays must be an array, got ${describe(extraWorkdays)}`);
+    for (const entry of extraWorkdays) extra.add(parseDate(entry));
   }
   return { weekend, dates, annual, predicate, extra };
 }
-var cache = /* @__PURE__ */ new WeakMap();
-var DEFAULT = compile(void 0);
-function getCompiled(options) {
-  if (options === void 0) return DEFAULT;
-  let c = cache.get(options);
-  if (!c) {
-    c = compile(options);
-    cache.set(options, c);
-  }
-  return c;
+function isWeekendDay(cal, epochDay) {
+  return cal.weekend[dayOfWeekFromEpochDay(epochDay)] === true;
 }
-function toPlainDate(date) {
-  if (date == null || typeof date.add !== "function") {
-    throw new TypeError("temporal-workdays: expected a Temporal.PlainDate, PlainDateTime or ZonedDateTime");
+function isListedHoliday(cal, epochDay, dates) {
+  if (cal.dates.has(epochDay)) return true;
+  if (cal.annual.size > 0) {
+    const [, month, day] = isoFromEpochDay(epochDay);
+    if (cal.annual.has(month * 100 + day)) return true;
   }
-  return "toPlainDate" in date ? date.toPlainDate() : date;
+  return Boolean(cal.predicate?.(dates.at(epochDay)));
 }
-function isHolidayDay(c, epochDay, base, baseDay) {
-  if (c.dates.has(epochDay)) return true;
-  if (c.annual.size > 0) {
-    const [, mo, d] = isoFromEpochDay(epochDay);
-    if (c.annual.has(mo * 100 + d)) return true;
-  }
-  if (c.predicate) {
-    const iso = base.calendarId === "iso8601" ? base : base.withCalendar("iso8601");
-    return c.predicate(epochDay === baseDay ? iso : iso.add({ days: epochDay - baseDay }));
-  }
-  return false;
-}
-function isWorkdayDay(c, epochDay, base, baseDay) {
-  if (c.extra.has(epochDay)) return true;
-  if (c.weekend[dayOfWeekFromEpochDay(epochDay)]) return false;
-  return !isHolidayDay(c, epochDay, base, baseDay);
+function isHolidayDay(cal, epochDay, dates) {
+  return !cal.extra.has(epochDay) && isListedHoliday(cal, epochDay, dates);
 }
-function checkInteger(n, name) {
-  if (!Number.isInteger(n)) throw new RangeError(`temporal-workdays: ${name} must be an integer, got ${String(n)}`);
+function isWorkdayDay(cal, epochDay, dates) {
+  if (cal.extra.has(epochDay)) return true;
+  if (isWeekendDay(cal, epochDay)) return false;
+  return !isListedHoliday(cal, epochDay, dates);
 }
 function noWorkdayError() {
-  return new RangeError(
-    `temporal-workdays: no workday found within ${MAX_SCAN_DAYS} days \u2014 check your weekend/holiday configuration`
-  );
+  return rangeError(`no workday found within ${MAX_SCAN_DAYS} days \u2014 check the weekend/holiday configuration`);
 }
-function step(c, base, count, dir) {
-  const baseDay = epochDayOfPlainDate(base);
-  let day = baseDay;
+function stepWorkdays(cal, from, count, dir, dates) {
+  let day = from;
   let remaining = count;
   let gap = 0;
   while (remaining > 0) {
     day += dir;
-    if (isWorkdayDay(c, day, base, baseDay)) {
+    if (isWorkdayDay(cal, day, dates)) {
       remaining--;
       gap = 0;
     } else if (++gap > MAX_SCAN_DAYS) {
       throw noWorkdayError();
     }
   }
-  return day - baseDay;
+  return day;
+}
+function countWorkdays(cal, from, to, dates) {
+  const [lo, hi, sign] = from <= to ? [from, to, 1] : [to, from, -1];
+  let count = 0;
+  for (let day = lo + 1; day <= hi; day++) {
+    if (isWorkdayDay(cal, day, dates)) count++;
+  }
+  return count === 0 ? 0 : sign * count;
+}
+
+// src/time.ts
+var NS_PER_SECOND = 1e9;
+var NS_PER_MINUTE = 60 * NS_PER_SECOND;
+var NS_PER_HOUR = 60 * NS_PER_MINUTE;
+var NS_PER_DAY = 24 * NS_PER_HOUR;
+var TIME_RE = /^(\d{2}):(\d{2})(?::(\d{2})(?:[.,](\d{1,9}))?)?$/;
+function nsOfDay(hour, minute, second = 0, subsecondNs = 0) {
+  return hour * NS_PER_HOUR + minute * NS_PER_MINUTE + second * NS_PER_SECOND + subsecondNs;
+}
+function nsOfTime(t) {
+  return nsOfDay(t.hour, t.minute, t.second, t.millisecond * 1e6 + t.microsecond * 1e3 + t.nanosecond);
+}
+function parseTime(value) {
+  if (typeof value === "string") {
+    const m = TIME_RE.exec(value);
+    if (m) {
+      const [hour, minute, second] = [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)];
+      const subsecond = Number((m[4] ?? "").padEnd(9, "0"));
+      const ns = nsOfDay(hour, minute, second, subsecond);
+      if (minute < 60 && second < 60 && ns <= NS_PER_DAY) return ns;
+    }
+    throw rangeError(`expected a time like "09:30" (00:00 \u2013 24:00), got ${describe(value)}`);
+  }
+  if (hasBrand(value, "Temporal.PlainTime")) return nsOfTime(value);
+  throw typeError(`expected a "HH:MM" string or Temporal.PlainTime, got ${describe(value)}`);
+}
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function formatTime(ns) {
+  const hour = Math.floor(ns / NS_PER_HOUR);
+  const minute = Math.floor(ns % NS_PER_HOUR / NS_PER_MINUTE);
+  const second = Math.floor(ns % NS_PER_MINUTE / NS_PER_SECOND);
+  const fraction = ns % NS_PER_SECOND;
+  let text = `${pad(hour)}:${pad(minute)}`;
+  if (second !== 0 || fraction !== 0) text += `:${pad(second)}`;
+  if (fraction !== 0) text += `.${pad(fraction, 9).replace(/0+$/, "")}`;
+  return text;
+}
+function parseDayHours(value, where) {
+  if (!Array.isArray(value))
+    throw typeError(`${where} must be an array of [start, end] ranges, got ${describe(value)}`);
+  const ranges = value.map((range) => {
+    if (!Array.isArray(range) || range.length !== 2) {
+      throw typeError(`${where}: each range must be a [start, end] pair, got ${describe(range)}`);
+    }
+    const [start, end] = range;
+    const interval = [parseTime(start), parseTime(end)];
+    if (interval[0] >= interval[1]) {
+      throw rangeError(`${where}: range start must be before its end, got ${describe(start)}\u2013${describe(end)}`);
+    }
+    return interval;
+  });
+  ranges.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [start, end] of ranges) {
+    const last = merged.at(-1);
+    if (last && start < last[1]) {
+      throw rangeError(
+        `${where}: ranges overlap (${formatTime(last[0])}\u2013${formatTime(last[1])} and ${formatTime(start)}\u2013${formatTime(end)})`
+      );
+    }
+    if (last?.[1] === start) last[1] = end;
+    else merged.push([start, end]);
+  }
+  return merged;
+}
+function formatDayHours(intervals) {
+  return intervals.map(([start, end]) => [formatTime(start), formatTime(end)]);
+}
+function subtractInterval(intervals, cutStart, cutEnd) {
+  const out = [];
+  for (const [start, end] of intervals) {
+    if (end <= cutStart || start >= cutEnd) {
+      out.push([start, end]);
+      continue;
+    }
+    if (start < cutStart) out.push([start, cutStart]);
+    if (end > cutEnd) out.push([cutEnd, end]);
+  }
+  return out;
+}
+
+// src/hours.ts
+function byDayOfWeek(f) {
+  return { 1: f(1), 2: f(2), 3: f(3), 4: f(4), 5: f(5), 6: f(6), 7: f(7) };
+}
+var WEEKLY_KEYS = /* @__PURE__ */ new Set(["1", "2", "3", "4", "5", "6", "7", "default"]);
+var EMPTY = [];
+function compileWeekly(hours) {
+  if (hours === void 0) throw typeError("working-time functions need an `hours` option");
+  if (Array.isArray(hours)) {
+    const uniform = parseDayHours(hours, "hours");
+    return byDayOfWeek(() => uniform);
+  }
+  if (typeof hours !== "object" || hours === null) {
+    throw typeError(`hours must be an array of ranges or an object by day of week, got ${describe(hours)}`);
+  }
+  checkOptionKeys(hours, WEEKLY_KEYS);
+  const byDay = hours;
+  const fallback = byDay["default"] === void 0 ? EMPTY : parseDayHours(byDay["default"], "hours.default");
+  return byDayOfWeek((dow) => byDay[dow] === void 0 ? fallback : parseDayHours(byDay[dow], `hours[${dow}]`));
+}
+function compileSpecial(special) {
+  if (special === void 0) return { kind: "none" };
+  if (typeof special === "function") return { kind: "function", fn: special };
+  if (typeof special !== "object" || special === null || Array.isArray(special)) {
+    throw typeError(`specialHours must be an object keyed by date or a function, got ${describe(special)}`);
+  }
+  const byDay = /* @__PURE__ */ new Map();
+  for (const [date, hours] of Object.entries(special)) {
+    byDay.set(parseDate(date), parseDayHours(hours, `specialHours[${JSON.stringify(date)}]`));
+  }
+  return { kind: "table", byDay };
+}
+function compileHoursCalendar(options) {
+  checkOptionsObject(options);
+  const days = compileDayCalendar(options);
+  const weekly = compileWeekly(options?.hours);
+  const weeklyText = byDayOfWeek((dow) => formatDayHours(weekly[dow]));
+  return { days, weekly, weeklyText, special: compileSpecial(options.specialHours) };
+}
+function intervalsOn(cal, epochDay, dates) {
+  const dow = dayOfWeekFromEpochDay(epochDay);
+  const workday = isWorkdayDay(cal.days, epochDay, dates);
+  const { special } = cal;
+  if (special.kind === "table") {
+    const override = special.byDay.get(epochDay);
+    if (override) return override;
+  } else if (special.kind === "function") {
+    const date = dates.at(epochDay);
+    const result = special.fn(date, workday ? cal.weeklyText[dow] : []);
+    if (result !== void 0) return parseDayHours(result, `specialHours(${date.toString()})`);
+  }
+  return workday ? cal.weekly[dow] : EMPTY;
+}
+var BIG_NS_PER_DAY = BigInt(NS_PER_DAY);
+var BIG_NS_PER_SECOND = BigInt(NS_PER_SECOND);
+function wallFields(day, ns) {
+  const [year, month, dd] = isoFromEpochDay(day);
+  return {
+    year,
+    month,
+    day: dd,
+    hour: Math.floor(ns / NS_PER_HOUR),
+    minute: Math.floor(ns % NS_PER_HOUR / NS_PER_MINUTE),
+    second: Math.floor(ns % NS_PER_MINUTE / NS_PER_SECOND),
+    millisecond: Math.floor(ns % NS_PER_SECOND / 1e6),
+    microsecond: Math.floor(ns % 1e6 / 1e3),
+    nanosecond: ns % 1e3
+  };
+}
+function wallPosition(day, ns) {
+  return BigInt(day) * BIG_NS_PER_DAY + BigInt(ns);
+}
+function wallDay(v) {
+  return epochDayFromIso(v.year, v.month, v.day);
+}
+function durationFrom(zero, ns) {
+  return zero.add({ seconds: Number(ns / BIG_NS_PER_SECOND), nanoseconds: Number(ns % BIG_NS_PER_SECOND) }).round({ largestUnit: "hours" });
+}
+function normalizePeriods(periods) {
+  periods.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  const merged = [];
+  for (const [start, end] of periods) {
+    if (end <= start) continue;
+    const last = merged.at(-1);
+    if (last && start <= last[1]) {
+      if (end > last[1]) last[1] = end;
+    } else {
+      merged.push([start, end]);
+    }
+  }
+  return merged;
+}
+var PlainTimeline = class {
+  origin;
+  lookahead = 0n;
+  dates;
+  #iso;
+  #calendarId;
+  constructor(value) {
+    this.#calendarId = value.calendarId;
+    this.#iso = toIso(value);
+    this.origin = wallPosition(wallDay(this.#iso), nsOfTime(this.#iso));
+    this.dates = new DateFactory(this.#iso.toPlainDate());
+  }
+  positionOf(value) {
+    if (!isPlainDateTime(value)) throw mixedTypesError(value);
+    const iso = toIso(value);
+    return wallPosition(wallDay(iso), nsOfTime(iso));
+  }
+  periods(day, intervals) {
+    return intervals.map(([start, end]) => [wallPosition(day, start), wallPosition(day, end)]);
+  }
+  at(position) {
+    const day = floorDiv(position, BIG_NS_PER_DAY);
+    const fields = wallFields(Number(day), Number(position - day * BIG_NS_PER_DAY));
+    return withCalendarId(this.#iso.with(fields), this.#calendarId);
+  }
+  duration(ns) {
+    return durationFrom(this.#iso.until(this.#iso), ns);
+  }
+};
+var SEGMENT_MARGIN = 48n * BigInt(NS_PER_HOUR);
+var FOREVER = 2n ** 100n;
+var ZONED_LOOKAHEAD = 48n * BigInt(NS_PER_HOUR);
+var ZonedTimeline = class {
+  origin;
+  lookahead = ZONED_LOOKAHEAD;
+  dates;
+  #iso;
+  #calendarId;
+  #segment;
+  constructor(value) {
+    this.#calendarId = value.calendarId;
+    this.#iso = toIso(value);
+    this.origin = this.#iso.epochNanoseconds;
+    this.dates = new DateFactory(this.#iso.toPlainDate());
+  }
+  positionOf(value) {
+    if (!isZonedDateTime(value)) throw mixedTypesError(value);
+    return value.epochNanoseconds;
+  }
+  periods(day, intervals) {
+    return normalizePeriods(intervals.map(([start, end]) => [this.#exact(day, start), this.#exact(day, end)]));
+  }
+  /** Exact time of a wall-clock time; skipped times move forward, repeated times use the earlier. */
+  #exact(day, ns) {
+    const wall = wallPosition(day, ns);
+    const segment = this.#segment;
+    if (segment) {
+      const candidate = wall - segment.offset;
+      if (candidate >= segment.start && candidate < segment.end) return candidate;
+    }
+    const d = Number(floorDiv(wall, BIG_NS_PER_DAY));
+    const fields = wallFields(d, Number(wall - BigInt(d) * BIG_NS_PER_DAY));
+    const zdt = this.#iso.with(fields, { disambiguation: "compatible", offset: "ignore" });
+    this.#segment = segmentAround(zdt);
+    return zdt.epochNanoseconds;
+  }
+  at(position) {
+    const delta = position - this.origin;
+    const result = this.#iso.add({
+      seconds: Number(delta / BIG_NS_PER_SECOND),
+      nanoseconds: Number(delta % BIG_NS_PER_SECOND)
+    });
+    return withCalendarId(result, this.#calendarId);
+  }
+  duration(ns) {
+    return durationFrom(this.#iso.until(this.#iso), ns);
+  }
+};
+function segmentAround(zdt) {
+  const previous = zdt.add({ nanoseconds: 1 }).getTimeZoneTransition("previous");
+  const next = zdt.getTimeZoneTransition("next");
+  return {
+    start: previous ? previous.epochNanoseconds + SEGMENT_MARGIN : -FOREVER,
+    end: next ? next.epochNanoseconds - SEGMENT_MARGIN : FOREVER,
+    offset: BigInt(zdt.offsetNanoseconds)
+  };
+}
+function addPeriods(pending, periods) {
+  const first = periods[0];
+  const last = periods.at(-1);
+  if (first === void 0 || last === void 0) return pending;
+  const pendingFirst = pending[0];
+  const pendingLast = pending.at(-1);
+  if (pendingFirst === void 0 || pendingLast === void 0) return [...periods];
+  if (first[0] > pendingLast[1]) return pending.concat(periods);
+  if (last[1] < pendingFirst[0]) return periods.concat(pending);
+  return normalizePeriods([...pending, ...periods]);
+}
+function mixedTypesError(value) {
+  return typeError(`start and end must be the same Temporal type, got ${describe(value)} for end`);
+}
+function withTimeline(value, run) {
+  if (isZonedDateTime(value)) return run(new ZonedTimeline(value));
+  if (isPlainDateTime(value)) return run(new PlainTimeline(value));
+  throw typeError(
+    `expected a Temporal.PlainDateTime or ZonedDateTime, got ${describe(value)}` + (isPlainDate(value) ? " (use the workday functions for dates)" : "")
+  );
+}
+function noWorkingTimeError() {
+  return rangeError(`no working time found within ${MAX_SCAN_DAYS} days \u2014 check the hours/holiday configuration`);
+}
+function scan(cal, tl, from, dir, visit) {
+  let pending = [];
+  let day = Number(floorDiv(from - BigInt(dir) * tl.lookahead, BIG_NS_PER_DAY));
+  for (let idle = 0; ; day += dir) {
+    const periods = tl.periods(day, intervalsOn(cal, day, tl.dates));
+    idle = periods.length === 0 ? idle + 1 : 0;
+    if (idle > MAX_SCAN_DAYS) throw noWorkingTimeError();
+    pending = addPeriods(pending, periods);
+    const frontier = dir === 1 ? wallPosition(day + 1, 0) - tl.lookahead : wallPosition(day, 0) + tl.lookahead;
+    for (; ; ) {
+      const next = dir === 1 ? pending[0] : pending.at(-1);
+      if (next === void 0 || (dir === 1 ? next[0] >= frontier : next[1] <= frontier)) break;
+      if (dir === 1) pending.shift();
+      else pending.pop();
+      const result = visit(next);
+      if (result !== void 0) return result;
+    }
+  }
+}
+var CALENDAR_UNITS = ["years", "months", "weeks", "days"];
+var TIME_UNITS = [
+  ["hours", BigInt(NS_PER_HOUR)],
+  ["minutes", BigInt(NS_PER_MINUTE)],
+  ["seconds", BigInt(NS_PER_SECOND)],
+  ["milliseconds", 1000000n],
+  ["microseconds", 1000n],
+  ["nanoseconds", 1n]
+];
+function durationToNs(duration) {
+  if (typeof duration !== "object" || duration === null) {
+    throw typeError(`expected a Temporal.Duration or an object like { hours: 4 }, got ${describe(duration)}`);
+  }
+  let seen = false;
+  for (const unit of CALENDAR_UNITS) {
+    const value = duration[unit];
+    if (value === void 0) continue;
+    seen = true;
+    if (value !== 0) throw rangeError(`${unit} are not supported in working time; use addWorkdays for whole days`);
+  }
+  let total = 0n;
+  let sign = 0;
+  for (const [unit, nsPerUnit] of TIME_UNITS) {
+    const value = duration[unit];
+    if (value === void 0) continue;
+    seen = true;
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      throw rangeError(`duration ${unit} must be an integer, got ${describe(value)}`);
+    }
+    if (value === 0) continue;
+    if (sign !== 0 && Math.sign(value) !== sign) throw rangeError("duration fields must all have the same sign");
+    sign = Math.sign(value);
+    total += BigInt(value) * nsPerUnit;
+  }
+  if (!seen) throw typeError("duration needs at least one of hours, minutes, seconds, \u2026 (e.g. { hours: 4 })");
+  return total;
+}
+function negate(duration) {
+  if (typeof duration !== "object" || duration === null) return duration;
+  const negated = {};
+  for (const unit of [...CALENDAR_UNITS, ...TIME_UNITS.map(([u]) => u)]) {
+    const value = duration[unit];
+    negated[unit] = typeof value === "number" ? -value : value;
+  }
+  return negated;
+}
+function isWorkingPosition(cal, tl, position) {
+  const first = Number(floorDiv(position - tl.lookahead, BIG_NS_PER_DAY));
+  const last = Number(floorDiv(position + tl.lookahead, BIG_NS_PER_DAY));
+  for (let day = first; day <= last; day++) {
+    for (const [start, end] of tl.periods(day, intervalsOn(cal, day, tl.dates))) {
+      if (position >= start && position < end) return true;
+    }
+  }
+  return false;
+}
+function addForward(cal, tl, total) {
+  let cursor = tl.origin;
+  let remaining = total;
+  return scan(cal, tl, tl.origin, 1, ([start, end]) => {
+    const from = start > cursor ? start : cursor;
+    if (end <= from) return void 0;
+    if (remaining <= end - from) return tl.at(from + remaining);
+    remaining -= end - from;
+    cursor = end;
+    return void 0;
+  });
+}
+function addBackward(cal, tl, total) {
+  let cursor = tl.origin;
+  let remaining = total;
+  return scan(cal, tl, tl.origin, -1, ([start, end]) => {
+    const to = end < cursor ? end : cursor;
+    if (to <= start) return void 0;
+    if (remaining <= to - start) return tl.at(to - remaining);
+    remaining -= to - start;
+    cursor = start;
+    return void 0;
+  });
+}
+function workingNsBetween(cal, tl, a, b) {
+  let total = 0n;
+  let cursor = a;
+  scan(cal, tl, a, 1, ([start, end]) => {
+    if (start >= b) return true;
+    const from = start > cursor ? start : cursor;
+    const to = end < b ? end : b;
+    if (to > from) {
+      total += to - from;
+      cursor = to;
+    }
+    return void 0;
+  });
+  return total;
+}
+function rollForwardPosition(cal, tl) {
+  if (isWorkingPosition(cal, tl, tl.origin)) return void 0;
+  return scan(cal, tl, tl.origin, 1, ([start]) => start > tl.origin ? tl.at(start) : void 0);
+}
+function rollBackwardPosition(cal, tl) {
+  if (isWorkingPosition(cal, tl, tl.origin)) return void 0;
+  return scan(cal, tl, tl.origin, -1, ([, end]) => end <= tl.origin ? tl.at(end) : void 0);
+}
+function isWorkingTimeWith(cal, dateTime) {
+  return withTimeline(dateTime, (tl) => isWorkingPosition(cal, tl, tl.origin));
+}
+function addWorkingTimeWith(cal, dateTime, duration) {
+  const total = durationToNs(duration);
+  return withTimeline(dateTime, (tl) => {
+    if (total === 0n) return dateTime;
+    return total > 0n ? addForward(cal, tl, total) : addBackward(cal, tl, -total);
+  });
+}
+function subtractWorkingTimeWith(cal, dateTime, duration) {
+  return addWorkingTimeWith(cal, dateTime, negate(duration));
+}
+function workingTimeBetweenWith(cal, start, end) {
+  return withTimeline(start, (tl) => {
+    const a = tl.origin;
+    const b = tl.positionOf(end);
+    const ns = a <= b ? workingNsBetween(cal, tl, a, b) : -workingNsBetween(cal, tl, b, a);
+    return tl.duration(ns);
+  });
+}
+function rollForwardToWorkingTimeWith(cal, dateTime) {
+  return withTimeline(dateTime, (tl) => rollForwardPosition(cal, tl)) ?? dateTime;
+}
+function rollBackwardToWorkingTimeWith(cal, dateTime) {
+  return withTimeline(dateTime, (tl) => rollBackwardPosition(cal, tl)) ?? dateTime;
 }
-function shift(date, days) {
+function getWorkingHoursWith(cal, date) {
+  const dates = new DateFactory(toPlainDate(date));
+  return formatDayHours(intervalsOn(cal, dates.epochDay, dates));
+}
+function isWorkingTime(dateTime, options) {
+  return isWorkingTimeWith(compileHoursCalendar(options), dateTime);
+}
+function addWorkingTime(dateTime, duration, options) {
+  return addWorkingTimeWith(compileHoursCalendar(options), dateTime, duration);
+}
+function subtractWorkingTime(dateTime, duration, options) {
+  return subtractWorkingTimeWith(compileHoursCalendar(options), dateTime, duration);
+}
+function workingTimeBetween(start, end, options) {
+  return workingTimeBetweenWith(compileHoursCalendar(options), start, end);
+}
+function rollForwardToWorkingTime(dateTime, options) {
+  return rollForwardToWorkingTimeWith(compileHoursCalendar(options), dateTime);
+}
+function rollBackwardToWorkingTime(dateTime, options) {
+  return rollBackwardToWorkingTimeWith(compileHoursCalendar(options), dateTime);
+}
+function getWorkingHours(date, options) {
+  return getWorkingHoursWith(compileHoursCalendar(options), date);
+}
+
+// src/workdays.ts
+function shiftDays(date, days) {
   return days === 0 ? date : date.add({ days });
 }
+function checkAmount(amount) {
+  if (!Number.isSafeInteger(amount)) throw rangeError(`amount must be an integer, got ${describe(amount)}`);
+}
+function isWeekendWith(cal, date) {
+  return isWeekendDay(cal, new DateFactory(toPlainDate(date)).epochDay);
+}
+function isHolidayWith(cal, date) {
+  const dates = new DateFactory(toPlainDate(date));
+  return isHolidayDay(cal, dates.epochDay, dates);
+}
+function isWorkdayWith(cal, date) {
+  const dates = new DateFactory(toPlainDate(date));
+  return isWorkdayDay(cal, dates.epochDay, dates);
+}
+function addWorkdaysWith(cal, date, amount) {
+  checkAmount(amount);
+  const dates = new DateFactory(toPlainDate(date));
+  if (amount === 0) return date;
+  const target = stepWorkdays(cal, dates.epochDay, Math.abs(amount), amount > 0 ? 1 : -1, dates);
+  return shiftDays(date, target - dates.epochDay);
+}
+function subtractWorkdaysWith(cal, date, amount) {
+  checkAmount(amount);
+  return addWorkdaysWith(cal, date, -amount);
+}
+function nextWorkdayWith(cal, date) {
+  const dates = new DateFactory(toPlainDate(date));
+  return shiftDays(date, stepWorkdays(cal, dates.epochDay, 1, 1, dates) - dates.epochDay);
+}
+function previousWorkdayWith(cal, date) {
+  const dates = new DateFactory(toPlainDate(date));
+  return shiftDays(date, stepWorkdays(cal, dates.epochDay, 1, -1, dates) - dates.epochDay);
+}
+function rollForwardWith(cal, date) {
+  return isWorkdayWith(cal, date) ? date : nextWorkdayWith(cal, date);
+}
+function rollBackwardWith(cal, date) {
+  return isWorkdayWith(cal, date) ? date : previousWorkdayWith(cal, date);
+}
+function workdaysBetweenWith(cal, start, end) {
+  const a = new DateFactory(toPlainDate(start));
+  const endDay = new DateFactory(toPlainDate(end)).epochDay;
+  return countWorkdays(cal, a.epochDay, endDay, a);
+}
+function* eachWorkdayWith(cal, start, end) {
+  const dates = new DateFactory(toPlainDate(start));
+  const endDay = new DateFactory(toPlainDate(end)).epochDay;
+  for (let day = dates.epochDay; day <= endDay; day++) {
+    if (isWorkdayDay(cal, day, dates)) yield shiftDays(start, day - dates.epochDay);
+  }
+}
 function isWeekend(date, options) {
-  return getCompiled(options).weekend[toPlainDate(date).dayOfWeek] === true;
+  return isWeekendWith(compileDayCalendar(options), date);
 }
 function isHoliday(date, options) {
-  const c = getCompiled(options);
-  const base = toPlainDate(date);
-  const day = epochDayOfPlainDate(base);
-  return !c.extra.has(day) && isHolidayDay(c, day, base, day);
+  return isHolidayWith(compileDayCalendar(options), date);
 }
 function isWorkday(date, options) {
-  const c = getCompiled(options);
-  const base = toPlainDate(date);
-  const day = epochDayOfPlainDate(base);
-  return isWorkdayDay(c, day, base, day);
+  return isWorkdayWith(compileDayCalendar(options), date);
 }
 function addWorkdays(date, amount, options) {
-  checkInteger(amount, "amount");
-  if (amount === 0) return date;
-  const c = getCompiled(options);
-  return shift(date, step(c, toPlainDate(date), Math.abs(amount), amount > 0 ? 1 : -1));
+  return addWorkdaysWith(compileDayCalendar(options), date, amount);
 }
 function subtractWorkdays(date, amount, options) {
-  checkInteger(amount, "amount");
-  return addWorkdays(date, -amount, options);
+  return subtractWorkdaysWith(compileDayCalendar(options), date, amount);
 }
 function nextWorkday(date, options) {
-  return shift(date, step(getCompiled(options), toPlainDate(date), 1, 1));
+  return nextWorkdayWith(compileDayCalendar(options), date);
 }
 function previousWorkday(date, options) {
-  return shift(date, step(getCompiled(options), toPlainDate(date), 1, -1));
+  return previousWorkdayWith(compileDayCalendar(options), date);
 }
 function rollForward(date, options) {
-  return isWorkday(date, options) ? date : nextWorkday(date, options);
+  return rollForwardWith(compileDayCalendar(options), date);
 }
 function rollBackward(date, options) {
-  return isWorkday(date, options) ? date : previousWorkday(date, options);
+  return rollBackwardWith(compileDayCalendar(options), date);
 }
 function workdaysBetween(start, end, options) {
-  const c = getCompiled(options);
-  const a = toPlainDate(start);
-  const b = toPlainDate(end);
-  const aDay = epochDayOfPlainDate(a);
-  const bDay = epochDayOfPlainDate(b);
-  if (aDay === bDay) return 0;
-  const [lo, hi, base, baseDay, sign] = aDay < bDay ? [aDay, bDay, a, aDay, 1] : [bDay, aDay, b, bDay, -1];
-  let count = 0;
-  for (let day = lo + 1; day <= hi; day++) {
-    if (isWorkdayDay(c, day, base, baseDay)) count++;
-  }
-  return sign * count;
+  return workdaysBetweenWith(compileDayCalendar(options), start, end);
 }
-function* eachWorkday(start, end, options) {
-  const c = getCompiled(options);
-  const base = toPlainDate(start);
-  const baseDay = epochDayOfPlainDate(base);
-  const endDay = epochDayOfPlainDate(toPlainDate(end));
-  for (let day = baseDay; day <= endDay; day++) {
-    if (isWorkdayDay(c, day, base, baseDay)) yield shift(start, day - baseDay);
-  }
+function eachWorkday(start, end, options) {
+  return eachWorkdayWith(compileDayCalendar(options), start, end);
 }
+
+// src/work-calendar.ts
 function createWorkCalendar(options = {}) {
-  const frozen = Object.freeze({
-    weekend: options.weekend ? Object.freeze([...options.weekend]) : void 0,
-    holidays: typeof options.holidays === "function" || options.holidays == null ? options.holidays : Object.freeze([...options.holidays]),
-    extraWorkdays: options.extraWorkdays ? Object.freeze([...options.extraWorkdays]) : void 0
+  checkOptionsObject(options);
+  const snapshot = snapshotOptions(options);
+  const days = compileDayCalendar(snapshot);
+  const calendar = {
+    options: snapshot,
+    isWorkday: (date) => isWorkdayWith(days, date),
+    isWeekend: (date) => isWeekendWith(days, date),
+    isHoliday: (date) => isHolidayWith(days, date),
+    addWorkdays: (date, amount) => addWorkdaysWith(days, date, amount),
+    subtractWorkdays: (date, amount) => subtractWorkdaysWith(days, date, amount),
+    nextWorkday: (date) => nextWorkdayWith(days, date),
+    previousWorkday: (date) => previousWorkdayWith(days, date),
+    rollForward: (date) => rollForwardWith(days, date),
+    rollBackward: (date) => rollBackwardWith(days, date),
+    workdaysBetween: (start, end) => workdaysBetweenWith(days, start, end),
+    eachWorkday: (start, end) => eachWorkdayWith(days, start, end)
+  };
+  if (!hasHours(snapshot)) return Object.freeze(calendar);
+  const hours = compileHoursCalendar(snapshot);
+  return Object.freeze({
+    ...calendar,
+    options: snapshot,
+    isWorkingTime: (dateTime) => isWorkingTimeWith(hours, dateTime),
+    addWorkingTime: (dateTime, duration) => addWorkingTimeWith(hours, dateTime, duration),
+    subtractWorkingTime: (dateTime, duration) => subtractWorkingTimeWith(hours, dateTime, duration),
+    workingTimeBetween: (start, end) => workingTimeBetweenWith(hours, start, end),
+    rollForwardToWorkingTime: (dateTime) => rollForwardToWorkingTimeWith(hours, dateTime),
+    rollBackwardToWorkingTime: (dateTime) => rollBackwardToWorkingTimeWith(hours, dateTime),
+    getWorkingHours: (date) => getWorkingHoursWith(hours, date)
   });
-  cache.set(frozen, compile(frozen));
+}
+function hasHours(options) {
+  return options.hours !== void 0;
+}
+function snapshotOptions(options) {
+  const copy = (value) => isIterable(value) ? Object.freeze(Array.from(value)) : value;
   return Object.freeze({
-    options: frozen,
-    isWorkday: (d) => isWorkday(d, frozen),
-    isWeekend: (d) => isWeekend(d, frozen),
-    isHoliday: (d) => isHoliday(d, frozen),
-    addWorkdays: (d, n) => addWorkdays(d, n, frozen),
-    subtractWorkdays: (d, n) => subtractWorkdays(d, n, frozen),
-    nextWorkday: (d) => nextWorkday(d, frozen),
-    previousWorkday: (d) => previousWorkday(d, frozen),
-    rollForward: (d) => rollForward(d, frozen),
-    rollBackward: (d) => rollBackward(d, frozen),
-    workdaysBetween: (a, b) => workdaysBetween(a, b, frozen),
-    eachWorkday: (a, b) => eachWorkday(a, b, frozen)
+    ...options,
+    weekend: copy(options.weekend),
+    holidays: copy(options.holidays),
+    extraWorkdays: copy(options.extraWorkdays)
   });
 }
 
+// src/date-holidays.ts
+var ENTRY_DATE_RE = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?: ([+-])(\d{2})(\d{2}))?$/;
+var DAY = BigInt(NS_PER_DAY);
+var SNAP = 90n * BigInt(NS_PER_MINUTE);
+function wallSpan(entry) {
+  const m = ENTRY_DATE_RE.exec(entry.date);
+  if (!m) throw rangeError(`unexpected date-holidays date ${describe(entry.date)}`);
+  const n = (i) => Number(m[i]);
+  const shiftSign = m[7] === "-" ? -1 : 1;
+  const shift = m[7] === void 0 ? 0 : shiftSign * (n(8) * NS_PER_HOUR + n(9) * NS_PER_MINUTE);
+  const timeNs = n(4) * NS_PER_HOUR + n(5) * NS_PER_MINUTE + n(6) * 1e9 + shift;
+  const start = BigInt(epochDayFromIso(n(1), n(2), n(3))) * DAY + BigInt(timeNs);
+  const durationMs = entry.end.getTime() - entry.start.getTime();
+  if (!Number.isFinite(durationMs) || durationMs <= 0) {
+    throw rangeError(`date-holidays entry ${describe(entry.date)} has no valid start/end`);
+  }
+  let end = start + BigInt(durationMs) * 1000000n;
+  const nearestMidnight = floorDiv(end + DAY / 2n, DAY) * DAY;
+  const distance = end - nearestMidnight;
+  if (distance !== 0n && distance > -SNAP && distance < SNAP) end = nearestMidnight;
+  return [start, end];
+}
+function addSpan(data, [start, end]) {
+  for (let day = floorDiv(start, DAY); day * DAY < end; day++) {
+    const dayStart = day * DAY;
+    const from = start > dayStart ? start - dayStart : 0n;
+    const to = end < dayStart + DAY ? end - dayStart : DAY;
+    const epochDay = Number(day);
+    if (from === 0n && to === DAY) {
+      data.full.add(epochDay);
+    } else {
+      const list = data.partial.get(epochDay) ?? [];
+      list.push([Number(from), Number(to)]);
+      data.partial.set(epochDay, list);
+    }
+  }
+}
+function fromDateHolidays(source, options = {}) {
+  if (typeof source?.getHolidays !== "function") {
+    throw typeError(`expected a date-holidays instance (with getHolidays), got ${describe(source)}`);
+  }
+  const typesOption = options.types ?? ["public"];
+  if (!Array.isArray(typesOption) || !typesOption.every((t) => typeof t === "string")) {
+    throw typeError(`types must be an array of strings, got ${describe(typesOption)}`);
+  }
+  const types = new Set(typesOption);
+  const loaded = /* @__PURE__ */ new Set();
+  const known = { full: /* @__PURE__ */ new Set(), partial: /* @__PURE__ */ new Map() };
+  const ensure = (date) => {
+    const iso = toIsoDate(date);
+    for (const year of [iso.year - 1, iso.year, iso.year + 1]) {
+      if (loaded.has(year)) continue;
+      loaded.add(year);
+      for (const entry of source.getHolidays(year)) {
+        if (types.has(entry.type)) addSpan(known, wallSpan(entry));
+      }
+    }
+    return epochDayOf(iso);
+  };
+  return {
+    holidays: (date) => known.full.has(ensure(date)),
+    specialHours: (date, regular) => {
+      const day = ensure(date);
+      if (known.full.has(day)) return void 0;
+      const closures = known.partial.get(day);
+      if (!closures) return void 0;
+      let open = parseDayHours(regular, "regular hours");
+      for (const [from, to] of closures) open = subtractInterval(open, from, to);
+      return formatDayHours(open);
+    }
+  };
+}
+
 exports.addWorkdays = addWorkdays;
+exports.addWorkingTime = addWorkingTime;
 exports.createWorkCalendar = createWorkCalendar;
 exports.eachWorkday = eachWorkday;
+exports.fromDateHolidays = fromDateHolidays;
+exports.getWorkingHours = getWorkingHours;
 exports.isHoliday = isHoliday;
 exports.isWeekend = isWeekend;
 exports.isWorkday = isWorkday;
+exports.isWorkingTime = isWorkingTime;
 exports.nextWorkday = nextWorkday;
 exports.previousWorkday = previousWorkday;
 exports.rollBackward = rollBackward;
+exports.rollBackwardToWorkingTime = rollBackwardToWorkingTime;
 exports.rollForward = rollForward;
+exports.rollForwardToWorkingTime = rollForwardToWorkingTime;
 exports.subtractWorkdays = subtractWorkdays;
+exports.subtractWorkingTime = subtractWorkingTime;
 exports.workdaysBetween = workdaysBetween;
+exports.workingTimeBetween = workingTimeBetween;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map