@northguild/gmt 1.18.0 → 1.20.0

package/dist/internal/resolveUnixIntervalPair.js

@@ -1,7 +1,7 @@
-import { normalizeTimeZone } from "./normalizeTimeZone.js";
 import { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
 import { parseUnixEpochInterval, resolveUnixEpochUnit, unixEpochToInstant, } from "./unixEpochValue.js";
 import { isValidDateTimeUnit } from "../plain/validate/index.js";
+import { frameZoned, normalizeZoneFrame } from "./zoneFrame.js";
 /**
  * Resolve the shared arguments of `intervalLengthUnix`, `intervalCountUnix` and
  * `splitIntervalByUnitUnix`: a non-reversed epoch pair in `epochUnit`, a singular-or-plural
@@ -9,13 +9,16 @@ import { isValidDateTimeUnit } from "../plain/validate/index.js";
  *
  * - Epochs follow the one `unix/` grammar (`parseUnixEpochValue`) and must name Temporal instants.
  * - `epochUnit` defaults to `"milliseconds"`; `timeZone` defaults to `"UTC"` (`"local"` is the
- *   system zone, an unknown zone is invalid).
+ *   system zone; a time zone identifier or a stored UTC offset `±HH:MM[:SS]` is read as written;
+ *   anything else is invalid).
+ * - The ends are placed with `frameZoned`: for a seconds offset they sit in the offset's
+ *   whole-minute zone, moved by its seconds, to compute with and never to write.
  *
  * @param start interval start epoch
  * @param end interval end epoch
  * @param unit unit name, singular or plural
  * @param options optional `{ epochUnit, timeZone }`
- * @returns the zoned ends, singular unit and epoch unit, or null on invalid input
+ * @returns the zoned ends, singular unit, epoch unit and frame, or null on invalid input
  *
  * @example resolveUnixIntervalPair(0, 86400, "days", { epochUnit: "seconds" })?.resolvedUnit // "day"
  * @example resolveUnixIntervalPair(10, 0, "day") // null (reversed)
@@ -23,10 +26,10 @@ import { isValidDateTimeUnit } from "../plain/validate/index.js";
 export function resolveUnixIntervalPair(start, end, unit, options) {
     const interval = parseUnixEpochInterval(start, end);
     const epochUnit = resolveUnixEpochUnit(options?.epochUnit);
-    const timeZone = normalizeTimeZone(options?.timeZone);
+    const frame = normalizeZoneFrame(options?.timeZone);
     if (interval === null ||
         epochUnit === null ||
-        !timeZone ||
+        frame === null ||
         typeof unit !== "string") {
         return null;
     }
@@ -41,10 +44,11 @@ export function resolveUnixIntervalPair(start, end, unit, options) {
     }
     try {
         return {
-            startVal: startInstant.toZonedDateTimeISO(timeZone),
-            endVal: endInstant.toZonedDateTimeISO(timeZone),
+            startVal: frameZoned(startInstant, frame),
+            endVal: frameZoned(endInstant, frame),
             resolvedUnit,
             epochUnit,
+            frame,
         };
     }
     catch {

package/dist/internal/rinexWeek.d.ts

@@ -0,0 +1,22 @@
+import type { GnssSystem, RinexWeekSystem } from "../types/gnss.js";
+/** Where a RINEX navigation record's continuous week count starts. */
+export interface RinexWeekEpoch {
+    /** The satellite time scale the record's week and time of week are read on. */
+    readonly system: GnssSystem;
+    /** Week 0's first label on that scale, label nanoseconds. */
+    readonly epochLabel: bigint;
+}
+/**
+ * Epoch label of each RINEX navigation record's continuous week count (RINEX 4.02). The count
+ * never wraps, so it has no modulus and no era. Each `epochLabel` is
+ * `Temporal.PlainDateTime.from(<label>).toZonedDateTime("UTC").epochNanoseconds` of the label in
+ * its comment; rinexWeek.test.ts asserts each one.
+ */
+export declare const RINEX_WEEK_EPOCHS: Readonly<Record<RinexWeekSystem, RinexWeekEpoch>>;
+/**
+ * Whether a value names a system whose RINEX navigation records carry a week number.
+ *
+ * @param value candidate system
+ * @returns true for `GPS`, `GAL`, `BDT`, `QZS` or `IRN`
+ */
+export declare function isRinexWeekSystem(value: unknown): value is RinexWeekSystem;

package/dist/internal/rinexWeek.js

@@ -0,0 +1,30 @@
+/**
+ * Epoch label of each RINEX navigation record's continuous week count (RINEX 4.02). The count
+ * never wraps, so it has no modulus and no era. Each `epochLabel` is
+ * `Temporal.PlainDateTime.from(<label>).toZonedDateTime("UTC").epochNanoseconds` of the label in
+ * its comment; rinexWeek.test.ts asserts each one.
+ */
+export const RINEX_WEEK_EPOCHS = Object.freeze({
+    // 1980-01-06T00:00:00 GPS: RINEX 4.02 Table A9; §4.1.8 Table 3, "GPS/QZS/IRN/GAL RINEX" row.
+    GPS: Object.freeze({ system: "GPS", epochLabel: 315964800000000000n }),
+    // 1980-01-06T00:00:00 GAL: RINEX 4.02 Table A13 footnote 5*; Table 3. Galileo time itself
+    // starts 1999-08-22, so weeks before 1024 have no Galileo label.
+    GAL: Object.freeze({ system: "GAL", epochLabel: 315964800000000000n }),
+    // 2006-01-01T00:00:00 BDT: RINEX 4.02 §5.4.6 p. 41 and Table A23 p. 99, BDT weeks from the
+    // BeiDou epoch; worked example in Table A27.
+    BDT: Object.freeze({ system: "BDT", epochLabel: 1136073600000000000n }),
+    // 1980-01-06T00:00:00 QZS: RINEX 4.02 Table A19; Table 3.
+    QZS: Object.freeze({ system: "QZS", epochLabel: 315964800000000000n }),
+    // 1980-01-06T00:00:00 IRN: RINEX 4.02 Table A30 p. 109, "Continuous number, not mod (1024),
+    // counted from 1980 (same as GPS)". NavIC time itself starts 1999-08-22.
+    IRN: Object.freeze({ system: "IRN", epochLabel: 315964800000000000n }),
+});
+/**
+ * Whether a value names a system whose RINEX navigation records carry a week number.
+ *
+ * @param value candidate system
+ * @returns true for `GPS`, `GAL`, `BDT`, `QZS` or `IRN`
+ */
+export function isRinexWeekSystem(value) {
+    return typeof value === "string" && Object.hasOwn(RINEX_WEEK_EPOCHS, value);
+}

package/dist/internal/rollBusinessDate.d.ts

@@ -0,0 +1,15 @@
+import { Temporal } from "./temporal.js";
+import { type ResolvedBusinessCalendar } from "./businessCalendar.js";
+import type { RollConvention } from "../types/index.js";
+/**
+ * Move a date onto a working day according to `convention`, over an already-parsed calendar.
+ * The core of `rollDate` and `cutoffAt`; neither calls the other.
+ *
+ * @param date the date to roll
+ * @param convention the roll convention, already validated
+ * @param calendar the parsed business calendar
+ * @returns the rolled date, or `null` when the walk runs out
+ *
+ * @example rollBusinessDate(Temporal.PlainDate.from("2024-06-01"), "following", calendar) // 2024-06-03 (Saturday to Monday)
+ */
+export declare function rollBusinessDate(date: Temporal.PlainDate, convention: RollConvention, calendar: ResolvedBusinessCalendar): Temporal.PlainDate | null;

package/dist/internal/rollBusinessDate.js

@@ -0,0 +1,46 @@
+import { Temporal } from "./temporal.js";
+import { businessDateFrom, } from "./businessCalendar.js";
+function sameMonth(a, b) {
+    return a.year === b.year && a.month === b.month;
+}
+/**
+ * Roll in `direction`, and if that leaves the date's month, roll the other way instead.
+ */
+function modifiedRoll(date, direction, calendar) {
+    const rolled = businessDateFrom(date, direction, calendar);
+    // An exhausted walk is a sentinel, not a "left the month" answer: turning round here would
+    // report the opposite direction's date as though the first walk had succeeded.
+    if (rolled === null) {
+        return null;
+    }
+    return sameMonth(rolled, date)
+        ? rolled
+        : businessDateFrom(date, direction === 1 ? -1 : 1, calendar);
+}
+/**
+ * Move a date onto a working day according to `convention`, over an already-parsed calendar.
+ * The core of `rollDate` and `cutoffAt`; neither calls the other.
+ *
+ * @param date the date to roll
+ * @param convention the roll convention, already validated
+ * @param calendar the parsed business calendar
+ * @returns the rolled date, or `null` when the walk runs out
+ *
+ * @example rollBusinessDate(Temporal.PlainDate.from("2024-06-01"), "following", calendar) // 2024-06-03 (Saturday to Monday)
+ */
+export function rollBusinessDate(date, convention, calendar) {
+    switch (convention) {
+        case "following":
+            return businessDateFrom(date, 1, calendar);
+        case "preceding":
+            return businessDateFrom(date, -1, calendar);
+        case "modifiedFollowing":
+            return modifiedRoll(date, 1, calendar);
+        case "modifiedPreceding":
+            return modifiedRoll(date, -1, calendar);
+        case "endOfMonth":
+            return businessDateFrom(date.with({ day: date.daysInMonth }), -1, calendar);
+        case "none":
+            return date;
+    }
+}

package/dist/internal/splitStep.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 /**
  * Consecutive split steps allowed to resolve to the previous boundary before a split gives up.
  *

package/dist/internal/splitStep.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 const EXACT_DURATION_UNITS = new Set([
     "hours",
     "minutes",

package/dist/internal/startOrEndOfUnix.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 /**
  * Internal shared implementation for `startOfUnix` / `endOfUnix` and the quarter functions.
  *
@@ -8,7 +8,8 @@ import type { Temporal } from "@js-temporal/polyfill";
  *   or `"quarter"` from `startOfQuarterForUnix` / `endOfQuarterForUnix` only.
  * - `value` follows the one epoch grammar (`parseUnixEpochValue`); `epochUnit` accepts singular
  *   and plural names and defaults to `"milliseconds"`.
- * - `timeZone` defaults to `"UTC"`; `"local"` is the system zone; an unknown zone returns null.
+ * - `timeZone` defaults to `"UTC"`; `"local"` is the system zone; a time zone identifier or a
+ *   stored UTC offset (`±HH:MM[:SS]`) is read as written; anything else returns null.
  * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - The boundary is always the real local bucket from `internal/zonedBucket.ts` — a start never
  *   after `value`, an end never before it.

package/dist/internal/startOrEndOfUnix.js

@@ -1,7 +1,7 @@
-import { normalizeTimeZone } from "./normalizeTimeZone.js";
 import { resolveWeekStartsOn } from "./resolveWeekStartsOn.js";
 import { resolveUnixEpochUnit, toUnixEpoch, unixEpochToInstant, } from "./unixEpochValue.js";
 import { zonedUnitEnd, zonedUnitStart } from "./zonedBucket.js";
+import { frameInstant, frameZoned, normalizeZoneFrame } from "./zoneFrame.js";
 /**
  * Internal shared implementation for `startOfUnix` / `endOfUnix` and the quarter functions.
  *
@@ -11,7 +11,8 @@ import { zonedUnitEnd, zonedUnitStart } from "./zonedBucket.js";
  *   or `"quarter"` from `startOfQuarterForUnix` / `endOfQuarterForUnix` only.
  * - `value` follows the one epoch grammar (`parseUnixEpochValue`); `epochUnit` accepts singular
  *   and plural names and defaults to `"milliseconds"`.
- * - `timeZone` defaults to `"UTC"`; `"local"` is the system zone; an unknown zone returns null.
+ * - `timeZone` defaults to `"UTC"`; `"local"` is the system zone; a time zone identifier or a
+ *   stored UTC offset (`±HH:MM[:SS]`) is read as written; anything else returns null.
  * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - The boundary is always the real local bucket from `internal/zonedBucket.ts` — a start never
  *   after `value`, an end never before it.
@@ -24,9 +25,9 @@ import { zonedUnitEnd, zonedUnitStart } from "./zonedBucket.js";
  */
 export function startOrEndOfUnix(value, unit, options, isEnd) {
     const epochUnit = resolveUnixEpochUnit(options.epochUnit);
-    const timeZone = normalizeTimeZone(options.timeZone);
+    const frame = normalizeZoneFrame(options.timeZone);
     const weekStartsOn = resolveWeekStartsOn(options.weekStartsOn);
-    if (!timeZone || epochUnit === null || weekStartsOn === null) {
+    if (frame === null || epochUnit === null || weekStartsOn === null) {
         return null;
     }
     const instant = unixEpochToInstant(value, epochUnit);
@@ -35,11 +36,13 @@ export function startOrEndOfUnix(value, unit, options, isEnd) {
     }
     const weekStartDay = weekStartsOn === "monday" ? 1 : 7;
     try {
-        const source = instant.toZonedDateTimeISO(timeZone);
+        const source = frameZoned(instant, frame);
         const boundary = isEnd
             ? zonedUnitEnd(source, unit, weekStartDay)
             : zonedUnitStart(source, unit, weekStartDay);
-        return boundary ? toUnixEpoch(boundary, epochUnit) : null;
+        return boundary
+            ? toUnixEpoch(frameInstant(boundary, frame), epochUnit)
+            : null;
     }
     catch {
         return null;

package/dist/internal/startOrEndOfUtc.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { FractionalDigit } from "../types/index.js";
 /**
  * Internal shared implementation for `startOfUtc` / `endOfUtc`.

package/dist/internal/startOrEndOfUtc.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { defaultFractionalDigits } from "./defaultFractionalDigits.js";
 import { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
 import { resolveWeekStartsOn } from "./resolveWeekStartsOn.js";

package/dist/internal/startOrEndOfZoned.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 import type { DateTimeUnit, FractionalDigit } from "../types/index.js";
 /**
  * Internal shared implementation for `startOfZoned` / `endOfZoned`.

package/dist/internal/temporal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The one module in `src` that names the Temporal implementation. Every other file, tests
+ * included, imports from here, so the implementation can change in one place.
+ */
+export { Intl, Temporal, toTemporalInstant } from "@js-temporal/polyfill";

package/dist/internal/temporal.js

@@ -0,0 +1,5 @@
+/**
+ * The one module in `src` that names the Temporal implementation. Every other file, tests
+ * included, imports from here, so the implementation can change in one place.
+ */
+export { Intl, Temporal, toTemporalInstant } from "@js-temporal/polyfill";

package/dist/internal/temporalCompat/calendarDateArithmetic.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "../temporal.js";
 import { type ArithmeticOverflow, type DateDurationFields } from "./nonIsoArithmetic.js";
 export type CalendarDateUnit = "year" | "month" | "week" | "day";
 /**

package/dist/internal/temporalCompat/calendarDateFromFields.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 import { type FieldKey } from "./fieldSearch.js";
 export type CalendarDateFields = FieldKey | {
     era: string;

package/dist/internal/temporalCompat/calendarDateFromFields.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 import { calendarFieldsOf, hasReadCorrection } from "./calendarFields.js";
 import { isDefectPresent } from "./capabilities.js";
 import { isoForFields } from "./fieldSearch.js";

package/dist/internal/temporalCompat/calendarFields.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "../temporal.js";
 /** A date's fields in one calendar. `month` is ordinal (Hebrew leap year: `M05L` is 6). */
 export interface CalendarFields {
     year: number;

package/dist/internal/temporalCompat/capabilities.d.ts

@@ -1,13 +1,15 @@
-import { type DefectId, type Repro } from "./repros.js";
+import { type DefectId, type ProbeRepro } from "./probeRepros.js";
 /** The repro's output, or `ERR <name>: <message>` when it throws. */
-export declare function runRepro(repro: Pick<Repro, "run">): string;
+export declare function runRepro(repro: Pick<ProbeRepro, "run">): string;
 /** True when a repro's output is the spec-correct value, i.e. the installed runtime is fixed. */
-export declare function reproPasses(repro: Pick<Repro, "expected">, output: string): boolean;
+export declare function reproPasses(repro: Pick<ProbeRepro, "expected">, output: string): boolean;
 /**
  * True when any of `candidates` for this defect and Temporal calendar id fails. Stops at the first
  * failure, so the order of a defect's repros is the order they are tried in.
  */
-export declare function anyReproFails(candidates: readonly Repro[], defect: DefectId, calendar: string): boolean;
+export declare function anyReproFails(candidates: readonly (Omit<ProbeRepro, "defect"> & {
+    defect: string;
+})[], defect: DefectId, calendar: string): boolean;
 /**
  * True when any repro for this defect and Temporal calendar id fails in the installed runtime.
  * A calendar with no repro for the defect is not affected by it.
@@ -45,9 +47,29 @@ export declare function isSecondsOffsetMatchCompatNeeded(): boolean;
  * dormant: a runtime that fixes the skipped pairs and still stalls on one zone keeps it.
  */
 export declare function isTransitionSearchCompatNeeded(): boolean;
+/**
+ * True when this runtime rounds to the day wrongly where a date starts twice (defect D14).
+ *
+ * A fall-back across midnight re-enters a date after the next date has started, as
+ * America/Goose_Bay did on 2010-11-06, and America/Sitka on 1867-10-18. TC39
+ * `ZonedDateTime#round` clamps an instant in the second piece of that date to the end of the date
+ * (tc39/ecma262#3966, commit 5f44331e0a11; test262 `same-date-starts-twice.js`). A runtime without
+ * that change answers the next date for `floor` and `trunc`, and in some zones (Sitka 1867) for the
+ * half modes, `ceil` and `expand` too, or throws.
+ */
+export declare function isDayRoundClampCompatNeeded(): boolean;
+/**
+ * True when this runtime applies `offset: "ignore"` to a `Z` string (defect D15).
+ *
+ * TC39 `ToTemporalZonedDateTime` reads a `Z` string as an exact instant under every `offset`
+ * option; `InterpretISODateTimeOffset` applies `ignore` only to an offset written as an option. A
+ * runtime that ignores the `Z` and reads the wall clock in the zone returns a different instant
+ * whenever the zone's offset is not zero.
+ */
+export declare function isZIgnoreExactCompatNeeded(): boolean;
 /**
  * True when calendar arithmetic in `calendarId` needs the compat layer in this runtime: any of its
- * add, until or read probes fails (CORE-6 spec §3.6.2). `iso8601` never does, and costs nothing.
+ * add, until or read probes fails. `iso8601` never does, and costs nothing.
  * Callers that own a spec path for a whole operation (zoned differences, `Duration` rounding,
  * totals and comparisons) take it when this is true.
  */

package/dist/internal/temporalCompat/capabilities.js

@@ -1,11 +1,11 @@
-import { repros } from "./repros.js";
+import { probeRepros } from "./probeRepros.js";
 /*
  * Lazy, memoized capability probes: one answer per (defect, calendar), computed the first time a
  * workaround asks and cached for the life of the process. Results are deterministic for a given
  * polyfill + ICU, and the polyfill is imported once, so a cached answer never goes stale.
  *
  * A workaround whose probe passes never runs: behaviour is the polyfill's own. Tests never force a
- * probe; they assert spec-correct outputs that hold either way (CORE-6 spec §4.5).
+ * probe; they assert spec-correct outputs that hold either way (temporalCompat README).
  */
 /** The repro's output, or `ERR <name>: <message>` when it throws. */
 export function runRepro(repro) {
@@ -41,7 +41,7 @@ export function isDefectPresent(defect, calendar) {
     if (cached !== undefined) {
         return cached;
     }
-    const present = anyReproFails(repros, defect, calendar);
+    const present = anyReproFails(probeRepros, defect, calendar);
     cache.set(key, present);
     return present;
 }
@@ -83,6 +83,30 @@ export function isSecondsOffsetMatchCompatNeeded() {
 export function isTransitionSearchCompatNeeded() {
     return isDefectPresent("D13", "iso8601");
 }
+/**
+ * True when this runtime rounds to the day wrongly where a date starts twice (defect D14).
+ *
+ * A fall-back across midnight re-enters a date after the next date has started, as
+ * America/Goose_Bay did on 2010-11-06, and America/Sitka on 1867-10-18. TC39
+ * `ZonedDateTime#round` clamps an instant in the second piece of that date to the end of the date
+ * (tc39/ecma262#3966, commit 5f44331e0a11; test262 `same-date-starts-twice.js`). A runtime without
+ * that change answers the next date for `floor` and `trunc`, and in some zones (Sitka 1867) for the
+ * half modes, `ceil` and `expand` too, or throws.
+ */
+export function isDayRoundClampCompatNeeded() {
+    return isDefectPresent("D14", "iso8601");
+}
+/**
+ * True when this runtime applies `offset: "ignore"` to a `Z` string (defect D15).
+ *
+ * TC39 `ToTemporalZonedDateTime` reads a `Z` string as an exact instant under every `offset`
+ * option; `InterpretISODateTimeOffset` applies `ignore` only to an offset written as an option. A
+ * runtime that ignores the `Z` and reads the wall clock in the zone returns a different instant
+ * whenever the zone's offset is not zero.
+ */
+export function isZIgnoreExactCompatNeeded() {
+    return isDefectPresent("D15", "iso8601");
+}
 /** Defects that make the runtime's calendar arithmetic or reads differ from the spec. */
 const ARITHMETIC_DEFECTS = [
     "D1",
@@ -96,7 +120,7 @@ const ARITHMETIC_DEFECTS = [
 ];
 /**
  * True when calendar arithmetic in `calendarId` needs the compat layer in this runtime: any of its
- * add, until or read probes fails (CORE-6 spec §3.6.2). `iso8601` never does, and costs nothing.
+ * add, until or read probes fails. `iso8601` never does, and costs nothing.
  * Callers that own a spec path for a whole operation (zoned differences, `Duration` rounding,
  * totals and comparisons) take it when this is true.
  */

package/dist/internal/temporalCompat/fieldSearch.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 export interface FieldKey {
     year: number;
     month: number;

package/dist/internal/temporalCompat/fieldSearch.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 import { MAX_ISO_EPOCH_DAYS } from "../epochNanoseconds.js";
 import { calendarFieldsOf } from "./calendarFields.js";
 /*

package/dist/internal/temporalCompat/fixedDay.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 /**
  * Floored integer division remainder: the result has the sign of `divisor` (`mod(-1, 19)` is 18),
  * as the calendar formulas below require. JS `%` keeps the dividend's sign.

package/dist/internal/temporalCompat/fixedDay.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 /** `fixedFromIso(1970, 1, 1)`. */
 const UNIX_EPOCH_FIXED_DAY = 719_163;
 /**

package/dist/internal/temporalCompat/index.d.ts

@@ -1,4 +1,4 @@
 export { type CalendarDateUnit, calendarDateAdd, calendarDateUntil, } from "./calendarDateArithmetic.js";
 export { calendarDateFromFields } from "./calendarDateFromFields.js";
-export { isCalendarArithmeticCompatNeeded, isNudgeWindowCompatNeeded, isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, } from "./capabilities.js";
+export { isCalendarArithmeticCompatNeeded, isDayRoundClampCompatNeeded, isNudgeWindowCompatNeeded, isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, isZIgnoreExactCompatNeeded, } from "./capabilities.js";
 export { calendarFieldsOf } from "./calendarFields.js";

package/dist/internal/temporalCompat/index.js

@@ -1,5 +1,5 @@
 // The only import surface of the Temporal compat layer. See README.md.
 export { calendarDateAdd, calendarDateUntil, } from "./calendarDateArithmetic.js";
 export { calendarDateFromFields } from "./calendarDateFromFields.js";
-export { isCalendarArithmeticCompatNeeded, isNudgeWindowCompatNeeded, isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, } from "./capabilities.js";
+export { isCalendarArithmeticCompatNeeded, isDayRoundClampCompatNeeded, isNudgeWindowCompatNeeded, isSecondsOffsetMatchCompatNeeded, isTransitionSearchCompatNeeded, isZIgnoreExactCompatNeeded, } from "./capabilities.js";
 export { calendarFieldsOf } from "./calendarFields.js";

package/dist/internal/temporalCompat/largeMonthSpan.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 import { calendarDateFromFields } from "./calendarDateFromFields.js";
 import { calendarFieldsOf } from "./calendarFields.js";
 /*

package/dist/internal/temporalCompat/nonIsoArithmetic.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 /** A date's fields in one calendar. `month` is ordinal. */
 export interface CalendarDateParts {
     year: number;

package/dist/internal/temporalCompat/nonIsoArithmetic.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../temporal.js";
 const ISO_CALENDAR = "iso8601";
 /** The estimates below are off by at most one unit; a few extra steps cost nothing. */
 const MAX_ADJUSTMENTS = 4;

package/dist/internal/temporalCompat/probeRepros.d.ts

@@ -0,0 +1,35 @@
+/** Defect ids from the temporalCompat README's workaround table. */
+export type DefectId = "D1" | "D2" | "D3" | "D4" | "D5" | "D6" | "D7" | "D8" | "D10" | "D11" | "D12" | "D13" | "D14" | "D15";
+export interface ProbeRepro {
+    defect: DefectId;
+    /** Temporal calendar id the repro exercises. */
+    calendar: string;
+    /** Short name, unique per defect and calendar. */
+    name: string;
+    /** The spec-correct output of `run()`. */
+    expected: string;
+    run: () => string;
+}
+/** The shipped-probe groups, each in the order the full table places it. */
+export declare const probeReproGroups: {
+    readonly d1: ProbeRepro[];
+    readonly d1Arithmetic: ProbeRepro[];
+    readonly d1RelativeTo: readonly [ProbeRepro];
+    readonly d10: ProbeRepro[];
+    readonly d12: ProbeRepro[];
+    readonly d13: readonly ProbeRepro[];
+    readonly d14: readonly ProbeRepro[];
+    readonly d15: readonly ProbeRepro[];
+    readonly d6: ProbeRepro[];
+    readonly d7: readonly [ProbeRepro, ProbeRepro];
+    /** D2-D5 and D8: single-read repros. */
+    readonly reads: readonly [ProbeRepro, ProbeRepro, {
+        readonly defect: "D3";
+        readonly calendar: "hebrew";
+        readonly name: "-100000-01-01";
+        readonly expected: "12";
+        readonly run: () => string;
+    }, ProbeRepro, ProbeRepro, ProbeRepro, ...ProbeRepro[]];
+};
+/** Every repro a shipped capability probe reads. */
+export declare const probeRepros: readonly ProbeRepro[];