@northguild/gmt 1.18.0 → 1.20.0

package/dist/gnss/convert/rinexWeekToUtc.js

@@ -0,0 +1,57 @@
+import { formatUtcReading, isRinexWeekSystem, labelOfFullWeek, RINEX_WEEK_EPOCHS, timeOfWeekNanoseconds, utcOfScaleLabel, weekNumber, } from "../../internal/index.js";
+/**
+ * Convert a week number from a RINEX navigation file, and the seconds of that week, to a UTC
+ * instant string.
+ *
+ * - A RINEX navigation record's week is a continuous count that never wraps. For GPS, QZSS, NavIC
+ *   and Galileo records it counts from the GPS epoch, 1980-01-06 (RINEX 4.02 Table A30: "Continuous
+ *   number, not mod (1024), counted from 1980 (same as GPS)"; Tables A9, A13, A19). A BeiDou record
+ *   counts BDT weeks from 2006-01-01 (RINEX 4.02 §5.4.6, Table A23).
+ * - CNAV/CNAV-2, BDS CNAV-1/2/3 and NavIC L1NV records have no week column: take the week from the
+ *   record's epoch line.
+ * - It is not the week a satellite broadcasts: a NavIC broadcast week counts from 1999 and wraps.
+ *   Use `gnssWeekToUtc` for those.
+ * - A full GPS week number from any other source is the same count, so `"GPS"` reads it too.
+ * - GLONASS records carry no week number.
+ * - A week time inside an inserted leap second returns `…T23:59:60Z`.
+ * - `timeOfWeekSeconds` may have a fraction; it is rounded to the nearest nanosecond, and a value
+ *   that rounds to 604 800 s returns "".
+ * - "" for a negative or non-integer week, a time of week outside 0 up to 604 800, a time before
+ *   the system's epoch (Galileo and NavIC time start on 1999-08-22, RINEX week 1024), a result past
+ *   year 9999, and on invalid input.
+ *
+ * @param system the RINEX record's system: "GPS", "GAL", "BDT", "QZS" or "IRN"
+ * @param week the record's week number
+ * @param timeOfWeekSeconds seconds since the start of the week, 0 up to but not including 604 800, rounded to the nearest nanosecond; a value that rounds to 604 800 s returns ""
+ * @returns ISO 8601 UTC instant string (`Z`), or "" on invalid input
+ *
+ * @example rinexWeekToUtc("IRN", 2295, 86418) // "2024-01-01T00:00:00Z"
+ * @example rinexWeekToUtc("GPS", 1930, 17) // "2016-12-31T23:59:60Z"
+ * @example rinexWeekToUtc("GPS", 3072, 0) // "2038-11-20T23:59:42Z"
+ * @example rinexWeekToUtc("BDT", 809, 165600) // "2021-07-05T21:59:56Z" — RINEX Table A27's C05 record
+ * @example rinexWeekToUtc("GPS", -1, 0) // ""
+ */
+export function rinexWeekToUtc(system, week, timeOfWeekSeconds) {
+    try {
+        if (!isRinexWeekSystem(system)) {
+            return "";
+        }
+        const fullWeek = weekNumber(week);
+        if (fullWeek === null) {
+            return "";
+        }
+        const timeOfWeek = timeOfWeekNanoseconds(timeOfWeekSeconds);
+        if (timeOfWeek === null) {
+            return "";
+        }
+        const epoch = RINEX_WEEK_EPOCHS[system];
+        const reading = utcOfScaleLabel(epoch.system, {
+            labelNanoseconds: labelOfFullWeek(epoch.epochLabel, fullWeek, timeOfWeek),
+            secondSixty: false,
+        });
+        return reading === null ? "" : formatUtcReading(reading);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/gnss/convert/utcToGnss.d.ts

@@ -0,0 +1,38 @@
+import type { GnssSystem } from "../../types/gnss.js";
+/**
+ * Convert a UTC instant to a satellite system's own time, as a time-scale string.
+ *
+ * - `GPS`, `GAL`, `BDT`, `QZS`: continuous scales a fixed number of seconds behind TAI (19, 19, 33,
+ *   19), so their lead over UTC grows with every leap second and is read from the built-in table,
+ *   never fixed. GPS was 0 s ahead at its 1980 epoch and is 18 s ahead since 2017.
+ * - `IRN`: NavIC time, 19 s behind TAI. RINEX 4.02 Table 1 equates IRN with GPS time in whole
+ *   seconds; BIPM publishes no NavIC relation, so the offset is derived, and NavIC's own ICD epoch
+ *   (13 s ahead of UTC when TAI − UTC was 32 s) agrees.
+ * - `GLO`: GLONASS time as RINEX and BIPM report it, "the same hours as UTC and not UTC+3 h" (RINEX
+ *   4.02 §4.1.2), with UTC's leap seconds: the label is UTC's own wall clock. A raw broadcast
+ *   GLONASS system time, which runs three hours ahead, must have the three hours removed first.
+ * - The token after the space is the system's RINEX time-system identifier.
+ * - Nominal scale relations only: the nanosecond corrections a satellite broadcasts are not applied.
+ * - Galileo's count starts 13 s before 1999-08-22T00:00:00 UTC (Galileo OS SIS ICD Issue 2.2 §5.1.2).
+ * - "" before the system's epoch (GPS and QZSS 1980-01-06, Galileo 1999-08-21T23:59:47Z, BeiDou
+ *   2006-01-01, GLONASS 1972-01-01, NavIC 1999-08-21T23:59:47Z), for a result past year 9999, and
+ *   on invalid input.
+ *
+ * @param system satellite time scale: "GPS", "GAL", "BDT", "QZS", "GLO" or "IRN"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns the system's time-scale string, or "" on invalid input or before the system's epoch
+ *
+ * @example utcToGnss("GPS", "1980-01-06T00:00:00Z") // "1980-01-06T00:00:00 GPS" — 0 s at the GPS epoch
+ * @example utcToGnss("GPS", "2016-06-01T00:00:00Z") // "2016-06-01T00:00:17 GPS"
+ * @example utcToGnss("GPS", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 GPS"
+ * @example utcToGnss("GPS", "2016-12-31T23:59:60Z") // "2017-01-01T00:00:17 GPS"
+ * @example utcToGnss("GAL", "1999-08-22T00:00:00Z") // "1999-08-22T00:00:13 GAL"
+ * @example utcToGnss("BDT", "2006-01-01T00:00:00Z") // "2006-01-01T00:00:00 BDT"
+ * @example utcToGnss("BDT", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:04 BDT"
+ * @example utcToGnss("QZS", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 QZS"
+ * @example utcToGnss("GLO", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:00 GLO"
+ * @example utcToGnss("GLO", "2016-12-31T23:59:60Z") // "2016-12-31T23:59:60 GLO"
+ * @example utcToGnss("IRN", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 IRN"
+ * @example utcToGnss("BDT", "2005-12-31T23:59:59Z") // "" — before BeiDou's epoch
+ */
+export declare function utcToGnss(system: GnssSystem, utcString: string): string;

package/dist/gnss/convert/utcToGnss.js

@@ -0,0 +1,53 @@
+import { formatTimeScaleString, isGnssSystem, parseUtcReading, scaleLabelOfUtc, } from "../../internal/index.js";
+/**
+ * Convert a UTC instant to a satellite system's own time, as a time-scale string.
+ *
+ * - `GPS`, `GAL`, `BDT`, `QZS`: continuous scales a fixed number of seconds behind TAI (19, 19, 33,
+ *   19), so their lead over UTC grows with every leap second and is read from the built-in table,
+ *   never fixed. GPS was 0 s ahead at its 1980 epoch and is 18 s ahead since 2017.
+ * - `IRN`: NavIC time, 19 s behind TAI. RINEX 4.02 Table 1 equates IRN with GPS time in whole
+ *   seconds; BIPM publishes no NavIC relation, so the offset is derived, and NavIC's own ICD epoch
+ *   (13 s ahead of UTC when TAI − UTC was 32 s) agrees.
+ * - `GLO`: GLONASS time as RINEX and BIPM report it, "the same hours as UTC and not UTC+3 h" (RINEX
+ *   4.02 §4.1.2), with UTC's leap seconds: the label is UTC's own wall clock. A raw broadcast
+ *   GLONASS system time, which runs three hours ahead, must have the three hours removed first.
+ * - The token after the space is the system's RINEX time-system identifier.
+ * - Nominal scale relations only: the nanosecond corrections a satellite broadcasts are not applied.
+ * - Galileo's count starts 13 s before 1999-08-22T00:00:00 UTC (Galileo OS SIS ICD Issue 2.2 §5.1.2).
+ * - "" before the system's epoch (GPS and QZSS 1980-01-06, Galileo 1999-08-21T23:59:47Z, BeiDou
+ *   2006-01-01, GLONASS 1972-01-01, NavIC 1999-08-21T23:59:47Z), for a result past year 9999, and
+ *   on invalid input.
+ *
+ * @param system satellite time scale: "GPS", "GAL", "BDT", "QZS", "GLO" or "IRN"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns the system's time-scale string, or "" on invalid input or before the system's epoch
+ *
+ * @example utcToGnss("GPS", "1980-01-06T00:00:00Z") // "1980-01-06T00:00:00 GPS" — 0 s at the GPS epoch
+ * @example utcToGnss("GPS", "2016-06-01T00:00:00Z") // "2016-06-01T00:00:17 GPS"
+ * @example utcToGnss("GPS", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 GPS"
+ * @example utcToGnss("GPS", "2016-12-31T23:59:60Z") // "2017-01-01T00:00:17 GPS"
+ * @example utcToGnss("GAL", "1999-08-22T00:00:00Z") // "1999-08-22T00:00:13 GAL"
+ * @example utcToGnss("BDT", "2006-01-01T00:00:00Z") // "2006-01-01T00:00:00 BDT"
+ * @example utcToGnss("BDT", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:04 BDT"
+ * @example utcToGnss("QZS", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 QZS"
+ * @example utcToGnss("GLO", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:00 GLO"
+ * @example utcToGnss("GLO", "2016-12-31T23:59:60Z") // "2016-12-31T23:59:60 GLO"
+ * @example utcToGnss("IRN", "2024-01-01T00:00:00Z") // "2024-01-01T00:00:18 IRN"
+ * @example utcToGnss("BDT", "2005-12-31T23:59:59Z") // "" — before BeiDou's epoch
+ */
+export function utcToGnss(system, utcString) {
+    try {
+        if (!isGnssSystem(system)) {
+            return "";
+        }
+        const reading = parseUtcReading(utcString);
+        if (reading === null) {
+            return "";
+        }
+        const label = scaleLabelOfUtc(system, reading);
+        return label === null ? "" : formatTimeScaleString(label, system);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/gnss/convert/utcToGnssWeek.d.ts

@@ -0,0 +1,24 @@
+import type { GnssWeek, GnssWeekCounter } from "../../types/gnss.js";
+/**
+ * Return the week, time of week and era of a UTC instant on a satellite week counter.
+ *
+ * - The inverse of `gnssWeekToUtc`: `week` is what the counter shows, `era` how often it has
+ *   wrapped.
+ * - Time of week is a `number` of seconds; a fraction is the nearest double to the exact value.
+ * - A listed leap second (`…T23:59:60Z`) falls in its own second of the week.
+ * - `null` before the system's epoch, for an instant past 9999-12-31T23:59:59.999999999Z (the
+ *   inverse writes four-digit years only), and on invalid input.
+ *
+ * @param counter the week counter: "GPS-LNAV", "GPS-CNAV", "GAL", "BDT", "QZS-LNAV", "QZS-CNAV", "IRN-LNAV" or "IRN-L1NV"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns `{ week, timeOfWeekSeconds, era }`, or null on invalid input, before the system's epoch or past year 9999
+ *
+ * @example utcToGnssWeek("GPS-LNAV", "2019-04-07T00:00:00Z") // { week: 0, timeOfWeekSeconds: 18, era: 2 }
+ * @example utcToGnssWeek("GPS-CNAV", "2019-04-07T00:00:00Z") // { week: 2048, timeOfWeekSeconds: 18, era: 0 }
+ * @example utcToGnssWeek("GAL", "2019-04-07T00:00:00Z") // { week: 1024, timeOfWeekSeconds: 18, era: 0 }
+ * @example utcToGnssWeek("BDT", "2024-01-01T00:00:00Z") // { week: 939, timeOfWeekSeconds: 86404, era: 0 }
+ * @example utcToGnssWeek("GPS-LNAV", "2016-12-31T23:59:60Z") // { week: 906, timeOfWeekSeconds: 17, era: 1 }
+ * @example utcToGnssWeek("GAL", "1999-08-21T23:59:46Z") // null — before Galileo's epoch
+ * @example utcToGnssWeek("GPS-LNAV", "+010000-01-01T00:00:00Z") // null — past year 9999
+ */
+export declare function utcToGnssWeek(counter: GnssWeekCounter, utcString: string): GnssWeek | null;

package/dist/gnss/convert/utcToGnssWeek.js

@@ -0,0 +1,40 @@
+import { formatUtcReading, GNSS_WEEK_COUNTERS, isGnssWeekCounter, parseUtcReading, scaleLabelOfUtc, weekOfLabel, } from "../../internal/index.js";
+/**
+ * Return the week, time of week and era of a UTC instant on a satellite week counter.
+ *
+ * - The inverse of `gnssWeekToUtc`: `week` is what the counter shows, `era` how often it has
+ *   wrapped.
+ * - Time of week is a `number` of seconds; a fraction is the nearest double to the exact value.
+ * - A listed leap second (`…T23:59:60Z`) falls in its own second of the week.
+ * - `null` before the system's epoch, for an instant past 9999-12-31T23:59:59.999999999Z (the
+ *   inverse writes four-digit years only), and on invalid input.
+ *
+ * @param counter the week counter: "GPS-LNAV", "GPS-CNAV", "GAL", "BDT", "QZS-LNAV", "QZS-CNAV", "IRN-LNAV" or "IRN-L1NV"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns `{ week, timeOfWeekSeconds, era }`, or null on invalid input, before the system's epoch or past year 9999
+ *
+ * @example utcToGnssWeek("GPS-LNAV", "2019-04-07T00:00:00Z") // { week: 0, timeOfWeekSeconds: 18, era: 2 }
+ * @example utcToGnssWeek("GPS-CNAV", "2019-04-07T00:00:00Z") // { week: 2048, timeOfWeekSeconds: 18, era: 0 }
+ * @example utcToGnssWeek("GAL", "2019-04-07T00:00:00Z") // { week: 1024, timeOfWeekSeconds: 18, era: 0 }
+ * @example utcToGnssWeek("BDT", "2024-01-01T00:00:00Z") // { week: 939, timeOfWeekSeconds: 86404, era: 0 }
+ * @example utcToGnssWeek("GPS-LNAV", "2016-12-31T23:59:60Z") // { week: 906, timeOfWeekSeconds: 17, era: 1 }
+ * @example utcToGnssWeek("GAL", "1999-08-21T23:59:46Z") // null — before Galileo's epoch
+ * @example utcToGnssWeek("GPS-LNAV", "+010000-01-01T00:00:00Z") // null — past year 9999
+ */
+export function utcToGnssWeek(counter, utcString) {
+    try {
+        if (!isGnssWeekCounter(counter)) {
+            return null;
+        }
+        const reading = parseUtcReading(utcString);
+        // `gnssWeekToUtc` writes four-digit years only, so a week past 9999-12-31 could not be read back.
+        if (reading === null || formatUtcReading(reading) === "") {
+            return null;
+        }
+        const label = scaleLabelOfUtc(GNSS_WEEK_COUNTERS[counter].system, reading);
+        return label === null ? null : weekOfLabel(counter, label.labelNanoseconds);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gnss/convert/utcToRinexWeek.d.ts

@@ -0,0 +1,19 @@
+import type { RinexWeek, RinexWeekSystem } from "../../types/gnss.js";
+/**
+ * Return the RINEX navigation-file week and seconds of week of a UTC instant.
+ *
+ * - The inverse of `rinexWeekToUtc`; the week is continuous, so there is no era.
+ * - GPS, QZSS, NavIC and Galileo weeks count from 1980-01-06; BeiDou weeks from 2006-01-01.
+ * - `null` before the system's epoch, for an instant past 9999-12-31T23:59:59.999999999Z (the
+ *   inverse writes four-digit years only), and on invalid input.
+ *
+ * @param system the RINEX record's system: "GPS", "GAL", "BDT", "QZS" or "IRN"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns `{ week, timeOfWeekSeconds }`, or null on invalid input, before the system's epoch or past year 9999
+ *
+ * @example utcToRinexWeek("IRN", "2024-01-01T00:00:00Z") // { week: 2295, timeOfWeekSeconds: 86418 }
+ * @example utcToRinexWeek("BDT", "2021-07-05T21:59:56Z") // { week: 809, timeOfWeekSeconds: 165600 }
+ * @example utcToRinexWeek("GPS", "1980-01-05T23:59:59Z") // null
+ * @example utcToRinexWeek("GPS", "+010000-01-01T00:00:00Z") // null — past year 9999
+ */
+export declare function utcToRinexWeek(system: RinexWeekSystem, utcString: string): RinexWeek | null;

package/dist/gnss/convert/utcToRinexWeek.js

@@ -0,0 +1,45 @@
+import { formatUtcReading, isRinexWeekSystem, parseUtcReading, RINEX_WEEK_EPOCHS, scaleLabelOfUtc, weeksSince, } from "../../internal/index.js";
+/**
+ * Return the RINEX navigation-file week and seconds of week of a UTC instant.
+ *
+ * - The inverse of `rinexWeekToUtc`; the week is continuous, so there is no era.
+ * - GPS, QZSS, NavIC and Galileo weeks count from 1980-01-06; BeiDou weeks from 2006-01-01.
+ * - `null` before the system's epoch, for an instant past 9999-12-31T23:59:59.999999999Z (the
+ *   inverse writes four-digit years only), and on invalid input.
+ *
+ * @param system the RINEX record's system: "GPS", "GAL", "BDT", "QZS" or "IRN"
+ * @param utcString ISO 8601 instant string; a listed leap second is accepted
+ * @returns `{ week, timeOfWeekSeconds }`, or null on invalid input, before the system's epoch or past year 9999
+ *
+ * @example utcToRinexWeek("IRN", "2024-01-01T00:00:00Z") // { week: 2295, timeOfWeekSeconds: 86418 }
+ * @example utcToRinexWeek("BDT", "2021-07-05T21:59:56Z") // { week: 809, timeOfWeekSeconds: 165600 }
+ * @example utcToRinexWeek("GPS", "1980-01-05T23:59:59Z") // null
+ * @example utcToRinexWeek("GPS", "+010000-01-01T00:00:00Z") // null — past year 9999
+ */
+export function utcToRinexWeek(system, utcString) {
+    try {
+        if (!isRinexWeekSystem(system)) {
+            return null;
+        }
+        const reading = parseUtcReading(utcString);
+        // `rinexWeekToUtc` writes four-digit years only, so a week past 9999-12-31 could not be read back.
+        if (reading === null || formatUtcReading(reading) === "") {
+            return null;
+        }
+        const epoch = RINEX_WEEK_EPOCHS[system];
+        const label = scaleLabelOfUtc(epoch.system, reading);
+        if (label === null) {
+            return null;
+        }
+        const split = weeksSince(epoch.epochLabel, label.labelNanoseconds);
+        return split === null
+            ? null
+            : {
+                week: Number(split.fullWeek),
+                timeOfWeekSeconds: split.timeOfWeekSeconds,
+            };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gnss/index.d.ts

@@ -0,0 +1,2 @@
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
+export * from "./convert/index.js";

package/dist/gnss/index.js

@@ -0,0 +1,3 @@
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
+export * from "./convert/index.js";

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "./internal/temporal.js";
 export * from "./calendar/index.js";
 export * from "./duration/index.js";
+export * from "./gnss/index.js";
 export * from "./instant/index.js";
 export * from "./intermodal/index.js";
 export * from "./interval/index.js";
@@ -8,8 +9,10 @@ export * from "./plain/index.js";
 export * from "./precision/index.js";
 export * from "./regex/index.js";
 export * from "./span/index.js";
+export * from "./timescale/index.js";
 export * from "./transport/index.js";
 export * from "./types/index.js";
 export * from "./unix/index.js";
 export * from "./utc/index.js";
+export * from "./workforce/index.js";
 export * from "./zoned/index.js";

package/dist/index.js

@@ -1,6 +1,7 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "./internal/temporal.js";
 export * from "./calendar/index.js";
 export * from "./duration/index.js";
+export * from "./gnss/index.js";
 export * from "./instant/index.js";
 export * from "./intermodal/index.js";
 export * from "./interval/index.js";
@@ -8,8 +9,10 @@ export * from "./plain/index.js";
 export * from "./precision/index.js";
 export * from "./regex/index.js";
 export * from "./span/index.js";
+export * from "./timescale/index.js";
 export * from "./transport/index.js";
 export * from "./types/index.js";
 export * from "./unix/index.js";
 export * from "./utc/index.js";
+export * from "./workforce/index.js";
 export * from "./zoned/index.js";

package/dist/instant/convert/classifyLocal.d.ts

@@ -32,19 +32,23 @@ export type LocalTimeClassification = "unique" | "ambiguous" | "nonexistent";
  *   annotations are read as `Temporal.PlainDateTime.from` reads them, so a time zone annotation
  *   is ignored and `timeZone` alone is the zone.
  * - Returns null on invalid input — never `"unique"`, which would read as a verdict.
+ * - `timeZone` may be a UTC offset, including one `getTimeZoneOffset` returned with seconds. A
+ *   fixed offset names one instant for every wall time, so the classification is always `"unique"`.
  *
  * @param localDateTime zoneless ISO 8601 local datetime string (e.g. "2024-11-03T01:30:00")
- * @param timeZone IANA name or UTC offset the wall time is read in
+ * @param timeZone IANA name or UTC offset the wall time is read in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns "unique" | "ambiguous" | "nonexistent", or null on invalid input
  *
- * @example classifyLocal("2024-07-15T12:00:00", "America/New_York") // "unique"
- * @example classifyLocal("2024-11-03T01:30:00", "America/New_York") // "ambiguous" (fall-back overlap)
- * @example classifyLocal("2024-03-10T02:30:00", "America/New_York") // "nonexistent" (spring-forward gap)
+ * @example classifyLocal("2024-07-15T12:00:00", "Asia/Tokyo") // "unique"
+ * @example classifyLocal("2024-10-27T01:30:00", "Europe/London") // "ambiguous" (fall-back overlap)
+ * @example classifyLocal("2024-10-06T02:30:00", "Australia/Sydney") // "nonexistent" (spring-forward gap)
  * @example classifyLocal("2024-04-07T01:45:00", "Australia/Lord_Howe") // "ambiguous" (a 30-minute overlap)
  * @example classifyLocal("2024-09-29T03:15:00", "Pacific/Chatham") // "nonexistent" (a 45-minute-offset zone's gap)
  * @example classifyLocal("2011-12-30T12:00:00", "Pacific/Apia") // "nonexistent" (the day Samoa skipped crossing the date line)
  * @example classifyLocal("2024-11-03T01:30:00", "UTC") // "unique" (UTC has no transitions)
- * @example classifyLocal("2024-11-03T01:30:00-04:00", "America/New_York") // null (not a zoneless wall time)
+ * @example classifyLocal("1970-01-01T12:00:00", "-00:44:30") // "unique" (a fixed offset has no transitions)
+ * @example classifyLocal("2024-11-03T01:30:00+00:00", "Europe/London") // null (not a zoneless wall time)
  * @example classifyLocal("2024-11-03T01:30:00", "Invalid/Zone") // null
  */
 export declare function classifyLocal(localDateTime: string, timeZone: string): LocalTimeClassification | null;

package/dist/instant/convert/classifyLocal.js

@@ -1,7 +1,7 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
+import { classifyWall } from "../../internal/earlierOccurrence.js";
 import { isValidDateTime } from "../../plain/validate/index.js";
-import { isValidTimeZone } from "../../zoned/validate/index.js";
-import { plainToZoned } from "../../internal/index.js";
+import { instantOfWallClock, isoStringBody, zoneFrame } from "../../internal/index.js";
 /**
  * Report whether a zoneless local wall time is unique, ambiguous or nonexistent in a zone —
  * before any policy resolves it.
@@ -20,39 +20,38 @@ import { plainToZoned } from "../../internal/index.js";
  *   annotations are read as `Temporal.PlainDateTime.from` reads them, so a time zone annotation
  *   is ignored and `timeZone` alone is the zone.
  * - Returns null on invalid input — never `"unique"`, which would read as a verdict.
+ * - `timeZone` may be a UTC offset, including one `getTimeZoneOffset` returned with seconds. A
+ *   fixed offset names one instant for every wall time, so the classification is always `"unique"`.
  *
  * @param localDateTime zoneless ISO 8601 local datetime string (e.g. "2024-11-03T01:30:00")
- * @param timeZone IANA name or UTC offset the wall time is read in
+ * @param timeZone IANA name or UTC offset the wall time is read in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns "unique" | "ambiguous" | "nonexistent", or null on invalid input
  *
- * @example classifyLocal("2024-07-15T12:00:00", "America/New_York") // "unique"
- * @example classifyLocal("2024-11-03T01:30:00", "America/New_York") // "ambiguous" (fall-back overlap)
- * @example classifyLocal("2024-03-10T02:30:00", "America/New_York") // "nonexistent" (spring-forward gap)
+ * @example classifyLocal("2024-07-15T12:00:00", "Asia/Tokyo") // "unique"
+ * @example classifyLocal("2024-10-27T01:30:00", "Europe/London") // "ambiguous" (fall-back overlap)
+ * @example classifyLocal("2024-10-06T02:30:00", "Australia/Sydney") // "nonexistent" (spring-forward gap)
  * @example classifyLocal("2024-04-07T01:45:00", "Australia/Lord_Howe") // "ambiguous" (a 30-minute overlap)
  * @example classifyLocal("2024-09-29T03:15:00", "Pacific/Chatham") // "nonexistent" (a 45-minute-offset zone's gap)
  * @example classifyLocal("2011-12-30T12:00:00", "Pacific/Apia") // "nonexistent" (the day Samoa skipped crossing the date line)
  * @example classifyLocal("2024-11-03T01:30:00", "UTC") // "unique" (UTC has no transitions)
- * @example classifyLocal("2024-11-03T01:30:00-04:00", "America/New_York") // null (not a zoneless wall time)
+ * @example classifyLocal("1970-01-01T12:00:00", "-00:44:30") // "unique" (a fixed offset has no transitions)
+ * @example classifyLocal("2024-11-03T01:30:00+00:00", "Europe/London") // null (not a zoneless wall time)
  * @example classifyLocal("2024-11-03T01:30:00", "Invalid/Zone") // null
  */
 export function classifyLocal(localDateTime, timeZone) {
-    if (!isValidDateTime(localDateTime) || !isValidTimeZone(timeZone)) {
+    const frame = zoneFrame(timeZone);
+    if (!isValidDateTime(localDateTime) || frame === null) {
         return null;
     }
     try {
-        const wallClock = Temporal.PlainDateTime.from(localDateTime);
-        const earliest = plainToZoned(wallClock, timeZone, "earlier");
-        const latest = plainToZoned(wallClock, timeZone, "later");
-        if (earliest.epochNanoseconds === latest.epochNanoseconds) {
+        // A fixed offset has no transition: a wall time it can place is one instant, and one it
+        // cannot (past the instant range) throws.
+        if (frame.shiftNanoseconds !== 0n) {
+            instantOfWallClock(isoStringBody(localDateTime), frame);
             return "unique";
         }
-        // Two instants, so the wall time is either repeated or skipped. Temporal separates them
-        // the same way for both, and only the wall clock it lands on tells them apart: for an
-        // overlap both instants read back as the requested time, and for a gap neither does —
-        // "earlier"/"later" resolve a gap by moving off the requested time entirely.
-        return earliest.toPlainDateTime().equals(wallClock)
-            ? "ambiguous"
-            : "nonexistent";
+        return classifyWall(Temporal.PlainDateTime.from(localDateTime), frame.timeZone).kind;
     }
     catch {
         return null;

package/dist/instant/convert/fromOffsetInstant.d.ts

@@ -29,19 +29,23 @@ import type { OffsetInstant } from "./toOffsetInstant.js";
  *   string whose local date is −271821-04-19 is refused by `toOffsetInstant`. Without a `timeZone` there is no zone to resolve against, so the
  *   full `±HH:MM:SS` is written instead; that is ISO 8601, not RFC 9557.
  * - Returns `""` on invalid input.
+ * - A `timeZone` that is an offset with seconds (`-00:44:30`) returns `""`, as any offset there
+ *   does. A written zone cannot carry seconds (RFC 9557 §4.1), so the result could not name it.
+ *   Pass the IANA name as `timeZone`, or leave `timeZone` out for the local time with its full
+ *   offset and no bracket.
  *
  * @param value `{ instant, offset, timeZone? }` pair, as produced by `toOffsetInstant`
  * @returns local ISO 8601 string carrying the pair's own offset, or "" on invalid input
  *
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00" }) // "2024-07-15T12:00:00-04:00"
- * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "America/New_York" }) // "2024-07-15T12:00:00-04:00[America/New_York]"
- * @example fromOffsetInstant({ instant: "2024-11-03T05:30:00Z", offset: "-04:00", timeZone: "America/New_York" }) // "2024-11-03T01:30:00-04:00[America/New_York]" — the first 01:30 of the fall-back night
- * @example fromOffsetInstant({ instant: "2024-11-03T06:30:00Z", offset: "-05:00", timeZone: "America/New_York" }) // "2024-11-03T01:30:00-05:00[America/New_York]" — the second, an hour later
+ * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "America/Santiago" }) // "2024-07-15T12:00:00-04:00[America/Santiago]"
+ * @example fromOffsetInstant({ instant: "2024-10-27T00:30:00Z", offset: "+01:00", timeZone: "Europe/London" }) // "2024-10-27T01:30:00+01:00[Europe/London]" — the first 01:30 of the fall-back night
+ * @example fromOffsetInstant({ instant: "2024-10-27T01:30:00Z", offset: "+00:00", timeZone: "Europe/London" }) // "2024-10-27T01:30:00+00:00[Europe/London]" — the second, an hour later
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "+00:00" }) // "2024-07-15T16:00:00+00:00"
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-00:00" }) // "2024-07-15T16:00:00+00:00" (RFC 9557's "offset unknown" is not kept)
  * @example fromOffsetInstant({ instant: "1970-01-01T00:00:00Z", offset: "-00:44:30", timeZone: "Africa/Monrovia" }) // "1969-12-31T23:15:30-00:45[Africa/Monrovia]" — RFC 9557 rounds the written offset; the zone keeps the instant exact
  * @example fromOffsetInstant({ instant: "1970-01-01T00:00:00Z", offset: "-00:44:30" }) // "1969-12-31T23:15:30-00:44:30" — no zone to round against, so the seconds are written
- * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-05:00", timeZone: "America/New_York" }) // "" (offset contradicts the zone)
+ * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "+11:00", timeZone: "Australia/Sydney" }) // "" (offset contradicts the zone: Sydney is +10:00 in July)
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "-04:00" }) // "" (an offset is not a zone)
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "Z" }) // "" (a designator, not an offset)
  * @example fromOffsetInstant({ instant: "not an instant", offset: "-04:00" }) // ""

package/dist/instant/convert/fromOffsetInstant.js

@@ -1,6 +1,7 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { formatUtcOffset, parseInstantNanoseconds, parseUtcOffsetNanoseconds, wallClockAtOffset, } from "../../internal/index.js";
 import { utcOffset } from "../../regex/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Render an instant-plus-offset pair back to the local time it describes.
  *
@@ -31,26 +32,30 @@ import { utcOffset } from "../../regex/index.js";
  *   string whose local date is −271821-04-19 is refused by `toOffsetInstant`. Without a `timeZone` there is no zone to resolve against, so the
  *   full `±HH:MM:SS` is written instead; that is ISO 8601, not RFC 9557.
  * - Returns `""` on invalid input.
+ * - A `timeZone` that is an offset with seconds (`-00:44:30`) returns `""`, as any offset there
+ *   does. A written zone cannot carry seconds (RFC 9557 §4.1), so the result could not name it.
+ *   Pass the IANA name as `timeZone`, or leave `timeZone` out for the local time with its full
+ *   offset and no bracket.
  *
  * @param value `{ instant, offset, timeZone? }` pair, as produced by `toOffsetInstant`
  * @returns local ISO 8601 string carrying the pair's own offset, or "" on invalid input
  *
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00" }) // "2024-07-15T12:00:00-04:00"
- * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "America/New_York" }) // "2024-07-15T12:00:00-04:00[America/New_York]"
- * @example fromOffsetInstant({ instant: "2024-11-03T05:30:00Z", offset: "-04:00", timeZone: "America/New_York" }) // "2024-11-03T01:30:00-04:00[America/New_York]" — the first 01:30 of the fall-back night
- * @example fromOffsetInstant({ instant: "2024-11-03T06:30:00Z", offset: "-05:00", timeZone: "America/New_York" }) // "2024-11-03T01:30:00-05:00[America/New_York]" — the second, an hour later
+ * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "America/Santiago" }) // "2024-07-15T12:00:00-04:00[America/Santiago]"
+ * @example fromOffsetInstant({ instant: "2024-10-27T00:30:00Z", offset: "+01:00", timeZone: "Europe/London" }) // "2024-10-27T01:30:00+01:00[Europe/London]" — the first 01:30 of the fall-back night
+ * @example fromOffsetInstant({ instant: "2024-10-27T01:30:00Z", offset: "+00:00", timeZone: "Europe/London" }) // "2024-10-27T01:30:00+00:00[Europe/London]" — the second, an hour later
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "+00:00" }) // "2024-07-15T16:00:00+00:00"
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-00:00" }) // "2024-07-15T16:00:00+00:00" (RFC 9557's "offset unknown" is not kept)
  * @example fromOffsetInstant({ instant: "1970-01-01T00:00:00Z", offset: "-00:44:30", timeZone: "Africa/Monrovia" }) // "1969-12-31T23:15:30-00:45[Africa/Monrovia]" — RFC 9557 rounds the written offset; the zone keeps the instant exact
  * @example fromOffsetInstant({ instant: "1970-01-01T00:00:00Z", offset: "-00:44:30" }) // "1969-12-31T23:15:30-00:44:30" — no zone to round against, so the seconds are written
- * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-05:00", timeZone: "America/New_York" }) // "" (offset contradicts the zone)
+ * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "+11:00", timeZone: "Australia/Sydney" }) // "" (offset contradicts the zone: Sydney is +10:00 in July)
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "-04:00", timeZone: "-04:00" }) // "" (an offset is not a zone)
  * @example fromOffsetInstant({ instant: "2024-07-15T16:00:00Z", offset: "Z" }) // "" (a designator, not an offset)
  * @example fromOffsetInstant({ instant: "not an instant", offset: "-04:00" }) // ""
  */
 export function fromOffsetInstant(value) {
     try {
-        if (typeof value !== "object" || value === null) {
+        if (!isObject(value)) {
             return "";
         }
         const epochNanoseconds = parseInstantNanoseconds(value.instant);

package/dist/instant/convert/resolveLocal.d.ts

@@ -1,6 +1,6 @@
 import type { Disambiguation } from "../../types/index.js";
 /**
- * Resolve a zoneless local wall time against an IANA zone and return the instant it names.
+ * Resolve a zoneless local wall time in a time zone and return the instant it names.
  *
  * Feeds deliver wall times with no offset all the time — "gate-out 08:00" — and turning one
  * into an instant takes a zone the sender did not send plus a policy for the two days a year
@@ -14,22 +14,27 @@ import type { Disambiguation } from "../../types/index.js";
  * - `localDateTime` is a PlainDateTime string, as `isValidDateTime` accepts: `<date>T<time>`
  *   with no offset (an offset means the wall time already resolved). Its RFC 9557 annotations
  *   are read as `Temporal.PlainDateTime.from` reads them, so a time zone annotation
- *   (`[America/New_York]`) is ignored and `timeZone` alone resolves the wall time.
+ *   (`[Asia/Tokyo]`) is ignored and `timeZone` alone resolves the wall time.
  * - Returns `""` on invalid input.
+ * - `timeZone` may be a UTC offset, including one `getTimeZoneOffset` returned with seconds. A
+ *   fixed offset names one instant for every wall time, so `disambiguation` has nothing to decide
+ *   and `"reject"` does not reject.
  *
  * @param localDateTime zoneless ISO 8601 local datetime string (e.g. "2024-11-03T01:30:00")
- * @param timeZone IANA name or UTC offset the wall time is read in
+ * @param timeZone IANA name or UTC offset the wall time is read in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param optionsArg How an ambiguous or nonexistent wall time is resolved
  * @returns UTC instant string ending in "Z", or "" on invalid input
  *
- * @example resolveLocal("2024-07-15T12:00:00", "America/New_York") // "2024-07-15T16:00:00Z"
- * @example resolveLocal("2024-11-03T01:30:00", "America/New_York") // "2024-11-03T05:30:00Z" (ambiguous; "compatible" takes the earlier)
- * @example resolveLocal("2024-11-03T01:30:00", "America/New_York", { disambiguation: "later" }) // "2024-11-03T06:30:00Z" (the same wall time, an hour later)
- * @example resolveLocal("2024-11-03T01:30:00", "America/New_York", { disambiguation: "reject" }) // "" (ambiguous, and not guessed)
- * @example resolveLocal("2024-03-10T02:30:00", "America/New_York") // "2024-03-10T07:30:00Z" (nonexistent; "compatible" takes the later)
- * @example resolveLocal("2024-03-10T02:30:00", "America/New_York", { disambiguation: "earlier" }) // "2024-03-10T06:30:00Z"
- * @example resolveLocal("2024-07-15T12:00:00-04:00", "America/New_York") // "" (not a zoneless wall time)
- * @example resolveLocal("2024-07-15T12:00:00[foo=bar]", "America/New_York") // "2024-07-15T16:00:00Z" (elective annotation ignored)
+ * @example resolveLocal("2024-07-15T12:00:00", "Asia/Tokyo") // "2024-07-15T03:00:00Z"
+ * @example resolveLocal("2024-10-27T01:30:00", "Europe/London") // "2024-10-27T00:30:00Z" (ambiguous; "compatible" takes the earlier)
+ * @example resolveLocal("2024-10-27T01:30:00", "Europe/London", { disambiguation: "later" }) // "2024-10-27T01:30:00Z" (the same wall time, an hour later)
+ * @example resolveLocal("2024-10-27T01:30:00", "Europe/London", { disambiguation: "reject" }) // "" (ambiguous, and not guessed)
+ * @example resolveLocal("2024-10-06T02:30:00", "Australia/Sydney") // "2024-10-05T16:30:00Z" (nonexistent; "compatible" takes the later)
+ * @example resolveLocal("2024-10-06T02:30:00", "Australia/Sydney", { disambiguation: "earlier" }) // "2024-10-05T15:30:00Z"
+ * @example resolveLocal("2024-07-15T12:00:00+05:30", "Asia/Kolkata") // "" (not a zoneless wall time)
+ * @example resolveLocal("1970-01-01T12:00:00", "-00:44:30") // "1970-01-01T12:44:30Z" (a stored offset with seconds, what `getTimeZoneOffset` returns for Africa/Monrovia then)
+ * @example resolveLocal("2024-07-15T12:00:00[foo=bar]", "Africa/Johannesburg") // "2024-07-15T10:00:00Z" (elective annotation ignored)
  * @example resolveLocal("2024-07-15T12:00:00", "Invalid/Zone") // ""
  */
 export declare function resolveLocal(localDateTime: string, timeZone: string, optionsArg?: {