@northguild/gmt 1.14.2 → 1.16.0

package/dist/plain/interval/intervalAbutsDate.js

@@ -1,18 +1,24 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { parseCalendarDateValue } from "../../internal/index.js";
+import { halfOpenAbuts, parseCalendarDateValue } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
- * Return true when two date intervals are exactly adjacent — one's end equals the other's start
- * with zero gap and zero overlap.
+ * Return true when two half-open date intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-day step: a one-day gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Returns `true` when `aEnd + 1 day === bStart` or `bEnd + 1 day === aStart`.
  * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
  * - Returns `false` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings (as produced by `convertDateToCalendar`) —
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings (as produced by `convertDateToCalendar`) —
  *   E5 (issue #78). Comparison is by calendar-independent ordering (`Temporal.PlainDate.compare`
  *   ignores calendar), so the four endpoints may carry different or no calendar tags — E5
  *   decision of record D4 (ordering-only functions accept mixed calendars).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param aStart ISO 8601 date string for the first interval start, optionally calendar-annotated
  * @param aEnd ISO 8601 date string for the first interval end, optionally calendar-annotated
@@ -20,9 +26,9 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
- * @example intervalAbutsDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // true
- * @example intervalAbutsDate("2024-07-01", "2024-12-31", "2024-01-01", "2024-06-30") // true
- * @example intervalAbutsDate("2024-01-01", "2024-06-30", "2024-07-02", "2024-12-31") // false (gap)
+ * @example intervalAbutsDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // true
+ * @example intervalAbutsDate("2024-06-30", "2024-12-31", "2024-01-01", "2024-06-30") // true
+ * @example intervalAbutsDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // false ([01-01, 06-30) ends before 06-30)
  * @example intervalAbutsDate("2024-01-01", "2024-07-01", "2024-06-30", "2024-12-31") // false (overlap)
  * @example intervalAbutsDate("invalid", "2024-06-30", "2024-07-01", "2024-12-31") // false
  */
@@ -50,17 +56,7 @@ export function intervalAbutsDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return false;
         }
-        // aEnd + 1 day === bStart
-        const aEndPlusOne = aE.add({ days: 1 });
-        if (Temporal.PlainDate.compare(aEndPlusOne, bS) === 0) {
-            return true;
-        }
-        // bEnd + 1 day === aStart
-        const bEndPlusOne = bE.add({ days: 1 });
-        if (Temporal.PlainDate.compare(bEndPlusOne, aS) === 0) {
-            return true;
-        }
-        return false;
+        return halfOpenAbuts({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

@@ -1,9 +1,12 @@
 /**
- * Return true when two datetime intervals are exactly adjacent — one's end equals the other's
- * start with zero gap and zero overlap.
+ * Return true when two half-open datetime intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
  * - Uses `Temporal.PlainDateTime.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).
  *
@@ -13,10 +16,9 @@
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-06-30T12:00:00.000000001", "2024-12-31T17:00:00") // true
- * @example intervalAbutsDateTime("2024-06-30T12:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-06-30T12:00:00.000000001") // true
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-06-30T12:00:01", "2024-12-31T17:00:00") // false (gap)
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T13:00:00", "2024-06-30T12:00:00", "2024-12-31T17:00:00") // false (overlap)
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00.000000001", "2024-01-01T17:00:00") // false (1 ns gap)
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // false (overlap)
  * @example intervalAbutsDateTime("invalid", "2024-06-30T12:00:00", "2024-06-30T12:00:00", "2024-12-31T17:00:00") // false
  */
 export declare function intervalAbutsDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalAbutsDateTime.js

@@ -1,11 +1,16 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
+import { halfOpenAbuts } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
- * Return true when two datetime intervals are exactly adjacent — one's end equals the other's
- * start with zero gap and zero overlap.
+ * Return true when two half-open datetime intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
  * - Uses `Temporal.PlainDateTime.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).
  *
@@ -15,10 +20,9 @@ import { plainDateTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-06-30T12:00:00.000000001", "2024-12-31T17:00:00") // true
- * @example intervalAbutsDateTime("2024-06-30T12:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-06-30T12:00:00.000000001") // true
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T12:00:00", "2024-06-30T12:00:01", "2024-12-31T17:00:00") // false (gap)
- * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-06-30T13:00:00", "2024-06-30T12:00:00", "2024-12-31T17:00:00") // false (overlap)
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00.000000001", "2024-01-01T17:00:00") // false (1 ns gap)
+ * @example intervalAbutsDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // false (overlap)
  * @example intervalAbutsDateTime("invalid", "2024-06-30T12:00:00", "2024-06-30T12:00:00", "2024-12-31T17:00:00") // false
  */
 export function intervalAbutsDateTime(aStart, aEnd, bStart, bEnd) {
@@ -28,10 +32,10 @@ export function intervalAbutsDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return false;
     }
     try {
@@ -45,17 +49,7 @@ export function intervalAbutsDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return false;
         }
-        // aEnd + 1 nanosecond === bStart
-        const aEndPlusOne = aE.add({ nanoseconds: 1 });
-        if (Temporal.PlainDateTime.compare(aEndPlusOne, bS) === 0) {
-            return true;
-        }
-        // bEnd + 1 nanosecond === aStart
-        const bEndPlusOne = bE.add({ nanoseconds: 1 });
-        if (Temporal.PlainDateTime.compare(bEndPlusOne, aS) === 0) {
-            return true;
-        }
-        return false;
+        return halfOpenAbuts({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;

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

@@ -1,9 +1,14 @@
 /**
- * Return true when two time intervals are exactly adjacent — one's end equals the other's start
- * with zero gap and zero overlap.
+ * Return true when two half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
+ * - PlainTime has no day rollover: an interval ending at `23:59:59.999999999` never abuts one
+ *   starting at `00:00:00`.
  * - 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).
  *
@@ -13,10 +18,11 @@
  * @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("09:00:00", "12:00:00", "12:00:00", "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", "12:00:00", "12:00:00.000000001", "17:00:00") // false (1 ns gap)
  * @example intervalAbutsTime("09:00:00", "13:00:00", "12:00:00", "17:00:00") // false (overlap)
+ * @example intervalAbutsTime("22:00:00", "23:59:59.999999999", "00:00:00", "01:00:00") // false (no midnight wrap)
  * @example intervalAbutsTime("invalid", "12:00:00", "12:00:00", "17:00:00") // false
  */
 export declare function intervalAbutsTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalAbutsTime.js

@@ -1,11 +1,18 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainTime } from "../../regex/index.js";
+import { halfOpenAbuts } from "../../internal/index.js";
+import { isValidTime } from "../validate/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.
+ * Return true when two half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
+ * - PlainTime has no day rollover: an interval ending at `23:59:59.999999999` never abuts one
+ *   starting at `00:00:00`.
  * - 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).
  *
@@ -15,10 +22,11 @@ import { plainTime } from "../../regex/index.js";
  * @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("09:00:00", "12:00:00", "12:00:00", "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", "12:00:00", "12:00:00.000000001", "17:00:00") // false (1 ns gap)
  * @example intervalAbutsTime("09:00:00", "13:00:00", "12:00:00", "17:00:00") // false (overlap)
+ * @example intervalAbutsTime("22:00:00", "23:59:59.999999999", "00:00:00", "01:00:00") // false (no midnight wrap)
  * @example intervalAbutsTime("invalid", "12:00:00", "12:00:00", "17:00:00") // false
  */
 export function intervalAbutsTime(aStart, aEnd, bStart, bEnd) {
@@ -28,10 +36,10 @@ export function intervalAbutsTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return false;
     }
     try {
@@ -45,17 +53,7 @@ export function intervalAbutsTime(aStart, aEnd, bStart, bEnd) {
         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;
+        return halfOpenAbuts({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
     }
     catch {
         return false;

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

@@ -1,26 +1,33 @@
 /**
- * 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).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every day `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - 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
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
  *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param 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 intervalEnd ISO 8601 date string for the outer interval end (excluded), 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
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-30") // true (last value before the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31") // false (end is excluded)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-12-31") // true (inner shares the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false (reversed interval)
  */
 export declare function intervalContainsDate(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDate.js

@@ -1,30 +1,37 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { parseCalendarDateValue } from "../../internal/index.js";
+import { halfOpenContainsPoint, halfOpenContainsSpan, 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).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every day `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - 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
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
  *   calendar-independent, so arguments may carry different or no calendar tags (D4).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param 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 intervalEnd ISO 8601 date string for the outer interval end (excluded), 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
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-30") // true (last value before the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31") // false (end is excluded)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-12-31") // true (inner shares the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false (reversed interval)
  */
 export function intervalContainsDate(intervalStart, intervalEnd, pointOrStart, pointEnd) {
     if (typeof intervalStart !== "string" ||
@@ -47,15 +54,13 @@ export function intervalContainsDate(intervalStart, intervalEnd, pointOrStart, p
             return false;
         }
         if (pointEnd === undefined) {
-            return (Temporal.PlainDate.compare(s, p) <= 0 &&
-                Temporal.PlainDate.compare(p, e) <= 0);
+            return halfOpenContainsPoint({ start: s, end: e }, p, Temporal.PlainDate.compare);
         }
         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);
+        return halfOpenContainsSpan({ start: s, end: e }, { start: p, end: pe }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

@@ -1,24 +1,29 @@
 /**
- * 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).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every moment `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - 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).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 datetime string for the outer interval start
- * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @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
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (end is excluded)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (inner shares the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsDateTime("2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T12:00:00") // false (reversed interval)
  */
 export declare function intervalContainsDateTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDateTime.js

@@ -1,27 +1,33 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
+import { halfOpenContainsPoint, halfOpenContainsSpan } from "../../internal/index.js";
+import { isValidDateTime } 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).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every moment `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - 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).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 datetime string for the outer interval start
- * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @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
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (end is excluded)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (inner shares the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsDateTime("2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T12:00:00") // false (reversed interval)
  */
 export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStart, pointEnd) {
     if (typeof intervalStart !== "string" ||
@@ -30,10 +36,10 @@ export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStar
         (pointEnd !== undefined && typeof pointEnd !== "string")) {
         return false;
     }
-    if (!plainDateTime.test(intervalStart) ||
-        !plainDateTime.test(intervalEnd) ||
-        !plainDateTime.test(pointOrStart) ||
-        (pointEnd !== undefined && !plainDateTime.test(pointEnd))) {
+    if (!isValidDateTime(intervalStart) ||
+        !isValidDateTime(intervalEnd) ||
+        !isValidDateTime(pointOrStart) ||
+        (pointEnd !== undefined && !isValidDateTime(pointEnd))) {
         return false;
     }
     try {
@@ -44,15 +50,13 @@ export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStar
             return false;
         }
         if (pointEnd === undefined) {
-            return (Temporal.PlainDateTime.compare(s, p) <= 0 &&
-                Temporal.PlainDateTime.compare(p, e) <= 0);
+            return halfOpenContainsPoint({ start: s, end: e }, p, Temporal.PlainDateTime.compare);
         }
         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);
+        return halfOpenContainsSpan({ start: s, end: e }, { start: p, end: pe }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;

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

@@ -1,24 +1,34 @@
 /**
- * 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).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every clock time `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
+ * - PlainTime has no day rollover: an interval never wraps past midnight. And because `end` is
+ *   excluded, no interval *contains* `23:59:59.999999999` — containing it would need an `end`
+ *   greater than it, and no PlainTime is. An interval may still *have* it as its `end`:
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:00:00")` is `true`, while
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:59:59.999999999")` is `false`.
  * - 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).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 time string for the outer interval start
- * @param intervalEnd ISO 8601 time string for the outer interval end
+ * @param intervalEnd ISO 8601 time string for the outer interval end (excluded)
  * @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
+ * @example intervalContainsTime("09:00:00", "17:00:00", "16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00") // false (end is excluded)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // true (inner shares the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00", "17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false (reversed interval)
  */
 export declare function intervalContainsTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;