@northguild/gmt 1.14.2

package/dist/utc/get/getUtcMonth.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the current month from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 2 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current month string (zero-padded to 2 digits) or "" on failure
+ *
+ * @example getUtcMonth() // "02"
+ * @example getUtcMonth() // "" (on failure)
+ */
+export function getUtcMonth() {
+    try {
+        return Temporal.Now.instant()
+            .toZonedDateTimeISO("UTC")
+            .month.toString()
+            .padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/getUtcNanosecond.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the current nanosecond from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 3 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current nanosecond string (zero-padded to 3 digits) or "" on failure
+ *
+ * @example getUtcNanosecond() // "789"
+ * @example getUtcNanosecond() // "" (on failure)
+ */
+export declare function getUtcNanosecond(): string;

package/dist/utc/get/getUtcNanosecond.js

@@ -0,0 +1,23 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the current nanosecond from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 3 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current nanosecond string (zero-padded to 3 digits) or "" on failure
+ *
+ * @example getUtcNanosecond() // "789"
+ * @example getUtcNanosecond() // "" (on failure)
+ */
+export function getUtcNanosecond() {
+    try {
+        return (Temporal.Now.instant().toZonedDateTimeISO("UTC").nanosecond ?? 0)
+            .toString()
+            .padStart(3, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/getUtcNow.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Return the current UTC instant as an ISO Instant string.
+ *
+ * - Uses Temporal.Now.instant() to get current UTC time.
+ * - Returns "" on failure.
+ *
+ * @returns ISO Instant string (e.g. "2024-02-29T00:00:00Z") or "" on failure
+ *
+ * @example getUtcNow() // "2024-02-29T00:00:00Z"
+ * @example getUtcNow() // "" (on failure)
+ */
+export declare function getUtcNow(): string;

package/dist/utc/get/getUtcNow.js

@@ -0,0 +1,20 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the current UTC instant as an ISO Instant string.
+ *
+ * - Uses Temporal.Now.instant() to get current UTC time.
+ * - Returns "" on failure.
+ *
+ * @returns ISO Instant string (e.g. "2024-02-29T00:00:00Z") or "" on failure
+ *
+ * @example getUtcNow() // "2024-02-29T00:00:00Z"
+ * @example getUtcNow() // "" (on failure)
+ */
+export function getUtcNow() {
+    try {
+        return Temporal.Now.instant().toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/getUtcNowUnit.d.ts

@@ -0,0 +1,18 @@
+import type { DateTimeUnit } from "../../types/index.js";
+type UtcNowUnit = DateTimeUnit | "dayOfWeek";
+/**
+ * Return the requested unit value from the current UTC instant.
+ *
+ * - Valid units: "year", "month", "week", "day", "dayOfWeek", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Uses Temporal.Now.instant() converted to UTC.
+ * - Returns "" on invalid unit or failure.
+ *
+ * @param unit unit to extract from current utc instant
+ * @returns string representation of the requested unit or "" on invalid
+ *
+ * @example getUtcNowUnit("year") // "2024"
+ * @example getUtcNowUnit("month") // "02"
+ * @example getUtcNowUnit("invalid") // ""
+ */
+export declare function getUtcNowUnit(unit: UtcNowUnit): string;
+export {};

package/dist/utc/get/getUtcNowUnit.js

@@ -0,0 +1,61 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTimeUnit } from "../../plain/validate/index.js";
+function isValidUtcNowUnit(unit) {
+    return isValidDateTimeUnit(unit) || ["dayOfWeek"].includes(unit);
+}
+/**
+ * Return the requested unit value from the current UTC instant.
+ *
+ * - Valid units: "year", "month", "week", "day", "dayOfWeek", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Uses Temporal.Now.instant() converted to UTC.
+ * - Returns "" on invalid unit or failure.
+ *
+ * @param unit unit to extract from current utc instant
+ * @returns string representation of the requested unit or "" on invalid
+ *
+ * @example getUtcNowUnit("year") // "2024"
+ * @example getUtcNowUnit("month") // "02"
+ * @example getUtcNowUnit("invalid") // ""
+ */
+export function getUtcNowUnit(unit) {
+    if (!isValidUtcNowUnit(String(unit ?? "")))
+        return "";
+    try {
+        const now = Temporal.Now.instant().toZonedDateTimeISO("UTC");
+        const plainDateTime = now.toPlainDateTime();
+        const plainDate = Temporal.PlainDate.from({
+            year: plainDateTime.year,
+            month: plainDateTime.month,
+            day: plainDateTime.day,
+        });
+        switch (unit) {
+            case "year":
+                return plainDateTime.year.toString();
+            case "month":
+                return plainDateTime.month.toString().padStart(2, "0");
+            case "week":
+                return (plainDate.weekOfYear ?? 0).toString();
+            case "day":
+                return plainDateTime.day.toString().padStart(2, "0");
+            case "dayOfWeek":
+                return now.dayOfWeek.toString();
+            case "hour":
+                return plainDateTime.hour.toString().padStart(2, "0");
+            case "minute":
+                return plainDateTime.minute.toString().padStart(2, "0");
+            case "second":
+                return plainDateTime.second.toString().padStart(2, "0");
+            case "millisecond":
+                return plainDateTime.millisecond.toString().padStart(3, "0");
+            case "microsecond":
+                return (plainDateTime.microsecond ?? 0).toString().padStart(3, "0");
+            case "nanosecond":
+                return (plainDateTime.nanosecond ?? 0).toString().padStart(3, "0");
+            default:
+                return "";
+        }
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/getUtcSecond.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the current second from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 2 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current second string (zero-padded to 2 digits) or "" on failure
+ *
+ * @example getUtcSecond() // "45"
+ * @example getUtcSecond() // "" (on failure)
+ */
+export declare function getUtcSecond(): string;

package/dist/utc/get/getUtcSecond.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the current second from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 2 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current second string (zero-padded to 2 digits) or "" on failure
+ *
+ * @example getUtcSecond() // "45"
+ * @example getUtcSecond() // "" (on failure)
+ */
+export function getUtcSecond() {
+    try {
+        return Temporal.Now.instant()
+            .toZonedDateTimeISO("UTC")
+            .second.toString()
+            .padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/getUtcYear.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the current year from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 4 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current year string (zero-padded to 4 digits) or "" on failure
+ *
+ * @example getUtcYear() // "2024"
+ * @example getUtcYear() // "" (on failure)
+ */
+export declare function getUtcYear(): string;

package/dist/utc/get/getUtcYear.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the current year from UTC as a zero-padded string.
+ *
+ * - Uses Temporal.Now.instant() converted to UTC zoned date time.
+ * - Returns zero-padded string to 4 digits.
+ * - Returns "" on failure.
+ *
+ * @returns current year string (zero-padded to 4 digits) or "" on failure
+ *
+ * @example getUtcYear() // "2024"
+ * @example getUtcYear() // "" (on failure)
+ */
+export function getUtcYear() {
+    try {
+        return Temporal.Now.instant()
+            .toZonedDateTimeISO("UTC")
+            .year.toString()
+            .padStart(4, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utc/get/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./getUtcDay.js";
+export * from "./getUtcHour.js";
+export * from "./getUtcMicrosecond.js";
+export * from "./getUtcMillisecond.js";
+export * from "./getUtcMinute.js";
+export * from "./getUtcMonth.js";
+export * from "./getUtcNanosecond.js";
+export * from "./getUtcNow.js";
+export * from "./getUtcNowUnit.js";
+export * from "./getUtcSecond.js";
+export * from "./getUtcYear.js";

package/dist/utc/get/index.js

@@ -0,0 +1,11 @@
+export * from "./getUtcDay.js";
+export * from "./getUtcHour.js";
+export * from "./getUtcMicrosecond.js";
+export * from "./getUtcMillisecond.js";
+export * from "./getUtcMinute.js";
+export * from "./getUtcMonth.js";
+export * from "./getUtcNanosecond.js";
+export * from "./getUtcNow.js";
+export * from "./getUtcNowUnit.js";
+export * from "./getUtcSecond.js";
+export * from "./getUtcYear.js";

package/dist/utc/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./calculate/index.js";
+export * from "./chop/index.js";
+export * from "./compare/index.js";
+export * from "./convert/index.js";
+export * from "./format/index.js";
+export * from "./get/index.js";
+export * from "./interval/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/utc/index.js

@@ -0,0 +1,9 @@
+export * from "./calculate/index.js";
+export * from "./chop/index.js";
+export * from "./compare/index.js";
+export * from "./convert/index.js";
+export * from "./format/index.js";
+export * from "./get/index.js";
+export * from "./interval/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/utc/interval/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./intervalAbutsUtc.js";
+export * from "./intervalContainsUtc.js";
+export * from "./intervalCountUtc.js";
+export * from "./intervalDifferenceUtc.js";
+export * from "./intervalDivideEquallyUtc.js";
+export * from "./intervalEngulfsUtc.js";
+export * from "./intervalFromDurationUtc.js";
+export * from "./intervalIntersectionUtc.js";
+export * from "./intervalLengthUtc.js";
+export * from "./intervalOverlappingDaysUtc.js";
+export * from "./intervalsOverlapUtc.js";
+export * from "./intervalSplitAtUtc.js";
+export * from "./intervalUnionUtc.js";
+export * from "./intervalXorAllUtc.js";
+export * from "./intervalXorUtc.js";
+export * from "./mergeIntervalsUtc.js";
+export * from "./splitIntervalByUnitUtc.js";
+export * from "./validate/index.js";

package/dist/utc/interval/index.js

@@ -0,0 +1,18 @@
+export * from "./intervalAbutsUtc.js";
+export * from "./intervalContainsUtc.js";
+export * from "./intervalCountUtc.js";
+export * from "./intervalDifferenceUtc.js";
+export * from "./intervalDivideEquallyUtc.js";
+export * from "./intervalEngulfsUtc.js";
+export * from "./intervalFromDurationUtc.js";
+export * from "./intervalIntersectionUtc.js";
+export * from "./intervalLengthUtc.js";
+export * from "./intervalOverlappingDaysUtc.js";
+export * from "./intervalsOverlapUtc.js";
+export * from "./intervalSplitAtUtc.js";
+export * from "./intervalUnionUtc.js";
+export * from "./intervalXorAllUtc.js";
+export * from "./intervalXorUtc.js";
+export * from "./mergeIntervalsUtc.js";
+export * from "./splitIntervalByUnitUtc.js";
+export * from "./validate/index.js";

package/dist/utc/interval/intervalAbutsUtc.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Return true when two UTC intervals are exactly adjacent — one's end equals the other's
+ * start with zero gap and zero overlap.
+ *
+ * - Uses `Temporal.Instant.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, leap seconds).
+ *
+ * @param aStart ISO 8601 UTC datetime string for the first interval start
+ * @param aEnd ISO 8601 UTC datetime string for the first interval end
+ * @param bStart ISO 8601 UTC datetime string for the second interval start
+ * @param bEnd ISO 8601 UTC datetime string for the second interval end
+ * @returns true if intervals are exactly adjacent, or false on invalid input
+ *
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-06-30T12:00:00.000000001Z", "2024-12-31T17:00:00Z") // true
+ * @example intervalAbutsUtc("2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z", "2024-01-01T09:00:00Z", "2024-06-30T12:00:00.000000001Z") // true
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-06-30T12:00:01Z", "2024-12-31T17:00:00Z") // false (gap)
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T13:00:00Z", "2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z") // false (overlap)
+ * @example intervalAbutsUtc("invalid", "2024-06-30T12:00:00Z", "2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z") // false
+ */
+export declare function intervalAbutsUtc(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/utc/interval/intervalAbutsUtc.js

@@ -0,0 +1,70 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { utcDateTime } from "../../regex/utc-date-time.js";
+/**
+ * Return true when two UTC intervals are exactly adjacent — one's end equals the other's
+ * start with zero gap and zero overlap.
+ *
+ * - Uses `Temporal.Instant.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, leap seconds).
+ *
+ * @param aStart ISO 8601 UTC datetime string for the first interval start
+ * @param aEnd ISO 8601 UTC datetime string for the first interval end
+ * @param bStart ISO 8601 UTC datetime string for the second interval start
+ * @param bEnd ISO 8601 UTC datetime string for the second interval end
+ * @returns true if intervals are exactly adjacent, or false on invalid input
+ *
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-06-30T12:00:00.000000001Z", "2024-12-31T17:00:00Z") // true
+ * @example intervalAbutsUtc("2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z", "2024-01-01T09:00:00Z", "2024-06-30T12:00:00.000000001Z") // true
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-06-30T12:00:01Z", "2024-12-31T17:00:00Z") // false (gap)
+ * @example intervalAbutsUtc("2024-01-01T09:00:00Z", "2024-06-30T13:00:00Z", "2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z") // false (overlap)
+ * @example intervalAbutsUtc("invalid", "2024-06-30T12:00:00Z", "2024-06-30T12:00:00Z", "2024-12-31T17:00:00Z") // false
+ */
+export function intervalAbutsUtc(aStart, aEnd, bStart, bEnd) {
+    if (typeof aStart !== "string" ||
+        typeof aEnd !== "string" ||
+        typeof bStart !== "string" ||
+        typeof bEnd !== "string") {
+        return false;
+    }
+    if (!utcDateTime.test(aStart) ||
+        !utcDateTime.test(aEnd) ||
+        !utcDateTime.test(bStart) ||
+        !utcDateTime.test(bEnd)) {
+        return false;
+    }
+    if (isLeapSecond(aStart) ||
+        isLeapSecond(aEnd) ||
+        isLeapSecond(bStart) ||
+        isLeapSecond(bEnd)) {
+        return false;
+    }
+    try {
+        const aS = Temporal.Instant.from(aStart);
+        const aE = Temporal.Instant.from(aEnd);
+        const bS = Temporal.Instant.from(bStart);
+        const bE = Temporal.Instant.from(bEnd);
+        if (Temporal.Instant.compare(aS, aE) > 0) {
+            return false;
+        }
+        if (Temporal.Instant.compare(bS, bE) > 0) {
+            return false;
+        }
+        // aEnd + 1 nanosecond === bStart
+        const aEndPlusOne = aE.add({ nanoseconds: 1 });
+        if (Temporal.Instant.compare(aEndPlusOne, bS) === 0) {
+            return true;
+        }
+        // bEnd + 1 nanosecond === aStart
+        const bEndPlusOne = bE.add({ nanoseconds: 1 });
+        if (Temporal.Instant.compare(bEndPlusOne, aS) === 0) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utc/interval/intervalContainsUtc.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.Instant.compare` for comparison (same instant semantics).
+ * - 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 UTC datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 UTC datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 UTC datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 UTC 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 intervalContainsUtc("2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z") // true
+ * @example intervalContainsUtc("2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z", "2024-07-15T12:00:00Z") // true
+ * @example intervalContainsUtc("2024-12-31T23:59:59Z", "2024-01-01T00:00:00Z", "2024-06-15T12:00:00Z") // false
+ * @example intervalContainsUtc("invalid", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z") // false
+ */
+export declare function intervalContainsUtc(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/utc/interval/intervalContainsUtc.js

@@ -0,0 +1,66 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { utcDateTime } from "../../regex/utc-date-time.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.Instant.compare` for comparison (same instant semantics).
+ * - 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 UTC datetime string for the outer interval start
+ * @param intervalEnd ISO 8601 UTC datetime string for the outer interval end
+ * @param pointOrStart ISO 8601 UTC datetime string for the point (3-arg) or inner start (4-arg)
+ * @param pointEnd optional ISO 8601 UTC 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 intervalContainsUtc("2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z") // true
+ * @example intervalContainsUtc("2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z", "2024-07-15T12:00:00Z") // true
+ * @example intervalContainsUtc("2024-12-31T23:59:59Z", "2024-01-01T00:00:00Z", "2024-06-15T12:00:00Z") // false
+ * @example intervalContainsUtc("invalid", "2024-12-31T23:59:59Z", "2024-06-15T12:00:00Z") // false
+ */
+export function intervalContainsUtc(intervalStart, intervalEnd, pointOrStart, pointEnd) {
+    if (typeof intervalStart !== "string" ||
+        typeof intervalEnd !== "string" ||
+        typeof pointOrStart !== "string" ||
+        (pointEnd !== undefined && typeof pointEnd !== "string")) {
+        return false;
+    }
+    if (!utcDateTime.test(intervalStart) ||
+        !utcDateTime.test(intervalEnd) ||
+        !utcDateTime.test(pointOrStart) ||
+        (pointEnd !== undefined && !utcDateTime.test(pointEnd))) {
+        return false;
+    }
+    if (isLeapSecond(intervalStart) ||
+        isLeapSecond(intervalEnd) ||
+        isLeapSecond(pointOrStart) ||
+        (pointEnd !== undefined && isLeapSecond(pointEnd))) {
+        return false;
+    }
+    try {
+        const startInstant = Temporal.Instant.from(intervalStart);
+        const endInstant = Temporal.Instant.from(intervalEnd);
+        const pointInstant = Temporal.Instant.from(pointOrStart);
+        if (Temporal.Instant.compare(startInstant, endInstant) > 0) {
+            return false;
+        }
+        if (pointEnd === undefined) {
+            return (Temporal.Instant.compare(startInstant, pointInstant) <= 0 &&
+                Temporal.Instant.compare(pointInstant, endInstant) <= 0);
+        }
+        const endPointInstant = Temporal.Instant.from(pointEnd);
+        if (Temporal.Instant.compare(pointInstant, endPointInstant) > 0) {
+            return false;
+        }
+        return (Temporal.Instant.compare(startInstant, pointInstant) <= 0 &&
+            Temporal.Instant.compare(endPointInstant, endInstant) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utc/interval/intervalCountUtc.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Count how many `unit` boundaries a UTC interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffUtc`, 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: midnight to midnight two days later counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Boundaries are UTC boundaries — no DST is involved.
+ * - 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,
+ *   leap-second strings).
+ *
+ * @param start ISO UTC datetime string for the interval start
+ * @param end ISO UTC datetime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountUtc("2024-01-01T23:59:00Z", "2024-01-02T00:01:00Z", "day") // 2
+ * @example intervalCountUtc("2024-01-01T00:00:00Z", "2024-01-03T00:00:00Z", "day") // 2
+ * @example intervalCountUtc("2024-01-15T00:00:00Z", "2024-03-10T00:00:00Z", "month") // 3
+ * @example intervalCountUtc("2024-01-01T05:00:00Z", "2024-01-01T05:00:00Z", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountUtc("2024-01-01T00:00:00Z", "2024-01-01T00:00:00Z", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountUtc("invalid", "2024-01-02T00:00:00Z", "day") // null
+ */
+export declare function intervalCountUtc(start: string, end: string, unit: string): number | null;

package/dist/utc/interval/intervalCountUtc.js

@@ -0,0 +1,68 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { getStartOfZonedUnit, getUnitSpan, resolveDateTimeUnit, } from "../../internal/index.js";
+import { isValidDateTimeUnit } from "../../plain/validate/index.js";
+import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { utcDateTime } from "../../regex/utc-date-time.js";
+import { isValidUtc } from "../validate/isValidUtc.js";
+/**
+ * Count how many `unit` boundaries a UTC interval crosses.
+ *
+ * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
+ *   from `diffUtc`, 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: midnight to midnight two days later counts 2 days.
+ * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
+ *   unit boundary.
+ * - Boundaries are UTC boundaries — no DST is involved.
+ * - 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,
+ *   leap-second strings).
+ *
+ * @param start ISO UTC datetime string for the interval start
+ * @param end ISO UTC datetime string for the interval end
+ * @param unit unit string — any `DateTimeUnit`
+ * @returns number of unit boundaries touched, or null on invalid input
+ *
+ * @example intervalCountUtc("2024-01-01T23:59:00Z", "2024-01-02T00:01:00Z", "day") // 2
+ * @example intervalCountUtc("2024-01-01T00:00:00Z", "2024-01-03T00:00:00Z", "day") // 2
+ * @example intervalCountUtc("2024-01-15T00:00:00Z", "2024-03-10T00:00:00Z", "month") // 3
+ * @example intervalCountUtc("2024-01-01T05:00:00Z", "2024-01-01T05:00:00Z", "day") // 1 (zero-length, mid-day)
+ * @example intervalCountUtc("2024-01-01T00:00:00Z", "2024-01-01T00:00:00Z", "day") // 0 (zero-length, on the boundary)
+ * @example intervalCountUtc("invalid", "2024-01-02T00:00:00Z", "day") // null
+ */
+export function intervalCountUtc(start, end, unit) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return null;
+    }
+    if (!utcDateTime.test(start) || !utcDateTime.test(end)) {
+        return null;
+    }
+    if (isLeapSecond(start) || isLeapSecond(end)) {
+        return null;
+    }
+    if (!isValidUtc(start) || !isValidUtc(end)) {
+        return null;
+    }
+    if (typeof unit !== "string") {
+        return null;
+    }
+    const resolvedUnit = resolveDateTimeUnit(unit);
+    if (!isValidDateTimeUnit(resolvedUnit)) {
+        return null;
+    }
+    try {
+        const startVal = Temporal.Instant.from(start).toZonedDateTimeISO("UTC");
+        const endVal = Temporal.Instant.from(end).toZonedDateTimeISO("UTC");
+        if (Temporal.ZonedDateTime.compare(startVal, endVal) > 0) {
+            return null;
+        }
+        const startOfStart = getStartOfZonedUnit(startVal, resolvedUnit);
+        const startOfEnd = getStartOfZonedUnit(endVal, resolvedUnit);
+        const spanned = getUnitSpan(startOfStart.until(startOfEnd, { largestUnit: resolvedUnit }), resolvedUnit);
+        return spanned + (startOfEnd.equals(endVal) ? 0 : 1);
+    }
+    catch {
+        return null;
+    }
+}