@northguild/gmt 1.17.0 → 1.19.0

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

@@ -10,6 +10,8 @@
  *   the nearest whole day (`round(totalDays · i / n)`, computed exactly in `bigint`, an exact half
  *   rounding up) — when `totalDays` isn't evenly divisible by `n`, the resulting sub-intervals
  *   differ by at most one day rather than being mathematically exact.
+ * - When `n` is larger than the number of whole days in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
@@ -18,14 +20,11 @@
  *   carry the *same* calendar tag (or both be bare ISO); a mismatch returns `[]` (E5 decision
  *   of record D4). Internal boundaries are computed in whole days (calendar-independent), then
  *   re-formatted in the shared calendar.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @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 n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input / mismatched calendars
  *
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-05", 4) // [{ start: "2024-01-01", end: "2024-01-02" }, { start: "2024-01-02", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-05" }]
@@ -38,8 +37,24 @@
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 3, { maxPieces: 3 }) // [{ start: "2024-01-01", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-10" }]
  */
 export declare function intervalDivideEquallyDate(start: string, end: string, n: number, options?: {
+    /**
+     * The most records the result may hold. A result that would hold more, or more than the longest
+     * possible array (2^32 - 1 elements), returns `[]` and none is built. A value that is not a
+     * positive safe integer also returns `[]`.
+     *
+     * @defaultValue `1_000_000`
+     */
     maxPieces?: number;
 }): Array<{
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It can equal `start`, which
+     * makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyDate.js

@@ -15,6 +15,8 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  *   the nearest whole day (`round(totalDays · i / n)`, computed exactly in `bigint`, an exact half
  *   rounding up) — when `totalDays` isn't evenly divisible by `n`, the resulting sub-intervals
  *   differ by at most one day rather than being mathematically exact.
+ * - When `n` is larger than the number of whole days in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
@@ -23,14 +25,11 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  *   carry the *same* calendar tag (or both be bare ISO); a mismatch returns `[]` (E5 decision
  *   of record D4). Internal boundaries are computed in whole days (calendar-independent), then
  *   re-formatted in the shared calendar.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @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 n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input / mismatched calendars
  *
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-05", 4) // [{ start: "2024-01-01", end: "2024-01-02" }, { start: "2024-01-02", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-05" }]

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

@@ -10,18 +10,17 @@
  *   `bigint`: the split is exact whenever the total divides evenly by `n`, and within half a
  *   nanosecond of the exact cut otherwise (an exact half rounds up), at any span length — the
  *   whole PlainDateTime range included.
+ * - When `n` is larger than the number of nanoseconds in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
@@ -32,8 +31,24 @@
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3, { maxPieces: 3 }) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
  */
 export declare function intervalDivideEquallyDateTime(start: string, end: string, n: number, options?: {
+    /**
+     * The most records the result may hold. A result that would hold more, or more than the longest
+     * possible array (2^32 - 1 elements), returns `[]` and none is built. A value that is not a
+     * positive safe integer also returns `[]`.
+     *
+     * @defaultValue `1_000_000`
+     */
     maxPieces?: number;
 }): Array<{
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyDateTime.js

@@ -16,18 +16,17 @@ const NANOSECONDS_PER_DAY = 86400000000000n;
  *   `bigint`: the split is exact whenever the total divides evenly by `n`, and within half a
  *   nanosecond of the exact cut otherwise (an exact half rounds up), at any span length — the
  *   whole PlainDateTime range included.
+ * - When `n` is larger than the number of nanoseconds in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]

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

@@ -10,18 +10,17 @@
  *   integer nanoseconds, computed in `bigint`: the split is exact whenever the total divides
  *   evenly by `n`, and within half a nanosecond of the exact cut otherwise (an exact half rounds
  *   up).
+ * - When `n` is larger than the number of nanoseconds in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 4) // [{ start: "09:00:00", end: "11:00:00" }, { start: "11:00:00", end: "13:00:00" }, { start: "13:00:00", end: "15:00:00" }, { start: "15:00:00", end: "17:00:00" }]
@@ -33,8 +32,24 @@
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 3, { maxPieces: 3 }) // [{ start: "09:00:00", end: "11:40:00" }, { start: "11:40:00", end: "14:20:00" }, { start: "14:20:00", end: "17:00:00" }]
  */
 export declare function intervalDivideEquallyTime(start: string, end: string, n: number, options?: {
+    /**
+     * The most records the result may hold. A result that would hold more, or more than the longest
+     * possible array (2^32 - 1 elements), returns `[]` and none is built. A value that is not a
+     * positive safe integer also returns `[]`.
+     *
+     * @defaultValue `1_000_000`
+     */
     maxPieces?: number;
 }): Array<{
+    /**
+     * The clock time the interval begins at, as an ISO 8601 time string with no date, offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first clock time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyTime.js

@@ -15,18 +15,17 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  *   integer nanoseconds, computed in `bigint`: the split is exact whenever the total divides
  *   evenly by `n`, and within half a nanosecond of the exact cut otherwise (an exact half rounds
  *   up).
+ * - When `n` is larger than the number of nanoseconds in the interval, some pieces are empty (their
+ *   `start` equals their `end`): the result always has exactly `n` pieces.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
- *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
- *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 4) // [{ start: "09:00:00", end: "11:00:00" }, { start: "11:00:00", end: "13:00:00" }, { start: "13:00:00", end: "15:00:00" }, { start: "15:00:00", end: "17:00:00" }]

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

@@ -9,8 +9,6 @@ import type { Overflow } from "../../types/index.js";
  *   unlike `addDuration`. Time units count as whole 24-hour days, as Temporal's do.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDate`'s `start > end` rejection.
- * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
- *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
  * - Accepts a RFC 9557 calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
  *   is resolved in `value`'s own calendar (no `relativeTo`/pair-matching question, since there
  *   is only one calendar-tagged input) and both endpoints are re-formatted in that calendar,
@@ -22,7 +20,7 @@ import type { Overflow } from "../../types/index.js";
  * @param value ISO PlainDate string, optionally calendar-annotated
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject")
+ * @param options How an out-of-range endpoint is handled
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationDate("2024-01-01", "P1M", "start") // { start: "2024-01-01", end: "2024-02-01" }
@@ -33,8 +31,23 @@ import type { Overflow } from "../../types/index.js";
  * @example intervalFromDurationDate("2024-02-24[u-ca=hebrew]", "P1M", "start") // { start: "2024-02-24[u-ca=hebrew]", end: "2024-03-25[u-ca=hebrew]" } (Adar I -> Adar)
  */
 export declare function intervalFromDurationDate(value: string, duration: string, anchor: "start" | "end", options?: {
+    /**
+     * What to do when the computed endpoint is not a real date. `"constrain"` clamps it to the
+     * last valid day, so Jan 31 + 1 month is Feb 29 or 28; `"reject"` returns `null`.
+     *
+     * @defaultValue `"constrain"`, Temporal's default.
+     */
     overflow?: Overflow;
 }): {
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It can equal `start`, which
+     * makes the interval empty.
+     */
     end: string;
 } | null;

package/dist/plain/interval/intervalFromDurationDate.js

@@ -13,8 +13,6 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  *   unlike `addDuration`. Time units count as whole 24-hour days, as Temporal's do.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDate`'s `start > end` rejection.
- * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
- *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
  * - Accepts a RFC 9557 calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
  *   is resolved in `value`'s own calendar (no `relativeTo`/pair-matching question, since there
  *   is only one calendar-tagged input) and both endpoints are re-formatted in that calendar,
@@ -26,7 +24,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * @param value ISO PlainDate string, optionally calendar-annotated
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject")
+ * @param options How an out-of-range endpoint is handled
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationDate("2024-01-01", "P1M", "start") // { start: "2024-01-01", end: "2024-02-01" }

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

@@ -8,15 +8,13 @@ import type { Overflow } from "../../types/index.js";
  *   resolve against `value` itself — no separate `relativeTo` is needed, unlike `addDuration`.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDateTime`'s `start > end` rejection.
- * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
- *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
  * - Returns null on invalid input (unparseable `value`, invalid `duration`, or an `anchor` other
  *   than `"start"`/`"end"`).
  *
  * @param value ISO PlainDateTime string
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject")
+ * @param options How an out-of-range endpoint is handled
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationDateTime("2024-01-01T00:00:00", "P1DT2H", "start") // { start: "2024-01-01T00:00:00", end: "2024-01-02T02:00:00" }
@@ -26,8 +24,23 @@ import type { Overflow } from "../../types/index.js";
  * @example intervalFromDurationDateTime("invalid", "P1D", "start") // null
  */
 export declare function intervalFromDurationDateTime(value: string, duration: string, anchor: "start" | "end", options?: {
+    /**
+     * What to do when the computed endpoint is not a real date. `"constrain"` clamps it to the
+     * last valid day, so Jan 31 + 1 month is Feb 29 or 28; `"reject"` returns `null`.
+     *
+     * @defaultValue `"constrain"`, Temporal's default.
+     */
     overflow?: Overflow;
 }): {
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 } | null;

package/dist/plain/interval/intervalFromDurationDateTime.js

@@ -12,15 +12,13 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  *   resolve against `value` itself — no separate `relativeTo` is needed, unlike `addDuration`.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDateTime`'s `start > end` rejection.
- * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
- *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
  * - Returns null on invalid input (unparseable `value`, invalid `duration`, or an `anchor` other
  *   than `"start"`/`"end"`).
  *
  * @param value ISO PlainDateTime string
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject")
+ * @param options How an out-of-range endpoint is handled
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationDateTime("2024-01-01T00:00:00", "P1DT2H", "start") // { start: "2024-01-01T00:00:00", end: "2024-01-02T02:00:00" }

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

@@ -31,6 +31,15 @@
  * @example intervalFromDurationTime("invalid", "PT1H", "start") // null
  */
 export declare function intervalFromDurationTime(value: string, duration: string, anchor: "start" | "end"): {
+    /**
+     * The clock time the interval begins at, as an ISO 8601 time string with no date, offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first clock time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 } | null;

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

@@ -28,6 +28,15 @@
  * @example intervalIntersectionDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // null
  */
 export declare function intervalIntersectionDate(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It can equal `start`, which
+     * makes the interval empty.
+     */
     end: string;
 } | null;

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

@@ -23,6 +23,15 @@
  * @example intervalIntersectionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export declare function intervalIntersectionDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 } | null;

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

@@ -23,6 +23,15 @@
  * @example intervalIntersectionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */
 export declare function intervalIntersectionTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The clock time the interval begins at, as an ISO 8601 time string with no date, offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first clock time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 } | null;

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

@@ -14,6 +14,8 @@
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO PlainDate
  *   string, or on invalid input (unparseable start/end, `start > end`).
  * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). `start`, `end`, and
@@ -34,6 +36,15 @@
  * @example intervalSplitAtDate("2024-01-01", "2024-01-10", ["not-a-date"]) // []
  */
 export declare function intervalSplitAtDate(start: string, end: string, points: string[]): Array<{
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It can equal `start`, which
+     * makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalSplitAtDate.js

@@ -18,6 +18,8 @@ import { isValidDateInterval } from "./validate/index.js";
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO PlainDate
  *   string, or on invalid input (unparseable start/end, `start > end`).
  * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). `start`, `end`, and

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

@@ -14,6 +14,8 @@
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO
  *   PlainDateTime string, or on invalid input (unparseable start/end, `start > end`).
  *
@@ -28,6 +30,15 @@
  * @example intervalSplitAtDateTime("2024-01-01T00:00:00", "2024-01-10T00:00:00", ["not-a-datetime"]) // []
  */
 export declare function intervalSplitAtDateTime(start: string, end: string, points: string[]): Array<{
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalSplitAtDateTime.js

@@ -17,6 +17,8 @@ import { isValidDateTime } from "../validate/index.js";
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO
  *   PlainDateTime string, or on invalid input (unparseable start/end, `start > end`).
  *

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

@@ -14,6 +14,8 @@
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO PlainTime
  *   string, or on invalid input (unparseable start/end, `start > end`).
  *
@@ -30,6 +32,15 @@
  * @example intervalSplitAtTime("09:00:00", "17:00:00", ["not-a-time"]) // []
  */
 export declare function intervalSplitAtTime(start: string, end: string, points: string[]): Array<{
+    /**
+     * The clock time the interval begins at, as an ISO 8601 time string with no date, offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first clock time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It can equal
+     * `start`, which makes the interval empty.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalSplitAtTime.js

@@ -17,6 +17,8 @@ import { isValidTime } from "../validate/index.js";
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - Returns `[{ start, end }]` (the whole interval, unsplit) when no valid in-range point remains.
+ * - A piece's `end` equals its `start` only when the interval itself is zero-length (`start`
+ *   equal to `end`): the result is then that one empty piece, whatever the points.
  * - Returns `[]` when `points` is not an array, when any element is not a valid ISO PlainTime
  *   string, or on invalid input (unparseable start/end, `start > end`).
  *

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

@@ -32,6 +32,15 @@
  * @example intervalUnionDate("2024-01-01[u-ca=hebrew]", "2024-06-30", "2024-04-01", "2024-12-31") // null (mismatched calendars)
  */
 export declare function intervalUnionDate(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It is always later than
+     * `start`.
+     */
     end: string;
 } | null;

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

@@ -26,6 +26,15 @@
  * @example intervalUnionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export declare function intervalUnionDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It is always later
+     * than `start`.
+     */
     end: string;
 } | null;

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

@@ -26,6 +26,15 @@
  * @example intervalUnionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */
 export declare function intervalUnionTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {
+    /**
+     * The clock time the interval begins at, as an ISO 8601 time string with no date, offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first clock time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It is always later
+     * than `start`.
+     */
     end: string;
 } | null;

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

@@ -31,6 +31,15 @@ export declare function intervalXorAllDate(intervals: Array<{
     start: string;
     end: string;
 }>): Array<{
+    /**
+     * The date the interval begins on, as an ISO 8601 date (`YYYY-MM-DD`). It keeps a calendar
+     * annotation such as `[u-ca=hebrew]` when the inputs carry one.
+     */
     start: string;
+    /**
+     * The first date after the interval, in the same format as `start`. It is exclusive: the interval
+     * holds everything from `start` up to but not including this value. It is always later than
+     * `start`.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalXorAllDate.js

@@ -2,6 +2,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { calendarOfAllDateValues, formatDateInCalendar, halfOpenXor, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidDateInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Return the symmetric difference across a list of date intervals — the set of dates covered
  * by an odd number of the input intervals.
@@ -36,8 +37,7 @@ export function intervalXorAllDate(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             isValidDateInterval(interval.start, interval.end))) {
             return [];
         }

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

@@ -26,6 +26,15 @@ export declare function intervalXorAllDateTime(intervals: Array<{
     start: string;
     end: string;
 }>): Array<{
+    /**
+     * The date-time the interval begins at, as an ISO 8601 date-time string with no offset or time
+     * zone.
+     */
     start: string;
+    /**
+     * The first date-time after the interval, in the same format as `start`. It is exclusive: the
+     * interval holds everything from `start` up to but not including this value. It is always later
+     * than `start`.
+     */
     end: string;
 }>;