@northguild/gmt 1.14.2

package/dist/plain/validate/isValidDateTimeDurationUnit.js

@@ -0,0 +1,26 @@
+/**
+ * Return true when `unit` is a valid DateTimeDurationUnit.
+ *
+ * - Valid units are: "years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate string
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeDurationUnit("days") // true
+ * @example isValidDateTimeDurationUnit("hours") // true
+ * @example isValidDateTimeDurationUnit("minutes") // true
+ * @example isValidDateTimeDurationUnit("invalid") // false
+ */
+export const isValidDateTimeDurationUnit = (unit) => {
+    return (unit === "years" ||
+        unit === "months" ||
+        unit === "weeks" ||
+        unit === "days" ||
+        unit === "hours" ||
+        unit === "minutes" ||
+        unit === "seconds" ||
+        unit === "milliseconds" ||
+        unit === "microseconds" ||
+        unit === "nanoseconds");
+};

package/dist/plain/validate/isValidDateTimeRange.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Return true if `value1` and `value2` form a valid datetime range — both parseable as
+ * ISO PlainDateTime strings and `value1 <= value2`.
+ *
+ * - Both inputs must be ISO 8601 datetime strings (e.g. `"2024-01-01T10:00:00"`).
+ * - Equal `value1 === value2` is valid when `options.allowEqual` is true.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param value1 first ISO PlainDateTime string
+ * @param value2 second ISO PlainDateTime string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the datetime range is valid
+ *
+ * @example isValidDateTimeRange({ value1: "2024-01-01T10:00:00", value2: "2024-12-31T23:59:59" }) // true
+ * @example isValidDateTimeRange({ value1: "2024-12-31T23:59:59", value2: "2024-01-01T10:00:00" }) // false
+ * @example isValidDateTimeRange({ value1: "2024-01-01T10:00:00", value2: "2024-01-01T10:00:00", options: { allowEqual: true } }) // true
+ */
+export declare function isValidDateTimeRange({ value1, value2, options, }: {
+    value1: string;
+    value2: string;
+    options?: {
+        allowEqual?: boolean;
+    };
+}): boolean;

package/dist/plain/validate/isValidDateTimeRange.js

@@ -0,0 +1,39 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../regex/index.js";
+/**
+ * Return true if `value1` and `value2` form a valid datetime range — both parseable as
+ * ISO PlainDateTime strings and `value1 <= value2`.
+ *
+ * - Both inputs must be ISO 8601 datetime strings (e.g. `"2024-01-01T10:00:00"`).
+ * - Equal `value1 === value2` is valid when `options.allowEqual` is true.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param value1 first ISO PlainDateTime string
+ * @param value2 second ISO PlainDateTime string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the datetime range is valid
+ *
+ * @example isValidDateTimeRange({ value1: "2024-01-01T10:00:00", value2: "2024-12-31T23:59:59" }) // true
+ * @example isValidDateTimeRange({ value1: "2024-12-31T23:59:59", value2: "2024-01-01T10:00:00" }) // false
+ * @example isValidDateTimeRange({ value1: "2024-01-01T10:00:00", value2: "2024-01-01T10:00:00", options: { allowEqual: true } }) // true
+ */
+export function isValidDateTimeRange({ value1, value2, options, }) {
+    if (typeof value1 !== "string" || typeof value2 !== "string") {
+        return false;
+    }
+    if (!plainDateTime.test(value1) || !plainDateTime.test(value2)) {
+        return false;
+    }
+    try {
+        const dt1 = Temporal.PlainDateTime.from(value1);
+        const dt2 = Temporal.PlainDateTime.from(value2);
+        const cmp = Temporal.PlainDateTime.compare(dt1, dt2);
+        if (options?.allowEqual) {
+            return cmp <= 0;
+        }
+        return cmp < 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidDateTimeUnit.d.ts

@@ -0,0 +1,19 @@
+import type { DateTimeUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid DateTimeUnit.
+ *
+ * - Valid units are: "year", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeUnit("year") // true
+ * @example isValidDateTimeUnit("month") // true
+ * @example isValidDateTimeUnit("weeks") // false
+ * @example isValidDateTimeUnit("invalid") // false
+ * @example isValidDateTimeUnit(123) // false
+ * @example isValidDateTimeUnit(null) // false
+ */
+export declare function isValidDateTimeUnit(unit: unknown): unit is DateTimeUnit;

package/dist/plain/validate/isValidDateTimeUnit.js

@@ -0,0 +1,32 @@
+/**
+ * Return true when `unit` is a valid DateTimeUnit.
+ *
+ * - Valid units are: "year", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeUnit("year") // true
+ * @example isValidDateTimeUnit("month") // true
+ * @example isValidDateTimeUnit("weeks") // false
+ * @example isValidDateTimeUnit("invalid") // false
+ * @example isValidDateTimeUnit(123) // false
+ * @example isValidDateTimeUnit(null) // false
+ */
+export function isValidDateTimeUnit(unit) {
+    if (typeof unit !== "string") {
+        return false;
+    }
+    return (unit === "year" ||
+        unit === "month" ||
+        unit === "week" ||
+        unit === "day" ||
+        unit === "hour" ||
+        unit === "minute" ||
+        unit === "second" ||
+        unit === "millisecond" ||
+        unit === "microsecond" ||
+        unit === "nanosecond");
+}

package/dist/plain/validate/isValidDateUnit.d.ts

@@ -0,0 +1,21 @@
+import type { DateUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid DateUnit.
+ *
+ * - Valid units are: "year", "month", "week", "day".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateUnit("year") // true
+ * @example isValidDateUnit("month") // true
+ * @example isValidDateUnit("week") // true
+ * @example isValidDateUnit("day") // true
+ * @example isValidDateUnit("hour") // false
+ * @example isValidDateUnit("invalid") // false
+ * @example isValidDateUnit(123) // false
+ * @example isValidDateUnit(null) // false
+ */
+export declare function isValidDateUnit(unit: unknown): unit is DateUnit;

package/dist/plain/validate/isValidDateUnit.js

@@ -0,0 +1,25 @@
+/**
+ * Return true when `unit` is a valid DateUnit.
+ *
+ * - Valid units are: "year", "month", "week", "day".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateUnit("year") // true
+ * @example isValidDateUnit("month") // true
+ * @example isValidDateUnit("week") // true
+ * @example isValidDateUnit("day") // true
+ * @example isValidDateUnit("hour") // false
+ * @example isValidDateUnit("invalid") // false
+ * @example isValidDateUnit(123) // false
+ * @example isValidDateUnit(null) // false
+ */
+export function isValidDateUnit(unit) {
+    if (typeof unit !== "string") {
+        return false;
+    }
+    return (unit === "year" || unit === "month" || unit === "week" || unit === "day");
+}

package/dist/plain/validate/isValidIsoDateLike.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when the input is a valid PlainDate or PlainDateTime ISO string.
+ *
+ * - Accepts both PlainDate ("2024-02-29") and PlainDateTime ("2024-02-29T12:34:56") formats.
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds and invalid dates/times.
+ *
+ * @param value ISO PlainDate or PlainDateTime string
+ * @returns boolean indicating validity
+ *
+ * @example isValidIsoDateLike("2024-02-29") // true
+ * @example isValidIsoDateLike("2024-02-30") // false (invalid date)
+ * @example isValidIsoDateLike("2024-02-29T12:34:56") // true
+ * @example isValidIsoDateLike("2024-02-29T24:00:00") // false (invalid time)
+ * @example isValidIsoDateLike("2024-12-31T23:59:60") // false (leap second)
+ */
+export declare function isValidIsoDateLike(value: string): boolean;

package/dist/plain/validate/isValidIsoDateLike.js

@@ -0,0 +1,43 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDate, plainDateTime } from "../../regex/index.js";
+import { isLeapSecond } from "./isLeapSecond.js";
+/**
+ * Return true when the input is a valid PlainDate or PlainDateTime ISO string.
+ *
+ * - Accepts both PlainDate ("2024-02-29") and PlainDateTime ("2024-02-29T12:34:56") formats.
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds and invalid dates/times.
+ *
+ * @param value ISO PlainDate or PlainDateTime string
+ * @returns boolean indicating validity
+ *
+ * @example isValidIsoDateLike("2024-02-29") // true
+ * @example isValidIsoDateLike("2024-02-30") // false (invalid date)
+ * @example isValidIsoDateLike("2024-02-29T12:34:56") // true
+ * @example isValidIsoDateLike("2024-02-29T24:00:00") // false (invalid time)
+ * @example isValidIsoDateLike("2024-12-31T23:59:60") // false (leap second)
+ */
+export function isValidIsoDateLike(value) {
+    if (isLeapSecond(value)) {
+        return false;
+    }
+    if (plainDate.test(value)) {
+        try {
+            Temporal.PlainDate.from(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (plainDateTime.test(value)) {
+        try {
+            Temporal.PlainDateTime.from(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/plain/validate/isValidTime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true when `value` is a valid ISO PlainTime string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "23:59:60").
+ * - Rejects invalid times (e.g., "24:00:00", "23:60:00").
+ *
+ * @param value ISO PlainTime string
+ * @returns boolean indicating validity
+ *
+ * @example isValidTime("12:34:56") // true
+ * @example isValidTime("24:00:00") // false (invalid hour)
+ * @example isValidTime("23:60:00") // false (invalid minute)
+ * @example isValidTime("23:59:60") // false (leap second)
+ */
+export declare function isValidTime(value: string): boolean;

package/dist/plain/validate/isValidTime.js

@@ -0,0 +1,33 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+import { isLeapSecond } from "./isLeapSecond.js";
+/**
+ * Return true when `value` is a valid ISO PlainTime string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "23:59:60").
+ * - Rejects invalid times (e.g., "24:00:00", "23:60:00").
+ *
+ * @param value ISO PlainTime string
+ * @returns boolean indicating validity
+ *
+ * @example isValidTime("12:34:56") // true
+ * @example isValidTime("24:00:00") // false (invalid hour)
+ * @example isValidTime("23:60:00") // false (invalid minute)
+ * @example isValidTime("23:59:60") // false (leap second)
+ */
+export function isValidTime(value) {
+    if (isLeapSecond(value)) {
+        return false;
+    }
+    if (!plainTime.test(value)) {
+        return false;
+    }
+    try {
+        Temporal.PlainTime.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidTimeCycleField.d.ts

@@ -0,0 +1,18 @@
+import type { TimeCycleField } from "../../types/index.js";
+/**
+ * Return true when `field` is a valid TimeCycleField.
+ *
+ * - Valid fields are: "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidTimeCycleField("hour") // true
+ * @example isValidTimeCycleField("nanosecond") // true
+ * @example isValidTimeCycleField("year") // false
+ * @example isValidTimeCycleField("invalid") // false
+ * @example isValidTimeCycleField(123) // false
+ * @example isValidTimeCycleField(null) // false
+ */
+export declare function isValidTimeCycleField(field: unknown): field is TimeCycleField;

package/dist/plain/validate/isValidTimeCycleField.js

@@ -0,0 +1,27 @@
+/**
+ * Return true when `field` is a valid TimeCycleField.
+ *
+ * - Valid fields are: "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidTimeCycleField("hour") // true
+ * @example isValidTimeCycleField("nanosecond") // true
+ * @example isValidTimeCycleField("year") // false
+ * @example isValidTimeCycleField("invalid") // false
+ * @example isValidTimeCycleField(123) // false
+ * @example isValidTimeCycleField(null) // false
+ */
+export function isValidTimeCycleField(field) {
+    if (typeof field !== "string") {
+        return false;
+    }
+    return (field === "hour" ||
+        field === "minute" ||
+        field === "second" ||
+        field === "millisecond" ||
+        field === "microsecond" ||
+        field === "nanosecond");
+}

package/dist/plain/validate/isValidTimeDurationUnit.d.ts

@@ -0,0 +1,16 @@
+import type { TimeDurationUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid TimeDurationUnit.
+ *
+ * - Valid units are: "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit string candidate
+ * @returns boolean indicating whether the unit is valid
+ *
+ * @example isValidTimeDurationUnit("hours") // true
+ * @example isValidTimeDurationUnit("minutes") // true
+ * @example isValidTimeDurationUnit("seconds") // true
+ * @example isValidTimeDurationUnit("invalid") // false
+ */
+export declare const isValidTimeDurationUnit: (unit: string) => unit is TimeDurationUnit;

package/dist/plain/validate/isValidTimeDurationUnit.js

@@ -0,0 +1,22 @@
+/**
+ * Return true when `unit` is a valid TimeDurationUnit.
+ *
+ * - Valid units are: "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit string candidate
+ * @returns boolean indicating whether the unit is valid
+ *
+ * @example isValidTimeDurationUnit("hours") // true
+ * @example isValidTimeDurationUnit("minutes") // true
+ * @example isValidTimeDurationUnit("seconds") // true
+ * @example isValidTimeDurationUnit("invalid") // false
+ */
+export const isValidTimeDurationUnit = (unit) => {
+    return (unit === "hours" ||
+        unit === "minutes" ||
+        unit === "seconds" ||
+        unit === "milliseconds" ||
+        unit === "microseconds" ||
+        unit === "nanoseconds");
+};

package/dist/plain/validate/isValidTimeRange.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Return true if `value1` and `value2` form a valid time range — both parseable as
+ * ISO PlainTime strings and `value1 <= value2`.
+ *
+ * - Both inputs must be ISO 8601 time strings (e.g. `"14:30:00"`).
+ * - Equal `value1 === value2` is valid when `options.allowEqual` is true.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param value1 first ISO PlainTime string
+ * @param value2 second ISO PlainTime string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the time range is valid
+ *
+ * @example isValidTimeRange({ value1: "09:00:00", value2: "17:00:00" }) // true
+ * @example isValidTimeRange({ value1: "17:00:00", value2: "09:00:00" }) // false
+ * @example isValidTimeRange({ value1: "12:00:00", value2: "12:00:00", options: { allowEqual: true } }) // true
+ */
+export declare function isValidTimeRange({ value1, value2, options, }: {
+    value1: string;
+    value2: string;
+    options?: {
+        allowEqual?: boolean;
+    };
+}): boolean;

package/dist/plain/validate/isValidTimeRange.js

@@ -0,0 +1,51 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainTime } from "../../regex/index.js";
+/**
+ * Return true if `value1` and `value2` form a valid time range — both parseable as
+ * ISO PlainTime strings and `value1 <= value2`.
+ *
+ * - Both inputs must be ISO 8601 time strings (e.g. `"14:30:00"`).
+ * - Equal `value1 === value2` is valid when `options.allowEqual` is true.
+ * - Invalid input, malformed strings, or leap-second strings return `false`.
+ *
+ * @param value1 first ISO PlainTime string
+ * @param value2 second ISO PlainTime string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the time range is valid
+ *
+ * @example isValidTimeRange({ value1: "09:00:00", value2: "17:00:00" }) // true
+ * @example isValidTimeRange({ value1: "17:00:00", value2: "09:00:00" }) // false
+ * @example isValidTimeRange({ value1: "12:00:00", value2: "12:00:00", options: { allowEqual: true } }) // true
+ */
+export function isValidTimeRange({ value1, value2, options, }) {
+    if (typeof value1 !== "string" || typeof value2 !== "string") {
+        return false;
+    }
+    if (!plainTime.test(value1) || !plainTime.test(value2)) {
+        return false;
+    }
+    try {
+        const time1 = Temporal.PlainTime.from(value1);
+        const time2 = Temporal.PlainTime.from(value2);
+        const isLessThan = time1.hour < time2.hour ||
+            (time1.hour === time2.hour && time1.minute < time2.minute) ||
+            (time1.hour === time2.hour &&
+                time1.minute === time2.minute &&
+                time1.second < time2.second) ||
+            (time1.hour === time2.hour &&
+                time1.minute === time2.minute &&
+                time1.second === time2.second &&
+                time1.millisecond < time2.millisecond);
+        const isEqual = time1.hour === time2.hour &&
+            time1.minute === time2.minute &&
+            time1.second === time2.second &&
+            time1.millisecond === time2.millisecond;
+        if (options?.allowEqual) {
+            return isLessThan || isEqual;
+        }
+        return isLessThan;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidTimeUnit.d.ts

@@ -0,0 +1,19 @@
+import type { TimeUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid TimeUnit.
+ *
+ * - Valid units are: "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidTimeUnit("hour") // true
+ * @example isValidTimeUnit("minute") // true
+ * @example isValidTimeUnit("second") // true
+ * @example isValidTimeUnit("invalid") // false
+ * @example isValidTimeUnit(123) // false
+ * @example isValidTimeUnit(null) // false
+ */
+export declare function isValidTimeUnit(unit: unknown): unit is TimeUnit;

package/dist/plain/validate/isValidTimeUnit.js

@@ -0,0 +1,28 @@
+/**
+ * Return true when `unit` is a valid TimeUnit.
+ *
+ * - Valid units are: "hour", "minute", "second", "millisecond", "microsecond", "nanosecond".
+ * - Accepts any input type and returns false for non-string values.
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidTimeUnit("hour") // true
+ * @example isValidTimeUnit("minute") // true
+ * @example isValidTimeUnit("second") // true
+ * @example isValidTimeUnit("invalid") // false
+ * @example isValidTimeUnit(123) // false
+ * @example isValidTimeUnit(null) // false
+ */
+export function isValidTimeUnit(unit) {
+    if (typeof unit !== "string") {
+        return false;
+    }
+    return (unit === "hour" ||
+        unit === "minute" ||
+        unit === "second" ||
+        unit === "millisecond" ||
+        unit === "microsecond" ||
+        unit === "nanosecond");
+}

package/dist/regex/calendar-date.d.ts

@@ -0,0 +1 @@
+export declare const calendarDate: RegExp;

package/dist/regex/calendar-date.js

@@ -0,0 +1,11 @@
+// GMT's own calendar-annotated PlainDate string: the calendar-native year/month/day
+// (e.g. Hebrew year 5785), tagged with the calendar identifier — not Temporal's own
+// `[u-ca=...]` annotation convention, which keeps the ISO/proleptic-Gregorian digits and
+// only tags the calendar. See convertDateToCalendar for the rationale.
+//
+// The optional trailing `;era=<name>` captures an era identifier (e.g. "reiwa"), needed
+// only for the "japanese" calendar: unlike every other supported calendar, Temporal's
+// `.year` for "japanese" stays proleptic (does not reset at an era change), so the
+// era-relative year (Temporal's `.eraYear`) has to be paired with the era name to be
+// unambiguous. See formatCalendarDate/parseCalendarDateValue for how it round-trips.
+export const calendarDate = /^(\d{4,6})-(\d{2})-(\d{2})\[u-ca=([a-z][a-z0-9-]*)(?:;era=([a-z]+))?\]$/;

package/dist/regex/calendar-zoned-date-time.d.ts

@@ -0,0 +1 @@
+export declare const calendarZonedDateTime: RegExp;

package/dist/regex/calendar-zoned-date-time.js

@@ -0,0 +1,41 @@
+// GMT's own calendar-annotated ZonedDateTime string — the zoned sibling of `calendarDate`
+// (regex/calendar-date.ts). Shape:
+//
+//   <calendar-native-date>T<time><offset>[u-ca=<id>[;era=<era>]][<timeZone>]
+//   5784-06-15T14:30:00-05:00[u-ca=hebrew][America/New_York]
+//   0031-04-30T12:00:00+09:00[u-ca=japanese;era=heisei][Asia/Tokyo]
+//
+// The date half (`(\d{4,6})-(\d{2})-(\d{2})`) and the annotation half
+// (`\[u-ca=([a-z][a-z0-9-]*)(?:;era=([a-z]+))?\]`) are deliberately byte-identical to
+// `calendarDate`'s, so the two grammars cannot drift apart — `calendar-zoned-date-time.test.ts`
+// asserts every `convertDateToCalendar` output splices into this pattern.
+//
+// ---------------------------------------------------------------------------------------
+// SEGMENT ORDERING: `[u-ca=...]` comes BEFORE `[timeZone]` — the reverse of RFC 9557.
+// ---------------------------------------------------------------------------------------
+// This is deliberate and load-bearing, not an oversight, and it must not be "fixed" to match
+// Temporal's own string convention. Verified against @js-temporal/polyfill@0.5.1:
+//
+//  1. GMT's digits are calendar-native (Hebrew year 5784, not ISO year 5784), so a GMT string is
+//     never a valid RFC 9557 string in the first place — E1's decision D1. Round-trippability
+//     through `Temporal.ZonedDateTime.from` was never achievable, and the `;era=` suffix (below)
+//     makes it impossible regardless of ordering.
+//  2. RFC 9557's own ordering is actively dangerous here.
+//     `Temporal.ZonedDateTime.from("5784-01-01T14:30:00-05:00[America/New_York][u-ca=hebrew]")`
+//     SUCCEEDS, silently reading `5784-01-01` as ISO year 5784 — a ~3760-year misparse with no
+//     error anywhere. GMT's ordering makes that same string shape uniformly rejected instead:
+//     `Temporal.ZonedDateTime.from("...-05:00[u-ca=hebrew][America/New_York]")` throws
+//     `RangeError: invalid RFC 9557 string` for all 13 calendars.
+//  3. `isValidZonedDateTime` is imported by ~90 non-test files, only ~18 of which are in E7's
+//     scope. With `[u-ca=]` first, every out-of-scope function fails closed (returns its
+//     sentinel) rather than silently returning an answer computed against the wrong calendar.
+//
+// The offset stays between the time and the bracketed tail, so `<date>T<time><offset>` remains a
+// contiguous, familiar ISO-8601 head; only the bracketed tail reorders.
+//
+// Capture groups: 1 year, 2 month, 3 day, 4 time, 5 offset (optional), 6 calendar id, 7 era
+// (optional), 8 time zone. As with every GMT grammar regex, a match proves SHAPE ONLY — real
+// field/calendar/era/zone validation is delegated to `Temporal.*.from(fields, { overflow:
+// "reject" })` in `internal/calendarZonedString.ts` (see `context/coding-standards.md`'s scoped
+// manual-string-parsing exception, rule 2).
+export const calendarZonedDateTime = /^(\d{4,6})-(\d{2})-(\d{2})T(\d{2}:\d{2}(?::\d{2}(?:[.,]\d{1,9})?)?)((?:[+-]\d{2}:\d{2}(?::\d{2}(?:[.,]\d{1,9})?)?)|[Zz])?\[u-ca=([a-z][a-z0-9-]*)(?:;era=([a-z]+))?\]\[([^[\]]+)\]$/;

package/dist/regex/date-time.d.ts

@@ -0,0 +1 @@
+export declare const plainDateTime: RegExp;

package/dist/regex/date-time.js

@@ -0,0 +1,2 @@
+// ISO 8601 local date-time (extended): <date>T<time>
+export const plainDateTime = /^(?:\d{4}|[+-]\d{6})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:[.,][0-9]{1,9})?)?$/;

package/dist/regex/date.d.ts

@@ -0,0 +1,4 @@
+export declare const year: RegExp;
+export declare const month: RegExp;
+export declare const day: RegExp;
+export declare const plainDate: RegExp;

package/dist/regex/date.js

@@ -0,0 +1,5 @@
+export const year = /^(?:\d{4}|[+-]\d{6})$/;
+export const month = /^(0[1-9]|1[0-2])$/;
+export const day = /^(0[1-9]|[12][0-9]|3[01])$/;
+// ISO 8601 calendar date (extended): YYYY-MM-DD or ±YYYYYY-MM-DD
+export const plainDate = /^(?:\d{4}|[+-]\d{6})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;

package/dist/regex/http-date.d.ts

@@ -0,0 +1 @@
+export declare const httpDate: RegExp;

package/dist/regex/http-date.js

@@ -0,0 +1,7 @@
+// RFC 7231 §7.1.1.1 IMF-fixdate — the only form GMT's `formatHttp` emits, and
+// the only form `parseHttp` accepts. Day, year, and time-of-day fields are
+// all fixed-width per the grammar (unlike RFC 2822's leniently-sized day);
+// the trailing "GMT" literal is mandatory, never a numeric offset. The
+// obsolete RFC 850 and asctime HTTP-date forms are a documented limitation
+// (see `parseHttp`'s JSDoc), not supported here.
+export const httpDate = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/;

package/dist/regex/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./calendar-date.js";
+export * from "./calendar-zoned-date-time.js";
+export * from "./date.js";
+export * from "./date-time.js";
+export * from "./http-date.js";
+export * from "./leap-second.js";
+export * from "./rfc-2822.js";
+export * from "./rfc-3339.js";
+export * from "./sql-date-time.js";
+export * from "./time.js";
+export * from "./time-zone-like.js";
+export * from "./unix.js";
+export * from "./utc-date-time.js";

package/dist/regex/index.js

@@ -0,0 +1,13 @@
+export * from "./calendar-date.js";
+export * from "./calendar-zoned-date-time.js";
+export * from "./date.js";
+export * from "./date-time.js";
+export * from "./http-date.js";
+export * from "./leap-second.js";
+export * from "./rfc-2822.js";
+export * from "./rfc-3339.js";
+export * from "./sql-date-time.js";
+export * from "./time.js";
+export * from "./time-zone-like.js";
+export * from "./unix.js";
+export * from "./utc-date-time.js";