@northguild/gmt 1.19.0 → 1.20.0

package/dist/intermodal/format/formatEpcisEvent.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { formatUtcOffset, isObject, parseInstantNanoseconds, parseUtcOffsetNanoseconds, } from "../../internal/index.js";
 import { epcisEventTime, epcisTimeZoneOffset } from "../../regex/index.js";
 /**
@@ -37,7 +37,7 @@ import { epcisEventTime, epcisTimeZoneOffset } from "../../regex/index.js";
  * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "-05:00" }) // { eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "-05:00" }
  * @example formatEpcisEvent({ instant: "2024-06-15T09:30:00-05:00", offset: "-05:00" }) // { eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "-05:00" } (the instant is written in UTC)
  * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00.120Z", offset: "+05:45" }) // { eventTime: "2024-06-15T14:30:00.12Z", eventTimeZoneOffset: "+05:45" }
- * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "-04:00", timeZone: "America/New_York" }) // { eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "-04:00" } (EPCIS carries no zone)
+ * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "+05:30", timeZone: "Asia/Kolkata" }) // { eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "+05:30" } (EPCIS carries no zone)
  * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "-00:00" }) // { eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "+00:00" }
  * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "+14:30" }) // null (past the range GS1 allows)
  * @example formatEpcisEvent({ instant: "2024-06-15T14:30:00Z", offset: "+05:30:00" }) // null (GS1 offsets have no seconds)

package/dist/intermodal/index.d.ts

@@ -1,4 +1,4 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
 export * from "./format/index.js";
 export * from "./parse/index.js";

package/dist/intermodal/index.js

@@ -1,5 +1,5 @@
-// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
-export * from "@js-temporal/polyfill";
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
 export * from "./format/index.js";
 export * from "./parse/index.js";

package/dist/intermodal/parse/parseEpcisEvent.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { formatUtcOffset, isObject, parseUtcOffsetNanoseconds, wallClockAtOffset, } from "../../internal/index.js";
 import { epcisEventTime, epcisTimeZoneOffset } from "../../regex/index.js";
 /**

package/dist/intermodal/validate/isValidEpcisEventTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { epcisEventTime } from "../../regex/index.js";
 /**
  * Return true when `value` is a real GS1 EPCIS 2.0 `eventTime`: the moment a supply-chain event

package/dist/internal/advanceToWeekday.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 /**
  * Return the PlainDate for the next/previous occurrence of `dayOfWeek` relative to `date`.
  *

package/dist/internal/businessCalendar.d.ts

@@ -1,21 +1,28 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { BusinessCalendar } from "../types/index.js";
 /**
  * Calendar days a single business-day walk may step before giving up — roughly 547 years, far
  * past any real schedule. A walk that runs out returns the sentinel, never a partial answer.
  */
 export declare const MAX_BUSINESS_DAY_STEPS = 200000;
-/** A `BusinessCalendar` reduced to the two lookups every walk needs. */
+/** A `BusinessCalendar` reduced to the lookups every walk needs. */
 export type ResolvedBusinessCalendar = {
     weekend: Set<number>;
-    holidays: Set<string>;
+    /** Every holiday as an epoch day, sorted ascending, no repeats. */
+    holidays: Int32Array;
+    /** The holidays that fall on a working weekday: the only ones that change a count. */
+    closures: Int32Array;
 };
+/** Shared by every caller without a calendar: its arrays are empty and never mutated. */
 export declare const DEFAULT_BUSINESS_CALENDAR: ResolvedBusinessCalendar;
+/** Empty the holiday memo. Tests only. */
+export declare function clearHolidayMemo(): void;
 /**
- * Reduce a holiday list to its normalised ISO dates, or `null` when it is not an array of ISO
- * PlainDate strings. Shared with `OperatingSchedule.holidays`, which takes the same list.
+ * Reduce a holiday list to its epoch days, sorted ascending without repeats, or `null` when it
+ * is not an array of ISO PlainDate strings. Shared with `OperatingSchedule.holidays`, which
+ * takes the same list.
  */
-export declare function parseHolidays(holidays: unknown): Set<string> | null;
+export declare function parseHolidays(holidays: unknown): Int32Array | null;
 /**
  * Reduce a caller-supplied `BusinessCalendar` to its lookups, or `null` when it is not one.
  *
@@ -28,8 +35,16 @@ export declare function parseBusinessCalendar(calendar: unknown): ResolvedBusine
  * holidays, anything else must be a valid `BusinessCalendar` or this returns `null`.
  */
 export declare function resolveBusinessCalendar(calendar: BusinessCalendar | undefined): ResolvedBusinessCalendar | null;
-/** True when `date` is neither a weekend day nor a holiday in `calendar`. */
+/**
+ * True when `date` is neither a weekend day nor a holiday in `calendar`. `date` must be an
+ * ISO-calendar date: any other calendar throws a `RangeError`. Every caller passes a date it
+ * parsed from an ISO string or took from `toPlainDate()` of a zoned string parsed the same way.
+ */
 export declare function isBusinessDate(date: Temporal.PlainDate, calendar: ResolvedBusinessCalendar): boolean;
+/** True when `epochDay` is neither a weekend day nor a holiday on a working weekday. */
+export declare function isBusinessEpochDay(epochDay: number, calendar: ResolvedBusinessCalendar): boolean;
+/** Business days in [from, to] (epoch days, from <= to); 0 when from > to. */
+export declare function businessDaysWithin(from: number, to: number, calendar: ResolvedBusinessCalendar): number;
 /**
  * The first business day at or beyond `date`, walking in `direction`.
  *
@@ -42,10 +57,11 @@ export declare function businessDateFrom(date: Temporal.PlainDate, direction: 1
  * Step `count` business days from `date` in `direction`, counting only days that are business
  * days in `calendar`.
  *
- * `date` is an ISO-calendar date, as every caller validates. `count` is a non-negative whole
- * number of business days. `date` itself is never counted, so a `count` of 0 returns `date`
- * unchanged even when it is not a business day. Returns `null`
- * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and throws a `RangeError` when it passes a
- * Temporal range limit.
+ * `date` is an ISO-calendar date, as every caller validates. `date` itself is never counted, so
+ * a `count` of 0 returns `date` unchanged even when it is not a business day. Returns `null`
+ * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and for a `count` that is not a whole number
+ * of days or is negative or NaN: a fractional or infinite `count` still walks first, as the
+ * day-by-day loop did, so it throws the same `RangeError` when it passes a Temporal range limit
+ * before finishing. Throws a `RangeError` when any walk passes a Temporal range limit.
  */
 export declare function stepBusinessDates(date: Temporal.PlainDate, direction: 1 | -1, count: number, calendar: ResolvedBusinessCalendar): Temporal.PlainDate | null;

package/dist/internal/businessCalendar.js

@@ -1,9 +1,8 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { isValidDate } from "../plain/validate/isValidDate.js";
 import { isValidTimeZone } from "../zoned/validate/isValidTimeZone.js";
 import { isObject } from "./isObject.js";
-import { isoYearString } from "./isoYearString.js";
-const ISO_WEEKDAYS = 7;
+import { countWithin, epochDayOfDate, hasEpochDay, isoFieldsOf, ISO_WEEKDAYS, isoWeekdayOf, MAX_EPOCH_DAY, MIN_EPOCH_DAY, sortedUnique, } from "./epochDay.js";
 /**
  * The weekend GMT assumed before calendars existed: Saturday and Sunday, no holidays. It is
  * what `isBusinessDay`, `addBusinessDays` and `subtractBusinessDays` use when no calendar is
@@ -15,9 +14,11 @@ const DEFAULT_WEEKEND = [6, 7];
  * past any real schedule. A walk that runs out returns the sentinel, never a partial answer.
  */
 export const MAX_BUSINESS_DAY_STEPS = 200_000;
+/** Shared by every caller without a calendar: its arrays are empty and never mutated. */
 export const DEFAULT_BUSINESS_CALENDAR = {
     weekend: new Set(DEFAULT_WEEKEND),
-    holidays: new Set(),
+    holidays: new Int32Array(0),
+    closures: new Int32Array(0),
 };
 function parseWeekend(weekend) {
     if (!Array.isArray(weekend)) {
@@ -31,28 +32,61 @@ function parseWeekend(weekend) {
     // All seven weekdays closed leaves no business day, so every walk would run to its cap.
     return days.size < ISO_WEEKDAYS ? days : null;
 }
+/** Most raw holiday strings the memo keeps before it starts over. */
+const HOLIDAY_MEMO_LIMIT = 65_536;
 /**
- * Reduce a holiday list to its normalised ISO dates, or `null` when it is not an array of ISO
- * PlainDate strings. Shared with `OperatingSchedule.holidays`, which takes the same list.
+ * Raw holiday string to its epoch day. Only valid strings are stored: `isValidDate` and
+ * `PlainDate.from` on an ISO string are pure functions of the string, so a hit is always
+ * right and clearing the map costs speed, never correctness.
+ */
+const holidayMemo = new Map();
+/** Empty the holiday memo. Tests only. */
+export function clearHolidayMemo() {
+    holidayMemo.clear();
+}
+/** The epoch day of an ISO holiday string, or `null` when it is not one. */
+function holidayEpochDay(holiday) {
+    if (typeof holiday !== "string") {
+        return null;
+    }
+    const known = holidayMemo.get(holiday);
+    if (known !== undefined) {
+        return known;
+    }
+    if (!isValidDate(holiday)) {
+        return null;
+    }
+    const epochDay = epochDayOfDate(Temporal.PlainDate.from(holiday));
+    if (holidayMemo.size >= HOLIDAY_MEMO_LIMIT) {
+        holidayMemo.clear();
+    }
+    holidayMemo.set(holiday, epochDay);
+    return epochDay;
+}
+/**
+ * Reduce a holiday list to its epoch days, sorted ascending without repeats, or `null` when it
+ * is not an array of ISO PlainDate strings. Shared with `OperatingSchedule.holidays`, which
+ * takes the same list.
  */
 export function parseHolidays(holidays) {
     if (!Array.isArray(holidays)) {
         return null;
     }
-    const dates = new Set();
+    // Grown element by element so a bad entry is rejected before any list-sized allocation.
+    const days = [];
     try {
-        for (const holiday of holidays) {
-            if (typeof holiday !== "string" || !isValidDate(holiday)) {
+        for (let index = 0; index < holidays.length; index++) {
+            const epochDay = holidayEpochDay(holidays[index]);
+            if (epochDay === null) {
                 return null;
             }
-            // Normalise through Temporal so a holiday and a walked date compare as the same string.
-            dates.add(Temporal.PlainDate.from(holiday).toString());
+            days.push(epochDay);
         }
     }
     catch {
         return null;
     }
-    return dates;
+    return sortedUnique(Int32Array.from(days));
 }
 /**
  * Reduce a caller-supplied `BusinessCalendar` to its lookups, or `null` when it is not one.
@@ -73,7 +107,8 @@ export function parseBusinessCalendar(calendar) {
     if (weekendDays === null || holidayDates === null) {
         return null;
     }
-    return { weekend: weekendDays, holidays: holidayDates };
+    const closures = holidayDates.filter((day) => !weekendDays.has(isoWeekdayOf(day)));
+    return { weekend: weekendDays, holidays: holidayDates, closures };
 }
 /**
  * Resolve an optional calendar: absent means the default Saturday–Sunday week with no
@@ -84,96 +119,39 @@ export function resolveBusinessCalendar(calendar) {
         ? DEFAULT_BUSINESS_CALENDAR
         : parseBusinessCalendar(calendar);
 }
-/** True when `date` is neither a weekend day nor a holiday in `calendar`. */
+/**
+ * True when `date` is neither a weekend day nor a holiday in `calendar`. `date` must be an
+ * ISO-calendar date: any other calendar throws a `RangeError`. Every caller passes a date it
+ * parsed from an ISO string or took from `toPlainDate()` of a zoned string parsed the same way.
+ */
 export function isBusinessDate(date, calendar) {
-    return (!calendar.weekend.has(date.dayOfWeek) &&
-        !calendar.holidays.has(date.toString()));
+    return isBusinessEpochDay(epochDayOfDate(date), calendar);
 }
 /*
  * The walks step whole days as integers — days since 1970-01-01 — rather than PlainDates: a walk
  * to the 200,000-day cap through the polyfill's `add`, `dayOfWeek` and `toString` took seconds.
  * Only the date a walk returns is built as a Temporal object.
  */
-/**
- * TC39 `ISODateWithinLimits`: -271821-04-19 and +275760-09-13, counted in days from 1970-01-01,
- * are the first and last dates a PlainDate holds.
- */
-const MIN_EPOCH_DAY = -100_000_001;
-const MAX_EPOCH_DAY = 100_000_000;
-/** 1970-01-01 was a Thursday, ISO weekday 4. */
-const EPOCH_WEEKDAY_OFFSET = 3;
-/** Days in a 400-year cycle of the proleptic Gregorian calendar. */
-const DAYS_PER_400_YEARS = 146_097;
-/** Days from 0000-03-01, the start of a March-based year, to 1970-01-01. */
-const DAYS_FROM_MARCH_0000_TO_EPOCH = 719_468;
-/**
- * Days from 1970-01-01 to an ISO date, in the proleptic Gregorian calendar of ECMA-262 §21.4.1
- * that Temporal's ISO calendar extends. Years run from March so the leap day ends each one.
- */
-function epochDayOf(year, month, day) {
-    const marchYear = month <= 2 ? year - 1 : year;
-    const cycle = Math.floor(marchYear / 400);
-    const yearOfCycle = marchYear - cycle * 400;
-    const dayOfYear = Math.floor((153 * ((month + 9) % 12) + 2) / 5) + day - 1;
-    const dayOfCycle = yearOfCycle * 365 +
-        Math.floor(yearOfCycle / 4) -
-        Math.floor(yearOfCycle / 100) +
-        dayOfYear;
-    return (cycle * DAYS_PER_400_YEARS + dayOfCycle - DAYS_FROM_MARCH_0000_TO_EPOCH);
-}
-/** The ISO year, month and day `epochDay` days from 1970-01-01 — `epochDayOf` inverted. */
-function isoFieldsOf(epochDay) {
-    const shifted = epochDay + DAYS_FROM_MARCH_0000_TO_EPOCH;
-    const cycle = Math.floor(shifted / DAYS_PER_400_YEARS);
-    const dayOfCycle = shifted - cycle * DAYS_PER_400_YEARS;
-    // Remove the leap days of every 4th, 100th and 400th year before dividing into 365-day years.
-    const yearOfCycle = Math.floor((dayOfCycle -
-        Math.floor(dayOfCycle / 1460) +
-        Math.floor(dayOfCycle / 36_524) -
-        Math.floor(dayOfCycle / (DAYS_PER_400_YEARS - 1))) /
-        365);
-    const dayOfYear = dayOfCycle -
-        (365 * yearOfCycle +
-            Math.floor(yearOfCycle / 4) -
-            Math.floor(yearOfCycle / 100));
-    const monthFromMarch = Math.floor((5 * dayOfYear + 2) / 153);
-    const day = dayOfYear - Math.floor((153 * monthFromMarch + 2) / 5) + 1;
-    const month = monthFromMarch < 10 ? monthFromMarch + 3 : monthFromMarch - 9;
-    const year = yearOfCycle + cycle * 400 + (month <= 2 ? 1 : 0);
-    return [year, month, day];
+/** True when `epochDay` is neither a weekend day nor a holiday on a working weekday. */
+export function isBusinessEpochDay(epochDay, calendar) {
+    return (!calendar.weekend.has(isoWeekdayOf(epochDay)) &&
+        !hasEpochDay(calendar.closures, epochDay));
 }
-/** `Temporal.PlainDate#toString` for an ISO date, which is how `holidays` stores its dates. */
-function isoDateString(epochDay) {
-    const [year, month, day] = isoFieldsOf(epochDay);
-    return `${isoYearString(year)}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
-}
-/**
- * Days from 1970-01-01 to `date`, an ISO-calendar date. Any other calendar throws a
- * `RangeError`, which callers turn into their sentinel: its year, month and day are not ISO
- * fields, so the arithmetic below would silently walk from the wrong day.
- */
-function epochDayOfDate(date) {
-    if (date.calendarId !== "iso8601") {
-        throw new RangeError("business-day walks take an ISO-calendar date");
+/** Business days in [from, to] (epoch days, from <= to); 0 when from > to. */
+export function businessDaysWithin(from, to, calendar) {
+    if (from > to) {
+        return 0;
     }
-    return epochDayOf(date.year, date.month, date.day);
-}
-function isBusinessEpochDay(epochDay, calendar) {
-    // `%` keeps the dividend's sign, so a date before 1970 needs the second `+ ISO_WEEKDAYS`.
-    const weekday = ((((epochDay + EPOCH_WEEKDAY_OFFSET) % ISO_WEEKDAYS) + ISO_WEEKDAYS) %
-        ISO_WEEKDAYS) +
-        1;
-    return (!calendar.weekend.has(weekday) &&
-        (calendar.holidays.size === 0 ||
-            !calendar.holidays.has(isoDateString(epochDay))));
-}
-/** One day on from `epochDay`, throwing the `RangeError` `PlainDate#add` throws past a limit. */
-function nextEpochDay(epochDay, direction) {
-    const next = epochDay + direction;
-    if (next < MIN_EPOCH_DAY || next > MAX_EPOCH_DAY) {
-        throw new RangeError("date/time value is outside of supported range");
+    const days = to - from + 1;
+    const wholeWeeks = Math.floor(days / ISO_WEEKDAYS);
+    let count = wholeWeeks * (ISO_WEEKDAYS - calendar.weekend.size);
+    // At most six days are left over once whole weeks are taken off.
+    for (let day = from + wholeWeeks * ISO_WEEKDAYS; day <= to; day++) {
+        if (!calendar.weekend.has(isoWeekdayOf(day))) {
+            count += 1;
+        }
     }
-    return next;
+    return count - countWithin(calendar.closures, from, to);
 }
 /** The walked-to date; `date` itself when the walk never moved. */
 function dateAt(date, startEpochDay, epochDay) {
@@ -183,6 +161,42 @@ function dateAt(date, startEpochDay, epochDay) {
     const [year, month, day] = isoFieldsOf(epochDay);
     return new Temporal.PlainDate(year, month, day);
 }
+/** Business days among the days `fromOffset` to `toOffset` away from `start` in `direction`. */
+function businessDaysInOffsetRange(start, direction, fromOffset, toOffset, calendar) {
+    return direction === 1
+        ? businessDaysWithin(start + fromOffset, start + toOffset, calendar)
+        : businessDaysWithin(start - toOffset, start - fromOffset, calendar);
+}
+/**
+ * The smallest distance `k` from `start`, at least `firstOffset`, whose span of days
+ * `firstOffset`..`k` holds `target` business days; the walk reaches at most `MAX_BUSINESS_DAY_STEPS`
+ * days out. Gives up as the day-by-day walk did: a `RangeError` when it would have stepped past a
+ * Temporal limit first, `null` when it ran out of steps.
+ */
+function distanceToNthBusinessDay(start, direction, firstOffset, target, calendar) {
+    const limitDistance = direction === 1 ? MAX_EPOCH_DAY - start : start - MIN_EPOCH_DAY;
+    const lastOffset = Math.min(MAX_BUSINESS_DAY_STEPS, limitDistance);
+    if (businessDaysInOffsetRange(start, direction, firstOffset, lastOffset, calendar) < target) {
+        if (MAX_BUSINESS_DAY_STEPS > limitDistance) {
+            throw new RangeError("date/time value is outside of supported range");
+        }
+        return null;
+    }
+    let low = firstOffset;
+    let high = lastOffset;
+    // The count rises by at most one a day, so the smallest offset reaching `target` holds
+    // exactly `target`.
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (businessDaysInOffsetRange(start, direction, firstOffset, middle, calendar) >= target) {
+            high = middle;
+        }
+        else {
+            low = middle + 1;
+        }
+    }
+    return low;
+}
 /**
  * The first business day at or beyond `date`, walking in `direction`.
  *
@@ -192,38 +206,35 @@ function dateAt(date, startEpochDay, epochDay) {
  */
 export function businessDateFrom(date, direction, calendar) {
     const start = epochDayOfDate(date);
-    let current = start;
-    // `step` counts calendar days moved, exactly as it does in `stepBusinessDates`, so both
-    // walks give up at the same distance — the 200,000 the public JSDoc quotes.
-    for (let step = 0; step < MAX_BUSINESS_DAY_STEPS; step++) {
-        if (isBusinessEpochDay(current, calendar)) {
-            return dateAt(date, start, current);
-        }
-        current = nextEpochDay(current, direction);
-    }
-    return isBusinessEpochDay(current, calendar)
-        ? dateAt(date, start, current)
-        : null;
+    const distance = distanceToNthBusinessDay(start, direction, 0, 1, calendar);
+    return distance === null
+        ? null
+        : dateAt(date, start, start + direction * distance);
 }
 /**
  * Step `count` business days from `date` in `direction`, counting only days that are business
  * days in `calendar`.
  *
- * `date` is an ISO-calendar date, as every caller validates. `count` is a non-negative whole
- * number of business days. `date` itself is never counted, so a `count` of 0 returns `date`
- * unchanged even when it is not a business day. Returns `null`
- * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and throws a `RangeError` when it passes a
- * Temporal range limit.
+ * `date` is an ISO-calendar date, as every caller validates. `date` itself is never counted, so
+ * a `count` of 0 returns `date` unchanged even when it is not a business day. Returns `null`
+ * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and for a `count` that is not a whole number
+ * of days or is negative or NaN: a fractional or infinite `count` still walks first, as the
+ * day-by-day loop did, so it throws the same `RangeError` when it passes a Temporal range limit
+ * before finishing. Throws a `RangeError` when any walk passes a Temporal range limit.
  */
 export function stepBusinessDates(date, direction, count, calendar) {
     const start = epochDayOfDate(date);
-    let current = start;
-    let remaining = count;
-    for (let step = 0; step < MAX_BUSINESS_DAY_STEPS && remaining > 0; step++) {
-        current = nextEpochDay(current, direction);
-        if (isBusinessEpochDay(current, calendar)) {
-            remaining -= 1;
-        }
+    if (count === 0) {
+        return date;
+    }
+    // A negative or NaN count names no business day and walks nowhere.
+    if (!(count > 0)) {
+        return null;
     }
-    return remaining === 0 ? dateAt(date, start, current) : null;
+    // A fractional count names no date, but walks to its next whole number first: one that runs past
+    // the range limit throws, as a whole count does.
+    const distance = distanceToNthBusinessDay(start, direction, 1, Math.ceil(count), calendar);
+    return distance === null || !Number.isInteger(count)
+        ? null
+        : dateAt(date, start, start + direction * distance);
 }

package/dist/internal/businessDayValues.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { parseBusinessCalendar, resolveBusinessCalendar, stepBusinessDates, } from "./businessCalendar.js";
 import { isValidAmount } from "./isValidAmount.js";
 import { isValidDate } from "../plain/validate/isValidDate.js";

package/dist/internal/calendarDatePairPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 import type { CalendarSystem } from "../types/index.js";
 export interface CalendarDatePair {
     calendar: CalendarSystem;

package/dist/internal/calendarDateString.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 /**
  * Second `60` in the time of day, before any `[`: `T`, `t` or space separator, extended or basic
  * digits. Temporal's ParseISODateTime clamps it to `:59`; GMT's Plain date-time inputs reject it

package/dist/internal/calendarDateString.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { plainDate } from "../regex/date.js";
 import { plainDateTime } from "../regex/date-time.js";
 import { canonicalCalendarSystem, computationCalendarId, } from "./calendarSystemIds.js";

package/dist/internal/calendarSystemIds.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 /**
  * Every `CalendarSystem`, by canonical calendar id: the CLDR `common/bcp47/calendar.xml` type,
  * which is also what Temporal's `CanonicalizeCalendar` returns and what RFC 9557's `[u-ca=<id>]`

package/dist/internal/calendarValueOfDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { canonicalCalendarSystem } from "./calendarSystemIds.js";
 import { hasCalendarAnnotation } from "./hasCalendarAnnotation.js";
 /**

package/dist/internal/calendarZonedPairPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 import type { CalendarSystem } from "../types/index.js";
 export interface CalendarZonedPair {
     calendar: CalendarSystem;

package/dist/internal/calendarZonedString.d.ts

@@ -1,8 +1,8 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 import type { CalendarSystem, Disambiguation, Offset } from "../types/index.js";
 /**
  * Parse a GMT ZonedDateTime string into a Temporal.ZonedDateTime, read exactly as
- * `Temporal.ZonedDateTime.from` reads it (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`,
+ * `Temporal.ZonedDateTime.from` reads it (`"2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]"`,
  * which is what `Temporal.ZonedDateTime#toString()` writes). Throws on invalid input — callers wrap
  * this in try-catch per GMT's sentinel contract.
  *
@@ -23,7 +23,7 @@ import type { CalendarSystem, Disambiguation, Offset } from "../types/index.js";
  * - The result computes in `computationCalendarId(calendar)` (`"ethioaa"` for `"ethiopic"` and
  *   `"coptic"`), so callers that write a string back take the calendar from
  *   `calendarSystemOfZonedValue(value)`.
- * - `isLeapSecond` runs first: `Temporal.ZonedDateTime.from("2024-06-30T23:59:60+00:00[UTC]")`
+ * - `hasSecond60` runs first: `Temporal.ZonedDateTime.from("2024-06-30T23:59:60+00:00[UTC]")`
  *   clamps to `:59` instead of throwing.
  *
  * @param value ISO zoned datetime string, optionally with RFC 9557 annotations after the zone

package/dist/internal/calendarZonedString.js

@@ -1,10 +1,10 @@
-import { isLeapSecond } from "../plain/validate/isLeapSecond.js";
+import { hasSecond60 } from "../plain/validate/hasSecond60.js";
 import { canonicalCalendarSystem, computationCalendarId, } from "./calendarSystemIds.js";
 import { hasZonedDateTimeShape } from "./isoStringBody.js";
 import { zonedDateTimeFrom } from "./zonedWallClock.js";
 /**
  * Parse a GMT ZonedDateTime string into a Temporal.ZonedDateTime, read exactly as
- * `Temporal.ZonedDateTime.from` reads it (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`,
+ * `Temporal.ZonedDateTime.from` reads it (`"2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]"`,
  * which is what `Temporal.ZonedDateTime#toString()` writes). Throws on invalid input — callers wrap
  * this in try-catch per GMT's sentinel contract.
  *
@@ -25,7 +25,7 @@ import { zonedDateTimeFrom } from "./zonedWallClock.js";
  * - The result computes in `computationCalendarId(calendar)` (`"ethioaa"` for `"ethiopic"` and
  *   `"coptic"`), so callers that write a string back take the calendar from
  *   `calendarSystemOfZonedValue(value)`.
- * - `isLeapSecond` runs first: `Temporal.ZonedDateTime.from("2024-06-30T23:59:60+00:00[UTC]")`
+ * - `hasSecond60` runs first: `Temporal.ZonedDateTime.from("2024-06-30T23:59:60+00:00[UTC]")`
  *   clamps to `:59` instead of throwing.
  *
  * @param value ISO zoned datetime string, optionally with RFC 9557 annotations after the zone
@@ -34,7 +34,7 @@ import { zonedDateTimeFrom } from "./zonedWallClock.js";
  * @returns Temporal.ZonedDateTime in the computation calendar (`iso8601` when unannotated)
  */
 export function parseCalendarZonedValue(value, options) {
-    if (isLeapSecond(value)) {
+    if (hasSecond60(value)) {
         throw new RangeError(`Leap seconds are not supported: ${value}`);
     }
     if (!hasZonedDateTimeShape(value)) {

package/dist/internal/compareUnixEpochs.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { resolveUnixEpochUnit, unixEpochToInstant } from "./unixEpochValue.js";
 /**
  * Compare two unix epoch values as instants, for the unix comparison predicates.

package/dist/internal/cutoffAtResolved.d.ts

@@ -0,0 +1,62 @@
+import { Temporal } from "./temporal.js";
+import { type ResolvedBusinessCalendar } from "./businessCalendar.js";
+import { type ZoneFrame } from "./zoneFrame.js";
+import type { RollConvention } from "../types/index.js";
+/**
+ * What every cut-off in a stack shares: the zone it is read in and, when it rolls, the parsed
+ * calendar and the convention. `rolling` is present exactly when a calendar and a convention
+ * are.
+ */
+export type SharedCutoffOptions = {
+    timeZone: string;
+    /** The zone built once, so a wall time never re-parses it. */
+    frame: ZoneFrame;
+    rolling: {
+        calendar: ResolvedBusinessCalendar;
+        roll: RollConvention;
+    } | null;
+};
+/**
+ * Validate the options a whole stack shares, parsing the calendar once.
+ *
+ * @param timeZone the zone the cut-offs are read in
+ * @param calendar the working week and holidays, or `undefined`
+ * @param roll the roll convention, or `undefined`
+ * @returns the shared options, or `null` when any is invalid, or only one of `calendar` and
+ * `roll` is given (no standard supplies either one by default)
+ *
+ * @example resolveSharedCutoffOptions("Europe/Amsterdam", undefined, undefined) // { timeZone: "Europe/Amsterdam", rolling: null }
+ * @example resolveSharedCutoffOptions("Europe/Amsterdam", undefined, "preceding") // null (a roll needs a calendar)
+ * @example resolveSharedCutoffOptions("Not/AZone", undefined, undefined) // null
+ */
+export declare function resolveSharedCutoffOptions(timeZone: unknown, calendar: unknown, roll: unknown): SharedCutoffOptions | null;
+/**
+ * Validate an entry's local time of day.
+ *
+ * @param atLocalTime the local time of day, or `undefined` for none
+ * @returns `{ time }` (`time` is `null` for none), or `null` when it is not a valid time
+ *
+ * @example resolveCutoffTime("17:00") // { time: PlainTime 17:00 }
+ * @example resolveCutoffTime(undefined) // { time: null }
+ * @example resolveCutoffTime("25:00") // null
+ */
+export declare function resolveCutoffTime(atLocalTime: unknown): {
+    time: Temporal.PlainTime | null;
+} | null;
+/**
+ * One cut-off over options already validated: the deadline `duration` before `anchor`, as
+ * `cutoffAt` defines it.
+ *
+ * @param anchor the event the deadline counts back from
+ * @param duration the offset before the anchor
+ * @param atLocalTime the local time of day to pin to, or `null` for none
+ * @param shared the zone and roll the whole stack shares
+ * @returns the cut-off as a zoned string and its epoch nanoseconds, or `null` when it falls in
+ * a skipped local hour or the roll runs out
+ *
+ * @example cutoffAtResolved(Temporal.Instant.from("2024-06-14T16:00:00Z"), Temporal.Duration.from("P2D"), Temporal.PlainTime.from("17:00"), { timeZone: "Europe/Amsterdam", rolling: null })?.text // "2024-06-12T17:00:00+02:00[Europe/Amsterdam]"
+ */
+export declare function cutoffAtResolved(anchor: Temporal.Instant, duration: Temporal.Duration, atLocalTime: Temporal.PlainTime | null, shared: SharedCutoffOptions): {
+    text: string;
+    ns: bigint;
+} | null;