@northguild/gmt 1.15.0 → 1.17.0

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

@@ -1,13 +1,15 @@
 /**
  * Return the symmetric difference of two date intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap (two non-overlapping pieces).
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one day.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
- * - 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*, all four arguments must carry the *same* calendar tag (or all be bare ISO);
  *   a mismatch returns `[]` (E5 decision of record D4). Each output piece's tag is re-derived,
  *   never copied from an input.
@@ -18,11 +20,10 @@
  * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input / mismatched calendars
  *
- * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-03-31" }, { start: "2024-07-01", end: "2024-12-31" }]
- * @example intervalXorDate("2024-01-01", "2024-12-31", "2024-04-01", "2024-06-30") // [{ start: "2024-01-01", end: "2024-03-31" }, { start: "2024-07-01", end: "2024-12-31" }]
+ * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-04-01" }, { start: "2024-06-30", end: "2024-12-31" }]
+ * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // [{ start: "2024-01-01", end: "2024-12-31" }] (touching)
  * @example intervalXorDate("2024-01-01", "2024-12-31", "2024-01-01", "2024-12-31") // []
- * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-06-30" }, { start: "2024-07-01", end: "2024-12-31" }]
- * @example intervalXorDate("invalid", "2024-06-30", "2024-07-01", "2024-12-31") // []
+ * @example intervalXorDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // []
  */
 export declare function intervalXorDate(aStart: string, aEnd: string, bStart: string, bEnd: string): Array<{
     start: string;

package/dist/plain/interval/intervalXorDate.js

@@ -1,16 +1,19 @@
+// 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 { isValidCalendarDate } from "../validate/index.js";
 /**
  * Return the symmetric difference of two date intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap (two non-overlapping pieces).
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one day.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
- * - 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*, all four arguments must carry the *same* calendar tag (or all be bare ISO);
  *   a mismatch returns `[]` (E5 decision of record D4). Each output piece's tag is re-derived,
  *   never copied from an input.
@@ -21,11 +24,10 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input / mismatched calendars
  *
- * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-03-31" }, { start: "2024-07-01", end: "2024-12-31" }]
- * @example intervalXorDate("2024-01-01", "2024-12-31", "2024-04-01", "2024-06-30") // [{ start: "2024-01-01", end: "2024-03-31" }, { start: "2024-07-01", end: "2024-12-31" }]
+ * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-04-01" }, { start: "2024-06-30", end: "2024-12-31" }]
+ * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // [{ start: "2024-01-01", end: "2024-12-31" }] (touching)
  * @example intervalXorDate("2024-01-01", "2024-12-31", "2024-01-01", "2024-12-31") // []
- * @example intervalXorDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // [{ start: "2024-01-01", end: "2024-06-30" }, { start: "2024-07-01", end: "2024-12-31" }]
- * @example intervalXorDate("invalid", "2024-06-30", "2024-07-01", "2024-12-31") // []
+ * @example intervalXorDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // []
  */
 export function intervalXorDate(aStart, aEnd, bStart, bEnd) {
     if (typeof aStart !== "string" ||
@@ -55,50 +57,13 @@ export function intervalXorDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return [];
         }
-        const result = [];
-        // If intervals don't overlap, return both as-is
-        if (Temporal.PlainDate.compare(aE, bS) < 0 ||
-            Temporal.PlainDate.compare(bE, aS) < 0) {
-            return [
-                {
-                    start: formatDateInCalendar(aS, calendar),
-                    end: formatDateInCalendar(aE, calendar),
-                },
-                {
-                    start: formatDateInCalendar(bS, calendar),
-                    end: formatDateInCalendar(bE, calendar),
-                },
-            ];
-        }
-        // Left piece: A before B starts
-        if (Temporal.PlainDate.compare(aS, bS) < 0) {
-            result.push({
-                start: formatDateInCalendar(aS, calendar),
-                end: formatDateInCalendar(bS.subtract({ days: 1 }), calendar),
-            });
-        }
-        // Right piece: A after B ends
-        if (Temporal.PlainDate.compare(aE, bE) > 0) {
-            result.push({
-                start: formatDateInCalendar(bE.add({ days: 1 }), calendar),
-                end: formatDateInCalendar(aE, calendar),
-            });
-        }
-        // Left piece: B before A starts
-        if (Temporal.PlainDate.compare(bS, aS) < 0) {
-            result.push({
-                start: formatDateInCalendar(bS, calendar),
-                end: formatDateInCalendar(aS.subtract({ days: 1 }), calendar),
-            });
-        }
-        // Right piece: B after A ends
-        if (Temporal.PlainDate.compare(bE, aE) > 0) {
-            result.push({
-                start: formatDateInCalendar(aE.add({ days: 1 }), calendar),
-                end: formatDateInCalendar(bE, calendar),
-            });
-        }
-        return result;
+        return halfOpenXor([
+            { start: aS, end: aE },
+            { start: bS, end: bE },
+        ], Temporal.PlainDate.compare).map(({ start, end }) => ({
+            start: formatDateInCalendar(start, calendar),
+            end: formatDateInCalendar(end, calendar),
+        }));
     }
     catch {
         return [];

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

@@ -1,10 +1,12 @@
 /**
  * Return the symmetric difference of two datetime intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
  *
@@ -14,9 +16,9 @@
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-04-01T11:00:00", "2024-12-31T17:00:00") // [{ start: "2024-01-01T09:00:00", end: "2024-03-31T17:00:00" }, { start: "2024-06-30T12:00:01", end: "2024-12-31T17:00:00" }]
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-04-01T11:00:00", "2024-06-30T12:00:00") // [{ start: "2024-01-01T09:00:00", end: "2024-03-31T17:00:00" }, { start: "2024-06-30T12:00:01", end: "2024-12-31T17:00:00" }]
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // []
+ * @example intervalXorDateTime("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-01T12:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T17:00:00" }]
+ * @example intervalXorDateTime("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 intervalXorDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // []
  * @example intervalXorDateTime("invalid", "2024-06-30T12:00:00", "2024-07-01T13:00:00", "2024-12-31T17:00:00") // []
  */
 export declare function intervalXorDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): Array<{

package/dist/plain/interval/intervalXorDateTime.js

@@ -1,12 +1,16 @@
+// 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 { halfOpenXor } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
  * Return the symmetric difference of two datetime intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
  *
@@ -16,9 +20,9 @@ import { plainDateTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-04-01T11:00:00", "2024-12-31T17:00:00") // [{ start: "2024-01-01T09:00:00", end: "2024-03-31T17:00:00" }, { start: "2024-06-30T12:00:01", end: "2024-12-31T17:00:00" }]
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-04-01T11:00:00", "2024-06-30T12:00:00") // [{ start: "2024-01-01T09:00:00", end: "2024-03-31T17:00:00" }, { start: "2024-06-30T12:00:01", end: "2024-12-31T17:00:00" }]
- * @example intervalXorDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // []
+ * @example intervalXorDateTime("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-01T12:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T17:00:00" }]
+ * @example intervalXorDateTime("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 intervalXorDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // []
  * @example intervalXorDateTime("invalid", "2024-06-30T12:00:00", "2024-07-01T13:00:00", "2024-12-31T17:00:00") // []
  */
 export function intervalXorDateTime(aStart, aEnd, bStart, bEnd) {
@@ -28,10 +32,10 @@ export function intervalXorDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return [];
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return [];
     }
     try {
@@ -45,44 +49,13 @@ export function intervalXorDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return [];
         }
-        const result = [];
-        // If intervals don't overlap, return both as-is
-        if (Temporal.PlainDateTime.compare(aE, bS) < 0 ||
-            Temporal.PlainDateTime.compare(bE, aS) < 0) {
-            return [
-                { start: aS.toString(), end: aE.toString() },
-                { start: bS.toString(), end: bE.toString() },
-            ];
-        }
-        // Left piece: A before B starts
-        if (Temporal.PlainDateTime.compare(aS, bS) < 0) {
-            result.push({
-                start: aS.toString(),
-                end: bS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: A after B ends
-        if (Temporal.PlainDateTime.compare(aE, bE) > 0) {
-            result.push({
-                start: bE.add({ nanoseconds: 1 }).toString(),
-                end: aE.toString(),
-            });
-        }
-        // Left piece: B before A starts
-        if (Temporal.PlainDateTime.compare(bS, aS) < 0) {
-            result.push({
-                start: bS.toString(),
-                end: aS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: B after A ends
-        if (Temporal.PlainDateTime.compare(bE, aE) > 0) {
-            result.push({
-                start: aE.add({ nanoseconds: 1 }).toString(),
-                end: bE.toString(),
-            });
-        }
-        return result;
+        return halfOpenXor([
+            { start: aS, end: aE },
+            { start: bS, end: bE },
+        ], Temporal.PlainDateTime.compare).map(({ start, end }) => ({
+            start: start.toString(),
+            end: end.toString(),
+        }));
     }
     catch {
         return [];

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

@@ -1,10 +1,12 @@
 /**
  * Return the symmetric difference of two time intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
  *
@@ -14,10 +16,9 @@
  * @param bEnd ISO 8601 time string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorTime("09:00:00", "12:00:00", "11:00:00", "17:00:00") // [{ start: "09:00:00", end: "10:59:59" }, { start: "12:00:01", end: "17:00:00" }]
- * @example intervalXorTime("09:00:00", "17:00:00", "11:00:00", "12:00:00") // [{ start: "09:00:00", end: "10:59:59" }, { start: "12:00:01", end: "17:00:00" }]
+ * @example intervalXorTime("09:00:00", "12:00:00", "11:00:00", "17:00:00") // [{ start: "09:00:00", end: "11:00:00" }, { start: "12:00:00", end: "17:00:00" }]
+ * @example intervalXorTime("09:00:00", "12:00:00", "12:00:00", "17:00:00") // [{ start: "09:00:00", end: "17:00:00" }] (touching)
  * @example intervalXorTime("09:00:00", "17:00:00", "09:00:00", "17:00:00") // []
- * @example intervalXorTime("09:00:00", "12:00:00", "13:00:00", "17:00:00") // [{ start: "09:00:00", end: "12:00:00" }, { start: "13:00:00", end: "17:00:00" }]
  * @example intervalXorTime("invalid", "12:00:00", "13:00:00", "17:00:00") // []
  */
 export declare function intervalXorTime(aStart: string, aEnd: string, bStart: string, bEnd: string): Array<{

package/dist/plain/interval/intervalXorTime.js

@@ -1,12 +1,16 @@
+// 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 { halfOpenXor } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
  * Return the symmetric difference of two time intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
  *
@@ -16,10 +20,9 @@ import { plainTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 time string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorTime("09:00:00", "12:00:00", "11:00:00", "17:00:00") // [{ start: "09:00:00", end: "10:59:59" }, { start: "12:00:01", end: "17:00:00" }]
- * @example intervalXorTime("09:00:00", "17:00:00", "11:00:00", "12:00:00") // [{ start: "09:00:00", end: "10:59:59" }, { start: "12:00:01", end: "17:00:00" }]
+ * @example intervalXorTime("09:00:00", "12:00:00", "11:00:00", "17:00:00") // [{ start: "09:00:00", end: "11:00:00" }, { start: "12:00:00", end: "17:00:00" }]
+ * @example intervalXorTime("09:00:00", "12:00:00", "12:00:00", "17:00:00") // [{ start: "09:00:00", end: "17:00:00" }] (touching)
  * @example intervalXorTime("09:00:00", "17:00:00", "09:00:00", "17:00:00") // []
- * @example intervalXorTime("09:00:00", "12:00:00", "13:00:00", "17:00:00") // [{ start: "09:00:00", end: "12:00:00" }, { start: "13:00:00", end: "17:00:00" }]
  * @example intervalXorTime("invalid", "12:00:00", "13:00:00", "17:00:00") // []
  */
 export function intervalXorTime(aStart, aEnd, bStart, bEnd) {
@@ -29,10 +32,10 @@ export function intervalXorTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return [];
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return [];
     }
     try {
@@ -46,44 +49,13 @@ export function intervalXorTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return [];
         }
-        const result = [];
-        // If intervals don't overlap, return both as-is
-        if (Temporal.PlainTime.compare(aE, bS) < 0 ||
-            Temporal.PlainTime.compare(bE, aS) < 0) {
-            return [
-                { start: aS.toString(), end: aE.toString() },
-                { start: bS.toString(), end: bE.toString() },
-            ];
-        }
-        // Left piece: A before B starts
-        if (Temporal.PlainTime.compare(aS, bS) < 0) {
-            result.push({
-                start: aS.toString(),
-                end: bS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: A after B ends
-        if (Temporal.PlainTime.compare(aE, bE) > 0) {
-            result.push({
-                start: bE.add({ nanoseconds: 1 }).toString(),
-                end: aE.toString(),
-            });
-        }
-        // Left piece: B before A starts
-        if (Temporal.PlainTime.compare(bS, aS) < 0) {
-            result.push({
-                start: bS.toString(),
-                end: aS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: B after A ends
-        if (Temporal.PlainTime.compare(bE, aE) > 0) {
-            result.push({
-                start: aE.add({ nanoseconds: 1 }).toString(),
-                end: bE.toString(),
-            });
-        }
-        return result;
+        return halfOpenXor([
+            { start: aS, end: aE },
+            { start: bS, end: bE },
+        ], Temporal.PlainTime.compare).map(({ start, end }) => ({
+            start: start.toString(),
+            end: end.toString(),
+        }));
     }
     catch {
         return [];

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

@@ -1,23 +1,30 @@
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open date intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one day.
  *
+ * - Half-open: an interval holds every date `d` with `start <= d < end`, so `end` itself is not
+ *   in it (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no day and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
  *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param aStart ISO 8601 date string for the first interval start, optionally calendar-annotated
- * @param aEnd ISO 8601 date string for the first interval end, optionally calendar-annotated
+ * @param aEnd ISO 8601 date string for the first interval end (excluded), optionally calendar-annotated
  * @param bStart ISO 8601 date string for the second interval start, optionally calendar-annotated
- * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
+ * @param bEnd ISO 8601 date string for the second interval end (excluded), optionally calendar-annotated
  * @returns true if intervals overlap, or false on invalid input
  *
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // true
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // false (adjacent)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // false (touching: A ends before 06-30)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-29", "2024-07-01") // true (both hold 06-29)
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-02", "2024-12-31") // false (disjoint)
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-02-01", "2024-03-01") // true (partial)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-06-30") // false (empty interval at the end)
  * @example intervalsOverlapDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // false
  */
 export declare function intervalsOverlapDate(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalsOverlapDate.js

@@ -1,26 +1,34 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { parseCalendarDateValue } from "../../internal/index.js";
+import { halfOpenOverlap, parseCalendarDateValue } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open date intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one day.
  *
+ * - Half-open: an interval holds every date `d` with `start <= d < end`, so `end` itself is not
+ *   in it (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no day and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
  *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param aStart ISO 8601 date string for the first interval start, optionally calendar-annotated
- * @param aEnd ISO 8601 date string for the first interval end, optionally calendar-annotated
+ * @param aEnd ISO 8601 date string for the first interval end (excluded), optionally calendar-annotated
  * @param bStart ISO 8601 date string for the second interval start, optionally calendar-annotated
- * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
+ * @param bEnd ISO 8601 date string for the second interval end (excluded), optionally calendar-annotated
  * @returns true if intervals overlap, or false on invalid input
  *
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // true
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // false (adjacent)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // false (touching: A ends before 06-30)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-29", "2024-07-01") // true (both hold 06-29)
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-02", "2024-12-31") // false (disjoint)
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-02-01", "2024-03-01") // true (partial)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-06-30") // false (empty interval at the end)
  * @example intervalsOverlapDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // false
  */
 export function intervalsOverlapDate(aStart, aEnd, bStart, bEnd) {
@@ -47,8 +55,7 @@ export function intervalsOverlapDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDate.compare(aE, bS) >= 0 &&
-            Temporal.PlainDate.compare(bE, aS) >= 0);
+        return halfOpenOverlap({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

@@ -1,20 +1,25 @@
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open datetime intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one moment.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so `end` itself is not in it
+ *   (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no moment and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param aStart ISO 8601 datetime string for the first interval start
- * @param aEnd ISO 8601 datetime string for the first interval end
+ * @param aEnd ISO 8601 datetime string for the first interval end (excluded)
  * @param bStart ISO 8601 datetime string for the second interval start
- * @param bEnd ISO 8601 datetime string for the second interval end
+ * @param bEnd ISO 8601 datetime string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // true
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // false (adjacent)
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-02T00:00:00", "2024-12-31T23:59:59") // false (disjoint)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // false (touching)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // true (empty interval strictly inside)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // false (empty interval at the end)
  * @example intervalsOverlapDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // false
  */
 export declare function intervalsOverlapDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalsOverlapDateTime.js

@@ -1,22 +1,29 @@
+// 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 { halfOpenOverlap } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open datetime intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one moment.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so `end` itself is not in it
+ *   (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no moment and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param aStart ISO 8601 datetime string for the first interval start
- * @param aEnd ISO 8601 datetime string for the first interval end
+ * @param aEnd ISO 8601 datetime string for the first interval end (excluded)
  * @param bStart ISO 8601 datetime string for the second interval start
- * @param bEnd ISO 8601 datetime string for the second interval end
+ * @param bEnd ISO 8601 datetime string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // true
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // false (adjacent)
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-02T00:00:00", "2024-12-31T23:59:59") // false (disjoint)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // false (touching)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // true (empty interval strictly inside)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // false (empty interval at the end)
  * @example intervalsOverlapDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // false
  */
 export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
@@ -26,10 +33,10 @@ export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return false;
     }
     try {
@@ -43,8 +50,7 @@ export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDateTime.compare(aE, bS) >= 0 &&
-            Temporal.PlainDateTime.compare(bE, aS) >= 0);
+        return halfOpenOverlap({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;