@northguild/gmt 1.14.2 → 1.16.0

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

@@ -1 +1,29 @@
+/**
+ * RegExp matching ISO 8601 local date-time (extended): `<date>T<time>`.
+ *
+ * - Date half: `YYYY-MM-DD` or `±YYYYYY-MM-DD` (6-digit year with sign, never `-000000`,
+ *   which is a Syntax Error in Temporal's `DateYear`).
+ * - Time half: `HH:mm` with optional `:ss[.fffffffff]` (fractional seconds use `.` or `,`).
+ * - Second `60` does not match. Temporal's `TimeSecond` admits it, but GMT rejects leap
+ *   seconds because Temporal would read one as `:59`. The 9-digit fraction cap is Temporal's
+ *   nanosecond precision.
+ * - No timezone designator — this is a plain/local date-time only.
+ * - Shape-only validation; real calendar validation is delegated to
+ *   `Temporal.PlainDateTime.from` in `isValidDateTime`.
+ *
+ * Capture groups: 1 month, 2 day, 3 hour. The year, minute, second and fraction are not
+ * captured.
+ *
+ * The written form only, with no RFC 9557 annotation. `isValidDateTime` reads more: it matches this
+ * against the part before the first `[` and lets Temporal read the annotations
+ * (`"…[u-ca=iso8601]"`, an elective `"…[foo=bar]"`).
+ *
+ * @example plainDateTime.test("2024-03-15T14:30:00")       // true
+ * @example plainDateTime.test("2024-03-15T14:30")          // true (seconds omitted)
+ * @example plainDateTime.test("+000031-04-30T12:00:00.123") // true (6-digit year)
+ * @example plainDateTime.exec("2024-03-15T14:30:45")?.slice(1) // ["03", "15", "14"] (month, day, hour)
+ * @example plainDateTime.test("-000000-01-01T00:00")       // false (negative zero year)
+ * @example plainDateTime.test("2024-03-15 14:30:00")       // false (space separator)
+ * @example plainDateTime.test("2024-03-15T14:30:00Z")      // false (has timezone)
+ */
 export declare const plainDateTime: RegExp;

package/dist/regex/date-time.js

@@ -1,2 +1,29 @@
-// 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})?)?$/;
+/**
+ * RegExp matching ISO 8601 local date-time (extended): `<date>T<time>`.
+ *
+ * - Date half: `YYYY-MM-DD` or `±YYYYYY-MM-DD` (6-digit year with sign, never `-000000`,
+ *   which is a Syntax Error in Temporal's `DateYear`).
+ * - Time half: `HH:mm` with optional `:ss[.fffffffff]` (fractional seconds use `.` or `,`).
+ * - Second `60` does not match. Temporal's `TimeSecond` admits it, but GMT rejects leap
+ *   seconds because Temporal would read one as `:59`. The 9-digit fraction cap is Temporal's
+ *   nanosecond precision.
+ * - No timezone designator — this is a plain/local date-time only.
+ * - Shape-only validation; real calendar validation is delegated to
+ *   `Temporal.PlainDateTime.from` in `isValidDateTime`.
+ *
+ * Capture groups: 1 month, 2 day, 3 hour. The year, minute, second and fraction are not
+ * captured.
+ *
+ * The written form only, with no RFC 9557 annotation. `isValidDateTime` reads more: it matches this
+ * against the part before the first `[` and lets Temporal read the annotations
+ * (`"…[u-ca=iso8601]"`, an elective `"…[foo=bar]"`).
+ *
+ * @example plainDateTime.test("2024-03-15T14:30:00")       // true
+ * @example plainDateTime.test("2024-03-15T14:30")          // true (seconds omitted)
+ * @example plainDateTime.test("+000031-04-30T12:00:00.123") // true (6-digit year)
+ * @example plainDateTime.exec("2024-03-15T14:30:45")?.slice(1) // ["03", "15", "14"] (month, day, hour)
+ * @example plainDateTime.test("-000000-01-01T00:00")       // false (negative zero year)
+ * @example plainDateTime.test("2024-03-15 14:30:00")       // false (space separator)
+ * @example plainDateTime.test("2024-03-15T14:30:00Z")      // false (has timezone)
+ */
+export const plainDateTime = /^(?:\d{4}|\+\d{6}|-(?!0{6})\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

@@ -1,4 +1,62 @@
+/**
+ * RegExp matching the shape of an ISO 8601 year: 4 digits, or a sign and 6 digits (Temporal's
+ * `DateYear`).
+ *
+ * - Shape only. Any 6 digits match, including years outside the range Temporal can represent
+ *   (`-271821` to `+275760`); that range is checked by `Temporal.PlainDate.from`.
+ * - `-000000` does not match: Temporal's grammar makes it a Syntax Error ("It is a Syntax Error
+ *   if DateYear is `-000000`"). `+000000` and `0000` match.
+ *
+ * @example year.test("2024")    // true
+ * @example year.test("+275760") // true (expanded year)
+ * @example year.test("-271821") // true (negative expanded year)
+ * @example year.test("+999999") // true (shape only; outside Temporal's range)
+ * @example year.test("-000000") // false (negative zero)
+ * @example year.test("24")      // false (too few digits)
+ * @example year.test("20245")   // false (5 digits without a sign)
+ */
 export declare const year: RegExp;
+/**
+ * RegExp matching an ISO 8601 month: `01`–`12`.
+ *
+ * @example month.test("01") // true
+ * @example month.test("12") // true
+ * @example month.test("13") // false (out of range)
+ * @example month.test("1")  // false (not zero-padded)
+ */
 export declare const month: RegExp;
+/**
+ * RegExp matching an ISO 8601 day of the month: `01`–`31` (shape only; whether the day exists
+ * in its month is checked by `Temporal.PlainDate.from` in `isValidDate`).
+ *
+ * @example day.test("01") // true
+ * @example day.test("31") // true
+ * @example day.test("32") // false (out of range)
+ * @example day.test("00") // false (day zero)
+ * @example day.test("9")  // false (not zero-padded)
+ */
 export declare const day: RegExp;
+/**
+ * RegExp matching ISO 8601 calendar date (extended): `YYYY-MM-DD` or `±YYYYYY-MM-DD`.
+ *
+ * - Year: 4-digit (`2024`) or 6-digit with sign (`+000031` / `-000031`), never `-000000`
+ *   (a Syntax Error in Temporal's `DateYear`).
+ * - Month: `01`–`12`, zero-padded.
+ * - Day: `01`–`31`, zero-padded (shape-only; real calendar validation is delegated to
+ *   `Temporal.PlainDate.from` in `isValidDate`).
+ *
+ * Capture groups: 1 month, 2 day. The year is not captured.
+ *
+ * The written form only, with no RFC 9557 annotation. `isValidDate` reads more: it matches this
+ * against the part before the first `[` and lets Temporal read the annotations
+ * (`"…[u-ca=iso8601]"`, an elective `"…[foo=bar]"`).
+ *
+ * @example plainDate.test("2024-03-15")       // true
+ * @example plainDate.test("+000031-04-30")    // true (6-digit year)
+ * @example plainDate.test("-000031-04-30")    // true (negative 6-digit year)
+ * @example plainDate.exec("2024-03-15")?.slice(1) // ["03", "15"] (month, day)
+ * @example plainDate.test("-000000-01-01")    // false (negative zero year)
+ * @example plainDate.test("2024-3-15")        // false (unpadded month)
+ * @example plainDate.test("2024-03-00")       // false (day zero)
+ */
 export declare const plainDate: RegExp;

package/dist/regex/date.js

@@ -1,5 +1,62 @@
-export const year = /^(?:\d{4}|[+-]\d{6})$/;
+/**
+ * RegExp matching the shape of an ISO 8601 year: 4 digits, or a sign and 6 digits (Temporal's
+ * `DateYear`).
+ *
+ * - Shape only. Any 6 digits match, including years outside the range Temporal can represent
+ *   (`-271821` to `+275760`); that range is checked by `Temporal.PlainDate.from`.
+ * - `-000000` does not match: Temporal's grammar makes it a Syntax Error ("It is a Syntax Error
+ *   if DateYear is `-000000`"). `+000000` and `0000` match.
+ *
+ * @example year.test("2024")    // true
+ * @example year.test("+275760") // true (expanded year)
+ * @example year.test("-271821") // true (negative expanded year)
+ * @example year.test("+999999") // true (shape only; outside Temporal's range)
+ * @example year.test("-000000") // false (negative zero)
+ * @example year.test("24")      // false (too few digits)
+ * @example year.test("20245")   // false (5 digits without a sign)
+ */
+export const year = /^(?:\d{4}|\+\d{6}|-(?!0{6})\d{6})$/;
+/**
+ * RegExp matching an ISO 8601 month: `01`–`12`.
+ *
+ * @example month.test("01") // true
+ * @example month.test("12") // true
+ * @example month.test("13") // false (out of range)
+ * @example month.test("1")  // false (not zero-padded)
+ */
 export const month = /^(0[1-9]|1[0-2])$/;
+/**
+ * RegExp matching an ISO 8601 day of the month: `01`–`31` (shape only; whether the day exists
+ * in its month is checked by `Temporal.PlainDate.from` in `isValidDate`).
+ *
+ * @example day.test("01") // true
+ * @example day.test("31") // true
+ * @example day.test("32") // false (out of range)
+ * @example day.test("00") // false (day zero)
+ * @example day.test("9")  // false (not zero-padded)
+ */
 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])$/;
+/**
+ * RegExp matching ISO 8601 calendar date (extended): `YYYY-MM-DD` or `±YYYYYY-MM-DD`.
+ *
+ * - Year: 4-digit (`2024`) or 6-digit with sign (`+000031` / `-000031`), never `-000000`
+ *   (a Syntax Error in Temporal's `DateYear`).
+ * - Month: `01`–`12`, zero-padded.
+ * - Day: `01`–`31`, zero-padded (shape-only; real calendar validation is delegated to
+ *   `Temporal.PlainDate.from` in `isValidDate`).
+ *
+ * Capture groups: 1 month, 2 day. The year is not captured.
+ *
+ * The written form only, with no RFC 9557 annotation. `isValidDate` reads more: it matches this
+ * against the part before the first `[` and lets Temporal read the annotations
+ * (`"…[u-ca=iso8601]"`, an elective `"…[foo=bar]"`).
+ *
+ * @example plainDate.test("2024-03-15")       // true
+ * @example plainDate.test("+000031-04-30")    // true (6-digit year)
+ * @example plainDate.test("-000031-04-30")    // true (negative 6-digit year)
+ * @example plainDate.exec("2024-03-15")?.slice(1) // ["03", "15"] (month, day)
+ * @example plainDate.test("-000000-01-01")    // false (negative zero year)
+ * @example plainDate.test("2024-3-15")        // false (unpadded month)
+ * @example plainDate.test("2024-03-00")       // false (day zero)
+ */
+export const plainDate = /^(?:\d{4}|\+\d{6}|-(?!0{6})\d{6})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;

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

@@ -1 +1,20 @@
+/**
+ * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttp` emits and
+ * the preferred HTTP-date form. Day, year, and time-of-day fields are all fixed-width per the
+ * grammar (unlike RFC 5322's leniently-sized day); the trailing "GMT" literal is mandatory,
+ * never a numeric offset.
+ *
+ * - **IMF-fixdate only.** RFC 9110 requires a recipient to accept all three HTTP-date formats;
+ *   the obsolete rfc850-date and asctime-date do not match this pattern. `parseHttp` reads all
+ *   three.
+ * - The day name is not checked against the date; `parseHttp` does check it.
+ *
+ * Capture groups: 1 day-of-week, 2 day, 3 month, 4 year, 5 hour, 6 minute, 7 second.
+ *
+ * @example httpDate.test("Wed, 09 Jun 2021 10:18:14 GMT") // true
+ * @example httpDate.test("Jun 09 2021 10:18:14 GMT")      // false (missing day-of-week)
+ * @example httpDate.test("Wed, 9 Jun 2021 10:18:14 GMT")  // false (single-digit day)
+ * @example httpDate.test("Wed, 09 Jun 2021 10:18:14 +0000") // false (numeric offset)
+ * @example httpDate.test("Wednesday, 09-Jun-21 10:18:14 GMT") // false (rfc850-date: parseHttp reads it)
+ */
 export declare const httpDate: RegExp;

package/dist/regex/http-date.js

@@ -1,7 +1,20 @@
-// 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.
+/**
+ * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttp` emits and
+ * the preferred HTTP-date form. Day, year, and time-of-day fields are all fixed-width per the
+ * grammar (unlike RFC 5322's leniently-sized day); the trailing "GMT" literal is mandatory,
+ * never a numeric offset.
+ *
+ * - **IMF-fixdate only.** RFC 9110 requires a recipient to accept all three HTTP-date formats;
+ *   the obsolete rfc850-date and asctime-date do not match this pattern. `parseHttp` reads all
+ *   three.
+ * - The day name is not checked against the date; `parseHttp` does check it.
+ *
+ * Capture groups: 1 day-of-week, 2 day, 3 month, 4 year, 5 hour, 6 minute, 7 second.
+ *
+ * @example httpDate.test("Wed, 09 Jun 2021 10:18:14 GMT") // true
+ * @example httpDate.test("Jun 09 2021 10:18:14 GMT")      // false (missing day-of-week)
+ * @example httpDate.test("Wed, 9 Jun 2021 10:18:14 GMT")  // false (single-digit day)
+ * @example httpDate.test("Wed, 09 Jun 2021 10:18:14 +0000") // false (numeric offset)
+ * @example httpDate.test("Wednesday, 09-Jun-21 10:18:14 GMT") // false (rfc850-date: parseHttp reads it)
+ */
 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

@@ -1,9 +1,11 @@
+export * from "@js-temporal/polyfill";
 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 "./nanoseconds.js";
 export * from "./rfc-2822.js";
 export * from "./rfc-3339.js";
 export * from "./sql-date-time.js";
@@ -11,3 +13,4 @@ export * from "./time.js";
 export * from "./time-zone-like.js";
 export * from "./unix.js";
 export * from "./utc-date-time.js";
+export * from "./utc-offset.js";

package/dist/regex/index.js

@@ -1,9 +1,12 @@
+// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
+export * from "@js-temporal/polyfill";
 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 "./nanoseconds.js";
 export * from "./rfc-2822.js";
 export * from "./rfc-3339.js";
 export * from "./sql-date-time.js";
@@ -11,3 +14,4 @@ export * from "./time.js";
 export * from "./time-zone-like.js";
 export * from "./unix.js";
 export * from "./utc-date-time.js";
+export * from "./utc-offset.js";

package/dist/regex/leap-second.d.ts

@@ -1 +1,46 @@
+/**
+ * RegExp fragment matching an ISO 8601 leap second (second `60`) in the time of day of a
+ * date-time or time string, in every spelling Temporal's `PlainDateTime.from`/`PlainTime.from`
+ * grammar parses.
+ *
+ * - Detects second = 60 within a date-time or time string, not a full standalone value.
+ * - Covers a `T`, `t` or space date/time separator (`DateTimeSeparator`), extended (`23:59:60`)
+ *   or basic (`235960`) time digits, extended or basic date digits, and a bare time with or
+ *   without a `T`/`t` designator (`TimeSpec`). The second may be followed by a fraction, then
+ *   `Z`/`z`, a numeric offset, `[` opening an annotation, or the end of the string: Temporal's
+ *   ParseISODateTime silently clamps a second of 60 to 59 in each case, so a guard that misses
+ *   a spelling lets that clamp through.
+ * - Looks only before the first `[`. An RFC 9557 annotation value is `1*alphanum` joined by
+ *   `-` (§4.1), so `[x=T123460Z]` is a legal elective tag, not a time of day.
+ * - Rejecting a leap second is GMT's decision, not the grammar's range: Temporal's
+ *   `TimeSecond` and RFC 3339's `time-second` both admit 60. GMT refuses the value because
+ *   Temporal cannot represent it and would otherwise read it as `:59`.
+ * - Used by `isLeapSecond`. Validators reject a second of 60 in their own patterns.
+ *
+ * @example leapSecond.test("2024-12-31T23:59:60Z")                // true
+ * @example leapSecond.test("2024-12-31T23:59:60.123+00:00")       // true
+ * @example leapSecond.test("2024-12-31t23:59:60+00:00[UTC]")      // true (lowercase t)
+ * @example leapSecond.test("20241231 235960Z")                    // true (space separator, basic format)
+ * @example leapSecond.test("2024-12-31T23:59:60")                 // true (no designator: PlainDateTime clamps it)
+ * @example leapSecond.test("23:59:60")                            // true (a time: PlainTime clamps it)
+ * @example leapSecond.test("2024-12-31T23:59:59Z")                // false (second = 59)
+ * @example leapSecond.test("2024-01-01T00:00:00Z[x=T123460Z]")    // false (inside an annotation value)
+ */
 export declare const leapSecond: RegExp;
+/**
+ * RegExp fragment matching an ISO 8601 leap second in every shape `Temporal.Instant.from`
+ * accepts.
+ *
+ * - An instant has a date, a `T`, `t` or space separator and a designator (`Z`/`z` or an
+ *   offset), so a second of 60 must be followed by a fraction or that designator (or `[`).
+ * - Covers extended (`23:59:60`) or basic (`235960`) time digits, and nothing inside an
+ *   RFC 9557 annotation value.
+ *
+ * @example instantLeapSecond.test("2016-12-31T23:59:60Z")              // true
+ * @example instantLeapSecond.test("2016-12-31 23:59:60Z")              // true (space separator)
+ * @example instantLeapSecond.test("20161231t235960Z")                  // true (basic format)
+ * @example instantLeapSecond.test("2016-12-31T23:59:59Z")              // false (second = 59)
+ * @example instantLeapSecond.test("2016-12-31T23:59:60")               // false (no designator, so not an instant)
+ * @example instantLeapSecond.test("2024-01-01T00:00:00Z[x=T123460Z]")  // false (inside an annotation value)
+ */
+export declare const instantLeapSecond: RegExp;

package/dist/regex/leap-second.js

@@ -1,2 +1,46 @@
-// ISO 8601 leap second pattern (second = 60)
-export const leapSecond = /T\d{2}:\d{2}:60(?:[.,]\d+)?(?:[-+Zz[])/;
+/**
+ * RegExp fragment matching an ISO 8601 leap second (second `60`) in the time of day of a
+ * date-time or time string, in every spelling Temporal's `PlainDateTime.from`/`PlainTime.from`
+ * grammar parses.
+ *
+ * - Detects second = 60 within a date-time or time string, not a full standalone value.
+ * - Covers a `T`, `t` or space date/time separator (`DateTimeSeparator`), extended (`23:59:60`)
+ *   or basic (`235960`) time digits, extended or basic date digits, and a bare time with or
+ *   without a `T`/`t` designator (`TimeSpec`). The second may be followed by a fraction, then
+ *   `Z`/`z`, a numeric offset, `[` opening an annotation, or the end of the string: Temporal's
+ *   ParseISODateTime silently clamps a second of 60 to 59 in each case, so a guard that misses
+ *   a spelling lets that clamp through.
+ * - Looks only before the first `[`. An RFC 9557 annotation value is `1*alphanum` joined by
+ *   `-` (§4.1), so `[x=T123460Z]` is a legal elective tag, not a time of day.
+ * - Rejecting a leap second is GMT's decision, not the grammar's range: Temporal's
+ *   `TimeSecond` and RFC 3339's `time-second` both admit 60. GMT refuses the value because
+ *   Temporal cannot represent it and would otherwise read it as `:59`.
+ * - Used by `isLeapSecond`. Validators reject a second of 60 in their own patterns.
+ *
+ * @example leapSecond.test("2024-12-31T23:59:60Z")                // true
+ * @example leapSecond.test("2024-12-31T23:59:60.123+00:00")       // true
+ * @example leapSecond.test("2024-12-31t23:59:60+00:00[UTC]")      // true (lowercase t)
+ * @example leapSecond.test("20241231 235960Z")                    // true (space separator, basic format)
+ * @example leapSecond.test("2024-12-31T23:59:60")                 // true (no designator: PlainDateTime clamps it)
+ * @example leapSecond.test("23:59:60")                            // true (a time: PlainTime clamps it)
+ * @example leapSecond.test("2024-12-31T23:59:59Z")                // false (second = 59)
+ * @example leapSecond.test("2024-01-01T00:00:00Z[x=T123460Z]")    // false (inside an annotation value)
+ */
+export const leapSecond = /^(?:[^[]*?[Tt ]|[Tt]?)\d{2}:?\d{2}:?60(?:[.,]\d+)?(?:[-+Zz[]|$)/;
+/**
+ * RegExp fragment matching an ISO 8601 leap second in every shape `Temporal.Instant.from`
+ * accepts.
+ *
+ * - An instant has a date, a `T`, `t` or space separator and a designator (`Z`/`z` or an
+ *   offset), so a second of 60 must be followed by a fraction or that designator (or `[`).
+ * - Covers extended (`23:59:60`) or basic (`235960`) time digits, and nothing inside an
+ *   RFC 9557 annotation value.
+ *
+ * @example instantLeapSecond.test("2016-12-31T23:59:60Z")              // true
+ * @example instantLeapSecond.test("2016-12-31 23:59:60Z")              // true (space separator)
+ * @example instantLeapSecond.test("20161231t235960Z")                  // true (basic format)
+ * @example instantLeapSecond.test("2016-12-31T23:59:59Z")              // false (second = 59)
+ * @example instantLeapSecond.test("2016-12-31T23:59:60")               // false (no designator, so not an instant)
+ * @example instantLeapSecond.test("2024-01-01T00:00:00Z[x=T123460Z]")  // false (inside an annotation value)
+ */
+export const instantLeapSecond = /^[^[]*?[Tt ]\d{2}:?\d{2}:?60(?:[.,]\d+)?[-+Zz[]/;

package/dist/regex/nanoseconds.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RegExp matching the canonical decimal form of a nanosecond timestamp — the shape
+ * `formatNanoseconds` emits and `parseNanoseconds` accepts.
+ *
+ * - An optional `-`, then digits with no leading zeros. Anchored, so it matches a whole
+ *   value rather than a fragment.
+ * - Exponents, fractions, hex, digit separators, a `+` sign and surrounding whitespace are
+ *   all rejected. That strictness is the point: a payload written by another language's
+ *   serialiser either reads back exactly or fails loudly, never silently coerced.
+ * - Shape only. The representable-instant range is a separate check — see
+ *   `isValidNanoPattern`, which applies both.
+ *
+ * @example nanosecondDecimal.test("1710072000123456789") // true
+ * @example nanosecondDecimal.test("-1000000000") // true
+ * @example nanosecondDecimal.test("0") // true
+ * @example nanosecondDecimal.test("01") // false (leading zero)
+ * @example nanosecondDecimal.test("1.5") // false
+ * @example nanosecondDecimal.test("1e18") // false
+ */
+export declare const nanosecondDecimal: RegExp;

package/dist/regex/nanoseconds.js

@@ -0,0 +1,20 @@
+/**
+ * RegExp matching the canonical decimal form of a nanosecond timestamp — the shape
+ * `formatNanoseconds` emits and `parseNanoseconds` accepts.
+ *
+ * - An optional `-`, then digits with no leading zeros. Anchored, so it matches a whole
+ *   value rather than a fragment.
+ * - Exponents, fractions, hex, digit separators, a `+` sign and surrounding whitespace are
+ *   all rejected. That strictness is the point: a payload written by another language's
+ *   serialiser either reads back exactly or fails loudly, never silently coerced.
+ * - Shape only. The representable-instant range is a separate check — see
+ *   `isValidNanoPattern`, which applies both.
+ *
+ * @example nanosecondDecimal.test("1710072000123456789") // true
+ * @example nanosecondDecimal.test("-1000000000") // true
+ * @example nanosecondDecimal.test("0") // true
+ * @example nanosecondDecimal.test("01") // false (leading zero)
+ * @example nanosecondDecimal.test("1.5") // false
+ * @example nanosecondDecimal.test("1e18") // false
+ */
+export const nanosecondDecimal = /^-?(?:0|[1-9][0-9]*)$/;

package/dist/regex/rfc-2822.d.ts

@@ -1 +1,27 @@
+/**
+ * RegExp matching the strict shape of an RFC 5322 §3.3 date-time (obsoletes RFC 2822): the
+ * single-space, case-exact form a generator writes. English day/month names are mandated by
+ * the spec regardless of locale — see `internal/englishCalendarNames.ts`. Day is `1*2DIGIT` per
+ * the formal grammar, so single-digit days are valid even though GMT's own formatter always
+ * emits the zero-padded 2-digit form. `zone` accepts a numeric offset or one of the obsolete
+ * named zones RFC 5322 §4.3 lists (UT/GMT plus the eight North American zones).
+ *
+ * - **A shape check, not the receiver grammar.** RFC 5322 §4 says obsolete syntax "MUST be
+ *   accepted and parsed by a conformant receiver", and §3.3 itself allows folding white space,
+ *   comments, lower-case names and 5-digit years. This pattern matches none of those; §4.3
+ *   also says military and unknown alphabetic zones SHOULD be read as `-0000`, not rejected.
+ *   `parseRfc2822` reads the full receiver grammar — use it to decode a header, and this
+ *   pattern only to check that a string has the strict shape.
+ * - The day-of-week is not checked against the date; `parseRfc2822` does check it.
+ *
+ * Capture groups: 1 day-of-week (optional, for weekday-prefixed form), 2 day, 3 month,
+ * 4 year, 5 hour, 6 minute, 7 second (optional), 8 zone.
+ *
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 GMT")   // true
+ * @example rfc2822DateTime.test("09 Jun 2021 10:18:14 +0000")       // true (no weekday)
+ * @example rfc2822DateTime.test("9 Jun 2021 10:18:14 PST")         // true (single-digit day)
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 EST")   // true (named zone)
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 -0400 (EDT)") // false (comment: valid RFC 5322, parseRfc2822 reads it)
+ * @example rfc2822DateTime.test("2024-03-15T14:30:00Z")            // false (ISO shape)
+ */
 export declare const rfc2822DateTime: RegExp;

package/dist/regex/rfc-2822.js

@@ -1,9 +1,27 @@
-// RFC 5322 §3.3 date-time grammar (obsoletes RFC 2822, same date-time shape).
-// English day/month names are mandated by the spec regardless of locale — see
-// `internal/englishCalendarNames.ts`. Day is `1*2DIGIT` per the formal
-// grammar, so single-digit days are valid on input even though GMT's own
-// formatter always emits the zero-padded 2-digit form. `zone` accepts a
-// numeric offset or one of the obsolete named zones RFC 5322 §4.3 lists
-// (UT/GMT plus the eight North American zones); any other obs-zone letter is
-// unrecognized and treated as invalid rather than guessed at.
+/**
+ * RegExp matching the strict shape of an RFC 5322 §3.3 date-time (obsoletes RFC 2822): the
+ * single-space, case-exact form a generator writes. English day/month names are mandated by
+ * the spec regardless of locale — see `internal/englishCalendarNames.ts`. Day is `1*2DIGIT` per
+ * the formal grammar, so single-digit days are valid even though GMT's own formatter always
+ * emits the zero-padded 2-digit form. `zone` accepts a numeric offset or one of the obsolete
+ * named zones RFC 5322 §4.3 lists (UT/GMT plus the eight North American zones).
+ *
+ * - **A shape check, not the receiver grammar.** RFC 5322 §4 says obsolete syntax "MUST be
+ *   accepted and parsed by a conformant receiver", and §3.3 itself allows folding white space,
+ *   comments, lower-case names and 5-digit years. This pattern matches none of those; §4.3
+ *   also says military and unknown alphabetic zones SHOULD be read as `-0000`, not rejected.
+ *   `parseRfc2822` reads the full receiver grammar — use it to decode a header, and this
+ *   pattern only to check that a string has the strict shape.
+ * - The day-of-week is not checked against the date; `parseRfc2822` does check it.
+ *
+ * Capture groups: 1 day-of-week (optional, for weekday-prefixed form), 2 day, 3 month,
+ * 4 year, 5 hour, 6 minute, 7 second (optional), 8 zone.
+ *
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 GMT")   // true
+ * @example rfc2822DateTime.test("09 Jun 2021 10:18:14 +0000")       // true (no weekday)
+ * @example rfc2822DateTime.test("9 Jun 2021 10:18:14 PST")         // true (single-digit day)
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 EST")   // true (named zone)
+ * @example rfc2822DateTime.test("Wed, 09 Jun 2021 10:18:14 -0400 (EDT)") // false (comment: valid RFC 5322, parseRfc2822 reads it)
+ * @example rfc2822DateTime.test("2024-03-15T14:30:00Z")            // false (ISO shape)
+ */
 export const rfc2822DateTime = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun), )?(\d{1,2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2})(?::(\d{2}))? (UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT|[+-]\d{4})$/;

package/dist/regex/rfc-3339.d.ts

@@ -1 +1,27 @@
+/**
+ * RegExp matching an RFC 3339 §5.6 date-time: ISO 8601 with a mandatory offset
+ * (`Z` or `±HH:MM`).
+ *
+ * - Separator may be `T`, `t`, or a space.
+ * - Offset is mandatory. GMT's own zoned strings with a bracketed IANA zone annotation
+ *   (`"...+00:00[UTC]"`) do NOT match — use `calendarZonedDateTime` for those.
+ * - Offset hour `00`–`23` and minute `00`–`59` (§5.6 `time-numoffset`).
+ * - Two GMT restrictions narrower than the grammar: second `60` does not match (§5.6
+ *   `time-second` admits it; GMT rejects leap seconds because Temporal would read one as
+ *   `:59`), and the fraction is capped at 9 digits (`time-secfrac` is `1*DIGIT`; Temporal keeps
+ *   nanoseconds).
+ * - Shape-only validation; real calendar validation is delegated to
+ *   `Temporal.PlainDateTime.from(...).toZonedDateTime(offset)` in `parseRfc3339`.
+ * - Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second,
+ *   7 fractional (optional), 8 offset.
+ *
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00-04:00")      // true
+ * @example rfc3339DateTime.test("2024-03-15t14:30:00z")           // true
+ * @example rfc3339DateTime.test("2024-03-15 14:30:00Z")           // true (space separator)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00")           // false (no offset)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00+00:00[UTC]") // false (bracketed zone)
+ * @example rfc3339DateTime.test("2024-3-15T14:30:00Z")            // false (unpadded)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00+24:00")      // false (offset hour out of range)
+ * @example rfc3339DateTime.test("2016-12-31T23:59:60Z")           // false (leap second; GMT rejects it)
+ */
 export declare const rfc3339DateTime: RegExp;

package/dist/regex/rfc-3339.js

@@ -1,7 +1,27 @@
-// RFC 3339 §5.6 date-time — the same field grammar as ISO 8601 but with a
-// *mandatory* offset (Z or ±HH:MM) and a date/time separator that may be
-// "T", "t", or " ". GMT's own zoned strings additionally carry a bracketed
-// IANA zone annotation ("...+00:00[UTC]") that RFC 3339 does not permit,
-// which is why this needs its own regex rather than reusing `plainDateTime`
-// or `zoned`-style patterns (see roadmap J13's RFC 3339 go/no-go decision).
-export const rfc3339DateTime = /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])[Tt ](0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(\.[0-9]{1,9})?(Z|z|[+-][0-9]{2}:[0-9]{2})$/;
+/**
+ * RegExp matching an RFC 3339 §5.6 date-time: ISO 8601 with a mandatory offset
+ * (`Z` or `±HH:MM`).
+ *
+ * - Separator may be `T`, `t`, or a space.
+ * - Offset is mandatory. GMT's own zoned strings with a bracketed IANA zone annotation
+ *   (`"...+00:00[UTC]"`) do NOT match — use `calendarZonedDateTime` for those.
+ * - Offset hour `00`–`23` and minute `00`–`59` (§5.6 `time-numoffset`).
+ * - Two GMT restrictions narrower than the grammar: second `60` does not match (§5.6
+ *   `time-second` admits it; GMT rejects leap seconds because Temporal would read one as
+ *   `:59`), and the fraction is capped at 9 digits (`time-secfrac` is `1*DIGIT`; Temporal keeps
+ *   nanoseconds).
+ * - Shape-only validation; real calendar validation is delegated to
+ *   `Temporal.PlainDateTime.from(...).toZonedDateTime(offset)` in `parseRfc3339`.
+ * - Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second,
+ *   7 fractional (optional), 8 offset.
+ *
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00-04:00")      // true
+ * @example rfc3339DateTime.test("2024-03-15t14:30:00z")           // true
+ * @example rfc3339DateTime.test("2024-03-15 14:30:00Z")           // true (space separator)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00")           // false (no offset)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00+00:00[UTC]") // false (bracketed zone)
+ * @example rfc3339DateTime.test("2024-3-15T14:30:00Z")            // false (unpadded)
+ * @example rfc3339DateTime.test("2024-03-15T14:30:00+24:00")      // false (offset hour out of range)
+ * @example rfc3339DateTime.test("2016-12-31T23:59:60Z")           // false (leap second; GMT rejects it)
+ */
+export const rfc3339DateTime = /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])[Tt ](0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(\.[0-9]{1,9})?(Z|z|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])$/;

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

@@ -1 +1,34 @@
+/**
+ * RegExp matching a SQL timestamp literal without a time zone: `YYYY-MM-DD HH:MM:SS[.fffffffff]`.
+ *
+ * The grammar is SQL-92 §5.3 `<timestamp string>` and the ODBC `ts` escape
+ * (`yyyy-mm-dd hh:mm:ss[.f...]`):
+ *
+ * - `<date value> <space> <time value>`: a single space separator, never `T`.
+ * - Syntax Rule 21: the year is four digits and every other field two digits, zero-padded. No
+ *   sign and no expanded year.
+ * - Table 10: YEAR `0001`–`9999`, MONTH `01`–`12`, DAY `01`–`31`, HOUR `00`–`23`, MINUTE
+ *   `00`–`59`.
+ * - Seconds are required (`<time value>` is `<hours value>:<minutes value>:<seconds value>`).
+ * - `<seconds value> ::= <seconds integer value> [ <period> [ <seconds fraction> ] ]`: an optional
+ *   `.` then up to 9 fraction digits. SQL-92 leaves the precision to the implementation; 9 is
+ *   Temporal's nanosecond.
+ * - SECOND `60`–`61` does not match, although Table 10 allows them: GMT rejects leap seconds
+ *   because Temporal would read one as `:59`.
+ * - Shape-only validation; the calendar date is checked by `Temporal.PlainDateTime.from` in
+ *   `parseSql`.
+ *
+ * Capture groups: 1 month, 2 day, 3 hour. The year, minute, second and fraction are not
+ * captured.
+ *
+ * @example sqlDateTime.test("2024-03-15 14:30:00.123456789") // true
+ * @example sqlDateTime.test("0001-01-01 00:00:00")           // true (the first year SQL allows)
+ * @example sqlDateTime.test("2024-03-15 14:30:00.")          // true (period with no fraction)
+ * @example sqlDateTime.test("2024-03-15 14:30")              // false (seconds are required)
+ * @example sqlDateTime.test("0000-01-01 00:00:00")           // false (year outside 0001–9999)
+ * @example sqlDateTime.test("+002024-03-15 14:30:00")        // false (expanded year)
+ * @example sqlDateTime.test("2024-03-15T14:30:00")           // false (T separator)
+ * @example sqlDateTime.test("2024-3-5 14:30:00")             // false (unpadded)
+ * @example sqlDateTime.test("2024-03-15 14:30:60")           // false (leap second; GMT rejects it)
+ */
 export declare const sqlDateTime: RegExp;