@northguild/gmt 1.18.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,11 +1,13 @@
-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 year and day of week unpadded. The week number is the
+ * (three for sub-second fields), the day of week unpadded, and the year as Temporal writes one
+ * (`isoYearString`: four digits, or a sign and six outside 0000–9999). The week number is the
  * caller's, since the plain and zoned accessors read it through `parseWeekFromDate` and the utc and
  * unix ones from the ISO date.
  *
- * @param now the current moment on the wall clock being read
+ * @param now the current moment on the wall clock being read: a zoned date-time, or the plain wall
+ *   clock of a stored UTC offset with seconds, which no time zone identifier can carry
  * @param unit a singular unit, `dayOfWeek` included (already validated by the caller)
  * @param week the week number for `now`, as a string
  * @returns the field, or "" for any other unit
@@ -13,11 +15,12 @@ import { Temporal } from "@js-temporal/polyfill";
  * @example zonedNowUnitValue(Temporal.ZonedDateTime.from("2024-03-05T07:08:09+00:00[UTC]"), "week", () => "10") // "10"
  * @example zonedNowUnitValue(Temporal.ZonedDateTime.from("2024-03-05T07:08:09+00:00[UTC]"), "quarter", () => "10") // ""
  */
-export declare function zonedNowUnitValue(now: Temporal.ZonedDateTime, unit: string | null | undefined, week: (now: Temporal.ZonedDateTime) => string): string;
+export declare function zonedNowUnitValue<Clock extends Temporal.ZonedDateTime | Temporal.PlainDateTime>(now: Clock, unit: string | null | undefined, week: (now: Clock) => string): string;
 /**
  * The ISO 8601 week number of `now`'s date, the week the utc and unix `get*NowUnit` accessors read.
  *
- * @param now the current moment on the wall clock being read
+ * @param now the current moment on the wall clock being read: a zoned date-time, or the plain wall
+ *   clock of a stored UTC offset with seconds, which no time zone identifier can carry
  * @returns the week number as a string
  * @example isoWeekOfYear(Temporal.ZonedDateTime.from("2024-12-30T00:00:00+00:00[UTC]")) // "1"
  */

package/dist/internal/zonedNowUnitValue.js

@@ -1,11 +1,14 @@
-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
- * (three for sub-second fields), the year and day of week unpadded. The week number is the
+ * (three for sub-second fields), the day of week unpadded, and the year as Temporal writes one
+ * (`isoYearString`: four digits, or a sign and six outside 0000–9999). The week number is the
  * caller's, since the plain and zoned accessors read it through `parseWeekFromDate` and the utc and
  * unix ones from the ISO date.
  *
- * @param now the current moment on the wall clock being read
+ * @param now the current moment on the wall clock being read: a zoned date-time, or the plain wall
+ *   clock of a stored UTC offset with seconds, which no time zone identifier can carry
  * @param unit a singular unit, `dayOfWeek` included (already validated by the caller)
  * @param week the week number for `now`, as a string
  * @returns the field, or "" for any other unit
@@ -16,7 +19,7 @@ import { Temporal } from "@js-temporal/polyfill";
 export function zonedNowUnitValue(now, unit, week) {
     switch (unit) {
         case "year":
-            return now.year.toString();
+            return isoYearString(now.year);
         case "month":
             return now.month.toString().padStart(2, "0");
         case "week":
@@ -44,7 +47,8 @@ export function zonedNowUnitValue(now, unit, week) {
 /**
  * The ISO 8601 week number of `now`'s date, the week the utc and unix `get*NowUnit` accessors read.
  *
- * @param now the current moment on the wall clock being read
+ * @param now the current moment on the wall clock being read: a zoned date-time, or the plain wall
+ *   clock of a stored UTC offset with seconds, which no time zone identifier can carry
  * @returns the week number as a string
  * @example isoWeekOfYear(Temporal.ZonedDateTime.from("2024-12-30T00:00:00+00:00[UTC]")) // "1"
  */

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,8 +1,9 @@
-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";
 import { epochNanosecondsFor, isNamedTimeZone, isValidEpoch, utcEpochNanoseconds, zonedDateTimeFrom, } from "./zonedWallClock.js";
+import { isObject } from "./isObject.js";
 const UNITS = [
     "year",
     "month",
@@ -459,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. */
@@ -771,7 +772,7 @@ function zonedRelativeTo(relativeTo) {
                 ? zonedDateTimeFrom(relativeTo)
                 : null;
         }
-        if (typeof relativeTo === "object" &&
+        if (isObject(relativeTo) &&
             !(relativeTo instanceof Temporal.PlainDateTime) &&
             "timeZone" in relativeTo &&
             relativeTo.timeZone !== undefined) {
@@ -956,7 +957,7 @@ function relativeToDayOfMonth(relativeTo, zoned) {
         if (typeof relativeTo === "string") {
             return Temporal.PlainDate.from(relativeTo).day;
         }
-        if (relativeTo !== null && typeof relativeTo === "object") {
+        if (isObject(relativeTo)) {
             return Temporal.PlainDate.from(relativeTo).day;
         }
     }
@@ -978,8 +979,7 @@ function plainRelativeTo(relativeTo) {
             !timeZoneAnnotation.test(relativeTo)) {
             return Temporal.PlainDate.from(relativeTo);
         }
-        if (relativeTo !== null &&
-            typeof relativeTo === "object" &&
+        if (isObject(relativeTo) &&
             !(relativeTo instanceof Temporal.ZonedDateTime)) {
             return Temporal.PlainDate.from(relativeTo);
         }

package/dist/internal/zonedWallClockOperations.d.ts

@@ -1,5 +1,6 @@
-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">;
 interface ZonedRoundTo {
     smallestUnit: RoundingSmallestUnit;
@@ -125,15 +126,17 @@ interface ZonedWithOptions {
     disambiguation?: Disambiguation;
     offset?: Offset;
 }
+/** The date and time fields a `set*` function passes, as `readSetFields` checked them. */
+type ZonedWithFields = SetFields<(typeof DATE_TIME_FIELDS)[number]>;
 /**
  * `ZonedDateTime#with`, correct at the range limits.
  *
  * @param zoned the value to change
- * @param fields the date/time (and optional offset) fields to set
+ * @param fields the date and time fields to set
  * @param options Temporal `overflow` / `disambiguation` / `offset` (default `"prefer"`)
  * @returns the changed value; throws where TC39 Temporal throws
  */
-export declare function withZonedFields(zoned: Temporal.ZonedDateTime, fields: Temporal.ZonedDateTimeLike, options?: ZonedWithOptions): Temporal.ZonedDateTime;
+export declare function withZonedFields(zoned: Temporal.ZonedDateTime, fields: ZonedWithFields, options?: ZonedWithOptions): Temporal.ZonedDateTime;
 /**
  * `ZonedDateTime#round`, correct at the range limits and, by day, before 1847.
  *
@@ -141,5 +144,5 @@ export declare function withZonedFields(zoned: Temporal.ZonedDateTime, fields: T
  * @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 {};