@northguild/gmt 1.19.0 → 1.20.0

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,7 +8,7 @@ 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";
@@ -27,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";
@@ -38,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";
@@ -55,7 +61,7 @@ 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, zonedStartOfDay, } from "./zonedWallClockOperations.js";

package/dist/internal/index.js

@@ -8,7 +8,7 @@ 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";
@@ -31,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";
@@ -42,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";
@@ -59,7 +65,7 @@ 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, zonedStartOfDay, } from "./zonedWallClockOperations.js";

package/dist/internal/inputChecks.d.ts

@@ -0,0 +1,53 @@
+import type { RollConvention } from "../types/index.js";
+/** The cores of the `isValid*` functions, so a public function never calls another. */
+/**
+ * The check behind `isValidTimeZone`: an IANA name or a UTC offset to the minute. A pass is
+ * remembered, so a repeat builds nothing.
+ *
+ * @param timeZone the candidate
+ * @returns whether it names a zone
+ *
+ * @example isZoneId("Europe/London") // true
+ * @example isZoneId("Not/AZone") // false
+ */
+export declare function isZoneId(timeZone: unknown): boolean;
+/**
+ * The check behind `isValidTime`: a plain ISO 8601 time of day.
+ *
+ * @param value the candidate string
+ * @returns whether Temporal reads it as a `PlainTime` and it has the strict shape
+ *
+ * @example isTimeString("17:00") // true
+ * @example isTimeString("25:00") // false
+ */
+export declare function isTimeString(value: string): boolean;
+/**
+ * The check behind `isValidDate`: a plain ISO 8601 calendar date.
+ *
+ * @param value the candidate string
+ * @returns whether Temporal reads it as an ISO calendar `PlainDate` and it has the strict shape
+ *
+ * @example isDateString("2024-02-29") // true
+ * @example isDateString("2024-02-30") // false
+ */
+export declare function isDateString(value: string): boolean;
+/**
+ * The check behind `isValidDuration`: an ISO 8601 duration string.
+ *
+ * @param value the candidate
+ * @returns whether it is a string Temporal reads as a `Duration`
+ *
+ * @example isDurationString("P1DT2H") // true
+ * @example isDurationString("2 days") // false
+ */
+export declare function isDurationString(value: unknown): boolean;
+/**
+ * The check behind `isValidRollConvention`: membership in the roll set.
+ *
+ * @param convention the candidate
+ * @returns whether it is one of the six conventions
+ *
+ * @example isRollConventionName("following") // true
+ * @example isRollConventionName("nearest") // false
+ */
+export declare function isRollConventionName(convention: unknown): convention is RollConvention;

package/dist/internal/inputChecks.js

@@ -0,0 +1,132 @@
+import { Temporal } from "./temporal.js";
+import { isoStringBody } from "./isoStringBody.js";
+import { isRememberedZone, rememberZone } from "./validatedZones.js";
+import { hasSecond60 } from "../plain/validate/hasSecond60.js";
+import { plainDate, plainTime, timeZoneLike } from "../regex/index.js";
+/** The cores of the `isValid*` functions, so a public function never calls another. */
+/**
+ * The check behind `isValidTimeZone`: an IANA name or a UTC offset to the minute. A pass is
+ * remembered, so a repeat builds nothing.
+ *
+ * @param timeZone the candidate
+ * @returns whether it names a zone
+ *
+ * @example isZoneId("Europe/London") // true
+ * @example isZoneId("Not/AZone") // false
+ */
+export function isZoneId(timeZone) {
+    if (typeof timeZone === "string" && isRememberedZone(timeZone)) {
+        return true;
+    }
+    try {
+        // The fixed 2020 bag is never near the range edge, so `zonedDateTimeFrom`'s only
+        // workaround does not apply; calling Temporal directly keeps `zonedWallClock` out of the
+        // business-day entries.
+        Temporal.ZonedDateTime.from({
+            year: 2020,
+            month: 2,
+            day: 28,
+            hour: 0,
+            minute: 0,
+            second: 0,
+            timeZone: timeZone,
+        });
+        if (!timeZoneLike.test(timeZone)) {
+            return false;
+        }
+        // Only a pass is stored, so hostile strings cannot grow the set.
+        if (typeof timeZone !== "string") {
+            return true;
+        }
+        rememberZone(timeZone);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The check behind `isValidTime`: a plain ISO 8601 time of day.
+ *
+ * @param value the candidate string
+ * @returns whether Temporal reads it as a `PlainTime` and it has the strict shape
+ *
+ * @example isTimeString("17:00") // true
+ * @example isTimeString("25:00") // false
+ */
+export function isTimeString(value) {
+    const body = isoStringBody(value);
+    if (hasSecond60(body) || !plainTime.test(body)) {
+        return false;
+    }
+    try {
+        Temporal.PlainTime.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The check behind `isValidDate`: a plain ISO 8601 calendar date.
+ *
+ * @param value the candidate string
+ * @returns whether Temporal reads it as an ISO calendar `PlainDate` and it has the strict shape
+ *
+ * @example isDateString("2024-02-29") // true
+ * @example isDateString("2024-02-30") // false
+ */
+export function isDateString(value) {
+    const body = isoStringBody(value);
+    if (hasSecond60(body) || !plainDate.test(body)) {
+        return false;
+    }
+    try {
+        return Temporal.PlainDate.from(value).calendarId === "iso8601";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The check behind `isValidDuration`: an ISO 8601 duration string.
+ *
+ * @param value the candidate
+ * @returns whether it is a string Temporal reads as a `Duration`
+ *
+ * @example isDurationString("P1DT2H") // true
+ * @example isDurationString("2 days") // false
+ */
+export function isDurationString(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    try {
+        Temporal.Duration.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const ROLL_CONVENTIONS = [
+    "following",
+    "modifiedFollowing",
+    "preceding",
+    "modifiedPreceding",
+    "endOfMonth",
+    "none",
+];
+/**
+ * The check behind `isValidRollConvention`: membership in the roll set.
+ *
+ * @param convention the candidate
+ * @returns whether it is one of the six conventions
+ *
+ * @example isRollConventionName("following") // true
+ * @example isRollConventionName("nearest") // false
+ */
+export function isRollConventionName(convention) {
+    return (typeof convention === "string" &&
+        ROLL_CONVENTIONS.includes(convention));
+}

package/dist/internal/instantFormatOptions.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 type Options = Intl.DateTimeFormatOptions;
 /**
  * Resolve caller options into runtime `Intl.DateTimeFormat` options that