@northguild/gmt 1.17.0 → 1.19.0

package/dist/plain/interval/intervalXorAllDateTime.js

@@ -1,6 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { halfOpenXor } from "../../internal/index.js";
 import { isValidDateTimeInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Return the symmetric difference across a list of datetime intervals — the set of instants
  * covered by an odd number of the input intervals.
@@ -30,8 +31,7 @@ export function intervalXorAllDateTime(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             isValidDateTimeInterval(interval.start, interval.end))) {
             return [];
         }

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

@@ -27,6 +27,15 @@ export declare function intervalXorAllTime(intervals: Array<{
     start: string;
     end: 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 is always later
+     * than `start`.
+     */
     end: string;
 }>;

package/dist/plain/interval/intervalXorAllTime.js

@@ -1,6 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { halfOpenXor } from "../../internal/index.js";
 import { isValidTimeInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Return the symmetric difference across a list of time intervals — the set of clock times
  * covered by an odd number of the input intervals.
@@ -31,8 +32,7 @@ export function intervalXorAllTime(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             isValidTimeInterval(interval.start, interval.end))) {
             return [];
         }

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

@@ -26,6 +26,15 @@
  * @example intervalXorDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // []
  */
 export declare function intervalXorDate(aStart: string, aEnd: string, bStart: string, bEnd: 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/intervalXorDateTime.d.ts

@@ -22,6 +22,15 @@
  * @example intervalXorDateTime("invalid", "2024-06-30T12:00:00", "2024-07-01T13:00:00", "2024-12-31T17:00:00") // []
  */
 export declare function intervalXorDateTime(aStart: string, aEnd: string, bStart: string, bEnd: 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;
 }>;

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

@@ -22,6 +22,15 @@
  * @example intervalXorTime("invalid", "12:00:00", "13:00:00", "17:00:00") // []
  */
 export declare function intervalXorTime(aStart: string, aEnd: string, bStart: string, bEnd: 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 is always later
+     * than `start`.
+     */
     end: string;
 }>;

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

@@ -30,6 +30,15 @@ export declare function mergeIntervalsDate(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/mergeIntervalsDate.js

@@ -1,6 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { calendarOfAllDateValues, formatDateInCalendar, halfOpenMerge, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidDateInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Collapse a list of date intervals into the minimum set of non-overlapping intervals.
  *
@@ -34,8 +35,7 @@ export function mergeIntervalsDate(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/mergeIntervalsDateTime.d.ts

@@ -25,6 +25,15 @@ export declare function mergeIntervalsDateTime(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;
 }>;

package/dist/plain/interval/mergeIntervalsDateTime.js

@@ -1,6 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { halfOpenMerge } from "../../internal/index.js";
 import { isValidDateTimeInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Collapse a list of datetime intervals into the minimum set of non-overlapping intervals.
  *
@@ -29,8 +30,7 @@ export function mergeIntervalsDateTime(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             isValidDateTimeInterval(interval.start, interval.end))) {
             return [];
         }

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

@@ -25,6 +25,15 @@ export declare function mergeIntervalsTime(intervals: Array<{
     start: string;
     end: 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 is always later
+     * than `start`.
+     */
     end: string;
 }>;

package/dist/plain/interval/mergeIntervalsTime.js

@@ -1,6 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { halfOpenMerge } from "../../internal/index.js";
 import { isValidTimeInterval } from "./validate/index.js";
+import { isObject } from "../../internal/isObject.js";
 /**
  * Collapse a list of time intervals into the minimum set of non-overlapping intervals.
  *
@@ -29,8 +30,7 @@ export function mergeIntervalsTime(intervals) {
         if (!Array.isArray(intervals) || intervals.length === 0) {
             return [];
         }
-        if (!intervals.every((interval) => interval &&
-            typeof interval === "object" &&
+        if (!intervals.every((interval) => isObject(interval) &&
             isValidTimeInterval(interval.start, interval.end))) {
             return [];
         }

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

@@ -7,9 +7,12 @@
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
- * - Each boundary is computed from `start` (`start + k × amount`, as Temporal and Luxon's
- *   `Interval.splitBy` do), not by stepping from the previous boundary, so month-end starts
- *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - Each boundary is computed from `start` (`start + k × amount`), not by stepping from the
+ *   previous boundary, so month-end starts don't drift: a monthly split from January 31 lands
+ *   on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks to
+ *   the month's last day, and stepping from that boundary would keep the shortened day
+ *   (February 29, then March 29).
+ * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
  * - A step that resolves to the same date as the previous boundary is skipped, so no empty
  *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
@@ -22,9 +25,6 @@
  *   when `CalendarEquals` is false (before 1.16.0 it stepped in ISO). Each boundary's tag is
  *   re-derived from the actual stepped date, never copied — a month-by-month step can cross a
  *   leap-month or era boundary mid-split.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping where it can be, and
- *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
  *   calendar ids); see `isValidCalendarDate`.
  *
@@ -32,7 +32,7 @@
  * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
  * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
@@ -45,8 +45,24 @@
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2, { maxPieces: 5 }) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
  */
 export declare function splitIntervalByUnitDate(start: string, end: string, unit: string, amount: 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/splitIntervalByUnitDate.js

@@ -13,9 +13,12 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  *   there, so the pieces share no value and together cover the interval exactly once (the rule
  *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
- * - Each boundary is computed from `start` (`start + k × amount`, as Temporal and Luxon's
- *   `Interval.splitBy` do), not by stepping from the previous boundary, so month-end starts
- *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - Each boundary is computed from `start` (`start + k × amount`), not by stepping from the
+ *   previous boundary, so month-end starts don't drift: a monthly split from January 31 lands
+ *   on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks to
+ *   the month's last day, and stepping from that boundary would keep the shortened day
+ *   (February 29, then March 29).
+ * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
  * - A step that resolves to the same date as the previous boundary is skipped, so no empty
  *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
@@ -28,9 +31,6 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  *   when `CalendarEquals` is false (before 1.16.0 it stepped in ISO). Each boundary's tag is
  *   re-derived from the actual stepped date, never copied — a month-by-month step can cross a
  *   leap-month or era boundary mid-split.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping where it can be, and
- *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
  *   calendar ids); see `isValidCalendarDate`.
  *
@@ -38,7 +38,7 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
  * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]

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

@@ -8,8 +8,11 @@
  *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
  * - Calendar-unit boundaries (years, months, weeks, days) are computed from `start`
- *   (`start + k × amount`, as Temporal and Luxon's `Interval.splitBy` do), so month-end starts
- *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ *   (`start + k × amount`), so month-end starts don't drift: a monthly split from January 31
+ *   lands on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks
+ *   to the month's last day, and stepping from that boundary would keep the shortened day
+ *   (February 29, then March 29).
+ * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
  * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
  *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
  *   `Number.MAX_SAFE_INTEGER`.
@@ -17,15 +20,12 @@
  *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping where it can be, and
- *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param unit duration unit string — any `DateTimeDurationUnit`
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
@@ -37,8 +37,24 @@
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1, { maxPieces: 2 }) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
  */
 export declare function splitIntervalByUnitDateTime(start: string, end: string, unit: string, amount: 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/splitIntervalByUnitDateTime.js

@@ -14,8 +14,11 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
  * - Calendar-unit boundaries (years, months, weeks, days) are computed from `start`
- *   (`start + k × amount`, as Temporal and Luxon's `Interval.splitBy` do), so month-end starts
- *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ *   (`start + k × amount`), so month-end starts don't drift: a monthly split from January 31
+ *   lands on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks
+ *   to the month's last day, and stepping from that boundary would keep the shortened day
+ *   (February 29, then March 29).
+ * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
  * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
  *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
  *   `Number.MAX_SAFE_INTEGER`.
@@ -23,15 +26,12 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping where it can be, and
- *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param unit duration unit string — any `DateTimeDurationUnit`
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]

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

@@ -13,15 +13,12 @@
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping. An invalid
- *   `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param unit duration unit string — `"hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds"` (calendar units are ignored by PlainTime and return [])
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }]
@@ -34,8 +31,24 @@
  * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1, { maxPieces: 3 }) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
  */
 export declare function splitIntervalByUnitTime(start: string, end: string, unit: string, amount: 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/splitIntervalByUnitTime.js

@@ -19,15 +19,12 @@ import { isExactDurationUnit, minSlicesForSpan, } from "../../internal/splitStep
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
- *   into more slices returns `[]`, decided from the span before stepping. An invalid
- *   `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param unit duration unit string — `"hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds"` (calendar units are ignored by PlainTime and return [])
  * @param amount positive number of units per step
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }]

package/dist/plain/map/mapDatesInRange.d.ts

@@ -3,9 +3,6 @@
  *
  * - Generates dates with optional step (default 1 day).
  * - Returns [] if start > end, invalid inputs, or step <= 0.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when the
- *   range holds more dates than that, it returns `[]` without generating any. An invalid
- *   `maxPieces` also returns `[]`.
  * - An explicit `undefined` `stepDays` is the default step, so `(start, end, undefined, options)`
  *   reaches `options`. **Compatibility:** before 1.16.0 it returned `[]`.
  * - **End-inclusive, where the `interval*` functions are half-open.** This enumerates the dates a
@@ -17,7 +14,7 @@
  * @param startDate ISO PlainDate string for the first date
  * @param endDate ISO PlainDate string for the last date (inclusive)
  * @param stepDays optional number of days to step between results
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of ISO PlainDate strings, or [] on invalid input
  *
  * @example mapDatesInRange("2024-03-01", "2024-03-05") // ["2024-03-01", "2024-03-02", "2024-03-03", "2024-03-04", "2024-03-05"]
@@ -32,5 +29,12 @@
  * @example mapDatesInRange("2024-03-01", "2024-03-05", 1, { maxPieces: 10 }) // ["2024-03-01", "2024-03-02", "2024-03-03", "2024-03-04", "2024-03-05"]
  */
 export declare function mapDatesInRange(startDate: string, endDate: string, stepDays?: number, options?: {
+    /**
+     * The most dates 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;
 }): string[];

package/dist/plain/map/mapDatesInRange.js

@@ -7,9 +7,6 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  *
  * - Generates dates with optional step (default 1 day).
  * - Returns [] if start > end, invalid inputs, or step <= 0.
- * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when the
- *   range holds more dates than that, it returns `[]` without generating any. An invalid
- *   `maxPieces` also returns `[]`.
  * - An explicit `undefined` `stepDays` is the default step, so `(start, end, undefined, options)`
  *   reaches `options`. **Compatibility:** before 1.16.0 it returned `[]`.
  * - **End-inclusive, where the `interval*` functions are half-open.** This enumerates the dates a
@@ -21,7 +18,7 @@ import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js
  * @param startDate ISO PlainDate string for the first date
  * @param endDate ISO PlainDate string for the last date (inclusive)
  * @param stepDays optional number of days to step between results
- * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
+ * @param options The limit on the size of the result
  * @returns array of ISO PlainDate strings, or [] on invalid input
  *
  * @example mapDatesInRange("2024-03-01", "2024-03-05") // ["2024-03-01", "2024-03-02", "2024-03-03", "2024-03-04", "2024-03-05"]

package/dist/plain/parse/index.d.ts

@@ -18,7 +18,7 @@ export * from "./parseNanosecondFromDateTime.js";
 export * from "./parseNanosecondFromTime.js";
 export * from "./parseSecondFromDateTime.js";
 export * from "./parseSecondFromTime.js";
-export * from "./parseSql.js";
+export * from "./parseSqlDateTime.js";
 export * from "./parseTimeWithPattern.js";
 export * from "./parseUnitFromDate.js";
 export * from "./parseUnitFromDateTime.js";

package/dist/plain/parse/index.js

@@ -18,7 +18,7 @@ export * from "./parseNanosecondFromDateTime.js";
 export * from "./parseNanosecondFromTime.js";
 export * from "./parseSecondFromDateTime.js";
 export * from "./parseSecondFromTime.js";
-export * from "./parseSql.js";
+export * from "./parseSqlDateTime.js";
 export * from "./parseTimeWithPattern.js";
 export * from "./parseUnitFromDate.js";
 export * from "./parseUnitFromDateTime.js";

package/dist/plain/parse/parseDateTimeWithPattern.d.ts

@@ -1,3 +1,4 @@
+import type { TwoDigitYearOptions } from "../../types/two-digit-year.js";
 /**
  * Parse a datetime string against a caller-supplied token pattern (e.g.
  * `"MM/dd/yyyy HH:mm:ss"`, `"dd-MMM-yyyy h:mm a"`) and return it as an
@@ -7,9 +8,8 @@
  *   producer format — a CSV column, a legacy API field, a partially-typed
  *   form value — not for generating locale-correct output. For display,
  *   use `formatDateTime`/`formatDateToParts`, which order fields per
- *   locale instead of hard-coding a field order (see roadmap Decision 1
- *   — a token *formatter*, the inverse of this function, is deliberately
- *   out of scope for GMT).
+ *   locale instead of hard-coding a field order (a token *formatter*,
+ *   the inverse of this function, is deliberately out of scope for GMT).
  * - Accepts the full combined date + time token set (unlike
  *   `parseDateWithPattern`/`parseTimeWithPattern`, which each reject the
  *   other's tokens).
@@ -18,7 +18,7 @@
  * | Token | Field | Width | Range | Notes |
  * |---|---|---|---|---|
  * | `yyyy` | year | 4 digits | 0000–9999 | |
- * | `yy` | year | 2 digits | 00–99 | Pivot: 00–68 → 2000–2068, 69–99 → 1969–1999 (fixed rule) |
+ * | `yy` | year | 2 digits | 00–99 | Needs `options.yearWindow`; returns `""` without it |
  * | `MM` | month | 2 digits | 01–12 | |
  * | `M` | month | 1-2 digits | 1–12 | |
  * | `MMMM` | month name (long) | locale | — | `getLocaleMonthNames(locale, "long")` |
@@ -40,10 +40,13 @@
  * | `GGGG` | era name (long) | locale | — | BCE label ⇒ final year = 1 − parsed year |
  * | `GG` | era name (short) | locale | — | same resolution |
  *
- * - Text in `'single quotes'` is a literal; a doubled `''` inside a
- *   quoted segment is a literal `'`. Any other character (`/ - , space
- *   :`, literal digits, etc.) outside a quote/letter-run is automatically
- *   a literal — no explicit quoting required.
+ * - Literal text follows the Unicode UTS #35 date format pattern rules.
+ *   Text in `'single quotes'` is a literal, letters included. Two
+ *   adjacent quotes `''` are one literal `'`, inside or outside quoted
+ *   text: `"yyyy''MM"` reads `"2024'03"`, and `"'o''clock'"` reads
+ *   `"o'clock"`. A quote that never closes makes the pattern malformed
+ *   (`""`). Any other character that is not a letter (`/ - , space :`,
+ *   digits and so on) is a literal with no quoting.
  * - `MMMM`/`MMM`/`EEEE`/`EEE`/`a`/`GGGG`/`GG` are locale-aware. If
  *   `locale` is omitted and the pattern uses any of them, GMT defaults
  *   to `"en-US"` rather than returning `""` for every caller who didn't
@@ -71,16 +74,29 @@
  * - Fields absent from `pattern` default the way `Temporal.PlainDateTime.from`
  *   defaults an omitted field (time fields default to `0`; `year`/`month`/`day`
  *   are still required for a valid result).
+ * - A `yy` token needs the caller's hundred-year window,
+ *   `options.yearWindow`: no standard says which century a two-digit
+ *   year belongs to, and a cut-off built into a library is right today
+ *   and wrong later. Without a valid window a `yy` pattern returns `""`.
+ *   A pattern with no `yy` never reads the option, so a `"rolling"`
+ *   window reads no clock for it. A two-digit year is a legacy form; a
+ *   four-digit year is the one to ask a data source for.
  *
  * @param value The string to decode (e.g. "03/15/2024 14:30:00")
  * @param pattern The token pattern describing `value`'s shape (e.g. "MM/dd/yyyy HH:mm:ss")
  * @param locale Optional BCP 47 locale tag, or a preference list of tags, for name-based tokens (default "en-US")
+ * @param options The hundred-year window a `yy` token resolves in
  * @returns ISO `PlainDateTime` string, or "" on no match, malformed pattern, or invalid input
  *
  * @example parseDateTimeWithPattern("03/15/2024 14:30:00", "MM/dd/yyyy HH:mm:ss") // "2024-03-15T14:30:00"
  * @example parseDateTimeWithPattern("15-Mar-2024 02:30 PM", "dd-MMM-yyyy hh:mm a") // "2024-03-15T14:30:00"
+ * @example parseDateTimeWithPattern("Mar 15, '24 at 14:30", "MMM d, ''yy 'at' HH:mm", undefined, { yearWindow: 2000 }) // "2024-03-15T14:30:00" ('' is one literal quote)
+ * @example parseDateTimeWithPattern("99-03-15 14:30", "yy-MM-dd HH:mm", undefined, { yearWindow: 1950 }) // "1999-03-15T14:30:00" (1950–2049 window)
+ * @example parseDateTimeWithPattern("24-03-15 14:30", "yy-MM-dd HH:mm", undefined, { yearWindow: "rolling" }) // "2024-03-15T14:30:00" (while the current UTC year is 1975–2074)
+ * @example parseDateTimeWithPattern("24-03-15 14:30", "yy-MM-dd HH:mm") // "" (yy with no window)
+ * @example parseDateTimeWithPattern("03/15/2024 14:30:00", "MM/dd/yyyy HH:mm:ss", undefined, { yearWindow: 2000 }) // "2024-03-15T14:30:00" (yyyy ignores the window)
  * @example parseDateTimeWithPattern("02/31/2024 14:30:00", "MM/dd/yyyy HH:mm:ss") // "" (shape-valid, not a real date)
  * @example parseDateTimeWithPattern("not a date", "MM/dd/yyyy HH:mm:ss") // ""
  * @example parseDateTimeWithPattern("19 mai 2024 10:20", "d MMMM yyyy HH:mm", ["fr-FR", "en-US"]) // "2024-05-19T10:20:00"
  */
-export declare function parseDateTimeWithPattern(value: string, pattern: string, locale?: string | string[]): string;
+export declare function parseDateTimeWithPattern(value: string, pattern: string, locale?: string | string[], options?: TwoDigitYearOptions): string;