@northguild/gmt 1.14.2

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

@@ -0,0 +1,18 @@
+export * from "./intervalAbutsZoned.js";
+export * from "./intervalContainsZoned.js";
+export * from "./intervalCountZoned.js";
+export * from "./intervalDifferenceZoned.js";
+export * from "./intervalDivideEquallyZoned.js";
+export * from "./intervalEngulfsZoned.js";
+export * from "./intervalFromDurationZoned.js";
+export * from "./intervalIntersectionZoned.js";
+export * from "./intervalLengthZoned.js";
+export * from "./intervalOverlappingDaysZoned.js";
+export * from "./intervalsOverlapZoned.js";
+export * from "./intervalSplitAtZoned.js";
+export * from "./intervalUnionZoned.js";
+export * from "./intervalXorAllZoned.js";
+export * from "./intervalXorZoned.js";
+export * from "./mergeIntervalsZoned.js";
+export * from "./splitIntervalByUnitZoned.js";
+export * from "./validate/index.js";

package/dist/zoned/interval/index.js

@@ -0,0 +1,18 @@
+export * from "./intervalAbutsZoned.js";
+export * from "./intervalContainsZoned.js";
+export * from "./intervalCountZoned.js";
+export * from "./intervalDifferenceZoned.js";
+export * from "./intervalDivideEquallyZoned.js";
+export * from "./intervalEngulfsZoned.js";
+export * from "./intervalFromDurationZoned.js";
+export * from "./intervalIntersectionZoned.js";
+export * from "./intervalLengthZoned.js";
+export * from "./intervalOverlappingDaysZoned.js";
+export * from "./intervalsOverlapZoned.js";
+export * from "./intervalSplitAtZoned.js";
+export * from "./intervalUnionZoned.js";
+export * from "./intervalXorAllZoned.js";
+export * from "./intervalXorZoned.js";
+export * from "./mergeIntervalsZoned.js";
+export * from "./splitIntervalByUnitZoned.js";
+export * from "./validate/index.js";

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

@@ -0,0 +1,30 @@
+/**
+ * Return true when two zoned intervals are exactly adjacent — one's end equals the other's
+ * start with zero gap and zero overlap.
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (via `.toInstant()`).
+ * - Returns `true` when `aEnd + 1 nanosecond === bStart` or `bEnd + 1 nanosecond === aStart`.
+ * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
+ * - 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 GMT calendar-annotated ones (`"5784-06-15T14:30:00-05:00[u-ca=hebrew][America/New_York]"`),
+ *   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
+ *   hebrew, islamic-civil, japanese and iso8601.
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering, which reads GMT's
+ *   calendar-native digits as ISO digits — see `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param aStart ISO 8601 zoned datetime string for the first interval start
+ * @param aEnd ISO 8601 zoned datetime string for the first interval end
+ * @param bStart ISO 8601 zoned datetime string for the second interval start
+ * @param bEnd ISO 8601 zoned datetime string for the second interval end
+ * @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.000000001+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-30T12:00:00.000000001+00:00[UTC]") // true
+ * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:01+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (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
+ */
+export declare function intervalAbutsZoned(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/zoned/interval/intervalAbutsZoned.js

@@ -0,0 +1,74 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { parseCalendarZonedValue } from "../../internal/index.js";
+import { isValidCalendarZonedDateTime } from "../validate/index.js";
+/**
+ * Return true when two zoned intervals are exactly adjacent — one's end equals the other's
+ * start with zero gap and zero overlap.
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (via `.toInstant()`).
+ * - Returns `true` when `aEnd + 1 nanosecond === bStart` or `bEnd + 1 nanosecond === aStart`.
+ * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
+ * - 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 GMT calendar-annotated ones (`"5784-06-15T14:30:00-05:00[u-ca=hebrew][America/New_York]"`),
+ *   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
+ *   hebrew, islamic-civil, japanese and iso8601.
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering, which reads GMT's
+ *   calendar-native digits as ISO digits — see `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param aStart ISO 8601 zoned datetime string for the first interval start
+ * @param aEnd ISO 8601 zoned datetime string for the first interval end
+ * @param bStart ISO 8601 zoned datetime string for the second interval start
+ * @param bEnd ISO 8601 zoned datetime string for the second interval end
+ * @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.000000001+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-30T12:00:00.000000001+00:00[UTC]") // true
+ * @example intervalAbutsZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-06-30T12:00:00+00:00[UTC]", "2024-06-30T12:00:01+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // false (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
+ */
+export function intervalAbutsZoned(aStart, aEnd, bStart, bEnd) {
+    // One gate for all four endpoints: `isValidCalendarZonedDateTime` already covers non-strings,
+    // empty strings, leap seconds (which Temporal would otherwise silently clamp to :59), unknown
+    // zones and Temporal's forbidden segment ordering — and, unlike `isValidZonedDateTime`, accepts
+    // GMT's calendar-annotated grammar.
+    if (!isValidCalendarZonedDateTime(aStart) ||
+        !isValidCalendarZonedDateTime(aEnd) ||
+        !isValidCalendarZonedDateTime(bStart) ||
+        !isValidCalendarZonedDateTime(bEnd)) {
+        return false;
+    }
+    try {
+        const aSZdt = parseCalendarZonedValue(aStart);
+        const aEZdt = parseCalendarZonedValue(aEnd);
+        const bSZdt = parseCalendarZonedValue(bStart);
+        const bEZdt = parseCalendarZonedValue(bEnd);
+        const aS = aSZdt.toInstant();
+        const aE = aEZdt.toInstant();
+        const bS = bSZdt.toInstant();
+        const bE = bEZdt.toInstant();
+        if (Temporal.Instant.compare(aS, aE) > 0) {
+            return false;
+        }
+        if (Temporal.Instant.compare(bS, bE) > 0) {
+            return false;
+        }
+        // aEnd + 1 nanosecond === bStart
+        const aEndPlusOne = aE.add({ nanoseconds: 1 });
+        if (Temporal.Instant.compare(aEndPlusOne, bS) === 0) {
+            return true;
+        }
+        // bEnd + 1 nanosecond === aStart
+        const bEndPlusOne = bE.add({ nanoseconds: 1 });
+        if (Temporal.Instant.compare(bEndPlusOne, aS) === 0) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (same instant semantics).
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - 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 GMT calendar-annotated ones (`"5784-06-15T14:30:00-05:00[u-ca=hebrew][America/New_York]"`),
+ *   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
+ *   hebrew, islamic-civil, japanese and iso8601.
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering, which reads GMT's
+ *   calendar-native digits as ISO digits — see `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param intervalStart ISO 8601 zoned datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 zoned datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 zoned datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 zoned datetime string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // true
+ * @example intervalContainsZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]", "2024-07-15T12:00:00+00:00[UTC]") // true
+ * @example intervalContainsZoned("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // false
+ * @example intervalContainsZoned("invalid", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // false
+ */
+export declare function intervalContainsZoned(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/zoned/interval/intervalContainsZoned.js

@@ -0,0 +1,70 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { parseCalendarZonedValue } from "../../internal/index.js";
+import { isValidCalendarZonedDateTime } from "../validate/index.js";
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (same instant semantics).
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - 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 GMT calendar-annotated ones (`"5784-06-15T14:30:00-05:00[u-ca=hebrew][America/New_York]"`),
+ *   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
+ *   hebrew, islamic-civil, japanese and iso8601.
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering, which reads GMT's
+ *   calendar-native digits as ISO digits — see `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param intervalStart ISO 8601 zoned datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 zoned datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 zoned datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 zoned datetime string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // true
+ * @example intervalContainsZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]", "2024-07-15T12:00:00+00:00[UTC]") // true
+ * @example intervalContainsZoned("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // false
+ * @example intervalContainsZoned("invalid", "2024-12-31T23:59:59+00:00[UTC]", "2024-06-15T12:00:00+00:00[UTC]") // false
+ */
+export function intervalContainsZoned(intervalStart, intervalEnd, pointOrStart, pointEnd) {
+    // One gate per endpoint: `isValidCalendarZonedDateTime` already covers non-strings, empty
+    // strings, leap seconds (which Temporal would otherwise silently clamp to :59), unknown zones
+    // and Temporal's forbidden segment ordering — and, unlike `isValidZonedDateTime`, accepts GMT's
+    // calendar-annotated grammar. `pointEnd` is optional, so it is only checked when supplied.
+    if (!isValidCalendarZonedDateTime(intervalStart) ||
+        !isValidCalendarZonedDateTime(intervalEnd) ||
+        !isValidCalendarZonedDateTime(pointOrStart) ||
+        (pointEnd !== undefined && !isValidCalendarZonedDateTime(pointEnd))) {
+        return false;
+    }
+    try {
+        const startZdt = parseCalendarZonedValue(intervalStart);
+        const endZdt = parseCalendarZonedValue(intervalEnd);
+        const pointZdt = parseCalendarZonedValue(pointOrStart);
+        const startInstant = startZdt.toInstant();
+        const endInstant = endZdt.toInstant();
+        const pointInstant = pointZdt.toInstant();
+        if (Temporal.Instant.compare(startInstant, endInstant) > 0) {
+            return false;
+        }
+        if (pointEnd === undefined) {
+            return (Temporal.Instant.compare(startInstant, pointInstant) <= 0 &&
+                Temporal.Instant.compare(pointInstant, endInstant) <= 0);
+        }
+        const endPointZdt = parseCalendarZonedValue(pointEnd);
+        const endPointInstant = endPointZdt.toInstant();
+        if (Temporal.Instant.compare(pointInstant, endPointInstant) > 0) {
+            return false;
+        }
+        return (Temporal.Instant.compare(startInstant, pointInstant) <= 0 &&
+            Temporal.Instant.compare(endPointInstant, endInstant) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Count how many `unit` boundaries a zoned interval crosses.
+ *
+ * - Counts local calendar boundaries touched by the half-open interval `[start, end)` —
+ *   distinct from `diffZoned`, which measures exact elapsed duration.
+ * - The end boundary is excluded: midnight to midnight two days later counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - DST-aware: a local day that springs forward counts 23 hour boundaries and one that falls
+ *   back counts 25. A local day whose midnight is skipped entirely starts at 01:00.
+ * - A fixed 24-hour span touches 25 local hour boundaries in zones offset by :30/:45.
+ * - When `start` and `end` carry different time zones, boundaries are counted in `start`'s zone.
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152). When BOTH endpoints carry the same calendar tag the
+ *   measurement is made in that calendar; when the tags mismatch, or either endpoint is bare ISO,
+ *   it falls back to Gregorian/ISO rather than returning the sentinel (E7's D5-zoned). The
+ *   fallback is mandatory, not a convenience: `ZonedDateTime.prototype.until` throws across
+ *   mismatched calendars for EVERY `largestUnit` — verified, including `"hour"` and
+ *   `"nanosecond"`.
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   leap-second strings).
+ *
+ * @param start ISO 8601 zoned datetime string for the interval start
+ * @param end ISO 8601 zoned datetime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @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-01-01T05:00:00+00:00[UTC]", "2024-01-01T05:00:00+00:00[UTC]", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountZoned("5784-01-01T00:00:00-04:00[u-ca=hebrew][America/New_York]", "5785-01-01T00:00:00-04:00[u-ca=hebrew][America/New_York]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
+ * @example intervalCountZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
+ */
+export declare function intervalCountZoned(start: string, end: string, unit: string): number | null;

package/dist/zoned/interval/intervalCountZoned.js

@@ -0,0 +1,82 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getStartOfZonedUnit, getUnitSpan, parseCalendarZonedPairForArithmetic, resolveDateTimeUnit, } from "../../internal/index.js";
+import { isValidDateTimeUnit } from "../../plain/validate/index.js";
+import { isValidCalendarZonedDateTime } from "../validate/isValidCalendarZonedDateTime.js";
+/**
+ * Count how many `unit` boundaries a zoned interval crosses.
+ *
+ * - Counts local calendar boundaries touched by the half-open interval `[start, end)` —
+ *   distinct from `diffZoned`, which measures exact elapsed duration.
+ * - The end boundary is excluded: midnight to midnight two days later counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - DST-aware: a local day that springs forward counts 23 hour boundaries and one that falls
+ *   back counts 25. A local day whose midnight is skipped entirely starts at 01:00.
+ * - A fixed 24-hour span touches 25 local hour boundaries in zones offset by :30/:45.
+ * - When `start` and `end` carry different time zones, boundaries are counted in `start`'s zone.
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152). When BOTH endpoints carry the same calendar tag the
+ *   measurement is made in that calendar; when the tags mismatch, or either endpoint is bare ISO,
+ *   it falls back to Gregorian/ISO rather than returning the sentinel (E7's D5-zoned). The
+ *   fallback is mandatory, not a convenience: `ZonedDateTime.prototype.until` throws across
+ *   mismatched calendars for EVERY `largestUnit` — verified, including `"hour"` and
+ *   `"nanosecond"`.
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   leap-second strings).
+ *
+ * @param start ISO 8601 zoned datetime string for the interval start
+ * @param end ISO 8601 zoned datetime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @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-01-01T05:00:00+00:00[UTC]", "2024-01-01T05:00:00+00:00[UTC]", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountZoned("2024-01-01T00:00:00+00:00[UTC]", "2024-01-01T00:00:00+00:00[UTC]", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountZoned("5784-01-01T00:00:00-04:00[u-ca=hebrew][America/New_York]", "5785-01-01T00:00:00-04:00[u-ca=hebrew][America/New_York]", "month") // 13 (Hebrew leap year; the ISO equivalent is 14)
+ * @example intervalCountZoned("invalid", "2024-01-02T00:00:00+00:00[UTC]", "day") // null
+ */
+export function intervalCountZoned(start, end, unit) {
+    if (!isValidCalendarZonedDateTime(start) ||
+        !isValidCalendarZonedDateTime(end)) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidDateTimeUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        // The pair is resolved BEFORE either endpoint reaches `getStartOfZonedUnit`. Normalizing only
+        // one side would leave `startOfStart.until(startOfEnd)` throwing on a mismatched pair
+        // (verified), so the D5 policy has to be applied to both operands together, up front.
+        const { a: startVal, b: pairedEnd } = parseCalendarZonedPairForArithmetic(start, end);
+        // Boundaries are counted in the start's zone, so the end is re-expressed there.
+        // Temporal refuses calendar-unit differences across two zones outright. `withTimeZone`
+        // preserves the calendar tag (verified), so this does not undo the pair normalization above.
+        const endVal = pairedEnd.withTimeZone(startVal.timeZoneId);
+        if (Temporal.ZonedDateTime.compare(startVal, endVal) > 0) {
+            return null;
+        }
+        const startOfStart = getStartOfZonedUnit(startVal, resolvedUnit);
+        const startOfEnd = getStartOfZonedUnit(endVal, resolvedUnit);
+        const spanned = getUnitSpan(startOfStart.until(startOfEnd, { largestUnit: resolvedUnit }), resolvedUnit);
+        // `.equals()` here IS calendar-sensitive — it is `ZonedDateTime.prototype.equals`, and
+        // `iso.equals(heb)` is `false` even at the same instant (verified). It is safe only by
+        // construction: `startOfEnd` is derived from `endVal` one line above
+        // (`getStartOfZonedUnit(endVal, resolvedUnit)`), so the two always share `endVal`'s calendar
+        // by definition of how `startOfEnd` is built. A refactor that hoists `endVal` out, or that
+        // sources `startOfEnd` from anywhere but `endVal`, breaks this silently — compare instants
+        // (or re-derive `startOfEnd` from `endVal`) if that ever happens.
+        return spanned + (startOfEnd.equals(endVal) ? 0 : 1);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Return the portion(s) of interval A not covered by interval B.
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (via `.toInstant()`).
+ * - Returns `[]` when B fully covers A.
+ * - Returns `[{ start, end }]` when B overlaps one edge of A (or equals A).
+ * - Returns `[{ start, end }, { start, end }]` when B is fully inside A with gaps on both sides.
+ * - Returns `[]` if either interval is invalid (`start > end`).
+ * - Returns `[]` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152) — but **rejects a mismatched pair**: every endpoint
+ *   must name the same calendar system (E7's D4-zoned). Unlike the ordering functions, this one
+ *   returns a *value* the caller reads back as a datetime, and there is no principled way to pick
+ *   one endpoint's calendar as the answer's. Rejection also keeps a uniform policy across all
+ *   eight value-returning zoned set operations, four of which return arrays — a per-element
+ *   "winner's tag" would produce a result set whose members disagree about which calendar they
+ *   are in. (`intervalUnionZoned`'s existing "winning endpoint's *time zone* wins" is not
+ *   precedent: the zone is a property of the surviving point, the calendar is a property of the
+ *   answer.) A mismatch returns the sentinel.
+ * - Output boundaries are re-derived in the resolved calendar via `formatZonedInCalendar`, never
+ *   copied from an input string (E7's D7-zoned).
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering — see
+ *   `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param aStart ISO 8601 zoned datetime string for the first interval start
+ * @param aEnd ISO 8601 zoned datetime string for the first interval end
+ * @param bStart ISO 8601 zoned datetime string for the second interval start
+ * @param bEnd ISO 8601 zoned datetime string for the second interval end
+ * @returns array of `{ start, end }` records representing A minus B, or `[]` on invalid input
+ *
+ * @example intervalDifferenceZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-06-01T12:00:00+00:00[UTC]", "2024-07-01T13:00:00+00:00[UTC]") // [{ start: "2024-01-01T09:00:00+00:00[UTC]", end: "2024-05-31T17:00:00+00:00[UTC]" }, { start: "2024-07-01T13:00:01+00:00[UTC]", end: "2024-12-31T17:00:00+00:00[UTC]" }]
+ * @example intervalDifferenceZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // []
+ * @example intervalDifferenceZoned("invalid", "2024-12-31T17:00:00+00:00[UTC]", "2024-06-01T12:00:00+00:00[UTC]", "2024-07-01T13:00:00+00:00[UTC]") // []
+ */
+export declare function intervalDifferenceZoned(aStart: string, aEnd: string, bStart: string, bEnd: string): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/zoned/interval/intervalDifferenceZoned.js

@@ -0,0 +1,94 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { calendarOfAllZonedValues, formatZonedInCalendar, parseCalendarZonedValue, } from "../../internal/index.js";
+import { isValidCalendarZonedDateTime } from "../validate/index.js";
+/**
+ * Return the portion(s) of interval A not covered by interval B.
+ *
+ * - Uses `Temporal.Instant.compare` for comparison (via `.toInstant()`).
+ * - Returns `[]` when B fully covers A.
+ * - Returns `[{ start, end }]` when B overlaps one edge of A (or equals A).
+ * - Returns `[{ start, end }, { start, end }]` when B is fully inside A with gaps on both sides.
+ * - Returns `[]` if either interval is invalid (`start > end`).
+ * - Returns `[]` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152) — but **rejects a mismatched pair**: every endpoint
+ *   must name the same calendar system (E7's D4-zoned). Unlike the ordering functions, this one
+ *   returns a *value* the caller reads back as a datetime, and there is no principled way to pick
+ *   one endpoint's calendar as the answer's. Rejection also keeps a uniform policy across all
+ *   eight value-returning zoned set operations, four of which return arrays — a per-element
+ *   "winner's tag" would produce a result set whose members disagree about which calendar they
+ *   are in. (`intervalUnionZoned`'s existing "winning endpoint's *time zone* wins" is not
+ *   precedent: the zone is a property of the surviving point, the calendar is a property of the
+ *   answer.) A mismatch returns the sentinel.
+ * - Output boundaries are re-derived in the resolved calendar via `formatZonedInCalendar`, never
+ *   copied from an input string (E7's D7-zoned).
+ * - Still rejects Temporal's own `[timeZone][u-ca=...]` RFC 9557 ordering — see
+ *   `regex/calendar-zoned-date-time.ts`.
+ *
+ * @param aStart ISO 8601 zoned datetime string for the first interval start
+ * @param aEnd ISO 8601 zoned datetime string for the first interval end
+ * @param bStart ISO 8601 zoned datetime string for the second interval start
+ * @param bEnd ISO 8601 zoned datetime string for the second interval end
+ * @returns array of `{ start, end }` records representing A minus B, or `[]` on invalid input
+ *
+ * @example intervalDifferenceZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-06-01T12:00:00+00:00[UTC]", "2024-07-01T13:00:00+00:00[UTC]") // [{ start: "2024-01-01T09:00:00+00:00[UTC]", end: "2024-05-31T17:00:00+00:00[UTC]" }, { start: "2024-07-01T13:00:01+00:00[UTC]", end: "2024-12-31T17:00:00+00:00[UTC]" }]
+ * @example intervalDifferenceZoned("2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]", "2024-01-01T09:00:00+00:00[UTC]", "2024-12-31T17:00:00+00:00[UTC]") // []
+ * @example intervalDifferenceZoned("invalid", "2024-12-31T17:00:00+00:00[UTC]", "2024-06-01T12:00:00+00:00[UTC]", "2024-07-01T13:00:00+00:00[UTC]") // []
+ */
+export function intervalDifferenceZoned(aStart, aEnd, bStart, bEnd) {
+    // One gate for all four endpoints: `isValidCalendarZonedDateTime` covers non-strings, empty
+    // strings, leap seconds (which Temporal would otherwise silently clamp to :59), unknown zones
+    // and Temporal's forbidden segment ordering, while accepting GMT's calendar-annotated grammar.
+    if (!isValidCalendarZonedDateTime(aStart) ||
+        !isValidCalendarZonedDateTime(aEnd) ||
+        !isValidCalendarZonedDateTime(bStart) ||
+        !isValidCalendarZonedDateTime(bEnd)) {
+        return [];
+    }
+    // D4-zoned reject gate: all four endpoints must agree on a calendar, or there is no calendar to
+    // express the returned value in.
+    const calendar = calendarOfAllZonedValues([aStart, aEnd, bStart, bEnd]);
+    if (!calendar) {
+        return [];
+    }
+    try {
+        const aSZdt = parseCalendarZonedValue(aStart);
+        const aEZdt = parseCalendarZonedValue(aEnd);
+        const bSZdt = parseCalendarZonedValue(bStart);
+        const bEZdt = parseCalendarZonedValue(bEnd);
+        const aS = aSZdt.toInstant();
+        const aE = aEZdt.toInstant();
+        const bS = bSZdt.toInstant();
+        const bE = bEZdt.toInstant();
+        if (Temporal.Instant.compare(aS, aE) > 0) {
+            return [];
+        }
+        if (Temporal.Instant.compare(bS, bE) > 0) {
+            return [];
+        }
+        const result = [];
+        // Left piece: A before B starts
+        if (Temporal.Instant.compare(aS, bS) < 0) {
+            const leftEnd = Temporal.Instant.compare(aE, bS) < 0
+                ? aE
+                : bS.subtract({ nanoseconds: 1 });
+            if (Temporal.Instant.compare(leftEnd, aS) >= 0) {
+                result.push({
+                    start: formatZonedInCalendar(aSZdt, calendar),
+                    end: formatZonedInCalendar(leftEnd.toZonedDateTimeISO(bEZdt.timeZoneId), calendar),
+                });
+            }
+        }
+        // Right piece: A after B ends
+        if (Temporal.Instant.compare(aE, bE) > 0) {
+            result.push({
+                start: formatZonedInCalendar(bE.add({ nanoseconds: 1 }).toZonedDateTimeISO(aEZdt.timeZoneId), calendar),
+                end: formatZonedInCalendar(aEZdt, calendar),
+            });
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Split a zoned interval into `n` equal-length sub-intervals.
+ *
+ * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
+ *   record's `end` equal to the next record's `start`.
+ * - Boundaries are computed from the total elapsed real time (nanoseconds, via
+ *   `Duration.prototype.total` with `relativeTo` set to `start`), so a spring-forward day split
+ *   in half lands exactly on the DST transition's real midpoint rather than the local-clock
+ *   midpoint.
+ * - `n === 1` returns the original interval unchanged, as a single-element array.
+ * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
+ * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
+ *   start/end, `start > end`, leap-second strings).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152) — but **rejects a mismatched pair**: `start` and `end`
+ *   must name the same calendar system (E7's D4-zoned), since the synthesized boundaries are
+ *   values the caller reads back as datetimes and an array of differently-tagged records would be
+ *   unreadable as a set. A mismatch returns `[]`.
+ * - Output boundaries are re-derived in the resolved calendar via `formatZonedInCalendar`, never
+ *   copied from an input string (E7's D7-zoned).
+ *
+ * @param start ISO 8601 zoned datetime string for the interval start
+ * @param end ISO 8601 zoned datetime string for the interval end
+ * @param n number of equal sub-intervals to produce (positive integer)
+ * @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-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) // []
+ */
+export declare function intervalDivideEquallyZoned(start: string, end: string, n: number): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/zoned/interval/intervalDivideEquallyZoned.js

@@ -0,0 +1,80 @@
+import { calendarOfAllZonedValues, formatZonedInCalendar, parseCalendarZonedValue, } from "../../internal/index.js";
+import { isValidCalendarZonedInterval } from "./validate/index.js";
+/**
+ * Split a zoned interval into `n` equal-length sub-intervals.
+ *
+ * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
+ *   record's `end` equal to the next record's `start`.
+ * - Boundaries are computed from the total elapsed real time (nanoseconds, via
+ *   `Duration.prototype.total` with `relativeTo` set to `start`), so a spring-forward day split
+ *   in half lands exactly on the DST transition's real midpoint rather than the local-clock
+ *   midpoint.
+ * - `n === 1` returns the original interval unchanged, as a single-element array.
+ * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
+ * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
+ *   start/end, `start > end`, leap-second strings).
+ * - Accepts GMT calendar-annotated zoned strings (as produced by `convertZonedToCalendar`) as
+ *   well as bare ISO ones — E7 (issue #152) — but **rejects a mismatched pair**: `start` and `end`
+ *   must name the same calendar system (E7's D4-zoned), since the synthesized boundaries are
+ *   values the caller reads back as datetimes and an array of differently-tagged records would be
+ *   unreadable as a set. A mismatch returns `[]`.
+ * - Output boundaries are re-derived in the resolved calendar via `formatZonedInCalendar`, never
+ *   copied from an input string (E7's D7-zoned).
+ *
+ * @param start ISO 8601 zoned datetime string for the interval start
+ * @param end ISO 8601 zoned datetime string for the interval end
+ * @param n number of equal sub-intervals to produce (positive integer)
+ * @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-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) // []
+ */
+export function intervalDivideEquallyZoned(start, end, n) {
+    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+        return [];
+    }
+    if (!isValidCalendarZonedInterval(start, end)) {
+        return [];
+    }
+    // D4-zoned reject gate: both endpoints must agree on a calendar, or there is no calendar to
+    // express the synthesized boundaries in.
+    const calendar = calendarOfAllZonedValues([start, end]);
+    if (!calendar) {
+        return [];
+    }
+    try {
+        const startVal = parseCalendarZonedValue(start);
+        const endVal = parseCalendarZonedValue(end);
+        // 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.
+        if (startVal.toInstant().equals(endVal.toInstant())) {
+            return Array.from({ length: n }, () => ({
+                start: formatZonedInCalendar(startVal, calendar),
+                end: formatZonedInCalendar(endVal, calendar),
+            }));
+        }
+        const totalNs = startVal
+            .until(endVal, { largestUnit: "nanosecond" })
+            .total({ unit: "nanosecond", relativeTo: startVal });
+        const boundaries = [startVal];
+        for (let i = 1; i < n; i++) {
+            boundaries.push(startVal.add({ nanoseconds: Math.round((totalNs * i) / n) }));
+        }
+        boundaries.push(endVal);
+        const result = [];
+        for (let i = 0; i < boundaries.length - 1; i++) {
+            result.push({
+                start: formatZonedInCalendar(boundaries[i], calendar),
+                end: formatZonedInCalendar(boundaries[i + 1], calendar),
+            });
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}