@northguild/gmt 1.19.0 → 1.20.0

package/dist/internal/zonedLocalDates.js

@@ -1,15 +1,14 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { zonedNextTransition } from "./zonedWallClockOperations.js";
-const UNIX_EPOCH_DATE = new Temporal.PlainDate(1970, 1, 1);
+import { floorDivide } from "./floorDivide.js";
+import { NANOSECONDS_PER_DAY } from "./foreignEpochs.js";
+import { offsetTimeline } from "./offsetTimeline.js";
 /**
  * Transitions walked while collecting local dates, matching `countZonedBuckets`' cap: roughly
  * 5,000 years of twice-yearly daylight saving; a longer walk answers with the sentinel.
  */
 const MAX_WALKED_TRANSITIONS = 10_000;
-function epochDayOf(zoned) {
-    return UNIX_EPOCH_DATE.until(zoned.toPlainDate().withCalendar("iso8601"), {
-        largestUnit: "days",
-    }).days;
+/** The local date, in days from 1970-01-01, of an instant at `offset` east of UTC. */
+function localDay(ns, offset) {
+    return Number(floorDivide(ns + offset, NANOSECONDS_PER_DAY));
 }
 /** Size of the union of inclusive integer ranges. */
 function unionSize(ranges) {
@@ -41,18 +40,22 @@ function unionSize(ranges) {
  * @returns the number of distinct local dates, or null past `MAX_WALKED_TRANSITIONS` transitions
  */
 export function countZonedLocalDates(start, end) {
+    const timeline = offsetTimeline({ timeZone: start.timeZoneId, shiftNanoseconds: 0n }, start.epochNanoseconds, end.epochNanoseconds, MAX_WALKED_TRANSITIONS);
+    if (timeline === null) {
+        return null;
+    }
+    const { changes, offsets } = timeline;
+    const endNs = end.epochNanoseconds;
     const ranges = [];
-    let runStart = start;
-    for (let i = 0; i <= MAX_WALKED_TRANSITIONS; i++) {
-        const transition = zonedNextTransition(runStart, end.epochNanoseconds);
-        const isLastRun = transition === null ||
-            Temporal.ZonedDateTime.compare(transition, end) > 0;
-        const runEnd = isLastRun ? end : transition.subtract({ nanoseconds: 1 });
-        ranges.push([epochDayOf(runStart), epochDayOf(runEnd)]);
-        if (isLastRun) {
-            return unionSize(ranges);
-        }
-        runStart = transition;
+    let runStart = start.epochNanoseconds;
+    // One stretch per offset change in the span, which the cap above bounds.
+    for (let index = 0; index <= changes.length; index++) {
+        const runEnd = index === changes.length ? endNs : changes[index] - 1n;
+        ranges.push([
+            localDay(runStart, offsets[index]),
+            localDay(runEnd, offsets[index]),
+        ]);
+        runStart = changes[index];
     }
-    return null;
+    return unionSize(ranges);
 }

package/dist/internal/zonedNowUnitValue.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 /**
  * One field of a zoned "now" as the `get*NowUnit` accessors return it: zero-padded to two digits
  * (three for sub-second fields), the day of week unpadded, and the year as Temporal writes one

package/dist/internal/zonedNowUnitValue.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { isoYearString } from "./isoYearString.js";
 /**
  * One field of a zoned "now" as the `get*NowUnit` accessors return it: zero-padded to two digits

package/dist/internal/zonedTransitionSearch.d.ts

@@ -3,6 +3,8 @@
  * one zone, 601,200 s in tz 2026c (`zdump -v`, America/Boa_Vista 2000-10-08 to 2000-10-15).
  */
 export declare const TRANSITION_SEARCH_STEP_NANOSECONDS: bigint;
+/** Forget every remembered span. Internal; tests call it to start from a cold memo. */
+export declare function clearTransitionMemo(): void;
 /**
  * TC39 `GetNamedTimeZoneNextTransition`: the first offset change strictly after `from`.
  *

package/dist/internal/zonedTransitionSearch.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { MAX_EPOCH_NANOSECONDS, MIN_EPOCH_NANOSECONDS, } from "./epochNanoseconds.js";
 import { POLYFILL_TRANSITION_SEARCH_FLOOR, missedNextTransition, missedPreviousTransition, offsetAt, transitionBetween, } from "./zonedWallClock.js";
 /*
@@ -101,6 +101,89 @@ function changeBetween(timeZone, low, high, lowOffset, highOffset) {
     }
     return transitionBetween(timeZone, low, high, highOffset);
 }
+/** Zones remembered; the oldest is dropped past this. */
+const MAX_MEMO_ZONES = 64;
+/** Changes remembered per zone; past this the zone's facts are cleared. */
+const MAX_MEMO_CHANGES = 4_096;
+/** Spans remembered per zone; past this the zone's facts are cleared. */
+const MAX_MEMO_SPANS = 256;
+const transitionMemo = new Map();
+/** Forget every remembered span. Internal; tests call it to start from a cold memo. */
+export function clearTransitionMemo() {
+    transitionMemo.clear();
+}
+/** Two sorted arrays merged into one sorted array, a value in both kept once. */
+function mergeSorted(a, b) {
+    const merged = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        const left = a[i];
+        const right = b[j];
+        if (left < right) {
+            merged.push(left);
+            i++;
+        }
+        else if (left > right) {
+            merged.push(right);
+            j++;
+        }
+        else {
+            merged.push(left);
+            i++;
+            j++;
+        }
+    }
+    while (i < a.length)
+        merged.push(a[i++]);
+    while (j < b.length)
+        merged.push(b[j++]);
+    return merged;
+}
+/** Remember that (low, high] changes offset exactly at `changes` and nowhere else. */
+function recordSpan(timeZone, low, high, changes) {
+    if (low >= high)
+        return;
+    let facts = transitionMemo.get(timeZone);
+    if (facts === undefined) {
+        if (transitionMemo.size >= MAX_MEMO_ZONES) {
+            const oldest = transitionMemo.keys().next();
+            if (!oldest.done)
+                transitionMemo.delete(oldest.value);
+        }
+        facts = { spans: [] };
+        transitionMemo.set(timeZone, facts);
+    }
+    // Spans are sorted and disjoint, so those this one overlaps or touches are one run.
+    let mergedLow = low;
+    let mergedHigh = high;
+    let mergedChanges = changes;
+    const kept = [];
+    const after = [];
+    for (const span of facts.spans) {
+        if (span.high < low) {
+            kept.push(span);
+        }
+        else if (span.low > high) {
+            after.push(span);
+        }
+        else {
+            mergedLow = minimum(mergedLow, span.low);
+            mergedHigh = maximum(mergedHigh, span.high);
+            mergedChanges = mergeSorted(mergedChanges, span.changes);
+        }
+    }
+    kept.push({ low: mergedLow, high: mergedHigh, changes: mergedChanges });
+    kept.push(...after);
+    const total = kept.reduce((sum, span) => sum + span.changes.length, 0);
+    facts.spans =
+        kept.length > MAX_MEMO_SPANS || total > MAX_MEMO_CHANGES
+            ? [{ low, high, changes: [...changes] }]
+            : kept;
+}
+function spanAround(timeZone, holds) {
+    return transitionMemo.get(timeZone)?.spans.find(holds);
+}
 function currentEpochNanoseconds() {
     return Temporal.Now.instant().epochNanoseconds;
 }
@@ -116,10 +199,13 @@ function currentEpochNanoseconds() {
  */
 export function nextTransitionAfter(timeZone, from, until) {
     // The horizon holds with or without a limit, as it does when the polyfill answers and the
-    // limit only filters its result.
-    const horizon = maximum(from, currentEpochNanoseconds()) +
-        NO_FURTHER_TRANSITION_HORIZON_NANOSECONDS;
-    const end = minimum(MAX_EPOCH_NANOSECONDS, until === undefined ? horizon : minimum(until, horizon));
+    // limit only filters its result. It is at least `from` plus the horizon span, so a limit within
+    // that span is never cut by it and the clock is not read.
+    const end = minimum(MAX_EPOCH_NANOSECONDS, until !== undefined &&
+        until <= from + NO_FURTHER_TRANSITION_HORIZON_NANOSECONDS
+        ? until
+        : minimum(until ?? MAX_EPOCH_NANOSECONDS, maximum(from, currentEpochNanoseconds()) +
+            NO_FURTHER_TRANSITION_HORIZON_NANOSECONDS));
     if (from >= end)
         return null;
     let low = from;
@@ -131,34 +217,97 @@ export function nextTransitionAfter(timeZone, from, until) {
             return null;
         low = POLYFILL_TRANSITION_SEARCH_FLOOR;
     }
+    return sampledNext(timeZone, low, end);
+}
+/** The first change in `(low, end]`, answered from the memo where it can be, else sampled. */
+function sampledNext(timeZone, from, end) {
+    // A cold search takes at most MAX_SEARCH_STEPS steps from `from`, so it reaches `cutoff`, and
+    // throws when `end` lies past it with no change before it. The memo answers the same: what it
+    // knows is never allowed to carry a search past a bound the cold search would stop at.
+    const cutoff = from + BigInt(MAX_SEARCH_STEPS) * TRANSITION_SEARCH_STEP_NANOSECONDS;
+    let low = from;
+    const known = spanAround(timeZone, (span) => span.low <= low && low < span.high);
+    if (known !== undefined) {
+        const change = known.changes.find((c) => c > low);
+        if (change !== undefined) {
+            if (change <= minimum(end, cutoff))
+                return change;
+            if (end <= cutoff)
+                return null;
+            throw outOfSteps(timeZone);
+        }
+        if (known.high >= end) {
+            if (end <= cutoff)
+                return null;
+            throw outOfSteps(timeZone);
+        }
+        low = known.high;
+        if (low >= cutoff)
+            throw outOfSteps(timeZone);
+    }
+    const searchStart = low;
     const lowOffset = offsetAt(timeZone, low);
-    for (let i = 0; i < MAX_SEARCH_STEPS; i++) {
-        const high = minimum(low + TRANSITION_SEARCH_STEP_NANOSECONDS, end);
+    while (low < cutoff) {
+        const high = minimum(minimum(low + TRANSITION_SEARCH_STEP_NANOSECONDS, end), cutoff);
         const highOffset = offsetAt(timeZone, high);
         if (highOffset !== lowOffset) {
-            return changeBetween(timeZone, low, high, lowOffset, highOffset);
+            const change = changeBetween(timeZone, low, high, lowOffset, highOffset);
+            recordSpan(timeZone, searchStart, change, [change]);
+            return change;
         }
-        if (high >= end)
+        if (high >= end) {
+            recordSpan(timeZone, searchStart, end, []);
             return null;
+        }
         low = high;
     }
-    throw new RangeError(`Transition search in ${timeZone} ran past its bound`);
+    throw outOfSteps(timeZone);
+}
+function outOfSteps(timeZone) {
+    return new RangeError(`Transition search in ${timeZone} ran past its bound`);
 }
 /** The last change in `(since, start]`, scanning back from `start`; null when there is none. */
 function lastChangeBack(timeZone, start, since) {
+    // As in `sampledNext`: a cold search runs MAX_SEARCH_STEPS steps down from `start`, and reaches
+    // `since` (null) only if that takes fewer than MAX_SEARCH_STEPS of them.
+    const cutoff = start - BigInt(MAX_SEARCH_STEPS) * TRANSITION_SEARCH_STEP_NANOSECONDS;
+    const reachesSince = start - since <=
+        BigInt(MAX_SEARCH_STEPS - 1) * TRANSITION_SEARCH_STEP_NANOSECONDS;
     let high = start;
-    const highOffset = offsetAt(timeZone, high);
-    for (let i = 0; i < MAX_SEARCH_STEPS; i++) {
-        if (high <= since)
+    const known = spanAround(timeZone, (span) => span.low < start && start <= span.high);
+    if (known !== undefined) {
+        const change = known.changes.filter((c) => c <= start).pop();
+        if (change !== undefined && change > maximum(since, cutoff))
+            return change;
+        if (change !== undefined || known.low <= since) {
+            if (reachesSince)
+                return null;
+            throw outOfSteps(timeZone);
+        }
+        high = known.low;
+    }
+    const searchStart = high;
+    // Read only once a step is taken: a start the memo carried to `since` or `cutoff` needs none.
+    let highOffset;
+    for (;;) {
+        if (high <= since) {
+            if (!reachesSince)
+                throw outOfSteps(timeZone);
+            recordSpan(timeZone, since, searchStart, []);
             return null;
-        const low = maximum(high - TRANSITION_SEARCH_STEP_NANOSECONDS, since);
+        }
+        if (high <= cutoff)
+            throw outOfSteps(timeZone);
+        highOffset ??= offsetAt(timeZone, searchStart);
+        const low = maximum(maximum(high - TRANSITION_SEARCH_STEP_NANOSECONDS, since), cutoff);
         const lowOffset = offsetAt(timeZone, low);
         if (lowOffset !== highOffset) {
-            return changeBetween(timeZone, low, high, lowOffset, highOffset);
+            const change = changeBetween(timeZone, low, high, lowOffset, highOffset);
+            recordSpan(timeZone, change - 1n, searchStart, [change]);
+            return change;
         }
         high = low;
     }
-    throw new RangeError(`Transition search in ${timeZone} ran past its bound`);
 }
 /**
  * The last change before an instant more than three years past the current one. The polyfill's

package/dist/internal/zonedWallClock.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { Disambiguation, Offset, Overflow } from "../types/index.js";
 /** Options accepted by `Temporal.ZonedDateTime.from`. */
 export interface ZonedFromOptions {
@@ -27,6 +27,16 @@ export declare const MAX_TRANSITIONS_BEFORE_MAXIMUM = 64;
  * looks for a transition before it (defect 3).
  */
 export declare const POLYFILL_TRANSITION_SEARCH_FLOOR = -3881520000000000000n;
+/** RFC 9557 offset with a seconds field — TC39 `ToTemporalZonedDateTime` then matches exactly. */
+export declare const UTC_OFFSET_WITH_SECONDS: RegExp;
+/**
+ * True when the date part of a wall clock is inside the TC39 `CheckISODaysRange` limit, which
+ * Temporal applies to the local date (not only the instant) under `prefer` and `reject`.
+ *
+ * @example isWithinIsoDaysRange(Temporal.PlainDateTime.from("-271821-04-20T00:00:00")) // true
+ * @example isWithinIsoDaysRange(Temporal.PlainDateTime.from("-271821-04-19T23:59:00")) // false
+ */
+export declare function isWithinIsoDaysRange(wall: Temporal.PlainDateTime): boolean;
 /** True for a date within `EDGE_WINDOW_DAYS` of either TC39 date limit. */
 export declare function isNearRangeEdge(date: Temporal.PlainDate): boolean;
 /** Offset time zones (`+10:00`) and `UTC` never consult tz data, so neither defect reaches them. */
@@ -88,11 +98,12 @@ export declare function utcOffsetStringNanoseconds(offset: string): bigint;
  * Returns the polyfill's result whenever it has one. When the polyfill throws for a named zone
  * within a month of either range limit, the TC39 result is recomputed (see the note at the top
  * of this file); every other failure re-throws the polyfill's own error. A string whose offset
- * is written with seconds is matched exactly, as TC39 requires (`matchSecondsOffsetExactly`).
+ * is written with seconds is matched exactly, as TC39 requires (`matchSecondsOffsetExactly`), and
+ * a string with a `Z` designator is an exact instant under every `offset` option (`zExactOptions`).
  *
  * @param item RFC 9557 zoned string or ZonedDateTime-like property bag
- * @param options Temporal `disambiguation` / `offset` / `overflow`
+ * @param callerOptions Temporal `disambiguation` / `offset` / `overflow`
  * @returns the resolved Temporal.ZonedDateTime; throws where TC39 Temporal throws
  */
-export declare function zonedDateTimeFrom(item: string | Temporal.ZonedDateTimeLike, options?: ZonedFromOptions): Temporal.ZonedDateTime;
+export declare function zonedDateTimeFrom(item: string | Temporal.ZonedDateTimeLike, callerOptions?: ZonedFromOptions): Temporal.ZonedDateTime;
 export {};

package/dist/internal/zonedWallClock.js

@@ -1,6 +1,6 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { MAX_EPOCH_NANOSECONDS, MAX_ISO_EPOCH_DAYS, MIN_EPOCH_NANOSECONDS, } from "./epochNanoseconds.js";
-import { isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, } from "./temporalCompat/index.js";
+import { isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, isZIgnoreExactCompatNeeded, } from "./temporalCompat/index.js";
 import { optionOrDefault } from "./optionOrDefault.js";
 const NANOSECONDS_PER_DAY = 86400000000000n;
 const NANOSECONDS_PER_MINUTE = 60000000000n;
@@ -44,7 +44,9 @@ const UTC_REFERENCE = new Temporal.ZonedDateTime(0n, "UTC");
 const TIME_SEPARATOR = /^[^[]*[Tt ]/;
 const UTC_OFFSET = /^[^[]*[Tt ][^[]*[+\-−]/;
 /** RFC 9557 offset with a seconds field — TC39 `ToTemporalZonedDateTime` then matches exactly. */
-const UTC_OFFSET_WITH_SECONDS = /^[^[]*[Tt ][^[+\-−]*[+\-−]\d{2}:?\d{2}:?\d{2}/;
+export const UTC_OFFSET_WITH_SECONDS = /^[^[]*[Tt ][^[+\-−]*[+\-−]\d{2}:?\d{2}:?\d{2}/;
+/** A UTC designator (`Z` or `z`) ends the date-time before the bracketed annotations. */
+const UTC_DESIGNATOR = /^[^[]*[Zz]\[/;
 // ---------------------------------------------------------------------------------------------
 // TC39 abstract operations, rebuilt from operations the polyfill gets right at the limits
 // ---------------------------------------------------------------------------------------------
@@ -53,6 +55,16 @@ function epochDays(date) {
         largestUnit: "day",
     }).days;
 }
+/**
+ * True when the date part of a wall clock is inside the TC39 `CheckISODaysRange` limit, which
+ * Temporal applies to the local date (not only the instant) under `prefer` and `reject`.
+ *
+ * @example isWithinIsoDaysRange(Temporal.PlainDateTime.from("-271821-04-20T00:00:00")) // true
+ * @example isWithinIsoDaysRange(Temporal.PlainDateTime.from("-271821-04-19T23:59:00")) // false
+ */
+export function isWithinIsoDaysRange(wall) {
+    return Math.abs(epochDays(wall.toPlainDate())) <= MAX_ISO_EPOCH_DAYS;
+}
 /** True for a date within `EDGE_WINDOW_DAYS` of either TC39 date limit. */
 export function isNearRangeEdge(date) {
     return Math.abs(epochDays(date)) >= MAX_ISO_EPOCH_DAYS - EDGE_WINDOW_DAYS;
@@ -459,19 +471,35 @@ function matchSecondsOffsetExactly(item, zoned, options) {
         ? zoned
         : new Temporal.ZonedDateTime(epoch, zoned.timeZoneId, zoned.calendarId);
 }
+/**
+ * The options to read `item` with: `offset: "use"` in place of `"ignore"` for a string with a UTC
+ * designator (defect 6, temporalCompat D15). TC39 reads `Z` as an exact instant under every
+ * `offset` value, and `"use"` is that reading. Dormant unless the D15 probe fails.
+ */
+function zExactOptions(item, options) {
+    return options?.offset === "ignore" &&
+        UTC_DESIGNATOR.test(item) &&
+        isZIgnoreExactCompatNeeded()
+        ? { ...options, offset: "use" }
+        : options;
+}
 /**
  * `Temporal.ZonedDateTime.from`, correct across the whole representable range.
  *
  * Returns the polyfill's result whenever it has one. When the polyfill throws for a named zone
  * within a month of either range limit, the TC39 result is recomputed (see the note at the top
  * of this file); every other failure re-throws the polyfill's own error. A string whose offset
- * is written with seconds is matched exactly, as TC39 requires (`matchSecondsOffsetExactly`).
+ * is written with seconds is matched exactly, as TC39 requires (`matchSecondsOffsetExactly`), and
+ * a string with a `Z` designator is an exact instant under every `offset` option (`zExactOptions`).
  *
  * @param item RFC 9557 zoned string or ZonedDateTime-like property bag
- * @param options Temporal `disambiguation` / `offset` / `overflow`
+ * @param callerOptions Temporal `disambiguation` / `offset` / `overflow`
  * @returns the resolved Temporal.ZonedDateTime; throws where TC39 Temporal throws
  */
-export function zonedDateTimeFrom(item, options) {
+export function zonedDateTimeFrom(item, callerOptions) {
+    const options = typeof item === "string"
+        ? zExactOptions(item, callerOptions)
+        : callerOptions;
     const dateOnly = typeof item === "string"
         ? dateOnlyBeforeTransitionSearch(item, options)
         : null;

package/dist/internal/zonedWallClockDifference.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { DurationRelativeTo } from "../types/index.js";
 /** Options accepted by `ZonedDateTime#until`. */
 export type ZonedDifferenceOptions = Temporal.DifferenceOptions<Temporal.DateTimeUnit>;

package/dist/internal/zonedWallClockDifference.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { TIME_ZONE_ANNOTATION } from "./isoStringBody.js";
 import { MAX_EPOCH_NANOSECONDS, MIN_EPOCH_NANOSECONDS, } from "./epochNanoseconds.js";
 import { calendarDateAdd as compatCalendarDateAdd, calendarDateUntil as compatCalendarDateUntil, isCalendarArithmeticCompatNeeded, isNudgeWindowCompatNeeded, } from "./temporalCompat/index.js";
@@ -460,7 +460,7 @@ function differenceZonedDateTimeWithRounding(ns1, ns2, context, settings) {
     return roundRelativeDuration(difference, ns1, ns2, { ...context, wall: isoDateTimeFor(context.timeZone, ns1) }, settings);
 }
 // ---------------------------------------------------------------------------------------------
-// Plain context (defect 3, CORE-6 spec §3.6.3): no time zone, exact times are
+// Plain context (defect 3 in the header comment): no time zone, exact times are
 // GetUTCEpochNanoseconds and are never checked against the instant range
 // ---------------------------------------------------------------------------------------------
 /** An ISO date far from the limits, used only to validate options. */

package/dist/internal/zonedWallClockOperations.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { Disambiguation, Offset, Overflow } from "../types/index.js";
 import type { DATE_TIME_FIELDS, SetFields } from "./readSetFields.js";
 type RoundingSmallestUnit = Temporal.SmallestUnit<"day" | "hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond">;
@@ -144,5 +144,5 @@ export declare function withZonedFields(zoned: Temporal.ZonedDateTime, fields: Z
  * @param roundTo Temporal `smallestUnit` (day or smaller) / `roundingIncrement` / `roundingMode`
  * @returns the rounded value; throws where TC39 Temporal throws
  */
-export declare function roundZonedDateTime(zoned: Temporal.ZonedDateTime, roundTo: ZonedRoundTo): Temporal.ZonedDateTime;
+export declare function roundZonedDateTime(zoned: Temporal.ZonedDateTime, options: ZonedRoundTo): Temporal.ZonedDateTime;
 export {};

package/dist/internal/zonedWallClockOperations.js

@@ -1,6 +1,6 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { MAX_EPOCH_NANOSECONDS } from "./epochNanoseconds.js";
-import { calendarDateAdd, isCalendarArithmeticCompatNeeded, isTransitionSearchCompatNeeded, } from "./temporalCompat/index.js";
+import { calendarDateAdd, isCalendarArithmeticCompatNeeded, isDayRoundClampCompatNeeded, isTransitionSearchCompatNeeded, } from "./temporalCompat/index.js";
 import { nextTransitionAfter, previousTransitionBefore, } from "./zonedTransitionSearch.js";
 import { epochNanosecondsFor, interpretISODateTimeOffset, isNamedTimeZone, isNearRangeEdge, isValidEpoch, MAX_TRANSITIONS_BEFORE_MAXIMUM, missedNextTransition, missedPreviousTransition, needsOwnDayBoundsSearch, needsOwnStartOfDaySearch, NEXT_TRANSITION_HORIZON_NANOSECONDS, startOfDayEpochNanoseconds, timeZoneIdOf, } from "./zonedWallClock.js";
 import { optionOrDefault } from "./optionOrDefault.js";
@@ -556,7 +556,13 @@ function roundToDayFromOwnStartOfDay(zoned, date, roundingMode) {
     const start = startOfDayEpochNanoseconds(zoned.timeZoneId, date);
     // Past the last representable date `add` throws, as TC39 `GetStartOfDay` does for that day.
     const end = startOfDayEpochNanoseconds(zoned.timeZoneId, date.add({ days: 1 }));
-    const progress = zoned.epochNanoseconds - start;
+    // An instant in the second piece of a date that starts twice lies at or past `end`. The spec
+    // step is "Set thisNs to min(thisNs, endNs - 1)" in Temporal.ZonedDateTime.prototype.round
+    // (tc39/ecma262#3966, commit 5f44331e0a11; test262
+    // intl402/Temporal/ZonedDateTime/prototype/round/same-date-starts-twice.js). It stays when the
+    // probe-gated routing is removed.
+    const thisNs = zoned.epochNanoseconds < end ? zoned.epochNanoseconds : end - 1n;
+    const progress = thisNs - start;
     return inZoneOf(start + roundDayProgress(progress, end - start, roundingMode), zoned);
 }
 function isDayUnit(unit) {
@@ -581,6 +587,33 @@ function roundAtEdge(zoned, roundTo) {
     const epoch = interpretISODateTimeOffset(zoned.timeZoneId, roundedWall, { nanoseconds: BigInt(zoned.offsetNanoseconds) }, "compatible", "prefer", false);
     return inZoneOf(epoch, zoned);
 }
+/**
+ * Convert `roundingIncrement` and `roundingMode` once, in the order `ZonedDateTime#round` reads them.
+ *
+ * - Temporal GetOption converts the value it reads: ToNumber for `roundingIncrement`, ToString for
+ *   `roundingMode`. The steps after this compare the mode with `===`, so a mode given as an object
+ *   (`new String("floor")`) must reach them as the plain string, or it falls through to another
+ *   mode's branch.
+ * - The unary plus and the template literal are ToNumber and ToString exactly, so a symbol or a
+ *   bigint throws the TypeError Temporal throws. `undefined` stays `undefined` (the default).
+ * - `smallestUnit` is left as it is: both callers pass a unit they have already checked is one of
+ *   the unit strings.
+ *
+ * @param options the caller's options, each member read once
+ * @returns the same options, increment and mode as primitives
+ */
+function convertRoundTo(options) {
+    const { roundingIncrement, roundingMode, smallestUnit } = options;
+    const increment = roundingIncrement === undefined ? undefined : +roundingIncrement;
+    const mode = roundingMode === undefined
+        ? undefined
+        : `${roundingMode}`;
+    return {
+        smallestUnit,
+        ...(increment === undefined ? {} : { roundingIncrement: increment }),
+        ...(mode === undefined ? {} : { roundingMode: mode }),
+    };
+}
 /**
  * `ZonedDateTime#round`, correct at the range limits and, by day, before 1847.
  *
@@ -588,11 +621,23 @@ function roundAtEdge(zoned, roundTo) {
  * @param roundTo Temporal `smallestUnit` (day or smaller) / `roundingIncrement` / `roundingMode`
  * @returns the rounded value; throws where TC39 Temporal throws
  */
-export function roundZonedDateTime(zoned, roundTo) {
-    if (isDayUnit(roundTo.smallestUnit) && needsOwnDayBounds(zoned)) {
+export function roundZonedDateTime(zoned, options) {
+    const roundTo = convertRoundTo(options);
+    if (isDayUnit(roundTo.smallestUnit) &&
+        isNamedTimeZone(zoned.timeZoneId) &&
+        (isDayRoundClampCompatNeeded() || needsOwnDayBounds(zoned))) {
         // Validates the options exactly as ZonedDateTime#round does, throwing where it throws.
         zoned.toPlainDateTime().round(roundTo);
-        return roundToDayFromOwnStartOfDay(zoned, zoned.toPlainDate(), roundTo.roundingMode ?? "halfExpand");
+        try {
+            return roundToDayFromOwnStartOfDay(zoned, zoned.toPlainDate(), roundTo.roundingMode ?? "halfExpand");
+        }
+        catch (error) {
+            // Only at the range limits, where the next date is not representable, does the path
+            // below answer; any other error propagates.
+            if (!isAtRangeEdge(zoned.timeZoneId, zoned.toPlainDate())) {
+                throw error;
+            }
+        }
     }
     try {
         return zoned.round(roundTo);

package/dist/internal/zonelessCalendarDate.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 /**
  * Read the calendar date `value` names, where `value` is a zoneless ISO date or datetime.
  *

package/dist/internal/zonelessCalendarDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { isValidIsoDateLike } from "../plain/validate/isValidIsoDateLike.js";
 /**
  * Read the calendar date `value` names, where `value` is a zoneless ISO date or datetime.

package/dist/interval/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 "./compare/index.js";
 export * from "./validate/index.js";

package/dist/interval/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 "./compare/index.js";
 export * from "./validate/index.js";

package/dist/plain/calculate/addBusinessDays.d.ts

@@ -25,8 +25,8 @@ import type { BusinessCalendar } from "../../types/index.js";
  * @example addBusinessDays("2024-03-15", 1) // "2024-03-18" (Friday to Monday)
  * @example addBusinessDays("2024-03-16", 1) // "2024-03-18" (from a Saturday)
  * @example addBusinessDays("2024-03-15", 0) // "2024-03-15"
- * @example addBusinessDays("2024-07-03", 1, { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // "2024-07-05" (skips the holiday)
- * @example addBusinessDays("2024-07-03", -1, { weekend: [6, 7], holidays: ["2024-07-02"], timeZone: "America/New_York" }) // "2024-07-01"
+ * @example addBusinessDays("2024-07-03", 1, { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // "2024-07-05" (skips the holiday)
+ * @example addBusinessDays("2024-07-03", -1, { weekend: [6, 7], holidays: ["2024-07-02"], timeZone: "Australia/Sydney" }) // "2024-07-01"
  * @example addBusinessDays("2024-07-04", 1, { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // "2024-07-07" (Friday–Saturday weekend)
  * @example addBusinessDays("invalid", 1) // ""
  * @example addBusinessDays("2024-03-15", 1, { weekend: [6, 7], holidays: [], timeZone: "Invalid/Zone" }) // "" (bad calendar)

package/dist/plain/calculate/addBusinessDays.js

@@ -25,8 +25,8 @@ import { stepBusinessDaysValue } from "../../internal/businessDayValues.js";
  * @example addBusinessDays("2024-03-15", 1) // "2024-03-18" (Friday to Monday)
  * @example addBusinessDays("2024-03-16", 1) // "2024-03-18" (from a Saturday)
  * @example addBusinessDays("2024-03-15", 0) // "2024-03-15"
- * @example addBusinessDays("2024-07-03", 1, { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // "2024-07-05" (skips the holiday)
- * @example addBusinessDays("2024-07-03", -1, { weekend: [6, 7], holidays: ["2024-07-02"], timeZone: "America/New_York" }) // "2024-07-01"
+ * @example addBusinessDays("2024-07-03", 1, { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // "2024-07-05" (skips the holiday)
+ * @example addBusinessDays("2024-07-03", -1, { weekend: [6, 7], holidays: ["2024-07-02"], timeZone: "Australia/Sydney" }) // "2024-07-01"
  * @example addBusinessDays("2024-07-04", 1, { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // "2024-07-07" (Friday–Saturday weekend)
  * @example addBusinessDays("invalid", 1) // ""
  * @example addBusinessDays("2024-03-15", 1, { weekend: [6, 7], holidays: [], timeZone: "Invalid/Zone" }) // "" (bad calendar)

package/dist/plain/calculate/addDateTime.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { readDurationUnits, resolveOverflow } from "../../internal/index.js";
 import { isValidDateTime, isValidDateTimeDurationUnit } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";

package/dist/plain/calculate/addTime.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { readDurationUnits } from "../../internal/index.js";
 import { isValidTime, isValidTimeDurationUnit } from "../validate/index.js";
 /**

package/dist/plain/calculate/clampDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDate } from "../validate/index.js";
 /**
  * Restrict `value` to the range [`min`, `max`].

package/dist/plain/calculate/closestDateTo.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDate } from "../validate/index.js";
 /**
  * Return the candidate date nearest to `target` by calendar distance.

package/dist/plain/calculate/cycleDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { cycleFieldValue, dateCycleFieldBounds, isValidAmount, } from "../../internal/index.js";
 import { isValidDate, isValidDateCycleField } from "../validate/index.js";
 import { setDate } from "./setDate.js";