@northguild/gmt 1.14.2

package/dist/plain/interval/intervalAbutsTime.js

@@ -0,0 +1,63 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+/**
+ * Return true when two time intervals are exactly adjacent — one's end equals the other's start
+ * with zero gap and zero overlap.
+ *
+ * - Uses `Temporal.PlainTime.compare` for comparison.
+ * - Returns `true` when `aEnd + 1 nanosecond === bStart` or `bEnd + 1 nanosecond === aStart`.
+ * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
+ * - Returns `false` on invalid input (wrong type, malformed strings).
+ *
+ * @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 are exactly adjacent, or false on invalid input
+ *
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00.000000001", "17:00:00") // true
+ * @example intervalAbutsTime("12:00:00", "17:00:00", "09:00:00", "12:00:00") // true
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:01", "17:00:00") // false (gap)
+ * @example intervalAbutsTime("09:00:00", "13:00:00", "12:00:00", "17:00:00") // false (overlap)
+ * @example intervalAbutsTime("invalid", "12:00:00", "12:00:00", "17:00:00") // false
+ */
+export function intervalAbutsTime(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;
+        }
+        // aEnd + 1 nanosecond === bStart
+        const aEndPlusOne = aE.add({ nanoseconds: 1 });
+        if (Temporal.PlainTime.compare(aEndPlusOne, bS) === 0) {
+            return true;
+        }
+        // bEnd + 1 nanosecond === aStart
+        const bEndPlusOne = bE.add({ nanoseconds: 1 });
+        if (Temporal.PlainTime.compare(bEndPlusOne, aS) === 0) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainDate.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ *
+ * @param intervalStart ISO 8601 date string for the outer interval start, optionally calendar-annotated
+ * @param intervalEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param pointOrStart ISO 8601 date string for the point (3-arg) or inner start (4-arg), optionally calendar-annotated
+ * @param pointEnd optional ISO 8601 date string for the inner interval end (4-arg mode), optionally calendar-annotated
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15") // true
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-07-15") // true
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-06-10") // false
+ * @example intervalContainsDate("invalid", "2024-12-31", "2024-06-15") // false
+ */
+export declare function intervalContainsDate(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDate.js

@@ -0,0 +1,63 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { parseCalendarDateValue } from "../../internal/index.js";
+import { isValidCalendarDate } from "../validate/index.js";
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainDate.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ *
+ * @param intervalStart ISO 8601 date string for the outer interval start, optionally calendar-annotated
+ * @param intervalEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param pointOrStart ISO 8601 date string for the point (3-arg) or inner start (4-arg), optionally calendar-annotated
+ * @param pointEnd optional ISO 8601 date string for the inner interval end (4-arg mode), optionally calendar-annotated
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15") // true
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-07-15") // true
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-06-10") // false
+ * @example intervalContainsDate("invalid", "2024-12-31", "2024-06-15") // false
+ */
+export function intervalContainsDate(intervalStart, intervalEnd, pointOrStart, pointEnd) {
+    if (typeof intervalStart !== "string" ||
+        typeof intervalEnd !== "string" ||
+        typeof pointOrStart !== "string" ||
+        (pointEnd !== undefined && typeof pointEnd !== "string")) {
+        return false;
+    }
+    if (!isValidCalendarDate(intervalStart) ||
+        !isValidCalendarDate(intervalEnd) ||
+        !isValidCalendarDate(pointOrStart) ||
+        (pointEnd !== undefined && !isValidCalendarDate(pointEnd))) {
+        return false;
+    }
+    try {
+        const s = parseCalendarDateValue(intervalStart);
+        const e = parseCalendarDateValue(intervalEnd);
+        const p = parseCalendarDateValue(pointOrStart);
+        if (Temporal.PlainDate.compare(s, e) > 0) {
+            return false;
+        }
+        if (pointEnd === undefined) {
+            return (Temporal.PlainDate.compare(s, p) <= 0 &&
+                Temporal.PlainDate.compare(p, e) <= 0);
+        }
+        const pe = parseCalendarDateValue(pointEnd);
+        if (Temporal.PlainDate.compare(p, pe) > 0) {
+            return false;
+        }
+        return (Temporal.PlainDate.compare(s, p) <= 0 &&
+            Temporal.PlainDate.compare(pe, e) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainDateTime.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ *
+ * @param intervalStart ISO 8601 datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 datetime string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-07-15T12:00:00") // true
+ * @example intervalContainsDateTime("2024-12-31T23:59:59", "2024-01-01T10:00:00", "2024-06-15T12:00:00") // false
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-06-10T12:00:00") // false
+ * @example intervalContainsDateTime("invalid", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // false
+ */
+export declare function intervalContainsDateTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDateTime.js

@@ -0,0 +1,60 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../regex/index.js";
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainDateTime.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ *
+ * @param intervalStart ISO 8601 datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 datetime string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-07-15T12:00:00") // true
+ * @example intervalContainsDateTime("2024-12-31T23:59:59", "2024-01-01T10:00:00", "2024-06-15T12:00:00") // false
+ * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-06-10T12:00:00") // false
+ * @example intervalContainsDateTime("invalid", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // false
+ */
+export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStart, pointEnd) {
+    if (typeof intervalStart !== "string" ||
+        typeof intervalEnd !== "string" ||
+        typeof pointOrStart !== "string" ||
+        (pointEnd !== undefined && typeof pointEnd !== "string")) {
+        return false;
+    }
+    if (!plainDateTime.test(intervalStart) ||
+        !plainDateTime.test(intervalEnd) ||
+        !plainDateTime.test(pointOrStart) ||
+        (pointEnd !== undefined && !plainDateTime.test(pointEnd))) {
+        return false;
+    }
+    try {
+        const s = Temporal.PlainDateTime.from(intervalStart);
+        const e = Temporal.PlainDateTime.from(intervalEnd);
+        const p = Temporal.PlainDateTime.from(pointOrStart);
+        if (Temporal.PlainDateTime.compare(s, e) > 0) {
+            return false;
+        }
+        if (pointEnd === undefined) {
+            return (Temporal.PlainDateTime.compare(s, p) <= 0 &&
+                Temporal.PlainDateTime.compare(p, e) <= 0);
+        }
+        const pe = Temporal.PlainDateTime.from(pointEnd);
+        if (Temporal.PlainDateTime.compare(p, pe) > 0) {
+            return false;
+        }
+        return (Temporal.PlainDateTime.compare(s, p) <= 0 &&
+            Temporal.PlainDateTime.compare(pe, e) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainTime.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ *
+ * @param intervalStart ISO 8601 time string for the outer interval start
+ * @param intervalEnd ISO 8601 time string for the outer interval end
+ * @param pointOrStart ISO 8601 time string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 time string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00") // true
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
+ * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "11:00:00") // false
+ * @example intervalContainsTime("invalid", "17:00:00", "12:00:00") // false
+ */
+export declare function intervalContainsTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsTime.js

@@ -0,0 +1,60 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+/**
+ * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
+ * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ *
+ * - Uses `Temporal.PlainTime.compare` for comparison.
+ * - Always-inclusive boundaries: `start <= point <= end`.
+ * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
+ * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
+ * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ *
+ * @param intervalStart ISO 8601 time string for the outer interval start
+ * @param intervalEnd ISO 8601 time string for the outer interval end
+ * @param pointOrStart ISO 8601 time string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 time string for the inner interval end (4-arg mode)
+ * @returns true if the point or inner interval is contained, or false on invalid input
+ *
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00") // true
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
+ * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "11:00:00") // false
+ * @example intervalContainsTime("invalid", "17:00:00", "12:00:00") // false
+ */
+export function intervalContainsTime(intervalStart, intervalEnd, pointOrStart, pointEnd) {
+    if (typeof intervalStart !== "string" ||
+        typeof intervalEnd !== "string" ||
+        typeof pointOrStart !== "string" ||
+        (pointEnd !== undefined && typeof pointEnd !== "string")) {
+        return false;
+    }
+    if (!plainTime.test(intervalStart) ||
+        !plainTime.test(intervalEnd) ||
+        !plainTime.test(pointOrStart) ||
+        (pointEnd !== undefined && !plainTime.test(pointEnd))) {
+        return false;
+    }
+    try {
+        const s = Temporal.PlainTime.from(intervalStart);
+        const e = Temporal.PlainTime.from(intervalEnd);
+        const p = Temporal.PlainTime.from(pointOrStart);
+        if (Temporal.PlainTime.compare(s, e) > 0) {
+            return false;
+        }
+        if (pointEnd === undefined) {
+            return (Temporal.PlainTime.compare(s, p) <= 0 &&
+                Temporal.PlainTime.compare(p, e) <= 0);
+        }
+        const pe = Temporal.PlainTime.from(pointEnd);
+        if (Temporal.PlainTime.compare(p, pe) > 0) {
+            return false;
+        }
+        return (Temporal.PlainTime.compare(s, p) <= 0 &&
+            Temporal.PlainTime.compare(pe, e) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Count how many `unit` boundaries a date interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffDate`, which measures exact elapsed duration.
+ * - `"2024-01-01"` to `"2024-01-03"` counted in days is 2: the end boundary is excluded.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary (e.g. `"2024-01-15"` counts 1 month but 0 days).
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   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, boundaries are counted in that calendar (a Hebrew leap year
+ *   crosses 13 month boundaries, not 12 — see the roadmap's E5 decisions of record, D5). When
+ *   they carry different tags (or either is bare ISO), counting falls back to Gregorian.
+ *
+ * @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 unit string — `"year" | "month" | "week" | "day"` (time units return null)
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountDate("2024-01-01", "2024-01-03", "day") // 2
+ * @example intervalCountDate("2024-01-15", "2024-03-10", "month") // 3
+ * @example intervalCountDate("2024-01-15", "2024-01-15", "month") // 1 (zero-length, mid-month)
+ * @example intervalCountDate("2024-01-01", "2024-01-01", "month") // 0 (zero-length, on the boundary)
+ * @example intervalCountDate("2024-01-01", "2024-01-10", "hour") // null
+ * @example intervalCountDate("invalid", "2024-01-10", "day") // null
+ * @example intervalCountDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month") // 13 (Hebrew leap year, measured in Hebrew)
+ */
+export declare function intervalCountDate(start: string, end: string, unit: string): number | null;

package/dist/plain/interval/intervalCountDate.js

@@ -0,0 +1,62 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getUnitSpan, parseCalendarDatePairForArithmetic, resolveDateTimeUnit, } from "../../internal/index.js";
+import { getStartOfDateUnit } from "../../internal/dateUnitHelpers.js";
+import { isValidCalendarDate, isValidDateUnit } from "../validate/index.js";
+/**
+ * Count how many `unit` boundaries a date interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffDate`, which measures exact elapsed duration.
+ * - `"2024-01-01"` to `"2024-01-03"` counted in days is 2: the end boundary is excluded.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary (e.g. `"2024-01-15"` counts 1 month but 0 days).
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   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, boundaries are counted in that calendar (a Hebrew leap year
+ *   crosses 13 month boundaries, not 12 — see the roadmap's E5 decisions of record, D5). When
+ *   they carry different tags (or either is bare ISO), counting falls back to Gregorian.
+ *
+ * @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 unit string — `"year" | "month" | "week" | "day"` (time units return null)
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountDate("2024-01-01", "2024-01-03", "day") // 2
+ * @example intervalCountDate("2024-01-15", "2024-03-10", "month") // 3
+ * @example intervalCountDate("2024-01-15", "2024-01-15", "month") // 1 (zero-length, mid-month)
+ * @example intervalCountDate("2024-01-01", "2024-01-01", "month") // 0 (zero-length, on the boundary)
+ * @example intervalCountDate("2024-01-01", "2024-01-10", "hour") // null
+ * @example intervalCountDate("invalid", "2024-01-10", "day") // null
+ * @example intervalCountDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month") // 13 (Hebrew leap year, measured in Hebrew)
+ */
+export function intervalCountDate(start, end, unit) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return null;
+    }
+    if (!isValidCalendarDate(start) || !isValidCalendarDate(end)) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidDateUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        const { a: startVal, b: endVal } = parseCalendarDatePairForArithmetic(start, end);
+        if (Temporal.PlainDate.compare(startVal, endVal) > 0) {
+            return null;
+        }
+        const startOfStart = getStartOfDateUnit(startVal, resolvedUnit);
+        const startOfEnd = getStartOfDateUnit(endVal, resolvedUnit);
+        const spanned = getUnitSpan(startOfStart.until(startOfEnd, { largestUnit: resolvedUnit }), resolvedUnit);
+        return spanned + (startOfEnd.equals(endVal) ? 0 : 1);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Count how many `unit` boundaries a date-time interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffDateTime`, which measures exact elapsed duration. An interval from 23:59 to
+ *   00:01 is two minutes long but touches 2 day boundaries.
+ * - The end boundary is excluded: `"2024-01-01T00:00:00"` to `"2024-01-03T00:00:00"` counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit).
+ *
+ * @param start ISO PlainDateTime string for the interval start
+ * @param end ISO PlainDateTime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountDateTime("2024-01-01T23:59:00", "2024-01-02T00:01:00", "day") // 2
+ * @example intervalCountDateTime("2024-01-01T00:00:00", "2024-01-03T00:00:00", "day") // 2
+ * @example intervalCountDateTime("2024-01-01T10:30:00", "2024-01-01T12:00:00", "hour") // 2
+ * @example intervalCountDateTime("2024-01-01T05:00:00", "2024-01-01T05:00:00", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountDateTime("2024-01-01T00:00:00", "2024-01-01T00:00:00", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountDateTime("invalid", "2024-01-02T00:00:00", "day") // null
+ */
+export declare function intervalCountDateTime(start: string, end: string, unit: string): number | null;

package/dist/plain/interval/intervalCountDateTime.js

@@ -0,0 +1,73 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getUnitSpan, resolveDateTimeUnit } from "../../internal/index.js";
+import { getStartOfDateTimeUnit } from "../../internal/dateTimeUnitHelpers.js";
+import { plainDateTime } from "../../regex/index.js";
+import { isValidDateTime, isValidDateTimeUnit, isValidDateUnit, } from "../validate/index.js";
+/**
+ * Return the start of `unit` for a `Temporal.PlainDateTime`, for every DateTimeUnit.
+ *
+ * Date units delegate to the shared helper; time units truncate via `round`.
+ */
+function startOfUnit(source, unit) {
+    if (isValidDateUnit(unit)) {
+        return getStartOfDateTimeUnit(source, unit);
+    }
+    return source.round({ smallestUnit: unit, roundingMode: "trunc" });
+}
+/**
+ * Count how many `unit` boundaries a date-time interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffDateTime`, which measures exact elapsed duration. An interval from 23:59 to
+ *   00:01 is two minutes long but touches 2 day boundaries.
+ * - The end boundary is excluded: `"2024-01-01T00:00:00"` to `"2024-01-03T00:00:00"` counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Weeks start on Monday (ISO 8601).
+ * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit).
+ *
+ * @param start ISO PlainDateTime string for the interval start
+ * @param end ISO PlainDateTime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountDateTime("2024-01-01T23:59:00", "2024-01-02T00:01:00", "day") // 2
+ * @example intervalCountDateTime("2024-01-01T00:00:00", "2024-01-03T00:00:00", "day") // 2
+ * @example intervalCountDateTime("2024-01-01T10:30:00", "2024-01-01T12:00:00", "hour") // 2
+ * @example intervalCountDateTime("2024-01-01T05:00:00", "2024-01-01T05:00:00", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountDateTime("2024-01-01T00:00:00", "2024-01-01T00:00:00", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountDateTime("invalid", "2024-01-02T00:00:00", "day") // null
+ */
+export function intervalCountDateTime(start, end, unit) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return null;
+    }
+    if (!plainDateTime.test(start) || !plainDateTime.test(end)) {
+        return null;
+    }
+    if (!isValidDateTime(start) || !isValidDateTime(end)) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidDateTimeUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        const startVal = Temporal.PlainDateTime.from(start);
+        const endVal = Temporal.PlainDateTime.from(end);
+        if (Temporal.PlainDateTime.compare(startVal, endVal) > 0) {
+            return null;
+        }
+        const startOfStart = startOfUnit(startVal, resolvedUnit);
+        const startOfEnd = startOfUnit(endVal, resolvedUnit);
+        const spanned = getUnitSpan(startOfStart.until(startOfEnd, { largestUnit: resolvedUnit }), resolvedUnit);
+        return spanned + (startOfEnd.equals(endVal) ? 0 : 1);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Count how many `unit` boundaries a time interval crosses.
+ *
+ * - Counts clock boundaries touched by the half-open interval `[start, end)` — distinct from
+ *   `diffTime`, which measures exact elapsed duration. An interval from 12:59 to 13:01 is two
+ *   minutes long but touches 2 hour boundaries.
+ * - The end boundary is excluded: `"12:00:00"` to `"14:00:00"` counts 2 hours.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Accepts singular or plural units (`"hour"` and `"hours"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
+ *
+ * @param start ISO PlainTime string for the interval start
+ * @param end ISO PlainTime string for the interval end
+ * @param unit unit string — `"hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond"` (calendar units return null)
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountTime("12:00:00", "14:00:00", "hour") // 2
+ * @example intervalCountTime("12:30:00", "13:00:00", "hour") // 1
+ * @example intervalCountTime("12:30:00", "12:30:00", "hour") // 1 (zero-length, mid-hour)
+ * @example intervalCountTime("12:00:00", "12:00:00", "hour") // 0 (zero-length, on the boundary)
+ * @example intervalCountTime("12:00:00", "14:00:00", "day") // null
+ * @example intervalCountTime("invalid", "14:00:00", "hour") // null
+ */
+export declare function intervalCountTime(start: string, end: string, unit: string): number | null;

package/dist/plain/interval/intervalCountTime.js

@@ -0,0 +1,67 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getUnitSpan, resolveDateTimeUnit } from "../../internal/index.js";
+import { plainTime } from "../../regex/index.js";
+import { isValidTime, isValidTimeUnit } from "../validate/index.js";
+/**
+ * Count how many `unit` boundaries a time interval crosses.
+ *
+ * - Counts clock boundaries touched by the half-open interval `[start, end)` — distinct from
+ *   `diffTime`, which measures exact elapsed duration. An interval from 12:59 to 13:01 is two
+ *   minutes long but touches 2 hour boundaries.
+ * - The end boundary is excluded: `"12:00:00"` to `"14:00:00"` counts 2 hours.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Accepts singular or plural units (`"hour"` and `"hours"` behave identically).
+ * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
+ *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
+ *
+ * @param start ISO PlainTime string for the interval start
+ * @param end ISO PlainTime string for the interval end
+ * @param unit unit string — `"hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond"` (calendar units return null)
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountTime("12:00:00", "14:00:00", "hour") // 2
+ * @example intervalCountTime("12:30:00", "13:00:00", "hour") // 1
+ * @example intervalCountTime("12:30:00", "12:30:00", "hour") // 1 (zero-length, mid-hour)
+ * @example intervalCountTime("12:00:00", "12:00:00", "hour") // 0 (zero-length, on the boundary)
+ * @example intervalCountTime("12:00:00", "14:00:00", "day") // null
+ * @example intervalCountTime("invalid", "14:00:00", "hour") // null
+ */
+export function intervalCountTime(start, end, unit) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return null;
+    }
+    if (!plainTime.test(start) || !plainTime.test(end)) {
+        return null;
+    }
+    if (!isValidTime(start) || !isValidTime(end)) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidTimeUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        const startVal = Temporal.PlainTime.from(start);
+        const endVal = Temporal.PlainTime.from(end);
+        if (Temporal.PlainTime.compare(startVal, endVal) > 0) {
+            return null;
+        }
+        const startOfStart = startVal.round({
+            smallestUnit: resolvedUnit,
+            roundingMode: "trunc",
+        });
+        const startOfEnd = endVal.round({
+            smallestUnit: resolvedUnit,
+            roundingMode: "trunc",
+        });
+        const spanned = getUnitSpan(startOfStart.until(startOfEnd, { largestUnit: resolvedUnit }), resolvedUnit);
+        return spanned + (startOfEnd.equals(endVal) ? 0 : 1);
+    }
+    catch {
+        return null;
+    }
+}