@northguild/gmt 1.18.0 → 1.20.0

package/dist/zoned/get/getZonedYear.js

@@ -1,24 +1,26 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isValidTimeZone } from "../validate/index.js";
+import { frameNowWallClock, zoneFrame } from "../../internal/zoneFrame.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return the current year for the specified IANA timeZone.
  *
  * - Uses Temporal.Now.zonedDateTimeISO to get the current time.
  * - Validation is performed on the timezone.
+ * - The year is zero-padded to 4 digits. A year outside 0000–9999 is written with a sign and six
+ *   digits (`+010000`, `-000005`), as Temporal writes it at the head of a date.
  *
- * @param ianaTimezone IANA timeZone identifier
+ * @param ianaTimezone IANA name or UTC offset: a time zone identifier (`+05:30`, `+0530`, `-08`) or
+ *   a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns current year string (zero-padded to 4 digits) or "" on invalid input
  *
- * @example getZonedYear("America/New_York") // "2024"
+ * @example getZonedYear("Africa/Johannesburg") // "2024"
  * @example getZonedYear("invalid") // ""
  */
 export function getZonedYear(ianaTimezone) {
-    if (!isValidTimeZone(ianaTimezone))
+    const frame = zoneFrame(ianaTimezone);
+    if (frame === null)
         return "";
     try {
-        return Temporal.Now.zonedDateTimeISO(ianaTimezone)
-            .year.toString()
-            .padStart(4, "0");
+        return isoYearString(frameNowWallClock(frame).year);
     }
     catch {
         return "";

package/dist/zoned/index.d.ts

@@ -1,6 +1,7 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
 export * from "./chop/index.js";
+export * from "./classify/index.js";
 export * from "./compare/index.js";
 export * from "./convert/index.js";
 export * from "./format/index.js";

package/dist/zoned/index.js

@@ -1,7 +1,8 @@
-// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
-export * from "@js-temporal/polyfill";
+// 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 "./chop/index.js";
+export * from "./classify/index.js";
 export * from "./compare/index.js";
 export * from "./convert/index.js";
 export * from "./format/index.js";

package/dist/zoned/interval/intervalAbutsZoned.d.ts

@@ -13,7 +13,7 @@
  *   nothing.
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in
@@ -29,7 +29,7 @@
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // true
- * @example intervalAbutsZoned("2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T08:00:00-04:00[America/New_York]") // true (the same instant in another zone)
+ * @example intervalAbutsZoned("2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T17:30:00+05:30[Asia/Kolkata]") // true (the same instant in another zone)
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00.000000001+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (one-nanosecond gap)
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T13:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (overlap)
  * @example intervalAbutsZoned("invalid", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false

package/dist/zoned/interval/intervalAbutsZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { halfOpenAbuts, parseCalendarZonedValue } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**
@@ -17,7 +17,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  *   nothing.
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in
@@ -33,7 +33,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // true
- * @example intervalAbutsZoned("2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T08:00:00-04:00[America/New_York]") // true (the same instant in another zone)
+ * @example intervalAbutsZoned("2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T17:30:00+05:30[Asia/Kolkata]") // true (the same instant in another zone)
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00.000000001+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (one-nanosecond gap)
  * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T13:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (overlap)
  * @example intervalAbutsZoned("invalid", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false

package/dist/zoned/interval/intervalContainsZoned.d.ts

@@ -15,7 +15,7 @@
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the endpoints need not agree on a calendar. Ordering is calendar-independent — verified
  *   that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in

package/dist/zoned/interval/intervalContainsZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { halfOpenContainsPoint, halfOpenContainsSpan, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**
@@ -18,7 +18,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the endpoints need not agree on a calendar. Ordering is calendar-independent — verified
  *   that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in

package/dist/zoned/interval/intervalCountZoned.d.ts

@@ -36,11 +36,11 @@
  * @returns number of unit boundaries touched, or null on invalid input
  *
  * @example intervalCountZoned("2024-01-01T23:59:00+00:00[UTC]", "2024-01-02T00:01:00+00:00[UTC]", "day") // 2
- * @example intervalCountZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "hour") // 23 (spring forward)
- * @example intervalCountZoned("2024-11-03T00:00:00-04:00[America/New_York]", "2024-11-04T00:00:00-05:00[America/New_York]", "hour") // 25 (fall back)
- * @example intervalCountZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+09:00[Asia/Tokyo]", "day") // 2 (counted in America/New_York)
+ * @example intervalCountZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "hour") // 23 (spring forward)
+ * @example intervalCountZoned("2024-04-07T00:00:00+11:00[Australia/Sydney]", "2024-04-08T00:00:00+10:00[Australia/Sydney]", "hour") // 25 (fall back)
+ * @example intervalCountZoned("2024-01-01T00:00:00-03:00[America/Sao_Paulo]", "2024-01-03T00:00:00+09:00[Asia/Tokyo]", "day") // 2 (counted in America/Sao_Paulo)
  * @example intervalCountZoned("2024-01-01T05:00:00+00:00[UTC]", "2024-01-01T05:00:00+00:00[UTC]", "day") // 0 (zero-length: holds no instant)
- * @example intervalCountZoned("2023-09-16T00:00:00-04:00[America/New_York][u-ca=hebrew]", "2024-10-03T00:00:00-04:00[America/New_York][u-ca=hebrew]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
+ * @example intervalCountZoned("2023-09-16T00:00:00+02:00[Africa/Johannesburg][u-ca=hebrew]", "2024-10-03T00:00:00+02:00[Africa/Johannesburg][u-ca=hebrew]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
  * @example intervalCountZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
  * @example intervalCountZoned("-271821-04-20T00:00:00+00:00[UTC]", "-271821-04-20T01:00:00+00:00[UTC]", "week") // 1 (the week began before the first instant, but is still touched)
  */

package/dist/zoned/interval/intervalCountZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { countZonedBuckets, parseCalendarZonedPairForArithmetic, resolveDateTimeUnit, } from "../../internal/index.js";
 import { isValidDateTimeUnit } from "../../plain/validate/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/isValidCalendarZonedDateTime.js";
@@ -41,11 +41,11 @@ import { isValidCalendarZonedDateTime } from "../validate/isValidCalendarZonedDa
  * @returns number of unit boundaries touched, or null on invalid input
  *
  * @example intervalCountZoned("2024-01-01T23:59:00+00:00[UTC]", "2024-01-02T00:01:00+00:00[UTC]", "day") // 2
- * @example intervalCountZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "hour") // 23 (spring forward)
- * @example intervalCountZoned("2024-11-03T00:00:00-04:00[America/New_York]", "2024-11-04T00:00:00-05:00[America/New_York]", "hour") // 25 (fall back)
- * @example intervalCountZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+09:00[Asia/Tokyo]", "day") // 2 (counted in America/New_York)
+ * @example intervalCountZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "hour") // 23 (spring forward)
+ * @example intervalCountZoned("2024-04-07T00:00:00+11:00[Australia/Sydney]", "2024-04-08T00:00:00+10:00[Australia/Sydney]", "hour") // 25 (fall back)
+ * @example intervalCountZoned("2024-01-01T00:00:00-03:00[America/Sao_Paulo]", "2024-01-03T00:00:00+09:00[Asia/Tokyo]", "day") // 2 (counted in America/Sao_Paulo)
  * @example intervalCountZoned("2024-01-01T05:00:00+00:00[UTC]", "2024-01-01T05:00:00+00:00[UTC]", "day") // 0 (zero-length: holds no instant)
- * @example intervalCountZoned("2023-09-16T00:00:00-04:00[America/New_York][u-ca=hebrew]", "2024-10-03T00:00:00-04:00[America/New_York][u-ca=hebrew]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
+ * @example intervalCountZoned("2023-09-16T00:00:00+02:00[Africa/Johannesburg][u-ca=hebrew]", "2024-10-03T00:00:00+02:00[Africa/Johannesburg][u-ca=hebrew]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
  * @example intervalCountZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
  * @example intervalCountZoned("-271821-04-20T00:00:00+00:00[UTC]", "-271821-04-20T01:00:00+00:00[UTC]", "week") // 1 (the week began before the first instant, but is still touched)
  */

package/dist/zoned/interval/intervalDifferenceZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenDifference, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**

package/dist/zoned/interval/intervalDivideEquallyZoned.d.ts

@@ -31,7 +31,7 @@
  * @param options optional limit on the size of the output
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
- * @example intervalDivideEquallyZoned("2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]", 2) // [{ start: "2024-03-09T12:00:00-05:00[America/New_York]", end: "2024-03-10T12:30:00-04:00[America/New_York]" }, { start: "2024-03-10T12:30:00-04:00[America/New_York]", end: "2024-03-11T12:00:00-04:00[America/New_York]" }] (47 real hours split in half)
+ * @example intervalDivideEquallyZoned("2024-10-05T12:00:00+10:00[Australia/Sydney]", "2024-10-07T12:00:00+11:00[Australia/Sydney]", 2) // [{ start: "2024-10-05T12:00:00+10:00[Australia/Sydney]", end: "2024-10-06T12:30:00+11:00[Australia/Sydney]" }, { start: "2024-10-06T12:30:00+11:00[Australia/Sydney]", end: "2024-10-07T12:00:00+11:00[Australia/Sydney]" }] (47 real hours split in half)
  * @example intervalDivideEquallyZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-04T00:00:00+00:00[UTC]", 1) // [{ start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-04T00:00:00+00:00[UTC]" }]
  * @example intervalDivideEquallyZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-04T00:00:00+00:00[UTC]", 0) // []
  * @example intervalDivideEquallyZoned("invalid", "2024-01-04T00:00:00+00:00[UTC]", 3) // []

package/dist/zoned/interval/intervalDivideEquallyZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedInterval } from "./validate/index.js";
 import { divisionBoundary } from "../../internal/divisionBoundary.js";
@@ -37,7 +37,7 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  * @param options optional limit on the size of the output
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
- * @example intervalDivideEquallyZoned("2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]", 2) // [{ start: "2024-03-09T12:00:00-05:00[America/New_York]", end: "2024-03-10T12:30:00-04:00[America/New_York]" }, { start: "2024-03-10T12:30:00-04:00[America/New_York]", end: "2024-03-11T12:00:00-04:00[America/New_York]" }] (47 real hours split in half)
+ * @example intervalDivideEquallyZoned("2024-10-05T12:00:00+10:00[Australia/Sydney]", "2024-10-07T12:00:00+11:00[Australia/Sydney]", 2) // [{ start: "2024-10-05T12:00:00+10:00[Australia/Sydney]", end: "2024-10-06T12:30:00+11:00[Australia/Sydney]" }, { start: "2024-10-06T12:30:00+11:00[Australia/Sydney]", end: "2024-10-07T12:00:00+11:00[Australia/Sydney]" }] (47 real hours split in half)
  * @example intervalDivideEquallyZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-04T00:00:00+00:00[UTC]", 1) // [{ start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-04T00:00:00+00:00[UTC]" }]
  * @example intervalDivideEquallyZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-04T00:00:00+00:00[UTC]", 0) // []
  * @example intervalDivideEquallyZoned("invalid", "2024-01-04T00:00:00+00:00[UTC]", 3) // []

package/dist/zoned/interval/intervalEngulfsZoned.d.ts

@@ -11,7 +11,7 @@
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in

package/dist/zoned/interval/intervalEngulfsZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { halfOpenContainsSpan, parseCalendarZonedValue } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**
@@ -15,7 +15,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in

package/dist/zoned/interval/intervalFromDurationZoned.d.ts

@@ -36,12 +36,12 @@ import type { Disambiguation, Overflow } from "../../types/index.js";
  *
  * @example intervalFromDurationZoned("2024-01-01T00:00:00+00:00[UTC]", "P1D", "start") // { start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-02T00:00:00+00:00[UTC]" }
  * @example intervalFromDurationZoned("2024-01-02T00:00:00+00:00[UTC]", "P1D", "end") // { start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-02T00:00:00+00:00[UTC]" }
- * @example intervalFromDurationZoned("2024-11-02T01:30:00-04:00[America/New_York]", "P1D", "start", { disambiguation: "later" }) // { start: "2024-11-02T01:30:00-04:00[America/New_York]", end: "2024-11-03T01:30:00-05:00[America/New_York]" } (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example intervalFromDurationZoned("2024-03-09T02:30:00-05:00[America/New_York]", "P1D", "start", { disambiguation: "earlier" }) // { start: "2024-03-09T02:30:00-05:00[America/New_York]", end: "2024-03-10T01:30:00-05:00[America/New_York]" } (spring-forward gap; "earlier" moves the end back an hour)
- * @example intervalFromDurationZoned("2024-03-09T02:30:00-05:00[America/New_York]", "P1D", "start", { disambiguation: "reject" }) // null (spring-forward gap rejected)
- * @example intervalFromDurationZoned("2024-11-03T00:30:00-04:00[America/New_York]", "PT1H", "start", { disambiguation: "later" }) // { start: "2024-11-03T00:30:00-04:00[America/New_York]", end: "2024-11-03T01:30:00-04:00[America/New_York]" } (exact time — disambiguation never re-resolves it)
- * @example setZoned(intervalFromDurationZoned("2024-11-03T00:30:00-04:00[America/New_York]", "PT1H", "start")?.end ?? "", { hour: 1, minute: 30, second: 0 }, { disambiguation: "later", offset: "ignore" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (pre-1.16.0 end)
- * @example intervalFromDurationZoned("2024-01-31T12:00:00-05:00[America/New_York]", "P1M", "start", { overflow: "reject" }) // null
+ * @example intervalFromDurationZoned("2024-10-26T01:30:00+01:00[Europe/London]", "P1D", "start", { disambiguation: "later" }) // { start: "2024-10-26T01:30:00+01:00[Europe/London]", end: "2024-10-27T01:30:00+00:00[Europe/London]" } (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example intervalFromDurationZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", "P1D", "start", { disambiguation: "earlier" }) // { start: "2024-10-05T02:30:00+10:00[Australia/Sydney]", end: "2024-10-06T01:30:00+10:00[Australia/Sydney]" } (spring-forward gap; "earlier" moves the end back an hour)
+ * @example intervalFromDurationZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", "P1D", "start", { disambiguation: "reject" }) // null (spring-forward gap rejected)
+ * @example intervalFromDurationZoned("2024-10-27T00:30:00+01:00[Europe/London]", "PT1H", "start", { disambiguation: "later" }) // { start: "2024-10-27T00:30:00+01:00[Europe/London]", end: "2024-10-27T01:30:00+01:00[Europe/London]" } (exact time — disambiguation never re-resolves it)
+ * @example setZoned(intervalFromDurationZoned("2024-10-27T00:30:00+01:00[Europe/London]", "PT1H", "start")?.end ?? "", { hour: 1, minute: 30, second: 0 }, { disambiguation: "later", offset: "ignore" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (pre-1.16.0 end)
+ * @example intervalFromDurationZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", "P1M", "start", { overflow: "reject" }) // null
  * @example intervalFromDurationZoned("invalid", "P1D", "start") // null
  */
 export declare function intervalFromDurationZoned(value: string, duration: string, anchor: "start" | "end", options?: {

package/dist/zoned/interval/intervalFromDurationZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDuration } from "../../duration/validate/index.js";
 import { addToZonedDisambiguated, calendarSystemOfZonedValue, formatZonedInCalendar, parseCalendarZonedValue, resolveOverflow, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
@@ -41,12 +41,12 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  *
  * @example intervalFromDurationZoned("2024-01-01T00:00:00+00:00[UTC]", "P1D", "start") // { start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-02T00:00:00+00:00[UTC]" }
  * @example intervalFromDurationZoned("2024-01-02T00:00:00+00:00[UTC]", "P1D", "end") // { start: "2024-01-01T00:00:00+00:00[UTC]", end: "2024-01-02T00:00:00+00:00[UTC]" }
- * @example intervalFromDurationZoned("2024-11-02T01:30:00-04:00[America/New_York]", "P1D", "start", { disambiguation: "later" }) // { start: "2024-11-02T01:30:00-04:00[America/New_York]", end: "2024-11-03T01:30:00-05:00[America/New_York]" } (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example intervalFromDurationZoned("2024-03-09T02:30:00-05:00[America/New_York]", "P1D", "start", { disambiguation: "earlier" }) // { start: "2024-03-09T02:30:00-05:00[America/New_York]", end: "2024-03-10T01:30:00-05:00[America/New_York]" } (spring-forward gap; "earlier" moves the end back an hour)
- * @example intervalFromDurationZoned("2024-03-09T02:30:00-05:00[America/New_York]", "P1D", "start", { disambiguation: "reject" }) // null (spring-forward gap rejected)
- * @example intervalFromDurationZoned("2024-11-03T00:30:00-04:00[America/New_York]", "PT1H", "start", { disambiguation: "later" }) // { start: "2024-11-03T00:30:00-04:00[America/New_York]", end: "2024-11-03T01:30:00-04:00[America/New_York]" } (exact time — disambiguation never re-resolves it)
- * @example setZoned(intervalFromDurationZoned("2024-11-03T00:30:00-04:00[America/New_York]", "PT1H", "start")?.end ?? "", { hour: 1, minute: 30, second: 0 }, { disambiguation: "later", offset: "ignore" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (pre-1.16.0 end)
- * @example intervalFromDurationZoned("2024-01-31T12:00:00-05:00[America/New_York]", "P1M", "start", { overflow: "reject" }) // null
+ * @example intervalFromDurationZoned("2024-10-26T01:30:00+01:00[Europe/London]", "P1D", "start", { disambiguation: "later" }) // { start: "2024-10-26T01:30:00+01:00[Europe/London]", end: "2024-10-27T01:30:00+00:00[Europe/London]" } (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example intervalFromDurationZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", "P1D", "start", { disambiguation: "earlier" }) // { start: "2024-10-05T02:30:00+10:00[Australia/Sydney]", end: "2024-10-06T01:30:00+10:00[Australia/Sydney]" } (spring-forward gap; "earlier" moves the end back an hour)
+ * @example intervalFromDurationZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", "P1D", "start", { disambiguation: "reject" }) // null (spring-forward gap rejected)
+ * @example intervalFromDurationZoned("2024-10-27T00:30:00+01:00[Europe/London]", "PT1H", "start", { disambiguation: "later" }) // { start: "2024-10-27T00:30:00+01:00[Europe/London]", end: "2024-10-27T01:30:00+01:00[Europe/London]" } (exact time — disambiguation never re-resolves it)
+ * @example setZoned(intervalFromDurationZoned("2024-10-27T00:30:00+01:00[Europe/London]", "PT1H", "start")?.end ?? "", { hour: 1, minute: 30, second: 0 }, { disambiguation: "later", offset: "ignore" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (pre-1.16.0 end)
+ * @example intervalFromDurationZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", "P1M", "start", { overflow: "reject" }) // null
  * @example intervalFromDurationZoned("invalid", "P1D", "start") // null
  */
 export function intervalFromDurationZoned(value, duration, anchor, options) {

package/dist/zoned/interval/intervalIntersectionZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenIntersection, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**

package/dist/zoned/interval/intervalLengthZoned.d.ts

@@ -29,12 +29,12 @@
  * @param unit unit string — any `DateTimeUnit`
  * @returns exact length of the interval expressed in `unit`, or null on invalid input
  *
- * @example intervalLengthZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "hour") // 23 (spring forward)
- * @example intervalLengthZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "day") // 1
+ * @example intervalLengthZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "hour") // 23 (spring forward)
+ * @example intervalLengthZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "day") // 1
  * @example intervalLengthZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "day") // 0
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "hour") // 42
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "day") // null (calendar unit across two time zones)
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", convertZonedToZoned("2024-01-03T00:00:00+01:00[Europe/Paris]", "America/New_York"), "day") // 1.75 (both ends in one zone first)
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "hour") // 52.5
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "day") // null (calendar unit across two time zones)
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", convertZonedToZoned("2024-01-03T00:00:00+01:00[Europe/Paris]", "Asia/Kolkata"), "day") // 2.1875 (both ends in one zone first)
  * @example intervalLengthZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
  */
 export declare function intervalLengthZoned(start: string, end: string, unit: string): number | null;

package/dist/zoned/interval/intervalLengthZoned.js

@@ -32,12 +32,12 @@ import { isValidCalendarZonedInterval } from "./validate/index.js";
  * @param unit unit string — any `DateTimeUnit`
  * @returns exact length of the interval expressed in `unit`, or null on invalid input
  *
- * @example intervalLengthZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "hour") // 23 (spring forward)
- * @example intervalLengthZoned("2024-03-10T00:00:00-05:00[America/New_York]", "2024-03-11T00:00:00-04:00[America/New_York]", "day") // 1
+ * @example intervalLengthZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "hour") // 23 (spring forward)
+ * @example intervalLengthZoned("2024-03-31T00:00:00+00:00[Europe/London]", "2024-04-01T00:00:00+01:00[Europe/London]", "day") // 1
  * @example intervalLengthZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "day") // 0
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "hour") // 42
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "day") // null (calendar unit across two time zones)
- * @example intervalLengthZoned("2024-01-01T00:00:00-05:00[America/New_York]", convertZonedToZoned("2024-01-03T00:00:00+01:00[Europe/Paris]", "America/New_York"), "day") // 1.75 (both ends in one zone first)
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "hour") // 52.5
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", "2024-01-03T00:00:00+01:00[Europe/Paris]", "day") // null (calendar unit across two time zones)
+ * @example intervalLengthZoned("2024-01-01T00:00:00+05:30[Asia/Kolkata]", convertZonedToZoned("2024-01-03T00:00:00+01:00[Europe/Paris]", "Asia/Kolkata"), "day") // 2.1875 (both ends in one zone first)
  * @example intervalLengthZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
  */
 export function intervalLengthZoned(start, end, unit) {

package/dist/zoned/interval/intervalOverlappingDaysZoned.d.ts

@@ -25,7 +25,7 @@
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings, leap seconds).
  * - Accepts RFC 9557 calendar-annotated zoned strings
- *   (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`; E7, issue #152). All four
+ *   (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`; E7, issue #152). All four
  *   arguments must name the same calendar (a bare string names `iso8601`): the count is a day
  *   difference, so different calendars return `null`, as Temporal's `until` throws when
  *   `CalendarEquals` is false. Before 1.16.0 the arguments could name different calendars.
@@ -42,7 +42,7 @@
  * @param bEnd ISO 8601 zoned datetime string for the second interval end
  * @returns number of shared calendar dates (counted in aStart's zone), `0` when disjoint, or null on invalid input
  *
- * @example intervalOverlappingDaysZoned("2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]", "2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]") // 3 (spring-forward, 47 real hours)
+ * @example intervalOverlappingDaysZoned("2024-03-30T12:00:00+00:00[Europe/London]", "2024-04-01T12:00:00+01:00[Europe/London]", "2024-03-30T12:00:00+00:00[Europe/London]", "2024-04-01T12:00:00+01:00[Europe/London]") // 3 (spring-forward, 47 real hours)
  * @example intervalOverlappingDaysZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-03T00:00:00+00:00[UTC]") // 0 (touching: no shared instant)
  * @example intervalOverlappingDaysZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]") // 1 (the end, 01-02T00:00, is excluded)
  * @example intervalOverlappingDaysZoned("2011-12-29T23:00:00-10:00[Pacific/Apia]", "2011-12-31T01:00:00+14:00[Pacific/Apia]", "2011-12-29T23:00:00-10:00[Pacific/Apia]", "2011-12-31T01:00:00+14:00[Pacific/Apia]") // 2 (2011-12-30 was deleted)

package/dist/zoned/interval/intervalOverlappingDaysZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, countZonedLocalDates, halfOpenIntersection, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**
@@ -28,7 +28,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings, leap seconds).
  * - Accepts RFC 9557 calendar-annotated zoned strings
- *   (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`; E7, issue #152). All four
+ *   (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`; E7, issue #152). All four
  *   arguments must name the same calendar (a bare string names `iso8601`): the count is a day
  *   difference, so different calendars return `null`, as Temporal's `until` throws when
  *   `CalendarEquals` is false. Before 1.16.0 the arguments could name different calendars.
@@ -45,7 +45,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * @param bEnd ISO 8601 zoned datetime string for the second interval end
  * @returns number of shared calendar dates (counted in aStart's zone), `0` when disjoint, or null on invalid input
  *
- * @example intervalOverlappingDaysZoned("2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]", "2024-03-09T12:00:00-05:00[America/New_York]", "2024-03-11T12:00:00-04:00[America/New_York]") // 3 (spring-forward, 47 real hours)
+ * @example intervalOverlappingDaysZoned("2024-03-30T12:00:00+00:00[Europe/London]", "2024-04-01T12:00:00+01:00[Europe/London]", "2024-03-30T12:00:00+00:00[Europe/London]", "2024-04-01T12:00:00+01:00[Europe/London]") // 3 (spring-forward, 47 real hours)
  * @example intervalOverlappingDaysZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-03T00:00:00+00:00[UTC]") // 0 (touching: no shared instant)
  * @example intervalOverlappingDaysZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "2024-01-02T00:00:00+00:00[UTC]") // 1 (the end, 01-02T00:00, is excluded)
  * @example intervalOverlappingDaysZoned("2011-12-29T23:00:00-10:00[Pacific/Apia]", "2011-12-31T01:00:00+14:00[Pacific/Apia]", "2011-12-29T23:00:00-10:00[Pacific/Apia]", "2011-12-31T01:00:00+14:00[Pacific/Apia]") // 2 (2011-12-30 was deleted)

package/dist/zoned/interval/intervalSplitAtZoned.js

@@ -1,4 +1,3 @@
-import { Temporal } from "@js-temporal/polyfill";
 import { calendarOfAllZonedValues, formatZonedInCalendar, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/isValidCalendarZonedDateTime.js";
 import { isValidCalendarZonedInterval } from "./validate/index.js";
@@ -59,21 +58,20 @@ export function intervalSplitAtZoned(start, end, points) {
         try {
             const startVal = parseCalendarZonedValue(start);
             const endVal = parseCalendarZonedValue(end);
-            const startInstant = startVal.toInstant();
-            const endInstant = endVal.toInstant();
-            const parsedPoints = points.map((point) => parseCalendarZonedValue(point));
-            const inRangePoints = parsedPoints.filter((point) => {
-                const instant = point.toInstant();
-                return (Temporal.Instant.compare(instant, startInstant) > 0 &&
-                    Temporal.Instant.compare(instant, endInstant) < 0);
-            });
-            inRangePoints.sort((a, b) => Temporal.Instant.compare(a.toInstant(), b.toInstant()));
-            // Safe: `.equals()` here is `Temporal.Instant.prototype.equals`, and `Instant` carries no
-            // calendar field at all — verified calendar-blind. E7 re-audited this site rather than
-            // inheriting E5's "structurally unreachable" verdict, which depended on mixed calendars never
-            // reaching `zoned/` at all.
-            const uniquePoints = inRangePoints.filter((point, index) => index === 0 ||
-                !point.toInstant().equals(inRangePoints[index - 1].toInstant()));
+            const startNs = startVal.epochNanoseconds;
+            const endNs = endVal.epochNanoseconds;
+            // Each point's instant is read once; filter, sort and dedupe compare the bigints. `sort`
+            // is stable, so points on one instant keep input order and the dedupe keeps the first.
+            const timedPoints = points
+                .map((point) => {
+                const value = parseCalendarZonedValue(point);
+                return { value, ns: value.epochNanoseconds };
+            })
+                .filter(({ ns }) => ns > startNs && ns < endNs);
+            timedPoints.sort((a, b) => (a.ns < b.ns ? -1 : a.ns > b.ns ? 1 : 0));
+            const uniquePoints = timedPoints
+                .filter(({ ns }, index) => index === 0 || ns !== timedPoints[index - 1].ns)
+                .map(({ value }) => value);
             const boundaries = [startVal, ...uniquePoints, endVal];
             const result = [];
             for (let i = 0; i < boundaries.length - 1; i++) {

package/dist/zoned/interval/intervalUnionZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenUnion, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**

package/dist/zoned/interval/intervalXorAllZoned.js

@@ -1,7 +1,8 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenXor, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Return the symmetric difference across a list of zoned intervals — the set of instants
  * covered by an odd number of the input intervals.
@@ -39,8 +40,7 @@ export function intervalXorAllZoned(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             typeof interval.start === "string" &&
             typeof interval.end === "string" &&
             isValidCalendarZonedInterval(interval.start, interval.end))) {

package/dist/zoned/interval/intervalXorZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenXor, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**

package/dist/zoned/interval/intervalsOverlapZoned.d.ts

@@ -12,7 +12,7 @@
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in
@@ -29,7 +29,7 @@
  *
  * @example intervalsOverlapZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-06-30T23:59:59+00:00[UTC]", "2024-04-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
  * @example intervalsOverlapZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-07-01T00:00:00+00:00[UTC]", "2024-07-01T00:00:00+00:00[UTC]", "2024-12-31T00:00:00+00:00[UTC]") // false (touching: the first interval excludes 07-01T00:00)
- * @example intervalsOverlapZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-01-01T12:00:00+00:00[UTC]", "2024-01-01T07:00:00-05:00[America/New_York]", "2024-01-01T17:00:00+00:00[UTC]") // false (touching across zones)
+ * @example intervalsOverlapZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-01-01T12:00:00+00:00[UTC]", "2024-01-01T21:00:00+09:00[Asia/Tokyo]", "2024-01-01T17:00:00+00:00[UTC]") // false (touching across zones)
  * @example intervalsOverlapZoned("invalid", "2024-06-30T23:59:59+00:00[UTC]", "2024-04-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // false
  */
 export declare function intervalsOverlapZoned(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/zoned/interval/intervalsOverlapZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { halfOpenOverlap, parseCalendarZonedValue } from "../../internal/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 /**
@@ -16,7 +16,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
  * - **Accepts mixed calendar systems** (E7's D4-zoned, issue #152): both bare ISO zoned strings
- *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`),
+ *   and RFC 9557 calendar-annotated ones (`"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`),
  *   and the two endpoints need not agree on a calendar. Ordering is calendar-independent —
  *   verified that `Temporal.Instant` carries no calendar field at all and that
  *   `Instant.compare`/`ZonedDateTime.compare` both return `0` for the same instant expressed in
@@ -33,7 +33,7 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  *
  * @example intervalsOverlapZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-06-30T23:59:59+00:00[UTC]", "2024-04-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
  * @example intervalsOverlapZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-07-01T00:00:00+00:00[UTC]", "2024-07-01T00:00:00+00:00[UTC]", "2024-12-31T00:00:00+00:00[UTC]") // false (touching: the first interval excludes 07-01T00:00)
- * @example intervalsOverlapZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-01-01T12:00:00+00:00[UTC]", "2024-01-01T07:00:00-05:00[America/New_York]", "2024-01-01T17:00:00+00:00[UTC]") // false (touching across zones)
+ * @example intervalsOverlapZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-01-01T12:00:00+00:00[UTC]", "2024-01-01T21:00:00+09:00[Asia/Tokyo]", "2024-01-01T17:00:00+00:00[UTC]") // false (touching across zones)
  * @example intervalsOverlapZoned("invalid", "2024-06-30T23:59:59+00:00[UTC]", "2024-04-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // false
  */
 export function intervalsOverlapZoned(aStart, aEnd, bStart, bEnd) {

package/dist/zoned/interval/mergeIntervalsZoned.js

@@ -1,7 +1,8 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { calendarOfAllZonedValues, formatZonedInCalendar, halfOpenMerge, parseCalendarZonedValue, } from "../../internal/index.js";
 import { isValidCalendarZonedInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Collapse a list of zoned intervals into the minimum set of non-overlapping intervals.
  *
@@ -43,8 +44,7 @@ export function mergeIntervalsZoned(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             typeof interval.start === "string" &&
             typeof interval.end === "string" &&
             isValidCalendarZonedInterval(interval.start, interval.end))) {

package/dist/zoned/interval/splitIntervalByUnitZoned.d.ts

@@ -10,7 +10,8 @@
  *   lands on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks
  *   to the month's last day, and stepping from that boundary would keep the shortened day
  *   (February 29, then March 29).
- * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
+ * - Each calendar-unit boundary is `start.add(amount × k)` with Temporal's
+ *   `overflow: "constrain"` (TC39 Temporal `add`), never a step from the previous boundary.
  * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
  *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
  *   `Number.MAX_SAFE_INTEGER`.