@northguild/gmt 1.14.2 → 1.16.0

package/dist/plain/interval/intervalUnionDate.d.ts

@@ -2,11 +2,18 @@
  * Return the combined span of two date intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
  *   date *value*, all four arguments must carry the *same* calendar tag (or all be bare ISO);
  *   a mismatch returns `null` rather than guessing an output calendar (E5 decision of record
  *   D4). The output's tag is re-derived from the merged span, never copied from an input.
@@ -18,10 +25,11 @@
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals / mismatched calendars
  *
  * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" }
- * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" }
- * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // null
+ * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" } (touching)
+ * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // null (06-30 is in neither)
+ * @example intervalUnionDate("2024-01-05", "2024-01-05", "2024-06-15", "2024-06-30") // { start: "2024-06-15", end: "2024-06-30" } (empty interval adds nothing)
  * @example intervalUnionDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // null
- * @example intervalUnionDate("5785-01-01[u-ca=hebrew]", "2024-06-30", "2024-04-01", "2024-12-31") // null (mismatched calendars)
+ * @example intervalUnionDate("2024-01-01[u-ca=hebrew]", "2024-06-30", "2024-04-01", "2024-12-31") // null (mismatched calendars)
  */
 export declare function intervalUnionDate(aStart: string, aEnd: string, bStart: string, bEnd: string): {
     start: string;

package/dist/plain/interval/intervalUnionDate.js

@@ -1,15 +1,23 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
+import { calendarOfAllDateValues, formatDateInCalendar, halfOpenUnion, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
  * Return the combined span of two date intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
  *   date *value*, all four arguments must carry the *same* calendar tag (or all be bare ISO);
  *   a mismatch returns `null` rather than guessing an output calendar (E5 decision of record
  *   D4). The output's tag is re-derived from the merged span, never copied from an input.
@@ -21,10 +29,11 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals / mismatched calendars
  *
  * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" }
- * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" }
- * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // null
+ * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // { start: "2024-01-01", end: "2024-12-31" } (touching)
+ * @example intervalUnionDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // null (06-30 is in neither)
+ * @example intervalUnionDate("2024-01-05", "2024-01-05", "2024-06-15", "2024-06-30") // { start: "2024-06-15", end: "2024-06-30" } (empty interval adds nothing)
  * @example intervalUnionDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // null
- * @example intervalUnionDate("5785-01-01[u-ca=hebrew]", "2024-06-30", "2024-04-01", "2024-12-31") // null (mismatched calendars)
+ * @example intervalUnionDate("2024-01-01[u-ca=hebrew]", "2024-06-30", "2024-04-01", "2024-12-31") // null (mismatched calendars)
  */
 export function intervalUnionDate(aStart, aEnd, bStart, bEnd) {
     if (typeof aStart !== "string" ||
@@ -54,12 +63,11 @@ export function intervalUnionDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainDate.compare(aE, bS) < 0 ||
-            Temporal.PlainDate.compare(bE, aS) < 0) {
+        const union = halfOpenUnion({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
+        if (union === null) {
             return null;
         }
-        const start = Temporal.PlainDate.compare(aS, bS) <= 0 ? aS : bS;
-        const end = Temporal.PlainDate.compare(aE, bE) >= 0 ? aE : bE;
+        const { start, end } = union;
         return {
             start: formatDateInCalendar(start, calendar),
             end: formatDateInCalendar(end, calendar),

package/dist/plain/interval/intervalUnionDateTime.d.ts

@@ -2,8 +2,15 @@
  * Return the combined span of two datetime intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
  *
@@ -13,9 +20,9 @@
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
  *
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // { start: "2024-01-01T10:00:00", end: "2024-12-31T23:59:59" }
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-06-30T23:59:59", "2024-12-31T23:59:59") // { start: "2024-01-01T10:00:00", end: "2024-12-31T23:59:59" }
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // null
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T09:00:00", end: "2024-01-01T17:00:00" }
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T09:00:00", end: "2024-01-01T17:00:00" } (touching)
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00.000000001", "2024-01-01T17:00:00") // null (1 ns gap)
  * @example intervalUnionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export declare function intervalUnionDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {

package/dist/plain/interval/intervalUnionDateTime.js

@@ -1,11 +1,20 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
+import { halfOpenUnion } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
  * Return the combined span of two datetime intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
  *
@@ -15,9 +24,9 @@ import { plainDateTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
  *
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // { start: "2024-01-01T10:00:00", end: "2024-12-31T23:59:59" }
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-06-30T23:59:59", "2024-12-31T23:59:59") // { start: "2024-01-01T10:00:00", end: "2024-12-31T23:59:59" }
- * @example intervalUnionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // null
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T09:00:00", end: "2024-01-01T17:00:00" }
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T09:00:00", end: "2024-01-01T17:00:00" } (touching)
+ * @example intervalUnionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00.000000001", "2024-01-01T17:00:00") // null (1 ns gap)
  * @example intervalUnionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export function intervalUnionDateTime(aStart, aEnd, bStart, bEnd) {
@@ -27,10 +36,10 @@ export function intervalUnionDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return null;
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return null;
     }
     try {
@@ -44,12 +53,11 @@ export function intervalUnionDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainDateTime.compare(aE, bS) < 0 ||
-            Temporal.PlainDateTime.compare(bE, aS) < 0) {
+        const union = halfOpenUnion({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
+        if (union === null) {
             return null;
         }
-        const start = Temporal.PlainDateTime.compare(aS, bS) <= 0 ? aS : bS;
-        const end = Temporal.PlainDateTime.compare(aE, bE) >= 0 ? aE : bE;
+        const { start, end } = union;
         return { start: start.toString(), end: end.toString() };
     }
     catch {

package/dist/plain/interval/intervalUnionTime.d.ts

@@ -2,8 +2,15 @@
  * Return the combined span of two time intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
  *
@@ -14,7 +21,7 @@
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
  *
  * @example intervalUnionTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" }
- * @example intervalUnionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" }
+ * @example intervalUnionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" } (touching)
  * @example intervalUnionTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // null
  * @example intervalUnionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */

package/dist/plain/interval/intervalUnionTime.js

@@ -1,11 +1,20 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainTime } from "../../regex/index.js";
+import { halfOpenUnion } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
  * Return the combined span of two time intervals, or null when they are disjoint.
  *
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Overlapping intervals return their merged span.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The union is returned only
+ *   when it is one non-empty interval — the single run CORE-6's `mergeIntervals` would give.
+ * - Overlapping intervals, and touching intervals (`aEnd === bStart`), return their combined span.
+ * - Two **non-empty** intervals with any gap between them return `null`, even a one-unit gap.
+ *   The caveat matters: an empty interval is the empty set, so it is never “separated” from
+ *   anything. A non-empty interval unioned with an empty one far away is still that non-empty
+ *   interval — see the next bullet — not `null`.
+ * - An empty interval (`start === end`) is the empty set: it adds nothing, so the union is the
+ *   other interval. Two empty intervals have no non-empty union and return `null`.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
  *
@@ -16,7 +25,7 @@ import { plainTime } from "../../regex/index.js";
  * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
  *
  * @example intervalUnionTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" }
- * @example intervalUnionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" }
+ * @example intervalUnionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "09:00:00", end: "18:00:00" } (touching)
  * @example intervalUnionTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // null
  * @example intervalUnionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */
@@ -27,10 +36,10 @@ export function intervalUnionTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return null;
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return null;
     }
     try {
@@ -44,12 +53,11 @@ export function intervalUnionTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainTime.compare(aE, bS) < 0 ||
-            Temporal.PlainTime.compare(bE, aS) < 0) {
+        const union = halfOpenUnion({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
+        if (union === null) {
             return null;
         }
-        const start = Temporal.PlainTime.compare(aS, bS) <= 0 ? aS : bS;
-        const end = Temporal.PlainTime.compare(aE, bE) >= 0 ? aE : bE;
+        const { start, end } = union;
         return { start: start.toString(), end: end.toString() };
     }
     catch {

package/dist/plain/interval/intervalXorAllDate.d.ts

@@ -3,28 +3,29 @@
  * by an odd number of the input intervals.
  *
  * - List-form generalization of `intervalXorDate`, which is pairwise only.
- * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
- *   the day after its end; the result is every maximal run where the running coverage count is
- *   odd. For two intervals this reduces to exactly `intervalXorDate`'s pairwise result.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered an odd number of times, computed as a coverage-parity sweep over the start and
+ *   end boundaries. Runs end exactly at a boundary; no boundary is ever stepped by one unit, so
+ *   an interval may end on the type's last value without overflow or midnight wrap.
+ * - Touching odd runs join into one run; an empty interval (`start === end`) contributes nothing.
+ *   For two intervals this is exactly `intervalXorDate`'s pairwise result.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list, and `[]` when every date is covered an even number of times
  *   (e.g. two identical intervals cancel out).
  * - Returns `[]` when `intervals` is not an array, when any element is not a
  *   `{ start, end }` record of valid ISO PlainDate strings, or when any element has
  *   `start > end`.
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
  *   date *values*, every `start`/`end` across the whole list must carry the *same* calendar tag
- *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4). This also makes
- *   `.equals()`'s dedup of coincident sweep events safe — same-calendar `PlainDate`s compare
- *   equal correctly, unlike cross-calendar ones.
+ *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4). Coincident sweep events are
+ *   grouped with `Temporal.PlainDate.compare`, which orders by ISO date and ignores the calendar.
  *
  * @param intervals array of `{ start, end }` records, optionally calendar-annotated
  * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input / mismatched calendars
  *
- * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }, { start: "2024-01-08", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-04" }, { start: "2024-01-08", end: "2024-01-10" }, { start: "2024-01-16", end: "2024-01-20" }]
- * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-01", end: "2024-01-05" }]) // [] (identical intervals cancel out)
+ * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]
+ * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-10" }]) // [{ start: "2024-01-01", end: "2024-01-10" }] (touching)
  * @example intervalXorAllDate([]) // []
- * @example intervalXorAllDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
  */
 export declare function intervalXorAllDate(intervals: Array<{
     start: string;

package/dist/plain/interval/intervalXorAllDate.js

@@ -1,89 +1,67 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
+import { calendarOfAllDateValues, formatDateInCalendar, halfOpenXor, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidDateInterval } from "./validate/index.js";
 /**
  * Return the symmetric difference across a list of date intervals — the set of dates covered
  * by an odd number of the input intervals.
  *
  * - List-form generalization of `intervalXorDate`, which is pairwise only.
- * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
- *   the day after its end; the result is every maximal run where the running coverage count is
- *   odd. For two intervals this reduces to exactly `intervalXorDate`'s pairwise result.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered an odd number of times, computed as a coverage-parity sweep over the start and
+ *   end boundaries. Runs end exactly at a boundary; no boundary is ever stepped by one unit, so
+ *   an interval may end on the type's last value without overflow or midnight wrap.
+ * - Touching odd runs join into one run; an empty interval (`start === end`) contributes nothing.
+ *   For two intervals this is exactly `intervalXorDate`'s pairwise result.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list, and `[]` when every date is covered an even number of times
  *   (e.g. two identical intervals cancel out).
  * - Returns `[]` when `intervals` is not an array, when any element is not a
  *   `{ start, end }` record of valid ISO PlainDate strings, or when any element has
  *   `start > end`.
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
  *   date *values*, every `start`/`end` across the whole list must carry the *same* calendar tag
- *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4). This also makes
- *   `.equals()`'s dedup of coincident sweep events safe — same-calendar `PlainDate`s compare
- *   equal correctly, unlike cross-calendar ones.
+ *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4). Coincident sweep events are
+ *   grouped with `Temporal.PlainDate.compare`, which orders by ISO date and ignores the calendar.
  *
  * @param intervals array of `{ start, end }` records, optionally calendar-annotated
  * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input / mismatched calendars
  *
- * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }, { start: "2024-01-08", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-04" }, { start: "2024-01-08", end: "2024-01-10" }, { start: "2024-01-16", end: "2024-01-20" }]
- * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-01", end: "2024-01-05" }]) // [] (identical intervals cancel out)
+ * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]
+ * @example intervalXorAllDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-10" }]) // [{ start: "2024-01-01", end: "2024-01-10" }] (touching)
  * @example intervalXorAllDate([]) // []
- * @example intervalXorAllDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
  */
 export function intervalXorAllDate(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        isValidDateInterval(interval.start, interval.end))) {
-        return [];
-    }
-    const calendar = calendarOfAllDateValues(intervals.flatMap((interval) => [interval.start, interval.end]));
-    if (!calendar) {
-        return [];
-    }
     try {
-        const events = [];
-        for (const interval of intervals) {
-            const start = parseCalendarDateValue(interval.start);
-            // The closing event fires the day after `end`, so `end` itself stays covered.
-            const closesAfter = parseCalendarDateValue(interval.end).add({
-                days: 1,
-            });
-            events.push({ point: start, delta: 1 });
-            events.push({ point: closesAfter, delta: -1 });
+        if (!Array.isArray(intervals) || intervals.length === 0) {
+            return [];
+        }
+        if (!intervals.every((interval) => interval &&
+            typeof interval === "object" &&
+            isValidDateInterval(interval.start, interval.end))) {
+            return [];
+        }
+        const calendar = calendarOfAllDateValues(intervals.flatMap((interval) => [interval.start, interval.end]));
+        if (!calendar) {
+            return [];
         }
-        events.sort((a, b) => Temporal.PlainDate.compare(a.point, b.point));
-        const grouped = [];
-        for (const event of events) {
-            const last = grouped[grouped.length - 1];
-            if (last && last.point.equals(event.point)) {
-                last.delta += event.delta;
-            }
-            else {
-                grouped.push({ point: event.point, delta: event.delta });
-            }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: parseCalendarDateValue(interval.start),
+                end: parseCalendarDateValue(interval.end),
+            }));
+            return halfOpenXor(parsed, Temporal.PlainDate.compare).map(({ start, end }) => ({
+                start: formatDateInCalendar(start, calendar),
+                end: formatDateInCalendar(end, calendar),
+            }));
         }
-        const result = [];
-        let coverage = 0;
-        let runStart = null;
-        for (const group of grouped) {
-            const previousCoverage = coverage;
-            coverage += group.delta;
-            if (previousCoverage % 2 === 0 && coverage % 2 === 1) {
-                runStart = group.point;
-            }
-            else if (previousCoverage % 2 === 1 && coverage % 2 === 0 && runStart) {
-                result.push({
-                    start: formatDateInCalendar(runStart, calendar),
-                    end: formatDateInCalendar(group.point.subtract({ days: 1 }), calendar),
-                });
-                runStart = null;
-            }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/plain/interval/intervalXorAllDateTime.d.ts

@@ -3,10 +3,12 @@
  * covered by an odd number of the input intervals.
  *
  * - List-form generalization of `intervalXorDateTime`, which is pairwise only.
- * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
- *   one nanosecond after its end; the result is every maximal run where the running coverage
- *   count is odd. For two intervals this reduces to exactly `intervalXorDateTime`'s pairwise
- *   result.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered an odd number of times, computed as a coverage-parity sweep over the start and
+ *   end boundaries. Runs end exactly at a boundary; no boundary is ever stepped by one unit, so
+ *   an interval may end on the type's last value without overflow or midnight wrap.
+ * - Touching odd runs join into one run; an empty interval (`start === end`) contributes nothing.
+ *   For two intervals this is exactly `intervalXorDateTime`'s pairwise result.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list, and `[]` when every instant is covered an even number of
  *   times (e.g. two identical intervals cancel out).
@@ -17,7 +19,7 @@
  * @param intervals array of `{ start, end }` records
  * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input
  *
- * @example intervalXorAllDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-04T23:59:59.999999999" }, { start: "2024-01-10T00:00:00.000000001", end: "2024-01-15T00:00:00" }]
+ * @example intervalXorAllDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-05T00:00:00" }, { start: "2024-01-10T00:00:00", end: "2024-01-15T00:00:00" }]
  * @example intervalXorAllDateTime([]) // []
  */
 export declare function intervalXorAllDateTime(intervals: Array<{

package/dist/plain/interval/intervalXorAllDateTime.js

@@ -1,14 +1,17 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { halfOpenXor } from "../../internal/index.js";
 import { isValidDateTimeInterval } from "./validate/index.js";
 /**
  * Return the symmetric difference across a list of datetime intervals — the set of instants
  * covered by an odd number of the input intervals.
  *
  * - List-form generalization of `intervalXorDateTime`, which is pairwise only.
- * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
- *   one nanosecond after its end; the result is every maximal run where the running coverage
- *   count is odd. For two intervals this reduces to exactly `intervalXorDateTime`'s pairwise
- *   result.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered an odd number of times, computed as a coverage-parity sweep over the start and
+ *   end boundaries. Runs end exactly at a boundary; no boundary is ever stepped by one unit, so
+ *   an interval may end on the type's last value without overflow or midnight wrap.
+ * - Touching odd runs join into one run; an empty interval (`start === end`) contributes nothing.
+ *   For two intervals this is exactly `intervalXorDateTime`'s pairwise result.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list, and `[]` when every instant is covered an even number of
  *   times (e.g. two identical intervals cancel out).
@@ -19,59 +22,36 @@ import { isValidDateTimeInterval } from "./validate/index.js";
  * @param intervals array of `{ start, end }` records
  * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input
  *
- * @example intervalXorAllDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-04T23:59:59.999999999" }, { start: "2024-01-10T00:00:00.000000001", end: "2024-01-15T00:00:00" }]
+ * @example intervalXorAllDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-05T00:00:00" }, { start: "2024-01-10T00:00:00", end: "2024-01-15T00:00:00" }]
  * @example intervalXorAllDateTime([]) // []
  */
 export function intervalXorAllDateTime(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        isValidDateTimeInterval(interval.start, interval.end))) {
-        return [];
-    }
     try {
-        const events = [];
-        for (const interval of intervals) {
-            const start = Temporal.PlainDateTime.from(interval.start);
-            const closesAfter = Temporal.PlainDateTime.from(interval.end).add({
-                nanoseconds: 1,
-            });
-            events.push({ point: start, delta: 1 });
-            events.push({ point: closesAfter, delta: -1 });
+        if (!Array.isArray(intervals) || intervals.length === 0) {
+            return [];
+        }
+        if (!intervals.every((interval) => interval &&
+            typeof interval === "object" &&
+            isValidDateTimeInterval(interval.start, interval.end))) {
+            return [];
         }
-        events.sort((a, b) => Temporal.PlainDateTime.compare(a.point, b.point));
-        const grouped = [];
-        for (const event of events) {
-            const last = grouped[grouped.length - 1];
-            if (last && last.point.equals(event.point)) {
-                last.delta += event.delta;
-            }
-            else {
-                grouped.push({ point: event.point, delta: event.delta });
-            }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: Temporal.PlainDateTime.from(interval.start),
+                end: Temporal.PlainDateTime.from(interval.end),
+            }));
+            return halfOpenXor(parsed, Temporal.PlainDateTime.compare).map(({ start, end }) => ({
+                start: start.toString(),
+                end: end.toString(),
+            }));
         }
-        const result = [];
-        let coverage = 0;
-        let runStart = null;
-        for (const group of grouped) {
-            const previousCoverage = coverage;
-            coverage += group.delta;
-            if (previousCoverage % 2 === 0 && coverage % 2 === 1) {
-                runStart = group.point;
-            }
-            else if (previousCoverage % 2 === 1 && coverage % 2 === 0 && runStart) {
-                result.push({
-                    start: runStart.toString(),
-                    end: group.point.subtract({ nanoseconds: 1 }).toString(),
-                });
-                runStart = null;
-            }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }