@northguild/gmt 1.14.2

package/dist/plain/interval/intervalXorTime.js

@@ -0,0 +1,91 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/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.
+ * - Returns `[]` if either interval is invalid (`start > end`).
+ * - Returns `[]` on invalid input (wrong type, malformed strings).
+ *
+ * @param aStart ISO 8601 time string for the first interval start
+ * @param aEnd ISO 8601 time string for the first interval end
+ * @param bStart ISO 8601 time string for the second interval start
+ * @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", "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) {
+    if (typeof aStart !== "string" ||
+        typeof aEnd !== "string" ||
+        typeof bStart !== "string" ||
+        typeof bEnd !== "string") {
+        return [];
+    }
+    if (!plainTime.test(aStart) ||
+        !plainTime.test(aEnd) ||
+        !plainTime.test(bStart) ||
+        !plainTime.test(bEnd)) {
+        return [];
+    }
+    try {
+        const aS = Temporal.PlainTime.from(aStart);
+        const aE = Temporal.PlainTime.from(aEnd);
+        const bS = Temporal.PlainTime.from(bStart);
+        const bE = Temporal.PlainTime.from(bEnd);
+        if (Temporal.PlainTime.compare(aS, aE) > 0) {
+            return [];
+        }
+        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;
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - 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
+ *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ *
+ * @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 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
+ * @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-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("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

@@ -0,0 +1,56 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { 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.
+ *
+ * - 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
+ *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ *
+ * @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 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
+ * @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-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("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // false
+ */
+export function intervalsOverlapDate(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "string" ||
+        typeof aEnd !== "string" ||
+        typeof bStart !== "string" ||
+        typeof bEnd !== "string") {
+        return false;
+    }
+    if (!isValidCalendarDate(aStart) ||
+        !isValidCalendarDate(aEnd) ||
+        !isValidCalendarDate(bStart) ||
+        !isValidCalendarDate(bEnd)) {
+        return false;
+    }
+    try {
+        const aS = parseCalendarDateValue(aStart);
+        const aE = parseCalendarDateValue(aEnd);
+        const bS = parseCalendarDateValue(bStart);
+        const bE = parseCalendarDateValue(bEnd);
+        if (Temporal.PlainDate.compare(aS, aE) > 0) {
+            return false;
+        }
+        if (Temporal.PlainDate.compare(bS, bE) > 0) {
+            return false;
+        }
+        return (Temporal.PlainDate.compare(aE, bS) >= 0 &&
+            Temporal.PlainDate.compare(bE, aS) >= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - 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 bStart ISO 8601 datetime string for the second interval start
+ * @param bEnd ISO 8601 datetime string for the second interval end
+ * @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("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

@@ -0,0 +1,52 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../regex/index.js";
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - 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 bStart ISO 8601 datetime string for the second interval start
+ * @param bEnd ISO 8601 datetime string for the second interval end
+ * @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("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // false
+ */
+export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "string" ||
+        typeof aEnd !== "string" ||
+        typeof bStart !== "string" ||
+        typeof bEnd !== "string") {
+        return false;
+    }
+    if (!plainDateTime.test(aStart) ||
+        !plainDateTime.test(aEnd) ||
+        !plainDateTime.test(bStart) ||
+        !plainDateTime.test(bEnd)) {
+        return false;
+    }
+    try {
+        const aS = Temporal.PlainDateTime.from(aStart);
+        const aE = Temporal.PlainDateTime.from(aEnd);
+        const bS = Temporal.PlainDateTime.from(bStart);
+        const bE = Temporal.PlainDateTime.from(bEnd);
+        if (Temporal.PlainDateTime.compare(aS, aE) > 0) {
+            return false;
+        }
+        if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
+            return false;
+        }
+        return (Temporal.PlainDateTime.compare(aE, bS) >= 0 &&
+            Temporal.PlainDateTime.compare(bE, aS) >= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - Uses `Temporal.PlainTime.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 time string for the first interval start
+ * @param aEnd ISO 8601 time string for the first interval end
+ * @param bStart ISO 8601 time string for the second interval start
+ * @param bEnd ISO 8601 time string for the second interval end
+ * @returns true if intervals overlap, or false on invalid input
+ *
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // true
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (adjacent)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // false (disjoint)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // true (contained)
+ * @example intervalsOverlapTime("invalid", "17:00:00", "12:00:00", "18:00:00") // false
+ */
+export declare function intervalsOverlapTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalsOverlapTime.js

@@ -0,0 +1,53 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - Uses `Temporal.PlainTime.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 time string for the first interval start
+ * @param aEnd ISO 8601 time string for the first interval end
+ * @param bStart ISO 8601 time string for the second interval start
+ * @param bEnd ISO 8601 time string for the second interval end
+ * @returns true if intervals overlap, or false on invalid input
+ *
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // true
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (adjacent)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // false (disjoint)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // true (contained)
+ * @example intervalsOverlapTime("invalid", "17:00:00", "12:00:00", "18:00:00") // false
+ */
+export function intervalsOverlapTime(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "string" ||
+        typeof aEnd !== "string" ||
+        typeof bStart !== "string" ||
+        typeof bEnd !== "string") {
+        return false;
+    }
+    if (!plainTime.test(aStart) ||
+        !plainTime.test(aEnd) ||
+        !plainTime.test(bStart) ||
+        !plainTime.test(bEnd)) {
+        return false;
+    }
+    try {
+        const aS = Temporal.PlainTime.from(aStart);
+        const aE = Temporal.PlainTime.from(aEnd);
+        const bS = Temporal.PlainTime.from(bStart);
+        const bE = Temporal.PlainTime.from(bEnd);
+        if (Temporal.PlainTime.compare(aS, aE) > 0) {
+            return false;
+        }
+        if (Temporal.PlainTime.compare(bS, bE) > 0) {
+            return false;
+        }
+        return (Temporal.PlainTime.compare(aE, bS) >= 0 &&
+            Temporal.PlainTime.compare(bE, aS) >= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Collapse a list of date intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionDate`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals,
+ *   e.g. `aEnd === bStart`, ARE merged — same rule as `intervalUnionDate`).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - 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
+ *   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).
+ *
+ * @param intervals array of `{ start, end }` records, optionally calendar-annotated
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input / mismatched calendars
+ *
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-15" }]
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (adjacent, merged)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }] (disjoint)
+ * @example mergeIntervalsDate([]) // []
+ * @example mergeIntervalsDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
+ */
+export declare function mergeIntervalsDate(intervals: Array<{
+    start: string;
+    end: string;
+}>): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/plain/interval/mergeIntervalsDate.js

@@ -0,0 +1,67 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
+import { isValidDateInterval } from "./validate/index.js";
+/**
+ * Collapse a list of date intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionDate`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals,
+ *   e.g. `aEnd === bStart`, ARE merged — same rule as `intervalUnionDate`).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - 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
+ *   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).
+ *
+ * @param intervals array of `{ start, end }` records, optionally calendar-annotated
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input / mismatched calendars
+ *
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-15" }]
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (adjacent, merged)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }] (disjoint)
+ * @example mergeIntervalsDate([]) // []
+ * @example mergeIntervalsDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
+ */
+export function mergeIntervalsDate(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 parsed = intervals.map((interval) => ({
+            start: parseCalendarDateValue(interval.start),
+            end: parseCalendarDateValue(interval.end),
+        }));
+        parsed.sort((a, b) => Temporal.PlainDate.compare(a.start, b.start));
+        const merged = [];
+        for (const interval of parsed) {
+            const last = merged[merged.length - 1];
+            if (last && Temporal.PlainDate.compare(interval.start, last.end) <= 0) {
+                if (Temporal.PlainDate.compare(interval.end, last.end) > 0) {
+                    last.end = interval.end;
+                }
+            }
+            else {
+                merged.push({ start: interval.start, end: interval.end });
+            }
+        }
+        return merged.map((interval) => ({
+            start: formatDateInCalendar(interval.start, calendar),
+            end: formatDateInCalendar(interval.end, calendar),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Collapse a list of datetime intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionDateTime`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals
+ *   ARE merged).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - Returns `[]` when `intervals` is not an array, when any element is not a
+ *   `{ start, end }` record of valid ISO PlainDateTime strings, or when any element has
+ *   `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
+ *
+ * @example mergeIntervalsDateTime([{ 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-15T00:00:00" }]
+ * @example mergeIntervalsDateTime([]) // []
+ * @example mergeIntervalsDateTime([{ start: "2024-01-10T00:00:00", end: "2024-01-01T00:00:00" }]) // []
+ */
+export declare function mergeIntervalsDateTime(intervals: Array<{
+    start: string;
+    end: string;
+}>): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/plain/interval/mergeIntervalsDateTime.js

@@ -0,0 +1,58 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTimeInterval } from "./validate/index.js";
+/**
+ * Collapse a list of datetime intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionDateTime`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals
+ *   ARE merged).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - Returns `[]` when `intervals` is not an array, when any element is not a
+ *   `{ start, end }` record of valid ISO PlainDateTime strings, or when any element has
+ *   `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
+ *
+ * @example mergeIntervalsDateTime([{ 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-15T00:00:00" }]
+ * @example mergeIntervalsDateTime([]) // []
+ * @example mergeIntervalsDateTime([{ start: "2024-01-10T00:00:00", end: "2024-01-01T00:00:00" }]) // []
+ */
+export function mergeIntervalsDateTime(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 parsed = intervals.map((interval) => ({
+            start: Temporal.PlainDateTime.from(interval.start),
+            end: Temporal.PlainDateTime.from(interval.end),
+        }));
+        parsed.sort((a, b) => Temporal.PlainDateTime.compare(a.start, b.start));
+        const merged = [];
+        for (const interval of parsed) {
+            const last = merged[merged.length - 1];
+            if (last &&
+                Temporal.PlainDateTime.compare(interval.start, last.end) <= 0) {
+                if (Temporal.PlainDateTime.compare(interval.end, last.end) > 0) {
+                    last.end = interval.end;
+                }
+            }
+            else {
+                merged.push({ start: interval.start, end: interval.end });
+            }
+        }
+        return merged.map((interval) => ({
+            start: interval.start.toString(),
+            end: interval.end.toString(),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Collapse a list of time intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionTime`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals
+ *   ARE merged).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - Returns `[]` when `intervals` is not an array, when any element is not a
+ *   `{ start, end }` record of valid ISO PlainTime strings, or when any element has
+ *   `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
+ *
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "11:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }]
+ * @example mergeIntervalsTime([]) // []
+ * @example mergeIntervalsTime([{ start: "15:00:00", end: "09:00:00" }]) // []
+ */
+export declare function mergeIntervalsTime(intervals: Array<{
+    start: string;
+    end: string;
+}>): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/plain/interval/mergeIntervalsTime.js

@@ -0,0 +1,57 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidTimeInterval } from "./validate/index.js";
+/**
+ * Collapse a list of time intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionTime`, which is pairwise only.
+ * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals
+ *   ARE merged).
+ * - Order of the input list does not matter; the result is sorted by start.
+ * - Returns `[]` for an empty list.
+ * - Returns `[]` when `intervals` is not an array, when any element is not a
+ *   `{ start, end }` record of valid ISO PlainTime strings, or when any element has
+ *   `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
+ *
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "11:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }]
+ * @example mergeIntervalsTime([]) // []
+ * @example mergeIntervalsTime([{ start: "15:00:00", end: "09:00:00" }]) // []
+ */
+export function mergeIntervalsTime(intervals) {
+    if (!Array.isArray(intervals) || intervals.length === 0) {
+        return [];
+    }
+    if (!intervals.every((interval) => interval &&
+        typeof interval === "object" &&
+        isValidTimeInterval(interval.start, interval.end))) {
+        return [];
+    }
+    try {
+        const parsed = intervals.map((interval) => ({
+            start: Temporal.PlainTime.from(interval.start),
+            end: Temporal.PlainTime.from(interval.end),
+        }));
+        parsed.sort((a, b) => Temporal.PlainTime.compare(a.start, b.start));
+        const merged = [];
+        for (const interval of parsed) {
+            const last = merged[merged.length - 1];
+            if (last && Temporal.PlainTime.compare(interval.start, last.end) <= 0) {
+                if (Temporal.PlainTime.compare(interval.end, last.end) > 0) {
+                    last.end = interval.end;
+                }
+            }
+            else {
+                merged.push({ start: interval.start, end: interval.end });
+            }
+        }
+        return merged.map((interval) => ({
+            start: interval.start.toString(),
+            end: interval.end.toString(),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Split a date interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
+ * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
+ *   or a unit that has no effect on `PlainDate`, e.g. `"hours"`).
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ *   carry the *same* calendar tag, stepping (and each slice's boundaries) happens in that
+ *   calendar — a Hebrew leap year splits into 13 month-slices, not 12 (E5 decision of record
+ *   D5); otherwise (or if either is bare ISO) it falls back to Gregorian. Each boundary's tag is
+ *   re-derived from the actual stepped date, never copied — a month-by-month step can cross a
+ *   leap-month or era boundary mid-split.
+ *
+ * @param start ISO PlainDate string for the interval start, optionally calendar-annotated
+ * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
+ * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
+ * @param amount positive number of units per step
+ * @returns array of `{ start, end }` records, or [] on invalid input
+ *
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-09", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-01", "day", 2) // [{ start: "2024-01-01", end: "2024-01-01" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 0) // []
+ * @example splitIntervalByUnitDate("invalid", "2024-01-10", "day", 2) // []
+ * @example splitIntervalByUnitDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ */
+export declare function splitIntervalByUnitDate(start: string, end: string, unit: string, amount: number): Array<{
+    start: string;
+    end: string;
+}>;