@northguild/gmt 1.18.0 → 1.20.0

package/dist/internal/gnssTimeScales.js

@@ -0,0 +1,128 @@
+import { NANOSECONDS_PER_SECOND } from "./foreignEpochs.js";
+import { LEAP_SECOND_STEPS, taiOfUtc, utcOfTai } from "./leapSeconds.js";
+/**
+ * The satellite time scales by RINEX 4.02 §5.2.8 time-system identifier. Each `epochLabel` is
+ * `Temporal.PlainDateTime.from(<label>).toZonedDateTime("UTC").epochNanoseconds` of the label in
+ * its comment; gnssTimeScales.test.ts asserts each one. The offsets are nominal: the broadcast
+ * corrections (C0, A0/A1, GGTO), tens of nanoseconds, are not inputs.
+ */
+export const GNSS_TIME_SCALES = Object.freeze({
+    // TAI − GPS = 19 s: BIPM Annual Report vol. 15, p. 48, "[TAI - GPS time] = 19 s + C0".
+    // Epoch 1980-01-06T00:00:00: IS-GPS-200N §3.3.4, "midnight on the night of January 5,
+    // 1980/morning of January 6, 1980".
+    GPS: Object.freeze({
+        taiMinusScale: 19n,
+        epochLabel: 315964800000000000n,
+    }),
+    // TAI − GST = 19 s: BIPM utc-gnss "[UTC-GALILEO time]: (19-xx) s"; RINEX 4.02 §4.1.7 Table 1,
+    // "GPS = GAL = UTC + ΔtLS". Epoch 1999-08-22T00:00:00 GST, GPS week 1024 (RINEX 4.02 §4.1.3),
+    // 13 s before 1999-08-22T00:00:00 UTC: Galileo OS SIS ICD Issue 2.2 §5.1.2, Table 69, "GST was
+    // equal to 13 seconds on August 22nd, 1999 at 00:00:00 UTC".
+    GAL: Object.freeze({
+        taiMinusScale: 19n,
+        epochLabel: 935280000000000000n,
+    }),
+    // TAI − BDT = 33 s: BIPM utc-gnss "[UTC-BEIDOU time]: (33-xx) s". Epoch 2006-01-01T00:00:00:
+    // BDS-SIS-ICD-B1I-3.0 §3.3, "accumulates continuously without leap seconds. The start epoch
+    // of BDT is 00:00:00 on January 1, 2006 of Coordinated Universal Time (UTC)".
+    BDT: Object.freeze({
+        taiMinusScale: 33n,
+        epochLabel: 1136073600000000000n,
+    }),
+    // TAI − QZSST = 19 s, the same whole seconds as GPS time: RINEX 4.02 §4.1.7 Table 1, "GPS =
+    // QZS = UTC + ΔtLS"; IS-QZSS-PNT-006 §5.1, "delayed from TAI by 19 seconds". Weeks from
+    // GPST's 1980-01-06T00:00:00 (IS-QZSS-PNT-006 §5.1).
+    QZS: Object.freeze({
+        taiMinusScale: 19n,
+        epochLabel: 315964800000000000n,
+    }),
+    // No TAI offset: GLO is GLONASS time in UTC hours, with UTC's leap seconds. RINEX 4.02
+    // §4.1.2, "the same hours as UTC and not UTC+3 h"; §5.2.8, "GLO to identify the GLONASS UTC
+    // time"; BIPM Annual Report vol. 15 p. 49, "[UTC - GLONASS time] = 0 s + C1". No stated
+    // epoch, so labels start at 1972-01-01T00:00:00, the leap-second table's first row (owner
+    // decision D10).
+    GLO: Object.freeze({
+        taiMinusScale: null,
+        epochLabel: 63072000000000000n,
+    }),
+    // TAI − IRNSST = 19 s. RINEX 4.02 §4.1.7 Table 1 equates IRN with GPS time in whole seconds
+    // ("GPS = IRN = UTC + ΔtLS"). BIPM publishes no NavIC relation and no NavIC ICD mentions TAI,
+    // so the offset is DERIVED, and NavIC's own ICD epoch agrees: NavIC led UTC by 13 s there
+    // (RINEX 4.02 §4.1.6; ISRO-IRNSS-ICD-SPS-1.1 §5.7; ISRO-NAVIC-ICD-SPS-L1-1.0 §5.6) when
+    // TAI − UTC was 32 s (IERS), so 32 − 13. Epoch 1999-08-22T00:00:00 IRNSST =
+    // 1999-08-21T23:59:47Z (RINEX 4.02 §4.1.6; ICD SPS 1.1 §5.7).
+    IRN: Object.freeze({
+        taiMinusScale: 19n,
+        epochLabel: 935280000000000000n,
+    }),
+});
+/**
+ * Whether a value is one of the six RINEX 4.02 §5.2.8 time-system identifiers GMT reads.
+ *
+ * @param value candidate system
+ * @returns true for `GPS`, `GAL`, `BDT`, `QZS`, `GLO` or `IRN`
+ */
+export function isGnssSystem(value) {
+    return typeof value === "string" && Object.hasOwn(GNSS_TIME_SCALES, value);
+}
+/**
+ * A UTC reading as a label on a satellite system's scale.
+ *
+ * - TAI-based scales: TAI from the leap-second table, minus the scale's fixed offset. A listed
+ *   inserted second maps to its own label; the result is never second 60.
+ * - `GLO`: the reading itself, second 60 included, once the table has checked it.
+ * - `null` when the reading has no TAI instant (before 1972, or a second 60 on a day with no
+ *   insertion), or when the label falls before the scale's epoch.
+ *
+ * @param system the satellite time scale
+ * @param reading the UTC reading
+ * @returns the scale's label, or null
+ */
+export function scaleLabelOfUtc(system, reading) {
+    const scale = GNSS_TIME_SCALES[system];
+    const tai = taiOfUtc(LEAP_SECOND_STEPS, reading);
+    if (tai === null) {
+        return null;
+    }
+    const label = scale.taiMinusScale === null
+        ? {
+            labelNanoseconds: reading.epochNanoseconds,
+            secondSixty: reading.secondSixty,
+        }
+        : {
+            labelNanoseconds: tai - scale.taiMinusScale * NANOSECONDS_PER_SECOND,
+            secondSixty: false,
+        };
+    return label.labelNanoseconds < scale.epochLabel ? null : label;
+}
+/**
+ * A label on a satellite system's scale as a UTC reading.
+ *
+ * - TAI-based scales: the label plus the scale's fixed offset is TAI, read back through the
+ *   leap-second table; inside an inserted second the reading is second 60.
+ * - `GLO`: the label itself is the UTC reading; a second 60 stands only where the table lists an
+ *   insertion.
+ * - `null` before the scale's epoch, for a second-60 label on a continuous scale, and for a `GLO`
+ *   second 60 on a day with no insertion.
+ *
+ * @param system the satellite time scale
+ * @param label the scale's label
+ * @returns the UTC reading, or null
+ */
+export function utcOfScaleLabel(system, label) {
+    const scale = GNSS_TIME_SCALES[system];
+    if (label.labelNanoseconds < scale.epochLabel) {
+        return null;
+    }
+    if (scale.taiMinusScale === null) {
+        const reading = {
+            epochNanoseconds: label.labelNanoseconds,
+            secondSixty: label.secondSixty,
+        };
+        return taiOfUtc(LEAP_SECOND_STEPS, reading) === null ? null : reading;
+    }
+    if (label.secondSixty) {
+        return null;
+    }
+    return utcOfTai(LEAP_SECOND_STEPS, label.labelNanoseconds + scale.taiMinusScale * NANOSECONDS_PER_SECOND);
+}

package/dist/internal/gnssWeek.d.ts

@@ -0,0 +1,92 @@
+import type { GnssSystem, GnssWeek, GnssWeekCounter } from "../types/gnss.js";
+/** The scale a week counter counts on, and after how many weeks it wraps. */
+export interface GnssWeekCounterSpec {
+    /** The satellite time scale whose epoch is week 0 of era 0. */
+    readonly system: GnssSystem;
+    /** The number of week values the counter can show: it wraps to 0 after `modulus − 1`. */
+    readonly modulus: bigint;
+}
+/**
+ * The broadcast week counters, each with exactly one width. GLONASS broadcasts no week number,
+ * so it has none.
+ */
+export declare const GNSS_WEEK_COUNTERS: Readonly<Record<GnssWeekCounter, GnssWeekCounterSpec>>;
+/**
+ * Whether a value names one of the eight broadcast week counters.
+ *
+ * @param value candidate counter
+ * @returns true for a `GnssWeekCounter` member
+ */
+export declare function isGnssWeekCounter(value: unknown): value is GnssWeekCounter;
+/**
+ * A week number as a bigint: any safe integer from 0. The caller checks a counter's modulus.
+ *
+ * @param week candidate week number
+ * @returns the week, or null when it is not a safe integer ≥ 0
+ */
+export declare function weekNumber(week: unknown): bigint | null;
+/**
+ * Seconds of week as nanoseconds, rounded to the nearest nanosecond (TC39 Temporal's resolution;
+ * a GMT rule). Valid from 0 up to but not including one week, 604 800 s (IS-GPS-200N §3.3.4).
+ *
+ * @param timeOfWeekSeconds candidate seconds of week
+ * @returns the time of week in nanoseconds, or null when it is not a finite number in range or
+ *   rounds to a whole week
+ */
+export declare function timeOfWeekNanoseconds(timeOfWeekSeconds: unknown): bigint | null;
+/**
+ * The label `fullWeek` weeks and `timeOfWeek` nanoseconds after an epoch label.
+ *
+ * @param epochLabel week 0's first label, label nanoseconds
+ * @param fullWeek weeks since the epoch, never wrapped
+ * @param timeOfWeek nanoseconds into that week
+ * @returns the label, label nanoseconds
+ */
+export declare function labelOfFullWeek(epochLabel: bigint, fullWeek: bigint, timeOfWeek: bigint): bigint;
+/**
+ * Split a label into whole weeks since an epoch label and seconds into the week. The seconds are
+ * a `number`: the nearest double to the exact nanosecond count.
+ *
+ * @param epochLabel week 0's first label, label nanoseconds
+ * @param labelNanoseconds the label to split
+ * @returns the full week and seconds of week, or null before the epoch
+ */
+export declare function weeksSince(epochLabel: bigint, labelNanoseconds: bigint): {
+    fullWeek: bigint;
+    timeOfWeekSeconds: number;
+} | null;
+/**
+ * The era a week number belongs to.
+ *
+ * - An integer from 0 is the era itself.
+ * - `"rolling"` reads `Temporal.Now.instant()` once and picks the era within half a counter
+ *   period of the current week, clamped at era 0. Call it inside `try`: the clock read can throw.
+ * - `{ notBefore }` reads `notBefore` once and picks the earliest occurrence at or after it, so a
+ *   pivot before the counter's epoch gives era 0; other keys are ignored. It never reads the clock.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @param timeOfWeek nanoseconds into the week
+ * @param rolloverEra an integer era from 0, "rolling", or `{ notBefore }`
+ * @returns the era, or null for any other value, when the clock reads before the counter's epoch,
+ *   or for a pivot that is not an instant string or is an unlisted second 60
+ */
+export declare function resolveRolloverEra(counter: GnssWeekCounter, week: bigint, timeOfWeek: bigint, rolloverEra: unknown): bigint | null;
+/**
+ * The label of a week time on a counter: epoch + (era × modulus + week) weeks + time of week.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @param timeOfWeek nanoseconds into the week
+ * @param era how many times the counter has wrapped
+ * @returns the label on the counter's scale, label nanoseconds
+ */
+export declare function labelOfWeek(counter: GnssWeekCounter, week: bigint, timeOfWeek: bigint, era: bigint): bigint;
+/**
+ * The week, time of week and era of a label on a counter's scale.
+ *
+ * @param counter the week counter
+ * @param labelNanoseconds a label on the counter's scale
+ * @returns a new `GnssWeek`, or null before the counter's epoch
+ */
+export declare function weekOfLabel(counter: GnssWeekCounter, labelNanoseconds: bigint): GnssWeek | null;

package/dist/internal/gnssWeek.js

@@ -0,0 +1,212 @@
+import { Temporal } from "./temporal.js";
+import { NANOSECONDS_PER_SECOND, NANOSECONDS_PER_WEEK } from "./foreignEpochs.js";
+import { GNSS_TIME_SCALES, scaleLabelOfUtc } from "./gnssTimeScales.js";
+import { isObject } from "./isObject.js";
+import { LEAP_SECOND_STEPS, taiOfUtc } from "./leapSeconds.js";
+import { parseUtcReading } from "./utcReading.js";
+/**
+ * The broadcast week counters, each with exactly one width. GLONASS broadcasts no week number,
+ * so it has none.
+ */
+export const GNSS_WEEK_COUNTERS = Object.freeze({
+    // IS-GPS-200N §20.3.3.3.1.1: LNAV week, "a modulo 1024 binary representation".
+    "GPS-LNAV": Object.freeze({ system: "GPS", modulus: 1024n }),
+    // IS-GPS-200N §30.3.3.1.1.1: CNAV week, "a modulo-8192 binary representation".
+    "GPS-CNAV": Object.freeze({ system: "GPS", modulus: 8192n }),
+    // Galileo OS SIS ICD Issue 2.2 §5.1.2, Table 69: 12-bit week, "covers 4096 weeks".
+    GAL: Object.freeze({ system: "GAL", modulus: 4096n }),
+    // BDS-SIS-ICD-B1I-3.0 §5.2.4.4: 13-bit week number, "0 through 8191".
+    BDT: Object.freeze({ system: "BDT", modulus: 8192n }),
+    // IS-QZSS-PNT-006 §4.1.2.3(1): LNAV week modulo 1024.
+    "QZS-LNAV": Object.freeze({ system: "QZS", modulus: 1024n }),
+    // IS-QZSS-PNT-006 §4.2.2: CNAV week modulo 8192.
+    "QZS-CNAV": Object.freeze({ system: "QZS", modulus: 8192n }),
+    // ISRO-IRNSS-ICD-SPS-1.1 §5.7: L5/S week "coded on 10 bits … which covers 1024 weeks".
+    "IRN-LNAV": Object.freeze({ system: "IRN", modulus: 1024n }),
+    // ISRO-NAVIC-ICD-SPS-L1-1.0 §5.6: L1 week "on 13 bits … which covers 8192 weeks".
+    "IRN-L1NV": Object.freeze({ system: "IRN", modulus: 8192n }),
+});
+/**
+ * Whether a value names one of the eight broadcast week counters.
+ *
+ * @param value candidate counter
+ * @returns true for a `GnssWeekCounter` member
+ */
+export function isGnssWeekCounter(value) {
+    return typeof value === "string" && Object.hasOwn(GNSS_WEEK_COUNTERS, value);
+}
+/**
+ * A week number as a bigint: any safe integer from 0. The caller checks a counter's modulus.
+ *
+ * @param week candidate week number
+ * @returns the week, or null when it is not a safe integer ≥ 0
+ */
+export function weekNumber(week) {
+    return Number.isSafeInteger(week) && week >= 0
+        ? BigInt(week)
+        : null;
+}
+/** Nanoseconds in one second, as a `number`, for reading a seconds-of-week `number`. */
+const NANOSECONDS_PER_SECOND_NUMBER = Number(NANOSECONDS_PER_SECOND);
+/**
+ * Seconds of week as nanoseconds, rounded to the nearest nanosecond (TC39 Temporal's resolution;
+ * a GMT rule). Valid from 0 up to but not including one week, 604 800 s (IS-GPS-200N §3.3.4).
+ *
+ * @param timeOfWeekSeconds candidate seconds of week
+ * @returns the time of week in nanoseconds, or null when it is not a finite number in range or
+ *   rounds to a whole week
+ */
+export function timeOfWeekNanoseconds(timeOfWeekSeconds) {
+    if (typeof timeOfWeekSeconds !== "number" ||
+        !Number.isFinite(timeOfWeekSeconds) ||
+        timeOfWeekSeconds < 0) {
+        return null;
+    }
+    const nanoseconds = BigInt(Math.round(timeOfWeekSeconds * NANOSECONDS_PER_SECOND_NUMBER));
+    return nanoseconds < NANOSECONDS_PER_WEEK ? nanoseconds : null;
+}
+/**
+ * The label `fullWeek` weeks and `timeOfWeek` nanoseconds after an epoch label.
+ *
+ * @param epochLabel week 0's first label, label nanoseconds
+ * @param fullWeek weeks since the epoch, never wrapped
+ * @param timeOfWeek nanoseconds into that week
+ * @returns the label, label nanoseconds
+ */
+export function labelOfFullWeek(epochLabel, fullWeek, timeOfWeek) {
+    return epochLabel + fullWeek * NANOSECONDS_PER_WEEK + timeOfWeek;
+}
+/**
+ * Split a label into whole weeks since an epoch label and seconds into the week. The seconds are
+ * a `number`: the nearest double to the exact nanosecond count.
+ *
+ * @param epochLabel week 0's first label, label nanoseconds
+ * @param labelNanoseconds the label to split
+ * @returns the full week and seconds of week, or null before the epoch
+ */
+export function weeksSince(epochLabel, labelNanoseconds) {
+    const elapsed = labelNanoseconds - epochLabel;
+    if (elapsed < 0n) {
+        return null;
+    }
+    return {
+        fullWeek: elapsed / NANOSECONDS_PER_WEEK,
+        timeOfWeekSeconds: Number(elapsed % NANOSECONDS_PER_WEEK) / NANOSECONDS_PER_SECOND_NUMBER,
+    };
+}
+/**
+ * The era that puts a week within half a counter period of the current one:
+ * `Fnow − M/2 < F ≤ Fnow + M/2`, clamped at era 0 (a GMT rule, after the rolling two-digit-year
+ * window). Reads `Temporal.Now.instant()` once; call it inside `try`, as the clock read can throw.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @returns the era, or null when the clock reads before the counter's epoch
+ */
+function rollingEra(counter, week) {
+    const { system, modulus } = GNSS_WEEK_COUNTERS[counter];
+    const now = scaleLabelOfUtc(system, {
+        epochNanoseconds: Temporal.Now.instant().epochNanoseconds,
+        secondSixty: false,
+    });
+    if (now === null) {
+        return null;
+    }
+    const currentWeek = (now.labelNanoseconds - GNSS_TIME_SCALES[system].epochLabel) /
+        NANOSECONDS_PER_WEEK;
+    const numerator = currentWeek - week + modulus / 2n;
+    return numerator < 0n ? 0n : numerator / modulus;
+}
+/**
+ * The era of the earliest occurrence of a week time whose label is at or after a pivot's label:
+ * `Lp ≤ L < Lp + period`. Labels are compared, not UTC instants: every scale with a week counter
+ * is continuous, so label order is instant order and a listed leap second keeps its place.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @param timeOfWeek nanoseconds into the week
+ * @param notBefore the pivot, an ISO 8601 UTC instant string; a listed second 60 is accepted
+ * @returns the era (0 for a pivot before the counter's epoch), or null when the pivot is not an
+ *   instant string or is a second 60 the leap-second table does not list
+ */
+function pivotEra(counter, week, timeOfWeek, notBefore) {
+    const reading = parseUtcReading(notBefore);
+    if (reading === null) {
+        return null;
+    }
+    const { system, modulus } = GNSS_WEEK_COUNTERS[counter];
+    const pivot = scaleLabelOfUtc(system, reading);
+    if (pivot === null) {
+        // No label: either a second 60 the table does not list (not an instant), or an instant before
+        // the counter's epoch, including before 1972 where TAI − UTC is undefined. The earliest
+        // occurrence at or after an instant before the epoch is era 0.
+        return taiOfUtc(LEAP_SECOND_STEPS, reading) === null && reading.secondSixty
+            ? null
+            : 0n;
+    }
+    const eraZero = labelOfWeek(counter, week, timeOfWeek, 0n);
+    if (pivot.labelNanoseconds <= eraZero) {
+        return 0n;
+    }
+    const period = modulus * NANOSECONDS_PER_WEEK;
+    // Ceiling division of a positive bigint: an occurrence exactly at the pivot counts.
+    return (pivot.labelNanoseconds - eraZero + period - 1n) / period;
+}
+/**
+ * The era a week number belongs to.
+ *
+ * - An integer from 0 is the era itself.
+ * - `"rolling"` reads `Temporal.Now.instant()` once and picks the era within half a counter
+ *   period of the current week, clamped at era 0. Call it inside `try`: the clock read can throw.
+ * - `{ notBefore }` reads `notBefore` once and picks the earliest occurrence at or after it, so a
+ *   pivot before the counter's epoch gives era 0; other keys are ignored. It never reads the clock.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @param timeOfWeek nanoseconds into the week
+ * @param rolloverEra an integer era from 0, "rolling", or `{ notBefore }`
+ * @returns the era, or null for any other value, when the clock reads before the counter's epoch,
+ *   or for a pivot that is not an instant string or is an unlisted second 60
+ */
+export function resolveRolloverEra(counter, week, timeOfWeek, rolloverEra) {
+    if (rolloverEra === "rolling") {
+        return rollingEra(counter, week);
+    }
+    if (isObject(rolloverEra)) {
+        const { notBefore } = rolloverEra;
+        return pivotEra(counter, week, timeOfWeek, notBefore);
+    }
+    return weekNumber(rolloverEra);
+}
+/**
+ * The label of a week time on a counter: epoch + (era × modulus + week) weeks + time of week.
+ *
+ * @param counter the week counter
+ * @param week the week number the counter shows
+ * @param timeOfWeek nanoseconds into the week
+ * @param era how many times the counter has wrapped
+ * @returns the label on the counter's scale, label nanoseconds
+ */
+export function labelOfWeek(counter, week, timeOfWeek, era) {
+    const { system, modulus } = GNSS_WEEK_COUNTERS[counter];
+    return labelOfFullWeek(GNSS_TIME_SCALES[system].epochLabel, era * modulus + week, timeOfWeek);
+}
+/**
+ * The week, time of week and era of a label on a counter's scale.
+ *
+ * @param counter the week counter
+ * @param labelNanoseconds a label on the counter's scale
+ * @returns a new `GnssWeek`, or null before the counter's epoch
+ */
+export function weekOfLabel(counter, labelNanoseconds) {
+    const { system, modulus } = GNSS_WEEK_COUNTERS[counter];
+    const split = weeksSince(GNSS_TIME_SCALES[system].epochLabel, labelNanoseconds);
+    if (split === null) {
+        return null;
+    }
+    return {
+        week: Number(split.fullWeek % modulus),
+        timeOfWeekSeconds: split.timeOfWeekSeconds,
+        era: Number(split.fullWeek / modulus),
+    };
+}

package/dist/internal/halfOpenIntervals.d.ts

@@ -3,7 +3,7 @@
  *
  * `t ∈ [start, end) ⇔ start ≤ t < end` — EWD831, SQL:2011 closed-open `PERIOD`
  * (ISO/IEC 9075-2:2011) and RFC 5545 §3.6.1 non-inclusive `DTEND`. These helpers carry the same
- * rules as the CORE-6 `interval/` namespace (see `context/domination/specs/CORE-6-spec.md` §3)
+ * rules as the CORE-6 `interval/` namespace (see `context/coding-standards.md` § 8, half-open intervals)
  * for the positional families whose values are not instants (`PlainDate`, `PlainDateTime`,
  * `PlainTime`) and for the relations `interval/` has no function for.
  *

package/dist/internal/halfOpenIntervals.js

@@ -3,7 +3,7 @@
  *
  * `t ∈ [start, end) ⇔ start ≤ t < end` — EWD831, SQL:2011 closed-open `PERIOD`
  * (ISO/IEC 9075-2:2011) and RFC 5545 §3.6.1 non-inclusive `DTEND`. These helpers carry the same
- * rules as the CORE-6 `interval/` namespace (see `context/domination/specs/CORE-6-spec.md` §3)
+ * rules as the CORE-6 `interval/` namespace (see `context/coding-standards.md` § 8, half-open intervals)
  * for the positional families whose values are not instants (`PlainDate`, `PlainDateTime`,
  * `PlainTime`) and for the relations `interval/` has no function for.
  *

package/dist/internal/hasCalendarAnnotation.d.ts

@@ -3,10 +3,10 @@
  *
  * RFC 9557 lets any suffix annotation carry a critical flag (§3.3; `critical-flag` in the §4.1
  * ABNF), and Temporal honours it for the calendar key:
- * `Temporal.ZonedDateTime.from("5784-01-01T14:30:00-05:00[America/New_York][!u-ca=hebrew]")`
+ * `Temporal.ZonedDateTime.from("5784-01-01T14:30:00+02:00[Asia/Jerusalem][!u-ca=hebrew]")`
  * succeeds in the Hebrew calendar, reading ISO year 5784 as Hebrew year 9544. The flag only makes
  * the annotation harder to ignore, so `[!u-ca=...]` is detected exactly like `[u-ca=...]`. A
- * critical time-zone annotation (`[!America/New_York]`) carries no key and does not match.
+ * critical time-zone annotation (`[!Asia/Jerusalem]`) carries no key and does not match.
  * Temporal rejects an upper-case `[U-CA=` key outright, so it needs no special case.
  *
  * Since CORE-8 (#22) the non-calendar validators no longer use it: `isValidDate`,
@@ -22,6 +22,6 @@
  *
  * @example hasCalendarAnnotation("2024-02-10T12:00:00Z[u-ca=hebrew]") // true
  * @example hasCalendarAnnotation("2024-02-10T12:00:00Z[!u-ca=hebrew]") // true (critical flag)
- * @example hasCalendarAnnotation("2024-02-10T12:00:00-05:00[!America/New_York]") // false (a zone, not a calendar)
+ * @example hasCalendarAnnotation("2024-02-10T12:00:00+02:00[!Asia/Jerusalem]") // false (a zone, not a calendar)
  */
 export declare function hasCalendarAnnotation(value: string): boolean;

package/dist/internal/hasCalendarAnnotation.js

@@ -5,10 +5,10 @@ const calendarAnnotation = /\[!?u-ca=/;
  *
  * RFC 9557 lets any suffix annotation carry a critical flag (§3.3; `critical-flag` in the §4.1
  * ABNF), and Temporal honours it for the calendar key:
- * `Temporal.ZonedDateTime.from("5784-01-01T14:30:00-05:00[America/New_York][!u-ca=hebrew]")`
+ * `Temporal.ZonedDateTime.from("5784-01-01T14:30:00+02:00[Asia/Jerusalem][!u-ca=hebrew]")`
  * succeeds in the Hebrew calendar, reading ISO year 5784 as Hebrew year 9544. The flag only makes
  * the annotation harder to ignore, so `[!u-ca=...]` is detected exactly like `[u-ca=...]`. A
- * critical time-zone annotation (`[!America/New_York]`) carries no key and does not match.
+ * critical time-zone annotation (`[!Asia/Jerusalem]`) carries no key and does not match.
  * Temporal rejects an upper-case `[U-CA=` key outright, so it needs no special case.
  *
  * Since CORE-8 (#22) the non-calendar validators no longer use it: `isValidDate`,
@@ -24,7 +24,7 @@ const calendarAnnotation = /\[!?u-ca=/;
  *
  * @example hasCalendarAnnotation("2024-02-10T12:00:00Z[u-ca=hebrew]") // true
  * @example hasCalendarAnnotation("2024-02-10T12:00:00Z[!u-ca=hebrew]") // true (critical flag)
- * @example hasCalendarAnnotation("2024-02-10T12:00:00-05:00[!America/New_York]") // false (a zone, not a calendar)
+ * @example hasCalendarAnnotation("2024-02-10T12:00:00+02:00[!Asia/Jerusalem]") // false (a zone, not a calendar)
  */
 export function hasCalendarAnnotation(value) {
     return typeof value === "string" && calendarAnnotation.test(value);

package/dist/internal/hourDurationString.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { NANOSECONDS_PER_MICROSECOND, NANOSECONDS_PER_MILLISECOND, NANOSECONDS_PER_SECOND, } from "./foreignEpochs.js";
 const NANOSECONDS_PER_HOUR = 3600000000000n;
 const NANOSECONDS_PER_MINUTE = 60000000000n;

package/dist/internal/httpDateFields.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { ENGLISH_MONTH_NAMES, ENGLISH_WEEKDAY_NAMES, } from "./englishCalendarNames.js";
 // RFC 9110 §5.6.7 obsolete formats. HTTP-date is case-sensitive (%s strings).
 //   rfc850-date  = day-name-l "," SP date2 SP time-of-day SP GMT

package/dist/internal/index.d.ts

@@ -8,13 +8,14 @@ export { calendarOfAllZonedValues, calendarSystemOfZonedValue, } from "./calenda
 export { formatZonedInCalendar, parseCalendarZonedValue, } from "./calendarZonedString.js";
 export { cycleFieldValue } from "./cycleFieldValue.js";
 export { isInDaylightTime, observesDaylightTime } from "./daylightTime.js";
-export { fiscalPeriodOfWeek, fiscalYearOf } from "./fiscalCalendar.js";
+export { fiscalPeriodOfWeek, fiscalYearLabel, fiscalYearOf, gregorianCycleShift, } from "./fiscalCalendar.js";
 export { floorDivide } from "./floorDivide.js";
 export { DOT_NET_TICKS_EPOCH_OFFSET, EXCEL_1900_EPOCH_NANOSECONDS, EXCEL_1900_PHANTOM_END_NANOSECONDS, EXCEL_1900_PRE_PHANTOM_EPOCH_NANOSECONDS, EXCEL_1904_EPOCH_NANOSECONDS, EXCEL_PHANTOM_SERIAL, FILE_TIME_EPOCH_OFFSET_TICKS, MAX_DOT_NET_TICKS, MAX_EXCEL_1900_SERIAL_EXCLUSIVE, MAX_EXCEL_1904_SERIAL_EXCLUSIVE, MAX_FILE_TIME, MILLISECONDS_PER_DAY, MIN_DOT_NET_TICKS, MIN_EXCEL_1900_SERIAL, MIN_EXCEL_1904_SERIAL, MIN_FILE_TIME, MIN_PG_MICROSECONDS, NANOSECONDS_PER_DAY, NANOSECONDS_PER_DAY_NUMBER, NANOSECONDS_PER_MICROSECOND, NANOSECONDS_PER_MILLISECOND, NANOSECONDS_PER_SECOND, NANOSECONDS_PER_TICK, NTP_EPOCH_OFFSET_NANOSECONDS, NTP_ERA_UNITS, NTP_UNITS_PER_SECOND, PG_EPOCH_OFFSET_MICROSECONDS, } from "./foreignEpochs.js";
 export { isValidEpochNanoseconds, MAX_EPOCH_NANOSECOND_DIGITS, } from "./epochNanoseconds.js";
 export { dateCycleFieldBounds } from "./dateCycleFieldBounds.js";
 export { timeCycleFieldBounds } from "./timeCycleFieldBounds.js";
 export { durationUntilString } from "./durationUntilString.js";
+export { EDIFACT_DTM_FORMATS, X12_DATE_TIME_PERIOD_FORMATS, X12_TIME_CODES, } from "./ediGrammar.js";
 export { exactDurationNanoseconds, nonNegativeExactDurationNanoseconds, } from "./exactDuration.js";
 export { type ExactMoment, readExactMoment, writeExactMoment, } from "./exactMoment.js";
 export { formatDateInCalendar } from "./formatDateInCalendar.js";
@@ -26,7 +27,12 @@ export { canonicalInstantIntervals } from "./instantIntervalText.js";
 export { instantFrom, parseInstantNanoseconds } from "./instantNanoseconds.js";
 export { coalesceIntervalNanoseconds, parseIntervalNanoseconds, parseIntervalNanosecondsList, } from "./intervalNanoseconds.js";
 export { resolveDurationRelativeTo } from "./resolveDurationRelativeTo.js";
-export { formatUtcOffset, parseUtcOffsetNanoseconds } from "./utcOffsetString.js";
+export { formatUtcOffset, parseUtcOffsetNanoseconds, writtenOffset, } from "./utcOffsetString.js";
+export { formatUtcReading, parseUtcReading } from "./utcReading.js";
+export { isGnssSystem, scaleLabelOfUtc, utcOfScaleLabel, } from "./gnssTimeScales.js";
+export { GNSS_WEEK_COUNTERS, isGnssWeekCounter, labelOfFullWeek, labelOfWeek, resolveRolloverEra, timeOfWeekNanoseconds, weekNumber, weekOfLabel, weeksSince, } from "./gnssWeek.js";
+export { isRinexWeekSystem, RINEX_WEEK_EPOCHS } from "./rinexWeek.js";
+export { formatTimeScaleString, parseTimeScaleString } from "./timeScaleString.js";
 export { ENGLISH_MONTH_NAMES, ENGLISH_WEEKDAY_NAMES, } from "./englishCalendarNames.js";
 export { defaultFractionalDigits } from "./defaultFractionalDigits.js";
 export { getLocaleFirstDayOfWeek } from "./getLocaleFirstDayOfWeek.js";
@@ -37,6 +43,7 @@ export { getUnitSpan } from "./intervalCountHelpers.js";
 export { isObject, isOptionsArgument } from "./isObject.js";
 export { isValidAmount } from "./isValidAmount.js";
 export { joinDateTimeConnector } from "./joinDateTimeConnector.js";
+export { LEAP_SECOND_STEPS, nextStepIndex, stepReading, taiOfUtc, utcOfTai, } from "./leapSeconds.js";
 export { isValidDayOfWeek } from "./isValidDayOfWeek.js";
 export { monthGridWeekRow } from "./monthGridWeekRow.js";
 export { normalizeDateTime } from "./normalizeDateTime.js";
@@ -45,16 +52,18 @@ export { plainDateAdd } from "./plainDateAdd.js";
 export { parsePunctualityTolerance, punctualityOf } from "./punctuality.js";
 export { plainDateUntil } from "./plainDateUntil.js";
 export { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
+export { readDurationUnits } from "./readDurationUnits.js";
+export { DATE_FIELDS, DATE_TIME_FIELDS, readSetFields, TIME_FIELDS, } from "./readSetFields.js";
 export { resolveDurationUnit } from "./resolveDurationUnit.js";
 export { resolveOverflow } from "./resolveOverflow.js";
-export { resolveRelativeRounding } from "./resolveRelativeRounding.js";
 export { parseUnixEpochInterval, parseUnixEpochIntervalList, parseUnixEpochIntervalPair, parseUnixEpochValue, } from "./unixEpochValue.js";
 export { tileByUnit } from "./splitStep.js";
 export { parseTimestampEvents } from "./timestampEvents.js";
 export { countZonedBuckets, nextZonedBucketStart, type WeekStartDay, zonedUnitEnd, zonedUnitStart, } from "./zonedBucket.js";
 export { countZonedLocalDates } from "./zonedLocalDates.js";
-export { zonedDateTimeFrom } from "./zonedWallClock.js";
+export { isWithinIsoDaysRange, UTC_OFFSET_WITH_SECONDS, zonedDateTimeFrom, } from "./zonedWallClock.js";
 export { wallClockAtOffset } from "./wallClockAtOffset.js";
 export { durationCompare, durationRound, durationTotal, isCalendarDifferenceAcrossZones, plainUntilWithRounding, zonedUntil, } from "./zonedWallClockDifference.js";
-export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedPreviousTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
+export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
 export { zonelessCalendarDate } from "./zonelessCalendarDate.js";
+export { frameInstant, frameOffset, frameWallClock, frameZoned, instantOfWallClock, normalizeZoneFrame, zoneFrame, } from "./zoneFrame.js";

package/dist/internal/index.js

@@ -8,13 +8,18 @@ export { calendarOfAllZonedValues, calendarSystemOfZonedValue, } from "./calenda
 export { formatZonedInCalendar, parseCalendarZonedValue, } from "./calendarZonedString.js";
 export { cycleFieldValue } from "./cycleFieldValue.js";
 export { isInDaylightTime, observesDaylightTime } from "./daylightTime.js";
-export { fiscalPeriodOfWeek, fiscalYearOf } from "./fiscalCalendar.js";
+export { fiscalPeriodOfWeek, fiscalYearLabel, fiscalYearOf, gregorianCycleShift, } from "./fiscalCalendar.js";
 export { floorDivide } from "./floorDivide.js";
 export { DOT_NET_TICKS_EPOCH_OFFSET, EXCEL_1900_EPOCH_NANOSECONDS, EXCEL_1900_PHANTOM_END_NANOSECONDS, EXCEL_1900_PRE_PHANTOM_EPOCH_NANOSECONDS, EXCEL_1904_EPOCH_NANOSECONDS, EXCEL_PHANTOM_SERIAL, FILE_TIME_EPOCH_OFFSET_TICKS, MAX_DOT_NET_TICKS, MAX_EXCEL_1900_SERIAL_EXCLUSIVE, MAX_EXCEL_1904_SERIAL_EXCLUSIVE, MAX_FILE_TIME, MILLISECONDS_PER_DAY, MIN_DOT_NET_TICKS, MIN_EXCEL_1900_SERIAL, MIN_EXCEL_1904_SERIAL, MIN_FILE_TIME, MIN_PG_MICROSECONDS, NANOSECONDS_PER_DAY, NANOSECONDS_PER_DAY_NUMBER, NANOSECONDS_PER_MICROSECOND, NANOSECONDS_PER_MILLISECOND, NANOSECONDS_PER_SECOND, NANOSECONDS_PER_TICK, NTP_EPOCH_OFFSET_NANOSECONDS, NTP_ERA_UNITS, NTP_UNITS_PER_SECOND, PG_EPOCH_OFFSET_MICROSECONDS, } from "./foreignEpochs.js";
 export { isValidEpochNanoseconds, MAX_EPOCH_NANOSECOND_DIGITS, } from "./epochNanoseconds.js";
 export { dateCycleFieldBounds } from "./dateCycleFieldBounds.js";
 export { timeCycleFieldBounds } from "./timeCycleFieldBounds.js";
 export { durationUntilString } from "./durationUntilString.js";
+// The EDI readers (./ediDateTimeFields) and writers (./ediDateTimeWriter) are deliberately not
+// re-exported here: they import `instant/convert/toOffsetInstant`, which reads this barrel at
+// module top level, so a barrel entry would close a cycle. Import each from its own file
+// ("../../internal/ediDateTimeFields", "../../internal/ediDateTimeWriter").
+export { EDIFACT_DTM_FORMATS, X12_DATE_TIME_PERIOD_FORMATS, X12_TIME_CODES, } from "./ediGrammar.js";
 export { exactDurationNanoseconds, nonNegativeExactDurationNanoseconds, } from "./exactDuration.js";
 export { readExactMoment, writeExactMoment, } from "./exactMoment.js";
 export { formatDateInCalendar } from "./formatDateInCalendar.js";
@@ -26,7 +31,12 @@ export { canonicalInstantIntervals } from "./instantIntervalText.js";
 export { instantFrom, parseInstantNanoseconds } from "./instantNanoseconds.js";
 export { coalesceIntervalNanoseconds, parseIntervalNanoseconds, parseIntervalNanosecondsList, } from "./intervalNanoseconds.js";
 export { resolveDurationRelativeTo } from "./resolveDurationRelativeTo.js";
-export { formatUtcOffset, parseUtcOffsetNanoseconds } from "./utcOffsetString.js";
+export { formatUtcOffset, parseUtcOffsetNanoseconds, writtenOffset, } from "./utcOffsetString.js";
+export { formatUtcReading, parseUtcReading } from "./utcReading.js";
+export { isGnssSystem, scaleLabelOfUtc, utcOfScaleLabel, } from "./gnssTimeScales.js";
+export { GNSS_WEEK_COUNTERS, isGnssWeekCounter, labelOfFullWeek, labelOfWeek, resolveRolloverEra, timeOfWeekNanoseconds, weekNumber, weekOfLabel, weeksSince, } from "./gnssWeek.js";
+export { isRinexWeekSystem, RINEX_WEEK_EPOCHS } from "./rinexWeek.js";
+export { formatTimeScaleString, parseTimeScaleString } from "./timeScaleString.js";
 export { ENGLISH_MONTH_NAMES, ENGLISH_WEEKDAY_NAMES, } from "./englishCalendarNames.js";
 export { defaultFractionalDigits } from "./defaultFractionalDigits.js";
 export { getLocaleFirstDayOfWeek } from "./getLocaleFirstDayOfWeek.js";
@@ -37,6 +47,7 @@ export { getUnitSpan } from "./intervalCountHelpers.js";
 export { isObject, isOptionsArgument } from "./isObject.js";
 export { isValidAmount } from "./isValidAmount.js";
 export { joinDateTimeConnector } from "./joinDateTimeConnector.js";
+export { LEAP_SECOND_STEPS, nextStepIndex, stepReading, taiOfUtc, utcOfTai, } from "./leapSeconds.js";
 export { isValidDayOfWeek } from "./isValidDayOfWeek.js";
 export { monthGridWeekRow } from "./monthGridWeekRow.js";
 export { normalizeDateTime } from "./normalizeDateTime.js";
@@ -45,16 +56,18 @@ export { plainDateAdd } from "./plainDateAdd.js";
 export { parsePunctualityTolerance, punctualityOf } from "./punctuality.js";
 export { plainDateUntil } from "./plainDateUntil.js";
 export { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
+export { readDurationUnits } from "./readDurationUnits.js";
+export { DATE_FIELDS, DATE_TIME_FIELDS, readSetFields, TIME_FIELDS, } from "./readSetFields.js";
 export { resolveDurationUnit } from "./resolveDurationUnit.js";
 export { resolveOverflow } from "./resolveOverflow.js";
-export { resolveRelativeRounding } from "./resolveRelativeRounding.js";
 export { parseUnixEpochInterval, parseUnixEpochIntervalList, parseUnixEpochIntervalPair, parseUnixEpochValue, } from "./unixEpochValue.js";
 export { tileByUnit } from "./splitStep.js";
 export { parseTimestampEvents } from "./timestampEvents.js";
 export { countZonedBuckets, nextZonedBucketStart, zonedUnitEnd, zonedUnitStart, } from "./zonedBucket.js";
 export { countZonedLocalDates } from "./zonedLocalDates.js";
-export { zonedDateTimeFrom } from "./zonedWallClock.js";
+export { isWithinIsoDaysRange, UTC_OFFSET_WITH_SECONDS, zonedDateTimeFrom, } from "./zonedWallClock.js";
 export { wallClockAtOffset } from "./wallClockAtOffset.js";
 export { durationCompare, durationRound, durationTotal, isCalendarDifferenceAcrossZones, plainUntilWithRounding, zonedUntil, } from "./zonedWallClockDifference.js";
-export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedPreviousTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
+export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
 export { zonelessCalendarDate } from "./zonelessCalendarDate.js";
+export { frameInstant, frameOffset, frameWallClock, frameZoned, instantOfWallClock, normalizeZoneFrame, zoneFrame, } from "./zoneFrame.js";