@northguild/gmt 1.19.0 → 1.20.0

package/dist/span/validate/isValidSpan.d.ts

@@ -33,10 +33,10 @@
  * @example isValidSpan("2024-03-10T12:00:00Z", "2024-03-10T12:00:01Z") // true
  * @example isValidSpan("2024-03-10T12:00:00Z", "2024-03-10T12:00:00Z") // true — a zero span is a span
  * @example isValidSpan("2024-03-10T12:00:01Z", "2024-03-10T12:00:00Z") // true — spans are signed
- * @example isValidSpan("2024-03-10T07:00:00-05:00[America/New_York]", "2024-03-10T12:00:00Z") // true
- * @example isValidSpan("2024-03-10T12:00:00+05:00[America/New_York]", "2024-03-10T12:00:00Z[Not/AZone]") // true — zone annotations are not checked
+ * @example isValidSpan("2024-03-10T07:00:00-05:00[America/Bogota]", "2024-03-10T12:00:00Z") // true
+ * @example isValidSpan("2024-03-10T12:00:00+05:00[Asia/Tokyo]", "2024-03-10T12:00:00Z[Not/AZone]") // true — zone annotations are not checked
  * @example isValidSpan("-271821-04-20T00:00:00Z", "+275760-09-13T00:00:00Z") // true — but spanMs returns null, use spanNs
  * @example isValidSpan("2024-03-10T12:00:00Z", "invalid") // false
- * @example isValidSpan("2024-03-10T12:00:00[America/New_York]", "2024-03-11T12:00:00[America/New_York]") // false — no offset designator
+ * @example isValidSpan("2024-03-10T12:00:00[Europe/London]", "2024-03-11T12:00:00[Europe/London]") // false — no offset designator
  */
 export declare function isValidSpan(start: string, end: string): boolean;

package/dist/span/validate/isValidSpan.js

@@ -34,11 +34,11 @@ import { parseInstantNanoseconds } from "../../internal/index.js";
  * @example isValidSpan("2024-03-10T12:00:00Z", "2024-03-10T12:00:01Z") // true
  * @example isValidSpan("2024-03-10T12:00:00Z", "2024-03-10T12:00:00Z") // true — a zero span is a span
  * @example isValidSpan("2024-03-10T12:00:01Z", "2024-03-10T12:00:00Z") // true — spans are signed
- * @example isValidSpan("2024-03-10T07:00:00-05:00[America/New_York]", "2024-03-10T12:00:00Z") // true
- * @example isValidSpan("2024-03-10T12:00:00+05:00[America/New_York]", "2024-03-10T12:00:00Z[Not/AZone]") // true — zone annotations are not checked
+ * @example isValidSpan("2024-03-10T07:00:00-05:00[America/Bogota]", "2024-03-10T12:00:00Z") // true
+ * @example isValidSpan("2024-03-10T12:00:00+05:00[Asia/Tokyo]", "2024-03-10T12:00:00Z[Not/AZone]") // true — zone annotations are not checked
  * @example isValidSpan("-271821-04-20T00:00:00Z", "+275760-09-13T00:00:00Z") // true — but spanMs returns null, use spanNs
  * @example isValidSpan("2024-03-10T12:00:00Z", "invalid") // false
- * @example isValidSpan("2024-03-10T12:00:00[America/New_York]", "2024-03-11T12:00:00[America/New_York]") // false — no offset designator
+ * @example isValidSpan("2024-03-10T12:00:00[Europe/London]", "2024-03-11T12:00:00[Europe/London]") // false — no offset designator
  */
 export function isValidSpan(start, end) {
     return (parseInstantNanoseconds(start) !== null &&

package/dist/timescale/calculate/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./leapSecondsBetween.js";
+export * from "./nextLeapSecond.js";
+export * from "./taiMinusUtc.js";

package/dist/timescale/calculate/index.js

@@ -0,0 +1,3 @@
+export * from "./leapSecondsBetween.js";
+export * from "./nextLeapSecond.js";
+export * from "./taiMinusUtc.js";

package/dist/timescale/calculate/leapSecondsBetween.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Return how many leap seconds start between two UTC instants, signed.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026). The table is closed: after the last insertion (2016-12-31) there are none.
+ * - Counts each leap second whose second starts in `[start, end)`. An inserted second starts at
+ *   `…T23:59:60.000Z` (ITU-R TF.460-6 Annex 1 §2.2): from `…T23:59:60Z` to the next
+ *   `…T00:00:00Z` is 1; from `…T23:59:59Z` to `…T23:59:60Z` is 0; from `…T23:59:60.5Z` to the
+ *   next `…T00:00:00Z` is 0.
+ * - Over whole days this is the change in TAI − UTC (`taiMinusUtc`). Inside an inserted second
+ *   the two differ: TAI − UTC changes at 00:00:00, the count at 23:59:60.000.
+ * - Signed: negative when `end` is before `start`.
+ * - `null` when either instant is before 1972-01-01 or invalid.
+ *
+ * @param start ISO 8601 instant string
+ * @param end ISO 8601 instant string
+ * @returns the signed count, or null on invalid input or a date before 1972
+ *
+ * @example leapSecondsBetween("2020-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // 0
+ * @example leapSecondsBetween("2000-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // 5
+ * @example leapSecondsBetween("2024-01-01T00:00:00Z", "2000-01-01T00:00:00Z") // -5
+ * @example leapSecondsBetween("2016-12-31T23:59:60Z", "2017-01-01T00:00:00Z") // 1
+ * @example leapSecondsBetween("2016-12-31T23:59:60.5Z", "2017-01-01T00:00:00Z") // 0 — it started at 23:59:60.000
+ * @example leapSecondsBetween("1971-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // null
+ */
+export declare function leapSecondsBetween(start: string, end: string): number | null;

package/dist/timescale/calculate/leapSecondsBetween.js

@@ -0,0 +1,62 @@
+import { LEAP_SECOND_STEPS, NANOSECONDS_PER_SECOND, parseUtcReading, taiOfUtc, } from "../../internal/index.js";
+/**
+ * The leap seconds that started before a UTC instant, as a running count: TAI − UTC there, plus
+ * 1 when the instant is inside an inserted second past its start. The inserted second begins at
+ * 23:59:60.000 (ITU-R TF.460-6 Annex 1 §2.2), while TAI − UTC steps only at the next 00:00:00.
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns the count in seconds, or null where `taiMinusUtc` is null
+ */
+function leapSecondsStartedBefore(isoString) {
+    const reading = parseUtcReading(isoString);
+    if (reading === null) {
+        return null;
+    }
+    const tai = taiOfUtc(LEAP_SECOND_STEPS, reading);
+    if (tai === null) {
+        return null;
+    }
+    const taiMinusUtcSeconds = Number((tai - reading.epochNanoseconds) / NANOSECONDS_PER_SECOND) -
+        (reading.secondSixty ? 1 : 0);
+    const insideInsertedSecond = reading.secondSixty &&
+        reading.epochNanoseconds % NANOSECONDS_PER_SECOND !== 0n;
+    return taiMinusUtcSeconds + (insideInsertedSecond ? 1 : 0);
+}
+/**
+ * Return how many leap seconds start between two UTC instants, signed.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026). The table is closed: after the last insertion (2016-12-31) there are none.
+ * - Counts each leap second whose second starts in `[start, end)`. An inserted second starts at
+ *   `…T23:59:60.000Z` (ITU-R TF.460-6 Annex 1 §2.2): from `…T23:59:60Z` to the next
+ *   `…T00:00:00Z` is 1; from `…T23:59:59Z` to `…T23:59:60Z` is 0; from `…T23:59:60.5Z` to the
+ *   next `…T00:00:00Z` is 0.
+ * - Over whole days this is the change in TAI − UTC (`taiMinusUtc`). Inside an inserted second
+ *   the two differ: TAI − UTC changes at 00:00:00, the count at 23:59:60.000.
+ * - Signed: negative when `end` is before `start`.
+ * - `null` when either instant is before 1972-01-01 or invalid.
+ *
+ * @param start ISO 8601 instant string
+ * @param end ISO 8601 instant string
+ * @returns the signed count, or null on invalid input or a date before 1972
+ *
+ * @example leapSecondsBetween("2020-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // 0
+ * @example leapSecondsBetween("2000-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // 5
+ * @example leapSecondsBetween("2024-01-01T00:00:00Z", "2000-01-01T00:00:00Z") // -5
+ * @example leapSecondsBetween("2016-12-31T23:59:60Z", "2017-01-01T00:00:00Z") // 1
+ * @example leapSecondsBetween("2016-12-31T23:59:60.5Z", "2017-01-01T00:00:00Z") // 0 — it started at 23:59:60.000
+ * @example leapSecondsBetween("1971-01-01T00:00:00Z", "2024-01-01T00:00:00Z") // null
+ */
+export function leapSecondsBetween(start, end) {
+    try {
+        const before = leapSecondsStartedBefore(start);
+        const after = leapSecondsStartedBefore(end);
+        if (before === null || after === null) {
+            return null;
+        }
+        return after - before;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/timescale/calculate/nextLeapSecond.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return the first leap second after a UTC instant, as its UTC label `…T23:59:60Z`.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026).
+ * - `""` for every instant from 2016-12-31T23:59:60Z on: there are no more. The table is closed
+ *   (continuous UTC from 20 May 2027, CGPM 2026).
+ * - `""` also on invalid input or a date before 1972; check with `isValidInstant` to tell them apart.
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns the next leap second's UTC label, or "" when there is none or on invalid input
+ *
+ * @example nextLeapSecond("2016-01-01T00:00:00Z") // "2016-12-31T23:59:60Z"
+ * @example nextLeapSecond("1999-08-22T00:00:00Z") // "2005-12-31T23:59:60Z"
+ * @example nextLeapSecond("2016-12-31T23:59:60Z") // ""
+ * @example nextLeapSecond("2024-01-01T00:00:00Z") // ""
+ */
+export declare function nextLeapSecond(isoString: string): string;

package/dist/timescale/calculate/nextLeapSecond.js

@@ -0,0 +1,33 @@
+import { formatUtcReading, LEAP_SECOND_STEPS, nextStepIndex, parseUtcReading, stepReading, taiOfUtc, } from "../../internal/index.js";
+/**
+ * Return the first leap second after a UTC instant, as its UTC label `…T23:59:60Z`.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026).
+ * - `""` for every instant from 2016-12-31T23:59:60Z on: there are no more. The table is closed
+ *   (continuous UTC from 20 May 2027, CGPM 2026).
+ * - `""` also on invalid input or a date before 1972; check with `isValidInstant` to tell them apart.
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns the next leap second's UTC label, or "" when there is none or on invalid input
+ *
+ * @example nextLeapSecond("2016-01-01T00:00:00Z") // "2016-12-31T23:59:60Z"
+ * @example nextLeapSecond("1999-08-22T00:00:00Z") // "2005-12-31T23:59:60Z"
+ * @example nextLeapSecond("2016-12-31T23:59:60Z") // ""
+ * @example nextLeapSecond("2024-01-01T00:00:00Z") // ""
+ */
+export function nextLeapSecond(isoString) {
+    try {
+        const reading = parseUtcReading(isoString);
+        if (reading === null || taiOfUtc(LEAP_SECOND_STEPS, reading) === null) {
+            return "";
+        }
+        const index = nextStepIndex(LEAP_SECOND_STEPS, reading);
+        return index === -1
+            ? ""
+            : formatUtcReading(stepReading(LEAP_SECOND_STEPS, index));
+    }
+    catch {
+        return "";
+    }
+}

package/dist/timescale/calculate/taiMinusUtc.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Return TAI − UTC, in whole seconds, at a UTC instant.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026): 10 s from 1972-01-01, 37 s from 2017-01-01 on. The table is closed
+ *   (continuous UTC from 20 May 2027, CGPM 2026), so 37 holds for every later date.
+ * - At an inserted leap second (`…T23:59:60Z`, accepted only on the 27 listed days) the value is
+ *   the one before the insertion: TAI − UTC changes at 00:00:00 UTC.
+ * - `null` before 1972-01-01 (TAI − UTC was then fractional with a daily rate term), for a
+ *   second-60 string on a day with no insertion, and on invalid input.
+ *
+ * @param isoString ISO 8601 instant string; a listed leap second (`…T23:59:60Z`) is accepted
+ * @returns TAI − UTC in seconds, or null on invalid input or a date before 1972
+ *
+ * @example taiMinusUtc("2024-01-01T00:00:00Z") // 37
+ * @example taiMinusUtc("2016-01-01T00:00:00Z") // 36
+ * @example taiMinusUtc("2016-12-31T23:59:60Z") // 36 — the inserted second
+ * @example taiMinusUtc("2100-01-01T00:00:00Z") // 37
+ * @example taiMinusUtc("1971-01-01T00:00:00Z") // null — before 1972
+ */
+export declare function taiMinusUtc(isoString: string): number | null;

package/dist/timescale/calculate/taiMinusUtc.js

@@ -0,0 +1,38 @@
+import { LEAP_SECOND_STEPS, NANOSECONDS_PER_SECOND, parseUtcReading, taiOfUtc, } from "../../internal/index.js";
+/**
+ * Return TAI − UTC, in whole seconds, at a UTC instant.
+ *
+ * - From the IERS leap-second table built into GMT (Leap_Second.dat through Bulletin C 72,
+ *   6 July 2026): 10 s from 1972-01-01, 37 s from 2017-01-01 on. The table is closed
+ *   (continuous UTC from 20 May 2027, CGPM 2026), so 37 holds for every later date.
+ * - At an inserted leap second (`…T23:59:60Z`, accepted only on the 27 listed days) the value is
+ *   the one before the insertion: TAI − UTC changes at 00:00:00 UTC.
+ * - `null` before 1972-01-01 (TAI − UTC was then fractional with a daily rate term), for a
+ *   second-60 string on a day with no insertion, and on invalid input.
+ *
+ * @param isoString ISO 8601 instant string; a listed leap second (`…T23:59:60Z`) is accepted
+ * @returns TAI − UTC in seconds, or null on invalid input or a date before 1972
+ *
+ * @example taiMinusUtc("2024-01-01T00:00:00Z") // 37
+ * @example taiMinusUtc("2016-01-01T00:00:00Z") // 36
+ * @example taiMinusUtc("2016-12-31T23:59:60Z") // 36 — the inserted second
+ * @example taiMinusUtc("2100-01-01T00:00:00Z") // 37
+ * @example taiMinusUtc("1971-01-01T00:00:00Z") // null — before 1972
+ */
+export function taiMinusUtc(isoString) {
+    try {
+        const reading = parseUtcReading(isoString);
+        if (reading === null) {
+            return null;
+        }
+        const tai = taiOfUtc(LEAP_SECOND_STEPS, reading);
+        if (tai === null) {
+            return null;
+        }
+        return (Number((tai - reading.epochNanoseconds) / NANOSECONDS_PER_SECOND) -
+            (reading.secondSixty ? 1 : 0));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/timescale/convert/fromTAI.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Convert a TAI time-scale string to a UTC instant string.
+ *
+ * - Reads `YYYY-MM-DDTHH:MM:SS[.fraction] TAI`: four-digit year, `T`, seconds required, 1 to 9
+ *   fraction digits after `.`, one space, `TAI` (the FITS time-scale token). TAI has no second 60.
+ * - UTC = TAI − (TAI − UTC), from the IERS leap-second table built into GMT (Leap_Second.dat
+ *   through Bulletin C 72, 6 July 2026). The table is closed: after the last insertion
+ *   (2016-12-31) TAI − UTC stays 37 s.
+ * - During an inserted leap second the result is `…T23:59:60Z` (ITU-R TF.460-6 Annex 3). Only this
+ *   realm's functions read that string back; other GMT functions reject a second of 60.
+ * - "" before 1972-01-01T00:00:10 TAI and on invalid input.
+ *
+ * @param taiString TAI time-scale string
+ * @returns ISO 8601 UTC instant string (`Z`), or "" on invalid input or a date before 1972
+ *
+ * @example fromTAI("2026-01-01T00:00:37 TAI") // "2026-01-01T00:00:00Z"
+ * @example fromTAI("2017-01-01T00:00:36 TAI") // "2016-12-31T23:59:60Z"
+ * @example fromTAI("2017-01-01T00:00:36.5 TAI") // "2016-12-31T23:59:60.5Z"
+ * @example fromTAI("2024-01-01T00:00:37 GPS") // "" — wrong token
+ * @example fromTAI("2016-12-31T23:59:60 TAI") // "" — TAI has no leap seconds
+ */
+export declare function fromTAI(taiString: string): string;

package/dist/timescale/convert/fromTAI.js

@@ -0,0 +1,35 @@
+import { formatUtcReading, LEAP_SECOND_STEPS, parseTimeScaleString, utcOfTai, } from "../../internal/index.js";
+/**
+ * Convert a TAI time-scale string to a UTC instant string.
+ *
+ * - Reads `YYYY-MM-DDTHH:MM:SS[.fraction] TAI`: four-digit year, `T`, seconds required, 1 to 9
+ *   fraction digits after `.`, one space, `TAI` (the FITS time-scale token). TAI has no second 60.
+ * - UTC = TAI − (TAI − UTC), from the IERS leap-second table built into GMT (Leap_Second.dat
+ *   through Bulletin C 72, 6 July 2026). The table is closed: after the last insertion
+ *   (2016-12-31) TAI − UTC stays 37 s.
+ * - During an inserted leap second the result is `…T23:59:60Z` (ITU-R TF.460-6 Annex 3). Only this
+ *   realm's functions read that string back; other GMT functions reject a second of 60.
+ * - "" before 1972-01-01T00:00:10 TAI and on invalid input.
+ *
+ * @param taiString TAI time-scale string
+ * @returns ISO 8601 UTC instant string (`Z`), or "" on invalid input or a date before 1972
+ *
+ * @example fromTAI("2026-01-01T00:00:37 TAI") // "2026-01-01T00:00:00Z"
+ * @example fromTAI("2017-01-01T00:00:36 TAI") // "2016-12-31T23:59:60Z"
+ * @example fromTAI("2017-01-01T00:00:36.5 TAI") // "2016-12-31T23:59:60.5Z"
+ * @example fromTAI("2024-01-01T00:00:37 GPS") // "" — wrong token
+ * @example fromTAI("2016-12-31T23:59:60 TAI") // "" — TAI has no leap seconds
+ */
+export function fromTAI(taiString) {
+    try {
+        const label = parseTimeScaleString(taiString, "TAI");
+        if (label === null || label.secondSixty) {
+            return "";
+        }
+        const reading = utcOfTai(LEAP_SECOND_STEPS, label.labelNanoseconds);
+        return reading === null ? "" : formatUtcReading(reading);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/timescale/convert/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./fromTAI.js";
+export * from "./toTAI.js";

package/dist/timescale/convert/index.js

@@ -0,0 +1,2 @@
+export * from "./fromTAI.js";
+export * from "./toTAI.js";

package/dist/timescale/convert/toTAI.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Convert a UTC instant to a TAI time-scale string, `YYYY-MM-DDTHH:MM:SS[.fraction] TAI`.
+ *
+ * - TAI = UTC + (TAI − UTC), from the IERS leap-second table built into GMT (Leap_Second.dat
+ *   through Bulletin C 72, 6 July 2026). The table is closed: the CGPM decided in 2026 that UTC
+ *   becomes continuous on 20 May 2027, so after the last insertion (2016-12-31) TAI − UTC stays
+ *   37 s.
+ * - An inserted leap second maps to its own TAI second: `2016-12-31T23:59:60Z` is
+ *   `2017-01-01T00:00:36 TAI`. A second 60 on any other day returns "".
+ * - Accepts any offset or bracketed zone `toNanoseconds` accepts; TAI has no zone.
+ * - `TAI` is the FITS time-scale token. No other GMT function reads the string; `fromTAI` does.
+ * - "" before 1972-01-01, for a result past year 9999, and on invalid input.
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns the TAI time-scale string, or "" on invalid input or a date before 1972
+ *
+ * @example toTAI("2026-01-01T00:00:00Z") // "2026-01-01T00:00:37 TAI"
+ * @example toTAI("2013-06-01T00:00:00Z") // "2013-06-01T00:00:35 TAI"
+ * @example toTAI("2016-12-31T23:59:60.5Z") // "2017-01-01T00:00:36.5 TAI"
+ * @example toTAI("2017-12-31T23:59:60Z") // "" — no leap second that day
+ * @example toTAI("1971-12-31T00:00:00Z") // ""
+ */
+export declare function toTAI(isoString: string): string;

package/dist/timescale/convert/toTAI.js

@@ -0,0 +1,39 @@
+import { formatTimeScaleString, LEAP_SECOND_STEPS, parseUtcReading, taiOfUtc, } from "../../internal/index.js";
+/**
+ * Convert a UTC instant to a TAI time-scale string, `YYYY-MM-DDTHH:MM:SS[.fraction] TAI`.
+ *
+ * - TAI = UTC + (TAI − UTC), from the IERS leap-second table built into GMT (Leap_Second.dat
+ *   through Bulletin C 72, 6 July 2026). The table is closed: the CGPM decided in 2026 that UTC
+ *   becomes continuous on 20 May 2027, so after the last insertion (2016-12-31) TAI − UTC stays
+ *   37 s.
+ * - An inserted leap second maps to its own TAI second: `2016-12-31T23:59:60Z` is
+ *   `2017-01-01T00:00:36 TAI`. A second 60 on any other day returns "".
+ * - Accepts any offset or bracketed zone `toNanoseconds` accepts; TAI has no zone.
+ * - `TAI` is the FITS time-scale token. No other GMT function reads the string; `fromTAI` does.
+ * - "" before 1972-01-01, for a result past year 9999, and on invalid input.
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns the TAI time-scale string, or "" on invalid input or a date before 1972
+ *
+ * @example toTAI("2026-01-01T00:00:00Z") // "2026-01-01T00:00:37 TAI"
+ * @example toTAI("2013-06-01T00:00:00Z") // "2013-06-01T00:00:35 TAI"
+ * @example toTAI("2016-12-31T23:59:60.5Z") // "2017-01-01T00:00:36.5 TAI"
+ * @example toTAI("2017-12-31T23:59:60Z") // "" — no leap second that day
+ * @example toTAI("1971-12-31T00:00:00Z") // ""
+ */
+export function toTAI(isoString) {
+    try {
+        const reading = parseUtcReading(isoString);
+        if (reading === null) {
+            return "";
+        }
+        const tai = taiOfUtc(LEAP_SECOND_STEPS, reading);
+        if (tai === null) {
+            return "";
+        }
+        return formatTimeScaleString({ labelNanoseconds: tai, secondSixty: false }, "TAI");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/timescale/index.d.ts

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

package/dist/timescale/index.js

@@ -0,0 +1,5 @@
+// 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 "./calculate/index.js";
+export * from "./convert/index.js";
+export * from "./validate/index.js";

package/dist/timescale/validate/index.d.ts

@@ -0,0 +1 @@
+export * from "./isLeapSecond.js";

package/dist/timescale/validate/index.js

@@ -0,0 +1 @@
+export * from "./isLeapSecond.js";

package/dist/timescale/validate/isLeapSecond.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Return true when a UTC instant string is one of the 27 inserted leap seconds.
+ *
+ * - A table lookup, not a pattern match: `23:59:60` is well-formed on any day and real on 27 of
+ *   them, the days the IERS leap-second table built into GMT lists (Leap_Second.dat through
+ *   Bulletin C 72, 6 July 2026). The table is closed (continuous UTC from 20 May 2027, CGPM
+ *   2026), so 2016-12-31 is the last. For the syntax test alone, use `hasSecond60`.
+ * - Accepts the inserted second in any offset spelling (`2017-01-01T08:59:60+09:00`).
+ * - Leap smearing is not a leap second: a smeared clock never reads `23:59:60` and is up to a second
+ *   off true UTC around an insertion. GMT cannot detect smearing.
+ * - `false` is also the answer for every ordinary second.
+ * - **Compatibility:** in 1.19.0 and earlier `isLeapSecond` (in `plain/`) was the syntactic
+ *   second-60 test, now `hasSecond60`; a call relying on that now returns `false` on days with no
+ *   insertion, and for a second 60 that is not an extended-format instant (`"23:59:60"`, no
+ *   designator, a lowercase `t`, basic format).
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns true for an inserted leap second, or false otherwise and on invalid input
+ *
+ * @example isLeapSecond("2016-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2009-01-01T08:59:60+09:00") // true
+ * @example isLeapSecond("2017-12-31T23:59:60Z") // false — well-formed, no insertion that day
+ * @example isLeapSecond("2016-12-31T23:59:59Z") // false
+ */
+export declare function isLeapSecond(isoString: string): boolean;

package/dist/timescale/validate/isLeapSecond.js

@@ -0,0 +1,36 @@
+import { LEAP_SECOND_STEPS, parseUtcReading, taiOfUtc } from "../../internal/index.js";
+/**
+ * Return true when a UTC instant string is one of the 27 inserted leap seconds.
+ *
+ * - A table lookup, not a pattern match: `23:59:60` is well-formed on any day and real on 27 of
+ *   them, the days the IERS leap-second table built into GMT lists (Leap_Second.dat through
+ *   Bulletin C 72, 6 July 2026). The table is closed (continuous UTC from 20 May 2027, CGPM
+ *   2026), so 2016-12-31 is the last. For the syntax test alone, use `hasSecond60`.
+ * - Accepts the inserted second in any offset spelling (`2017-01-01T08:59:60+09:00`).
+ * - Leap smearing is not a leap second: a smeared clock never reads `23:59:60` and is up to a second
+ *   off true UTC around an insertion. GMT cannot detect smearing.
+ * - `false` is also the answer for every ordinary second.
+ * - **Compatibility:** in 1.19.0 and earlier `isLeapSecond` (in `plain/`) was the syntactic
+ *   second-60 test, now `hasSecond60`; a call relying on that now returns `false` on days with no
+ *   insertion, and for a second 60 that is not an extended-format instant (`"23:59:60"`, no
+ *   designator, a lowercase `t`, basic format).
+ *
+ * @param isoString ISO 8601 instant string
+ * @returns true for an inserted leap second, or false otherwise and on invalid input
+ *
+ * @example isLeapSecond("2016-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2009-01-01T08:59:60+09:00") // true
+ * @example isLeapSecond("2017-12-31T23:59:60Z") // false — well-formed, no insertion that day
+ * @example isLeapSecond("2016-12-31T23:59:59Z") // false
+ */
+export function isLeapSecond(isoString) {
+    try {
+        const reading = parseUtcReading(isoString);
+        return (reading !== null &&
+            reading.secondSixty &&
+            taiOfUtc(LEAP_SECOND_STEPS, reading) !== null);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/transport/calculate/crossingTime.d.ts

@@ -52,8 +52,8 @@ export interface Crossing {
  *
  * @example crossingTime("2024-06-15T08:00:00Z", "2024-06-15T17:30:00Z", "Europe/Berlin") // { duration: "PT9H30M", enter: "2024-06-15T10:00:00+02:00[Europe/Berlin]", exit: "2024-06-15T19:30:00+02:00[Europe/Berlin]" }
  * @example crossingTime("2024-06-15T10:00:00+09:00", "2024-06-15T12:00:00+09:00", "Asia/Tokyo") // { duration: "PT2H", enter: "2024-06-15T10:00:00+09:00[Asia/Tokyo]", exit: "2024-06-15T12:00:00+09:00[Asia/Tokyo]" }
- * @example crossingTime("2024-03-10T05:00:00Z", "2024-03-10T12:00:00Z", "America/New_York") // { duration: "PT7H", enter: "2024-03-10T00:00:00-05:00[America/New_York]", exit: "2024-03-10T08:00:00-04:00[America/New_York]" } (seven elapsed hours across the spring-forward)
- * @example crossingTime("2024-11-03T05:30:00Z", "2024-11-03T06:30:00Z", "America/New_York") // { duration: "PT1H", enter: "2024-11-03T01:30:00-04:00[America/New_York]", exit: "2024-11-03T01:30:00-05:00[America/New_York]" } (both ends read 01:30; the offsets tell them apart)
+ * @example crossingTime("2024-10-05T14:00:00Z", "2024-10-05T21:00:00Z", "Australia/Sydney") // { duration: "PT7H", enter: "2024-10-06T00:00:00+10:00[Australia/Sydney]", exit: "2024-10-06T08:00:00+11:00[Australia/Sydney]" } (seven elapsed hours across the spring-forward)
+ * @example crossingTime("2024-10-27T00:30:00Z", "2024-10-27T01:30:00Z", "Europe/London") // { duration: "PT1H", enter: "2024-10-27T01:30:00+01:00[Europe/London]", exit: "2024-10-27T01:30:00+00:00[Europe/London]" } (both ends read 01:30; the offsets tell them apart)
  * @example crossingTime("2024-06-15T10:00:00Z", "2024-06-15T10:00:00Z", "Asia/Tokyo") // { duration: "PT0S", enter: "2024-06-15T19:00:00+09:00[Asia/Tokyo]", exit: "2024-06-15T19:00:00+09:00[Asia/Tokyo]" }
  * @example crossingTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "+02:00") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[+02:00]", exit: "2024-06-16T03:00:00+02:00[+02:00]" } (a fixed offset renders with no DST)
  * @example crossingTime("2024-06-16T01:00:00Z", "2024-06-15T22:30:00Z", "Europe/London") // null (exit before entry)

package/dist/transport/calculate/crossingTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { instantFrom } from "../../internal/index.js";
 import { isValidInstant } from "../../precision/validate/isValidInstant.js";
 import { isValidTimeZone } from "../../zoned/validate/isValidTimeZone.js";
@@ -44,8 +44,8 @@ import { isValidTimeZone } from "../../zoned/validate/isValidTimeZone.js";
  *
  * @example crossingTime("2024-06-15T08:00:00Z", "2024-06-15T17:30:00Z", "Europe/Berlin") // { duration: "PT9H30M", enter: "2024-06-15T10:00:00+02:00[Europe/Berlin]", exit: "2024-06-15T19:30:00+02:00[Europe/Berlin]" }
  * @example crossingTime("2024-06-15T10:00:00+09:00", "2024-06-15T12:00:00+09:00", "Asia/Tokyo") // { duration: "PT2H", enter: "2024-06-15T10:00:00+09:00[Asia/Tokyo]", exit: "2024-06-15T12:00:00+09:00[Asia/Tokyo]" }
- * @example crossingTime("2024-03-10T05:00:00Z", "2024-03-10T12:00:00Z", "America/New_York") // { duration: "PT7H", enter: "2024-03-10T00:00:00-05:00[America/New_York]", exit: "2024-03-10T08:00:00-04:00[America/New_York]" } (seven elapsed hours across the spring-forward)
- * @example crossingTime("2024-11-03T05:30:00Z", "2024-11-03T06:30:00Z", "America/New_York") // { duration: "PT1H", enter: "2024-11-03T01:30:00-04:00[America/New_York]", exit: "2024-11-03T01:30:00-05:00[America/New_York]" } (both ends read 01:30; the offsets tell them apart)
+ * @example crossingTime("2024-10-05T14:00:00Z", "2024-10-05T21:00:00Z", "Australia/Sydney") // { duration: "PT7H", enter: "2024-10-06T00:00:00+10:00[Australia/Sydney]", exit: "2024-10-06T08:00:00+11:00[Australia/Sydney]" } (seven elapsed hours across the spring-forward)
+ * @example crossingTime("2024-10-27T00:30:00Z", "2024-10-27T01:30:00Z", "Europe/London") // { duration: "PT1H", enter: "2024-10-27T01:30:00+01:00[Europe/London]", exit: "2024-10-27T01:30:00+00:00[Europe/London]" } (both ends read 01:30; the offsets tell them apart)
  * @example crossingTime("2024-06-15T10:00:00Z", "2024-06-15T10:00:00Z", "Asia/Tokyo") // { duration: "PT0S", enter: "2024-06-15T19:00:00+09:00[Asia/Tokyo]", exit: "2024-06-15T19:00:00+09:00[Asia/Tokyo]" }
  * @example crossingTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "+02:00") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[+02:00]", exit: "2024-06-16T03:00:00+02:00[+02:00]" } (a fixed offset renders with no DST)
  * @example crossingTime("2024-06-16T01:00:00Z", "2024-06-15T22:30:00Z", "Europe/London") // null (exit before entry)

package/dist/transport/calculate/cutoffAt.d.ts

@@ -83,12 +83,12 @@ export interface CutoffOptions {
  * @example cutoffAt("2024-06-14T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00" }) // "2024-06-12T17:00:00+02:00[Europe/Amsterdam]"
  * @example cutoffAt("2024-06-14T16:00:00Z", "PT48H", { timeZone: "Europe/Amsterdam" }) // "2024-06-12T18:00:00+02:00[Europe/Amsterdam]" (48 hours keeps the departure's 18:00)
  * @example cutoffAt("2024-06-14T16:00:00Z", "P1D", { timeZone: "Europe/Amsterdam", atLocalTime: "10:00" }) // "2024-06-13T10:00:00+02:00[Europe/Amsterdam]"
- * @example cutoffAt("2024-11-05T17:00:00Z", "PT96H", { timeZone: "America/New_York" }) // "2024-11-01T13:00:00-04:00[America/New_York]" (96 elapsed hours across the fall-back)
- * @example cutoffAt("2024-03-11T22:00:00Z", "P2D", { timeZone: "America/New_York", atLocalTime: "17:00" }) // "2024-03-09T17:00:00-05:00[America/New_York]" (17:00 local, across the spring-forward)
+ * @example cutoffAt("2024-04-09T07:00:00Z", "PT96H", { timeZone: "Australia/Sydney" }) // "2024-04-05T18:00:00+11:00[Australia/Sydney]" (96 elapsed hours across the fall-back)
+ * @example cutoffAt("2024-04-01T16:00:00Z", "P2D", { timeZone: "Europe/London", atLocalTime: "17:00" }) // "2024-03-30T17:00:00+00:00[Europe/London]" (17:00 local, across the spring-forward)
  * @example cutoffAt("2024-06-18T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" }, roll: "preceding" }) // "2024-06-14T17:00:00+02:00[Europe/Amsterdam]" (Sunday rolls back to Friday)
  * @example cutoffAt("2024-06-18T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" } }) // "" (a calendar needs a roll convention)
- * @example cutoffAt("2024-11-04T23:00:00Z", "P1D", { timeZone: "America/New_York", atLocalTime: "01:30" }) // "2024-11-03T01:30:00-04:00[America/New_York]" (a repeated hour takes the earlier pass)
- * @example cutoffAt("2024-03-11T22:00:00Z", "P1D", { timeZone: "America/New_York", atLocalTime: "02:30" }) // "" (02:30 on 10 March never happened)
+ * @example cutoffAt("2024-10-28T18:00:00Z", "P1D", { timeZone: "Europe/London", atLocalTime: "01:30" }) // "2024-10-27T01:30:00+01:00[Europe/London]" (a repeated hour takes the earlier pass)
+ * @example cutoffAt("2024-10-07T07:00:00Z", "P1D", { timeZone: "Australia/Sydney", atLocalTime: "02:30" }) // "" (02:30 on 6 October never happened)
  * @example cutoffAt("2024-06-14T18:00:00", "P2D", { timeZone: "Europe/Amsterdam" }) // "" (a zoneless anchor is not a moment)
  * @example cutoffAt("2024-06-14T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", roll: "preceding" }) // "" (a roll needs a calendar)
  */