@northguild/gmt 1.14.2

package/dist/unix/interval/intervalSplitAtUnix.js

@@ -0,0 +1,55 @@
+import { isValidUnixEpochPair } from "../../internal/resolveUnixTimeZone.js";
+/**
+ * Split a Unix epoch interval at arbitrary `points`, producing consecutive sub-intervals.
+ *
+ * - `points` need not be sorted — they are sorted internally before splitting.
+ * - Points outside `[start, end]` are dropped; they cannot introduce a boundary that isn't
+ *   inside the interval.
+ * - Points exactly on `start` or `end` are dropped too — they would only produce a
+ *   zero-length sub-interval at the edge.
+ * - Duplicate points collapse to a single boundary.
+ * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - Returns `[]` when `points` is not an array, when any element is not a finite number (or
+ *   numeric string), or on invalid input (non-finite/non-integer start/end, `start > end`).
+ *
+ * @param start Unix epoch value (seconds or milliseconds) — interval start
+ * @param end Unix epoch value (seconds or milliseconds) — interval end
+ * @param points array of Unix epoch values to split at
+ * @returns array of `{ start, end }` records, or `[]` on invalid input
+ *
+ * @example intervalSplitAtUnix(0, 100000, [50000]) // [{ start: 0, end: 50000 }, { start: 50000, end: 100000 }]
+ * @example intervalSplitAtUnix(0, 100000, []) // [{ start: 0, end: 100000 }]
+ * @example intervalSplitAtUnix(NaN, 100000, [50000]) // []
+ */
+export function intervalSplitAtUnix(start, end, points) {
+    if (!Array.isArray(points)) {
+        return [];
+    }
+    if (typeof start !== "number" && typeof start !== "string") {
+        return [];
+    }
+    if (typeof end !== "number" && typeof end !== "string") {
+        return [];
+    }
+    const startMs = typeof start === "number" ? start : Number(start);
+    const endMs = typeof end === "number" ? end : Number(end);
+    if (!isValidUnixEpochPair(startMs, endMs) || startMs > endMs) {
+        return [];
+    }
+    if (!points.every((point) => typeof point === "number" || typeof point === "string")) {
+        return [];
+    }
+    const parsedPoints = points.map((point) => typeof point === "number" ? point : Number(point));
+    if (!parsedPoints.every((point) => Number.isFinite(point))) {
+        return [];
+    }
+    const inRangePoints = parsedPoints.filter((point) => point > startMs && point < endMs);
+    inRangePoints.sort((a, b) => a - b);
+    const uniquePoints = inRangePoints.filter((point, index) => index === 0 || point !== inRangePoints[index - 1]);
+    const boundaries = [startMs, ...uniquePoints, endMs];
+    const result = [];
+    for (let i = 0; i < boundaries.length - 1; i++) {
+        result.push({ start: boundaries[i], end: boundaries[i + 1] });
+    }
+    return result;
+}

package/dist/unix/interval/intervalUnionUnix.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Return the combined span of two Unix epoch intervals, or null when they are disjoint.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - Overlapping intervals return their merged span.
+ * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Returns `null` if either interval is invalid (`start > end`).
+ * - Returns `null` on invalid input (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
+ *
+ * @example intervalUnionUnix(0, 1700000000, 1000000, 2000000) // { start: 0, end: 1700000000 }
+ * @example intervalUnionUnix(0, 1000000, 1000000, 2000000) // { start: 0, end: 2000000 }
+ * @example intervalUnionUnix(0, 1000000, 1000001, 2000000) // null
+ * @example intervalUnionUnix(NaN, 1700000000, 1000000, 2000000) // null
+ * @example intervalUnionUnix("0", "1700000000", "1000000", "2000000") // { start: 0, end: 1700000000 }
+ */
+export declare function intervalUnionUnix(aStart: number | string, aEnd: number | string, bStart: number | string, bEnd: number | string): {
+    start: number;
+    end: number;
+} | null;

package/dist/unix/interval/intervalUnionUnix.js

@@ -0,0 +1,58 @@
+/**
+ * Return the combined span of two Unix epoch intervals, or null when they are disjoint.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - Overlapping intervals return their merged span.
+ * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and ARE merged.
+ * - Returns `null` if either interval is invalid (`start > end`).
+ * - Returns `null` on invalid input (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns `{ start, end }` with the merged span, or null on invalid input / disjoint intervals
+ *
+ * @example intervalUnionUnix(0, 1700000000, 1000000, 2000000) // { start: 0, end: 1700000000 }
+ * @example intervalUnionUnix(0, 1000000, 1000000, 2000000) // { start: 0, end: 2000000 }
+ * @example intervalUnionUnix(0, 1000000, 1000001, 2000000) // null
+ * @example intervalUnionUnix(NaN, 1700000000, 1000000, 2000000) // null
+ * @example intervalUnionUnix("0", "1700000000", "1000000", "2000000") // { start: 0, end: 1700000000 }
+ */
+export function intervalUnionUnix(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "number" && typeof aStart !== "string") {
+        return null;
+    }
+    if (typeof aEnd !== "number" && typeof aEnd !== "string") {
+        return null;
+    }
+    if (typeof bStart !== "number" && typeof bStart !== "string") {
+        return null;
+    }
+    if (typeof bEnd !== "number" && typeof bEnd !== "string") {
+        return null;
+    }
+    const a1 = typeof aStart === "number" ? aStart : Number(aStart);
+    const a2 = typeof aEnd === "number" ? aEnd : Number(aEnd);
+    const b1 = typeof bStart === "number" ? bStart : Number(bStart);
+    const b2 = typeof bEnd === "number" ? bEnd : Number(bEnd);
+    if (!Number.isFinite(a1) ||
+        !Number.isFinite(a2) ||
+        !Number.isFinite(b1) ||
+        !Number.isFinite(b2)) {
+        return null;
+    }
+    if (a1 > a2) {
+        return null;
+    }
+    if (b1 > b2) {
+        return null;
+    }
+    if (a2 < b1 || b2 < a1) {
+        return null;
+    }
+    return {
+        start: Math.min(a1, b1),
+        end: Math.max(a2, b2),
+    };
+}

package/dist/unix/interval/intervalXorAllUnix.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Return the symmetric difference across a list of Unix epoch intervals — the set of epoch
+ * values covered by an odd number of the input intervals.
+ *
+ * - List-form generalization of `intervalXorUnix`, which is pairwise only.
+ * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
+ *   one epoch unit after its end; the result is every maximal run where the running coverage
+ *   count is odd. For two intervals this reduces to exactly `intervalXorUnix`'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 value 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 finite numeric (or numeric-string) values, or when any element
+ *   has `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input
+ *
+ * @example intervalXorAllUnix([{ start: 0, end: 1500000000 }, { start: 1400000000, end: 1700000000 }]) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorAllUnix([]) // []
+ */
+export declare function intervalXorAllUnix(intervals: Array<{
+    start: number | string;
+    end: number | string;
+}>): Array<{
+    start: number;
+    end: number;
+}>;

package/dist/unix/interval/intervalXorAllUnix.js

@@ -0,0 +1,77 @@
+import { isValidUnixEpochPair } from "../../internal/resolveUnixTimeZone.js";
+/**
+ * Return the symmetric difference across a list of Unix epoch intervals — the set of epoch
+ * values covered by an odd number of the input intervals.
+ *
+ * - List-form generalization of `intervalXorUnix`, which is pairwise only.
+ * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
+ *   one epoch unit after its end; the result is every maximal run where the running coverage
+ *   count is odd. For two intervals this reduces to exactly `intervalXorUnix`'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 value 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 finite numeric (or numeric-string) values, or when any element
+ *   has `start > end`.
+ *
+ * @param intervals array of `{ start, end }` records
+ * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input
+ *
+ * @example intervalXorAllUnix([{ start: 0, end: 1500000000 }, { start: 1400000000, end: 1700000000 }]) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorAllUnix([]) // []
+ */
+export function intervalXorAllUnix(intervals) {
+    if (!Array.isArray(intervals) || intervals.length === 0) {
+        return [];
+    }
+    if (!intervals.every((interval) => interval &&
+        typeof interval === "object" &&
+        (typeof interval.start === "number" ||
+            typeof interval.start === "string") &&
+        (typeof interval.end === "number" || typeof interval.end === "string"))) {
+        return [];
+    }
+    const parsed = intervals.map((interval) => ({
+        start: typeof interval.start === "number"
+            ? interval.start
+            : Number(interval.start),
+        end: typeof interval.end === "number" ? interval.end : Number(interval.end),
+    }));
+    if (!parsed.every((interval) => isValidUnixEpochPair(interval.start, interval.end) &&
+        interval.start <= interval.end)) {
+        return [];
+    }
+    const events = [];
+    for (const interval of parsed) {
+        events.push({ point: interval.start, delta: 1 });
+        events.push({ point: interval.end + 1, delta: -1 });
+    }
+    events.sort((a, b) => a.point - b.point);
+    const grouped = [];
+    for (const event of events) {
+        const last = grouped[grouped.length - 1];
+        if (last && last.point === event.point) {
+            last.delta += event.delta;
+        }
+        else {
+            grouped.push(event);
+        }
+    }
+    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 !== null) {
+            result.push({ start: runStart, end: group.point - 1 });
+            runStart = null;
+        }
+    }
+    return result;
+}

package/dist/unix/interval/intervalXorUnix.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Return the symmetric difference of two Unix intervals — time covered by exactly one interval.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - 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 (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
+ *
+ * @example intervalXorUnix(0, 1500000000, 1400000000, 1700000000) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorUnix(0, 1700000000, 1400000000, 1500000000) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorUnix(0, 1700000000, 0, 1700000000) // []
+ * @example intervalXorUnix(NaN, 1500000000, 1400000000, 1700000000) // []
+ */
+export declare function intervalXorUnix(aStart: number | string, aEnd: number | string, bStart: number | string, bEnd: number | string): Array<{
+    start: number;
+    end: number;
+}>;

package/dist/unix/interval/intervalXorUnix.js

@@ -0,0 +1,70 @@
+/**
+ * Return the symmetric difference of two Unix intervals — time covered by exactly one interval.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - 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 (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
+ *
+ * @example intervalXorUnix(0, 1500000000, 1400000000, 1700000000) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorUnix(0, 1700000000, 1400000000, 1500000000) // [{ start: 0, end: 1399999999 }, { start: 1500000001, end: 1700000000 }]
+ * @example intervalXorUnix(0, 1700000000, 0, 1700000000) // []
+ * @example intervalXorUnix(NaN, 1500000000, 1400000000, 1700000000) // []
+ */
+export function intervalXorUnix(aStart, aEnd, bStart, bEnd) {
+    if ((typeof aStart !== "number" && typeof aStart !== "string") ||
+        (typeof aEnd !== "number" && typeof aEnd !== "string") ||
+        (typeof bStart !== "number" && typeof bStart !== "string") ||
+        (typeof bEnd !== "number" && typeof bEnd !== "string")) {
+        return [];
+    }
+    const n1 = typeof aStart === "number" ? aStart : Number(aStart);
+    const n2 = typeof aEnd === "number" ? aEnd : Number(aEnd);
+    const n3 = typeof bStart === "number" ? bStart : Number(bStart);
+    const n4 = typeof bEnd === "number" ? bEnd : Number(bEnd);
+    if (!Number.isFinite(n1) ||
+        !Number.isFinite(n2) ||
+        !Number.isFinite(n3) ||
+        !Number.isFinite(n4)) {
+        return [];
+    }
+    if (n1 > n2) {
+        return [];
+    }
+    if (n3 > n4) {
+        return [];
+    }
+    const result = [];
+    // If intervals don't overlap, return both as-is
+    if (n2 < n3 || n4 < n1) {
+        return [
+            { start: n1, end: n2 },
+            { start: n3, end: n4 },
+        ];
+    }
+    // Left piece: A before B starts
+    if (n1 < n3) {
+        result.push({ start: n1, end: n3 - 1 });
+    }
+    // Right piece: A after B ends
+    if (n2 > n4) {
+        result.push({ start: n4 + 1, end: n2 });
+    }
+    // Left piece: B before A starts
+    if (n3 < n1) {
+        result.push({ start: n3, end: n1 - 1 });
+    }
+    // Right piece: B after A ends
+    if (n4 > n2) {
+        result.push({ start: n2 + 1, end: n4 });
+    }
+    return result;
+}

package/dist/unix/interval/intervalsOverlapUnix.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - 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 (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns true if intervals overlap, or false on invalid input
+ *
+ * @example intervalsOverlapUnix(0, 1700000000, 1000000, 2000000) // true
+ * @example intervalsOverlapUnix(0, 1000000, 1000000, 2000000) // false (adjacent)
+ * @example intervalsOverlapUnix(0, 1000000, 1000001, 2000000) // false (disjoint)
+ * @example intervalsOverlapUnix(NaN, 1700000000, 1000000, 2000000) // false
+ * @example intervalsOverlapUnix("0", "1700000000", "1000000", "2000000") // true
+ */
+export declare function intervalsOverlapUnix(aStart: number | string, aEnd: number | string, bStart: number | string, bEnd: number | string): boolean;

package/dist/unix/interval/intervalsOverlapUnix.js

@@ -0,0 +1,51 @@
+/**
+ * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ *
+ * - Compares numeric Unix epoch values directly.
+ * - 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 (non-numeric types, non-finite values).
+ *
+ * @param aStart Unix epoch value (seconds or milliseconds) — first interval start
+ * @param aEnd Unix epoch value (seconds or milliseconds) — first interval end
+ * @param bStart Unix epoch value (seconds or milliseconds) — second interval start
+ * @param bEnd Unix epoch value (seconds or milliseconds) — second interval end
+ * @returns true if intervals overlap, or false on invalid input
+ *
+ * @example intervalsOverlapUnix(0, 1700000000, 1000000, 2000000) // true
+ * @example intervalsOverlapUnix(0, 1000000, 1000000, 2000000) // false (adjacent)
+ * @example intervalsOverlapUnix(0, 1000000, 1000001, 2000000) // false (disjoint)
+ * @example intervalsOverlapUnix(NaN, 1700000000, 1000000, 2000000) // false
+ * @example intervalsOverlapUnix("0", "1700000000", "1000000", "2000000") // true
+ */
+export function intervalsOverlapUnix(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "number" && typeof aStart !== "string") {
+        return false;
+    }
+    if (typeof aEnd !== "number" && typeof aEnd !== "string") {
+        return false;
+    }
+    if (typeof bStart !== "number" && typeof bStart !== "string") {
+        return false;
+    }
+    if (typeof bEnd !== "number" && typeof bEnd !== "string") {
+        return false;
+    }
+    const a1 = typeof aStart === "number" ? aStart : Number(aStart);
+    const a2 = typeof aEnd === "number" ? aEnd : Number(aEnd);
+    const b1 = typeof bStart === "number" ? bStart : Number(bStart);
+    const b2 = typeof bEnd === "number" ? bEnd : Number(bEnd);
+    if (!Number.isFinite(a1) ||
+        !Number.isFinite(a2) ||
+        !Number.isFinite(b1) ||
+        !Number.isFinite(b2)) {
+        return false;
+    }
+    if (a1 > a2) {
+        return false;
+    }
+    if (b1 > b2) {
+        return false;
+    }
+    return a2 >= b1 && b2 >= a1;
+}

package/dist/unix/interval/mergeIntervalsUnix.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Collapse a list of Unix epoch intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionUnix`, 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 finite numeric (or numeric-string) values, 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 mergeIntervalsUnix([{ start: 0, end: 1000000 }, { start: 500000, end: 1500000 }]) // [{ start: 0, end: 1500000 }]
+ * @example mergeIntervalsUnix([]) // []
+ */
+export declare function mergeIntervalsUnix(intervals: Array<{
+    start: number | string;
+    end: number | string;
+}>): Array<{
+    start: number;
+    end: number;
+}>;

package/dist/unix/interval/mergeIntervalsUnix.js

@@ -0,0 +1,55 @@
+import { isValidUnixEpochPair } from "../../internal/resolveUnixTimeZone.js";
+/**
+ * Collapse a list of Unix epoch intervals into the minimum set of non-overlapping intervals.
+ *
+ * - List-form generalization of `intervalUnionUnix`, 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 finite numeric (or numeric-string) values, 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 mergeIntervalsUnix([{ start: 0, end: 1000000 }, { start: 500000, end: 1500000 }]) // [{ start: 0, end: 1500000 }]
+ * @example mergeIntervalsUnix([]) // []
+ */
+export function mergeIntervalsUnix(intervals) {
+    if (!Array.isArray(intervals) || intervals.length === 0) {
+        return [];
+    }
+    if (!intervals.every((interval) => interval &&
+        typeof interval === "object" &&
+        (typeof interval.start === "number" ||
+            typeof interval.start === "string") &&
+        (typeof interval.end === "number" || typeof interval.end === "string"))) {
+        return [];
+    }
+    const parsed = intervals.map((interval) => ({
+        start: typeof interval.start === "number"
+            ? interval.start
+            : Number(interval.start),
+        end: typeof interval.end === "number" ? interval.end : Number(interval.end),
+    }));
+    if (!parsed.every((interval) => isValidUnixEpochPair(interval.start, interval.end) &&
+        interval.start <= interval.end)) {
+        return [];
+    }
+    parsed.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const interval of parsed) {
+        const last = merged[merged.length - 1];
+        if (last && interval.start <= last.end) {
+            if (interval.end > last.end) {
+                last.end = interval.end;
+            }
+        }
+        else {
+            merged.push({ start: interval.start, end: interval.end });
+        }
+    }
+    return merged;
+}

package/dist/unix/interval/resolveUnixIntervalPair.d.ts

@@ -0,0 +1,7 @@
+import { Temporal } from "@js-temporal/polyfill";
+export interface ResolvedUnixInterval {
+    startVal: Temporal.ZonedDateTime;
+    endVal: Temporal.ZonedDateTime;
+    resolvedUnit: Temporal.DateTimeUnit;
+}
+export declare function resolveUnixIntervalPair(start: number | string, end: number | string, unit: string): ResolvedUnixInterval | null;

package/dist/unix/interval/resolveUnixIntervalPair.js

@@ -0,0 +1,36 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { resolveDateTimeUnit } from "../../internal/index.js";
+import { isValidUnixEpochPair, resolveUnixTimeZone, } from "../../internal/resolveUnixTimeZone.js";
+import { isValidDateTimeUnit } from "../../plain/validate/index.js";
+export function resolveUnixIntervalPair(start, end, unit) {
+    if (typeof start !== "number" && typeof start !== "string") {
+        return null;
+    }
+    if (typeof end !== "number" && typeof end !== "string") {
+        return null;
+    }
+    const startMs = typeof start === "number" ? start : Number(start);
+    const endMs = typeof end === "number" ? end : Number(end);
+    if (!isValidUnixEpochPair(startMs, endMs) || startMs > endMs) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidDateTimeUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        const timeZone = resolveUnixTimeZone();
+        if (!timeZone) {
+            return null;
+        }
+        const startVal = Temporal.Instant.fromEpochMilliseconds(startMs).toZonedDateTimeISO(timeZone);
+        const endVal = Temporal.Instant.fromEpochMilliseconds(endMs).toZonedDateTimeISO(timeZone);
+        return { startVal, endVal, resolvedUnit };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/unix/interval/splitIntervalByUnitUnix.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Split a Unix epoch 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 (non-finite/non-integer start/end, unsupported unit,
+ *   non-positive amount, or invalid timeZone).
+ *
+ * Uses the system timeZone for calendar-unit arithmetic (consistent with `addUnix`).
+ *
+ * @param start Unix epoch value (seconds or milliseconds) — interval start
+ * @param end Unix epoch value (seconds or milliseconds) — interval end
+ * @param unit duration unit string — any `DateTimeDurationUnit`
+ * @param amount positive number of units per step
+ * @returns array of `{ start, end }` records, or [] on invalid input
+ *
+ * @example splitIntervalByUnitUnix(0, 86400000, "hour", 6) // [{ start: 0, end: 21600000 }, { start: 21600000, end: 43200000 }, { start: 43200000, end: 64800000 }, { start: 64800000, end: 86400000 }]
+ * @example splitIntervalByUnitUnix(0, 3600000, "hour", 1) // [{ start: 0, end: 3600000 }]
+ * @example splitIntervalByUnitUnix(0, 0, "hour", 1) // [{ start: 0, end: 0 }]
+ * @example splitIntervalByUnitUnix(0, 86400000, "hour", 0) // []
+ * @example splitIntervalByUnitUnix("invalid", 86400000, "hour", 1) // []
+ */
+export declare function splitIntervalByUnitUnix(start: number | string, end: number | string, unit: string, amount: number): Array<{
+    start: number;
+    end: number;
+}>;

package/dist/unix/interval/splitIntervalByUnitUnix.js

@@ -0,0 +1,85 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getSystemTimeZone } from "../../zoned/get/index.js";
+import { isValidTimeZone } from "../../zoned/validate/index.js";
+import { resolveDurationUnit } from "../../internal/index.js";
+/**
+ * Split a Unix epoch 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 (non-finite/non-integer start/end, unsupported unit,
+ *   non-positive amount, or invalid timeZone).
+ *
+ * Uses the system timeZone for calendar-unit arithmetic (consistent with `addUnix`).
+ *
+ * @param start Unix epoch value (seconds or milliseconds) — interval start
+ * @param end Unix epoch value (seconds or milliseconds) — interval end
+ * @param unit duration unit string — any `DateTimeDurationUnit`
+ * @param amount positive number of units per step
+ * @returns array of `{ start, end }` records, or [] on invalid input
+ *
+ * @example splitIntervalByUnitUnix(0, 86400000, "hour", 6) // [{ start: 0, end: 21600000 }, { start: 21600000, end: 43200000 }, { start: 43200000, end: 64800000 }, { start: 64800000, end: 86400000 }]
+ * @example splitIntervalByUnitUnix(0, 3600000, "hour", 1) // [{ start: 0, end: 3600000 }]
+ * @example splitIntervalByUnitUnix(0, 0, "hour", 1) // [{ start: 0, end: 0 }]
+ * @example splitIntervalByUnitUnix(0, 86400000, "hour", 0) // []
+ * @example splitIntervalByUnitUnix("invalid", 86400000, "hour", 1) // []
+ */
+export function splitIntervalByUnitUnix(start, end, unit, amount) {
+    if (typeof start !== "number" && typeof start !== "string") {
+        return [];
+    }
+    if (typeof end !== "number" && typeof end !== "string") {
+        return [];
+    }
+    const startMs = typeof start === "number" ? start : Number(start);
+    const endMs = typeof end === "number" ? end : Number(end);
+    if (!Number.isFinite(startMs) || !Number.isInteger(startMs)) {
+        return [];
+    }
+    if (!Number.isFinite(endMs) || !Number.isInteger(endMs)) {
+        return [];
+    }
+    if (startMs > endMs) {
+        return [];
+    }
+    if (typeof unit !== "string") {
+        return [];
+    }
+    const resolvedUnit = resolveDurationUnit(unit);
+    if (!resolvedUnit) {
+        return [];
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return [];
+    }
+    try {
+        const timeZone = getSystemTimeZone();
+        if (!timeZone || !isValidTimeZone(timeZone)) {
+            return [];
+        }
+        if (startMs === endMs) {
+            return [{ start: startMs, end: endMs }];
+        }
+        const result = [];
+        for (let currentMs = startMs; currentMs < endMs;) {
+            const instant = Temporal.Instant.fromEpochMilliseconds(currentMs);
+            const zoned = instant.toZonedDateTimeISO(timeZone);
+            const next = zoned.add({ [resolvedUnit]: amount }).toInstant();
+            const nextMs = next.epochMilliseconds;
+            if (nextMs === currentMs) {
+                return [];
+            }
+            const sliceEndMs = nextMs > endMs ? endMs : nextMs;
+            result.push({
+                start: currentMs,
+                end: sliceEndMs,
+            });
+            currentMs = nextMs;
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/unix/interval/validate/index.d.ts

@@ -0,0 +1 @@
+export * from "./isValidUnixInterval.js";