@northguild/gmt 1.14.2

package/dist/plain/interval/splitIntervalByUnitDate.js

@@ -0,0 +1,80 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { formatDateInCalendar, parseCalendarDatePairForArithmetic, resolveDurationUnit, } from "../../internal/index.js";
+import { isValidCalendarDate } from "../validate/index.js";
+/**
+ * Split a date interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - 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 `PlainDate`, e.g. `"hours"`).
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ *   carry the *same* calendar tag, stepping (and each slice's boundaries) happens in that
+ *   calendar — a Hebrew leap year splits into 13 month-slices, not 12 (E5 decision of record
+ *   D5); otherwise (or if either is bare ISO) it falls back to Gregorian. 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.
+ *
+ * @param start ISO PlainDate string for the interval start, optionally calendar-annotated
+ * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
+ * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
+ * @param amount positive number of units per step
+ * @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" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-09", "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" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-01", "day", 2) // [{ start: "2024-01-01", end: "2024-01-01" }]
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 0) // []
+ * @example splitIntervalByUnitDate("invalid", "2024-01-10", "day", 2) // []
+ * @example splitIntervalByUnitDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ */
+export function splitIntervalByUnitDate(start, end, unit, amount) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return [];
+    }
+    if (!isValidCalendarDate(start) || !isValidCalendarDate(end)) {
+        return [];
+    }
+    if (typeof unit !== "string") {
+        return [];
+    }
+    const resolvedUnit = resolveDurationUnit(unit);
+    if (!resolvedUnit) {
+        return [];
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return [];
+    }
+    try {
+        const { calendar, a: startVal, b: endVal } = parseCalendarDatePairForArithmetic(start, end);
+        if (Temporal.PlainDate.compare(startVal, endVal) > 0) {
+            return [];
+        }
+        if (Temporal.PlainDate.compare(startVal, endVal) === 0) {
+            return [
+                {
+                    start: formatDateInCalendar(startVal, calendar),
+                    end: formatDateInCalendar(endVal, calendar),
+                },
+            ];
+        }
+        const result = [];
+        for (let current = startVal; Temporal.PlainDate.compare(current, endVal) < 0;) {
+            const next = current.add({ [resolvedUnit]: amount });
+            if (Temporal.PlainDate.compare(next, current) === 0) {
+                return [];
+            }
+            const sliceEnd = Temporal.PlainDate.compare(next, endVal) > 0 ? endVal : next;
+            result.push({
+                start: formatDateInCalendar(current, calendar),
+                end: formatDateInCalendar(sliceEnd, calendar),
+            });
+            current = next;
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Split a date-time interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
+ * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
+ *
+ * @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
+ * @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" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:30: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" }, { start: "2024-01-01T14:00:00", end: "2024-01-01T14:30:00" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T12:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 0) // []
+ * @example splitIntervalByUnitDateTime("invalid", "2024-01-01T14:00:00", "hour", 1) // []
+ */
+export declare function splitIntervalByUnitDateTime(start: string, end: string, unit: string, amount: number): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/plain/interval/splitIntervalByUnitDateTime.js

@@ -0,0 +1,72 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../regex/index.js";
+import { isValidDateTime } from "../validate/index.js";
+import { resolveDurationUnit } from "../../internal/index.js";
+/**
+ * Split a date-time interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
+ * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
+ *
+ * @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
+ * @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" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:30: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" }, { start: "2024-01-01T14:00:00", end: "2024-01-01T14:30:00" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T12:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" }]
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 0) // []
+ * @example splitIntervalByUnitDateTime("invalid", "2024-01-01T14:00:00", "hour", 1) // []
+ */
+export function splitIntervalByUnitDateTime(start, end, unit, amount) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return [];
+    }
+    if (!plainDateTime.test(start) || !plainDateTime.test(end)) {
+        return [];
+    }
+    if (!isValidDateTime(start) || !isValidDateTime(end)) {
+        return [];
+    }
+    if (typeof unit !== "string") {
+        return [];
+    }
+    const resolvedUnit = resolveDurationUnit(unit);
+    if (!resolvedUnit) {
+        return [];
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return [];
+    }
+    try {
+        const startVal = Temporal.PlainDateTime.from(start);
+        const endVal = Temporal.PlainDateTime.from(end);
+        if (Temporal.PlainDateTime.compare(startVal, endVal) > 0) {
+            return [];
+        }
+        if (Temporal.PlainDateTime.compare(startVal, endVal) === 0) {
+            return [{ start: startVal.toString(), end: endVal.toString() }];
+        }
+        const result = [];
+        for (let current = startVal; Temporal.PlainDateTime.compare(current, endVal) < 0;) {
+            const next = current.add({ [resolvedUnit]: amount });
+            if (Temporal.PlainDateTime.compare(next, current) === 0) {
+                return [];
+            }
+            const sliceEnd = Temporal.PlainDateTime.compare(next, endVal) > 0 ? endVal : next;
+            result.push({
+                start: current.toString(),
+                end: sliceEnd.toString(),
+            });
+            current = next;
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Split a time interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - 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"`).
+ *
+ * @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
+ * @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" }]
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
+ * @example splitIntervalByUnitTime("12:00:00", "12:00:00", "hour", 1) // [{ start: "12:00:00", end: "12:00:00" }]
+ * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 0) // []
+ * @example splitIntervalByUnitTime("invalid", "14:00:00", "hour", 1) // []
+ */
+export declare function splitIntervalByUnitTime(start: string, end: string, unit: string, amount: number): Array<{
+    start: string;
+    end: string;
+}>;

package/dist/plain/interval/splitIntervalByUnitTime.js

@@ -0,0 +1,73 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+import { isValidTime } from "../validate/index.js";
+import { resolveDurationUnit } from "../../internal/index.js";
+/**
+ * Split a time interval into sub-intervals of `amount × unit`.
+ *
+ * - Returns an array of `{ start, end }` records that tile the interval.
+ * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - 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"`).
+ *
+ * @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
+ * @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" }]
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
+ * @example splitIntervalByUnitTime("12:00:00", "12:00:00", "hour", 1) // [{ start: "12:00:00", end: "12:00:00" }]
+ * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 0) // []
+ * @example splitIntervalByUnitTime("invalid", "14:00:00", "hour", 1) // []
+ */
+export function splitIntervalByUnitTime(start, end, unit, amount) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return [];
+    }
+    if (!plainTime.test(start) || !plainTime.test(end)) {
+        return [];
+    }
+    if (!isValidTime(start) || !isValidTime(end)) {
+        return [];
+    }
+    if (typeof unit !== "string") {
+        return [];
+    }
+    const resolvedUnit = resolveDurationUnit(unit);
+    if (!resolvedUnit) {
+        return [];
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+        return [];
+    }
+    try {
+        const startVal = Temporal.PlainTime.from(start);
+        const endVal = Temporal.PlainTime.from(end);
+        if (Temporal.PlainTime.compare(startVal, endVal) > 0) {
+            return [];
+        }
+        if (Temporal.PlainTime.compare(startVal, endVal) === 0) {
+            return [{ start: startVal.toString(), end: endVal.toString() }];
+        }
+        const result = [];
+        for (let current = startVal; Temporal.PlainTime.compare(current, endVal) < 0;) {
+            const next = current.add({ [resolvedUnit]: amount });
+            if (Temporal.PlainTime.compare(next, current) === 0) {
+                return [];
+            }
+            const sliceEnd = Temporal.PlainTime.compare(next, endVal) > 0 ? endVal : next;
+            result.push({
+                start: current.toString(),
+                end: sliceEnd.toString(),
+            });
+            current = next;
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/plain/interval/validate/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./isValidDateInterval.js";
+export * from "./isValidDateTimeInterval.js";
+export * from "./isValidTimeInterval.js";

package/dist/plain/interval/validate/index.js

@@ -0,0 +1,3 @@
+export * from "./isValidDateInterval.js";
+export * from "./isValidDateTimeInterval.js";
+export * from "./isValidTimeInterval.js";

package/dist/plain/interval/validate/isValidDateInterval.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Return true if `start` and `end` form a valid date interval — both parseable as
+ * ISO PlainDate strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 date strings (e.g. `"2024-01-01"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ *   calendar-independent, so `start`/`end` may carry different or no calendar tags (D4).
+ *
+ * @param start ISO 8601 date string (interval start), optionally calendar-annotated
+ * @param end ISO 8601 date string (interval end), optionally calendar-annotated
+ * @returns true if start and end form a valid date interval, or false on invalid input
+ *
+ * @example isValidDateInterval("2024-01-01", "2024-12-31") // true
+ * @example isValidDateInterval("2024-01-01", "2024-01-01") // true
+ * @example isValidDateInterval("2024-12-31", "2024-01-01") // false
+ * @example isValidDateInterval("invalid", "2024-12-31") // false
+ * @example isValidDateInterval("5785-01-01[u-ca=hebrew]", "2024-12-31") // true (mixed calendars — ordering is calendar-independent)
+ */
+export declare function isValidDateInterval(start: string, end: string): boolean;

package/dist/plain/interval/validate/isValidDateInterval.js

@@ -0,0 +1,37 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { parseCalendarDateValue } from "../../../internal/index.js";
+import { isValidCalendarDate } from "../../validate/index.js";
+/**
+ * Return true if `start` and `end` form a valid date interval — both parseable as
+ * ISO PlainDate strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 date strings (e.g. `"2024-01-01"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ *   calendar-independent, so `start`/`end` may carry different or no calendar tags (D4).
+ *
+ * @param start ISO 8601 date string (interval start), optionally calendar-annotated
+ * @param end ISO 8601 date string (interval end), optionally calendar-annotated
+ * @returns true if start and end form a valid date interval, or false on invalid input
+ *
+ * @example isValidDateInterval("2024-01-01", "2024-12-31") // true
+ * @example isValidDateInterval("2024-01-01", "2024-01-01") // true
+ * @example isValidDateInterval("2024-12-31", "2024-01-01") // false
+ * @example isValidDateInterval("invalid", "2024-12-31") // false
+ * @example isValidDateInterval("5785-01-01[u-ca=hebrew]", "2024-12-31") // true (mixed calendars — ordering is calendar-independent)
+ */
+export function isValidDateInterval(start, end) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return false;
+    }
+    if (!isValidCalendarDate(start) || !isValidCalendarDate(end)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDate.compare(parseCalendarDateValue(start), parseCalendarDateValue(end)) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/interval/validate/isValidDateTimeInterval.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return true if `start` and `end` form a valid datetime interval — both parseable as
+ * ISO PlainDateTime strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 datetime strings (e.g. `"2024-01-01T10:00:00"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param start ISO 8601 datetime string (interval start)
+ * @param end ISO 8601 datetime string (interval end)
+ * @returns true if start and end form a valid datetime interval, or false on invalid input
+ *
+ * @example isValidDateTimeInterval("2024-01-01T10:00:00", "2024-12-31T23:59:59") // true
+ * @example isValidDateTimeInterval("2024-01-01T10:00:00", "2024-01-01T10:00:00") // true
+ * @example isValidDateTimeInterval("2024-12-31T23:59:59", "2024-01-01T10:00:00") // false
+ * @example isValidDateTimeInterval("invalid", "2024-12-31T23:59:59") // false
+ */
+export declare function isValidDateTimeInterval(start: string, end: string): boolean;

package/dist/plain/interval/validate/isValidDateTimeInterval.js

@@ -0,0 +1,33 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../../regex/index.js";
+/**
+ * Return true if `start` and `end` form a valid datetime interval — both parseable as
+ * ISO PlainDateTime strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 datetime strings (e.g. `"2024-01-01T10:00:00"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param start ISO 8601 datetime string (interval start)
+ * @param end ISO 8601 datetime string (interval end)
+ * @returns true if start and end form a valid datetime interval, or false on invalid input
+ *
+ * @example isValidDateTimeInterval("2024-01-01T10:00:00", "2024-12-31T23:59:59") // true
+ * @example isValidDateTimeInterval("2024-01-01T10:00:00", "2024-01-01T10:00:00") // true
+ * @example isValidDateTimeInterval("2024-12-31T23:59:59", "2024-01-01T10:00:00") // false
+ * @example isValidDateTimeInterval("invalid", "2024-12-31T23:59:59") // false
+ */
+export function isValidDateTimeInterval(start, end) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return false;
+    }
+    if (!plainDateTime.test(start) || !plainDateTime.test(end)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDateTime.compare(Temporal.PlainDateTime.from(start), Temporal.PlainDateTime.from(end)) <= 0);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/interval/validate/isValidTimeInterval.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return true if `start` and `end` form a valid time interval — both parseable as
+ * ISO PlainTime strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 time strings (e.g. `"14:30:00"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param start ISO 8601 time string (interval start)
+ * @param end ISO 8601 time string (interval end)
+ * @returns true if start and end form a valid time interval, or false on invalid input
+ *
+ * @example isValidTimeInterval("09:00:00", "17:00:00") // true
+ * @example isValidTimeInterval("12:00:00", "12:00:00") // true
+ * @example isValidTimeInterval("17:00:00", "09:00:00") // false
+ * @example isValidTimeInterval("invalid", "12:00:00") // false
+ */
+export declare function isValidTimeInterval(start: string, end: string): boolean;

package/dist/plain/interval/validate/isValidTimeInterval.js

@@ -0,0 +1,48 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../../regex/index.js";
+/**
+ * Return true if `start` and `end` form a valid time interval — both parseable as
+ * ISO PlainTime strings and `start <= end`.
+ *
+ * - Both inputs must be ISO 8601 time strings (e.g. `"14:30:00"`).
+ * - Equal `start === end` is valid.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param start ISO 8601 time string (interval start)
+ * @param end ISO 8601 time string (interval end)
+ * @returns true if start and end form a valid time interval, or false on invalid input
+ *
+ * @example isValidTimeInterval("09:00:00", "17:00:00") // true
+ * @example isValidTimeInterval("12:00:00", "12:00:00") // true
+ * @example isValidTimeInterval("17:00:00", "09:00:00") // false
+ * @example isValidTimeInterval("invalid", "12:00:00") // false
+ */
+export function isValidTimeInterval(start, end) {
+    if (typeof start !== "string" || typeof end !== "string") {
+        return false;
+    }
+    if (!plainTime.test(start) || !plainTime.test(end)) {
+        return false;
+    }
+    try {
+        const t1 = Temporal.PlainTime.from(start);
+        const t2 = Temporal.PlainTime.from(end);
+        const isLessThan = t1.hour < t2.hour ||
+            (t1.hour === t2.hour && t1.minute < t2.minute) ||
+            (t1.hour === t2.hour &&
+                t1.minute === t2.minute &&
+                t1.second < t2.second) ||
+            (t1.hour === t2.hour &&
+                t1.minute === t2.minute &&
+                t1.second === t2.second &&
+                t1.millisecond < t2.millisecond);
+        const isEqual = t1.hour === t2.hour &&
+            t1.minute === t2.minute &&
+            t1.second === t2.second &&
+            t1.millisecond === t2.millisecond;
+        return isLessThan || isEqual;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/locale/getLocaleEraNames.d.ts

@@ -0,0 +1,23 @@
+import type { LocaleNameStyle } from "./getLocaleMonthNames.js";
+/**
+ * Return a locale's Gregorian era names as [BCE-label, CE-label].
+ *
+ * - The two-element array is [Before Common Era label, Common Era label].
+ * - Uses the host runtime's `Intl` data via `Intl.DateTimeFormat`, so output
+ *   depends on the runtime's ICU build (full-ICU runtimes localize every
+ *   locale; partial-ICU runtimes fall back to English).
+ * - If a locale has no distinct BCE/CE era names, both array elements
+ *   contain the same string — the function never returns a sentinel for
+ *   a valid locale, only for invalid input.
+ * - Returns `[]` if `locale` is not a valid BCP 47 tag.
+ *
+ * @param locale BCP 47 locale tag (e.g. "en-US", "fr-FR", "ar-SA")
+ * @param style Optional name style: `"long"` (default), `"short"`, or `"narrow"`
+ * @returns 2-element `[BCE-label, CE-label]` array, or `[]` on invalid input
+ *
+ * @example getLocaleEraNames("en-US") // ["Before Christ", "Anno Domini"]
+ * @example getLocaleEraNames("de-DE", "short") // ["v. Chr.", "n. Chr."]
+ * @example getLocaleEraNames("ja-JP", "narrow") // ["BC", "AD"]
+ * @example getLocaleEraNames("not-a-locale") // []
+ */
+export declare function getLocaleEraNames(locale: string, style?: LocaleNameStyle): string[];

package/dist/plain/locale/getLocaleEraNames.js

@@ -0,0 +1,66 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return a locale's Gregorian era names as [BCE-label, CE-label].
+ *
+ * - The two-element array is [Before Common Era label, Common Era label].
+ * - Uses the host runtime's `Intl` data via `Intl.DateTimeFormat`, so output
+ *   depends on the runtime's ICU build (full-ICU runtimes localize every
+ *   locale; partial-ICU runtimes fall back to English).
+ * - If a locale has no distinct BCE/CE era names, both array elements
+ *   contain the same string — the function never returns a sentinel for
+ *   a valid locale, only for invalid input.
+ * - Returns `[]` if `locale` is not a valid BCP 47 tag.
+ *
+ * @param locale BCP 47 locale tag (e.g. "en-US", "fr-FR", "ar-SA")
+ * @param style Optional name style: `"long"` (default), `"short"`, or `"narrow"`
+ * @returns 2-element `[BCE-label, CE-label]` array, or `[]` on invalid input
+ *
+ * @example getLocaleEraNames("en-US") // ["Before Christ", "Anno Domini"]
+ * @example getLocaleEraNames("de-DE", "short") // ["v. Chr.", "n. Chr."]
+ * @example getLocaleEraNames("ja-JP", "narrow") // ["BC", "AD"]
+ * @example getLocaleEraNames("not-a-locale") // []
+ */
+export function getLocaleEraNames(locale, style = "long") {
+    if (typeof locale !== "string")
+        return [];
+    try {
+        new Intl.Locale(locale);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const resolved = style === "short" || style === "narrow" ? style : "long";
+        const formatter = new Intl.DateTimeFormat(locale, {
+            calendar: "gregory",
+            era: resolved,
+            timeZone: "UTC",
+        });
+        // Year 1 BC (proleptic Gregorian) — Temporal represents 1 BC as year 0.
+        const bceInstant = Temporal.ZonedDateTime.from({
+            year: 0,
+            month: 1,
+            day: 1,
+            hour: 12,
+            timeZone: "UTC",
+            calendar: "gregory",
+        }).toInstant();
+        // Year 1 AD (proleptic Gregorian).
+        const ceInstant = Temporal.ZonedDateTime.from({
+            year: 1,
+            month: 1,
+            day: 1,
+            hour: 12,
+            timeZone: "UTC",
+            calendar: "gregory",
+        }).toInstant();
+        const bceParts = formatter.formatToParts(bceInstant.epochMilliseconds);
+        const bceEra = bceParts.find((part) => part.type === "era")?.value ?? "";
+        const ceParts = formatter.formatToParts(ceInstant.epochMilliseconds);
+        const ceEra = ceParts.find((part) => part.type === "era")?.value ?? "";
+        return [bceEra, ceEra];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/plain/locale/getLocaleMeridiems.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Return a locale's AM/PM (day-period) labels as `[AM-label, PM-label]`.
+ *
+ * - Labels are locale-varying: `en-US` → `["AM", "PM"]`, `en-GB` →
+ *   `["am", "pm"]`, `sv-SE` → `["fm", "em"]`, `zh-CN` → `["上午", "下午"]`,
+ *   `ar-SA` → `["ص", "م"]`.
+ * - Uses the host runtime's `Intl` data via `Intl.DateTimeFormat`, so output
+ *   depends on the runtime's ICU build.
+ * - Returns `[]` if `locale` is not a valid BCP 47 tag.
+ *
+ * @param locale BCP 47 locale tag (e.g. "en-US", "fr-FR", "ar-SA")
+ * @returns 2-element `[AM-label, PM-label]` array, or `[]` on invalid input
+ *
+ * @example getLocaleMeridiems("en-US") // ["AM", "PM"]
+ * @example getLocaleMeridiems("en-GB") // ["am", "pm"]
+ * @example getLocaleMeridiems("zh-CN") // ["上午", "下午"]
+ * @example getLocaleMeridiems("not-a-locale") // []
+ */
+export declare function getLocaleMeridiems(locale: string): string[];

package/dist/plain/locale/getLocaleMeridiems.js

@@ -0,0 +1,44 @@
+/**
+ * Return a locale's AM/PM (day-period) labels as `[AM-label, PM-label]`.
+ *
+ * - Labels are locale-varying: `en-US` → `["AM", "PM"]`, `en-GB` →
+ *   `["am", "pm"]`, `sv-SE` → `["fm", "em"]`, `zh-CN` → `["上午", "下午"]`,
+ *   `ar-SA` → `["ص", "م"]`.
+ * - Uses the host runtime's `Intl` data via `Intl.DateTimeFormat`, so output
+ *   depends on the runtime's ICU build.
+ * - Returns `[]` if `locale` is not a valid BCP 47 tag.
+ *
+ * @param locale BCP 47 locale tag (e.g. "en-US", "fr-FR", "ar-SA")
+ * @returns 2-element `[AM-label, PM-label]` array, or `[]` on invalid input
+ *
+ * @example getLocaleMeridiems("en-US") // ["AM", "PM"]
+ * @example getLocaleMeridiems("en-GB") // ["am", "pm"]
+ * @example getLocaleMeridiems("zh-CN") // ["上午", "下午"]
+ * @example getLocaleMeridiems("not-a-locale") // []
+ */
+export function getLocaleMeridiems(locale) {
+    if (typeof locale !== "string")
+        return [];
+    try {
+        new Intl.Locale(locale);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const formatter = new Intl.DateTimeFormat(locale, {
+            timeZone: "UTC",
+            hour: "numeric",
+            hour12: true,
+        });
+        const am = formatter.formatToParts(0).find((part) => part.type === "dayPeriod")
+            ?.value ?? "";
+        const pm = formatter
+            .formatToParts(12 * 60 * 60 * 1000)
+            .find((part) => part.type === "dayPeriod")?.value ?? "";
+        return [am, pm];
+    }
+    catch {
+        return [];
+    }
+}