@northguild/gmt 1.18.0 → 1.20.0

package/dist/plain/validate/isValidDate.js

@@ -1,7 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isoStringBody } from "../../internal/isoStringBody.js";
-import { plainDate } from "../../regex/index.js";
-import { isLeapSecond } from "./isLeapSecond.js";
+import { isDateString } from "../../internal/inputChecks.js";
 /**
  * Return true if `value` is a valid ISO PlainDate string.
  *
@@ -26,17 +23,5 @@ import { isLeapSecond } from "./isLeapSecond.js";
  * @example isValidDate("2024-12-31T23:59:60") // false (leap second - not a valid date)
  */
 export function isValidDate(value) {
-    const body = isoStringBody(value);
-    if (isLeapSecond(body)) {
-        return false;
-    }
-    if (!plainDate.test(body)) {
-        return false;
-    }
-    try {
-        return Temporal.PlainDate.from(value).calendarId === "iso8601";
-    }
-    catch {
-        return false;
-    }
+    return isDateString(value);
 }

package/dist/plain/validate/isValidDateRange.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDate } from "./isValidDate.js";
 import { isObject, isOptionsArgument } from "../../internal/isObject.js";
 /**

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

@@ -13,7 +13,7 @@
  *
  * @example isValidDateTime("2024-02-29T12:34:56") // true
  * @example isValidDateTime("2024-02-30T12:34:56") // false (invalid date)
- * @example isValidDateTime("2024-02-29T12:34:56[America/New_York]") // true (time zone annotation ignored)
+ * @example isValidDateTime("2024-02-29T12:34:56[Asia/Kolkata]") // true (time zone annotation ignored)
  * @example isValidDateTime("2024-02-29T12:34:56[!foo=bar]") // false (unknown critical annotation)
  * @example isValidDateTime("2024-02-29T12:34:56[u-ca=hebrew]") // false (non-ISO calendar)
  * @example isValidDateTime("2024-02-29T24:00:00") // false (invalid time)

package/dist/plain/validate/isValidDateTime.js

@@ -1,7 +1,7 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isoStringBody } from "../../internal/isoStringBody.js";
 import { plainDateTime } from "../../regex/index.js";
-import { isLeapSecond } from "./isLeapSecond.js";
+import { hasSecond60 } from "./hasSecond60.js";
 /**
  * Return true when `value` is a valid PlainDateTime string.
  *
@@ -17,7 +17,7 @@ import { isLeapSecond } from "./isLeapSecond.js";
  *
  * @example isValidDateTime("2024-02-29T12:34:56") // true
  * @example isValidDateTime("2024-02-30T12:34:56") // false (invalid date)
- * @example isValidDateTime("2024-02-29T12:34:56[America/New_York]") // true (time zone annotation ignored)
+ * @example isValidDateTime("2024-02-29T12:34:56[Asia/Kolkata]") // true (time zone annotation ignored)
  * @example isValidDateTime("2024-02-29T12:34:56[!foo=bar]") // false (unknown critical annotation)
  * @example isValidDateTime("2024-02-29T12:34:56[u-ca=hebrew]") // false (non-ISO calendar)
  * @example isValidDateTime("2024-02-29T24:00:00") // false (invalid time)
@@ -25,7 +25,7 @@ import { isLeapSecond } from "./isLeapSecond.js";
  */
 export function isValidDateTime(value) {
     const body = isoStringBody(value);
-    if (isLeapSecond(body)) {
+    if (hasSecond60(body)) {
         return false;
     }
     if (!plainDateTime.test(body)) {

package/dist/plain/validate/isValidDateTimeRange.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "./isValidDateTime.js";
 import { isObject, isOptionsArgument } from "../../internal/isObject.js";
 /**

package/dist/plain/validate/isValidIsoDateLike.js

@@ -1,7 +1,7 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isoStringBody } from "../../internal/isoStringBody.js";
 import { plainDate, plainDateTime } from "../../regex/index.js";
-import { isLeapSecond } from "./isLeapSecond.js";
+import { hasSecond60 } from "./hasSecond60.js";
 /**
  * Return true when the input is a valid PlainDate or PlainDateTime ISO string.
  *
@@ -25,7 +25,7 @@ import { isLeapSecond } from "./isLeapSecond.js";
  */
 export function isValidIsoDateLike(value) {
     const body = isoStringBody(value);
-    if (isLeapSecond(body)) {
+    if (hasSecond60(body)) {
         return false;
     }
     if (plainDate.test(body)) {

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

@@ -0,0 +1,33 @@
+/**
+ * Return true when `value` is a real SQL timestamp literal without a time zone: the
+ * `YYYY-MM-DD HH:MM:SS[.fff]` value of a standard SQL `TIMESTAMP` or a MySQL/SQLite `DATETIME`
+ * column. It checks one date-and-time value, not a SQL statement.
+ *
+ * - True exactly when `parseSqlDateTime` returns a plain string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Grammar:** SQL-92 §5.3 `<timestamp string>` and the ODBC `ts` escape, as `sqlDateTime`
+ *   matches: a single space separator, a four-digit year `0001`–`9999`, two-digit month, day,
+ *   hour, minute and second (seconds are required), and an optional `.` followed by up to 9
+ *   fraction digits.
+ * - Checks the calendar as well as the shape. The `sqlDateTime` pattern proves the shape alone, so
+ *   it matches a day that does not exist: 30 February, 29 February in a common year and 31 June
+ *   are false here.
+ * - False for a second of 60: GMT rejects leap seconds.
+ * - **Plain only.** A `T` separator, a `Z` and an offset are false: SQL's offset-carrying
+ *   `TIMESTAMP WITH TIME ZONE` literal is out of scope.
+ * - False for a non-string. Read the value with `parseSqlDateTime`; write one with
+ *   `formatSqlDateTime`.
+ *
+ * @param value candidate SQL timestamp literal
+ * @returns boolean indicating validity
+ *
+ * @example isValidSqlDateTime("2024-03-15 14:30:00") // true
+ * @example isValidSqlDateTime("2024-03-15 14:30:00.123456789") // true
+ * @example isValidSqlDateTime("2024-02-30 14:30:00") // false (February has no 30th; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2023-02-29 14:30:00") // false (2023 has no 29 February; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2024-06-31 00:00:00") // false (June has 30 days; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2024-03-15 14:30") // false (seconds are required)
+ * @example isValidSqlDateTime("2024-03-15T14:30:00") // false (T separator)
+ * @example isValidSqlDateTime("not a date") // false
+ */
+export declare function isValidSqlDateTime(value: string): boolean;

package/dist/plain/validate/isValidSqlDateTime.js

@@ -0,0 +1,36 @@
+import { parseSqlDateTime } from "../parse/parseSqlDateTime.js";
+/**
+ * Return true when `value` is a real SQL timestamp literal without a time zone: the
+ * `YYYY-MM-DD HH:MM:SS[.fff]` value of a standard SQL `TIMESTAMP` or a MySQL/SQLite `DATETIME`
+ * column. It checks one date-and-time value, not a SQL statement.
+ *
+ * - True exactly when `parseSqlDateTime` returns a plain string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Grammar:** SQL-92 §5.3 `<timestamp string>` and the ODBC `ts` escape, as `sqlDateTime`
+ *   matches: a single space separator, a four-digit year `0001`–`9999`, two-digit month, day,
+ *   hour, minute and second (seconds are required), and an optional `.` followed by up to 9
+ *   fraction digits.
+ * - Checks the calendar as well as the shape. The `sqlDateTime` pattern proves the shape alone, so
+ *   it matches a day that does not exist: 30 February, 29 February in a common year and 31 June
+ *   are false here.
+ * - False for a second of 60: GMT rejects leap seconds.
+ * - **Plain only.** A `T` separator, a `Z` and an offset are false: SQL's offset-carrying
+ *   `TIMESTAMP WITH TIME ZONE` literal is out of scope.
+ * - False for a non-string. Read the value with `parseSqlDateTime`; write one with
+ *   `formatSqlDateTime`.
+ *
+ * @param value candidate SQL timestamp literal
+ * @returns boolean indicating validity
+ *
+ * @example isValidSqlDateTime("2024-03-15 14:30:00") // true
+ * @example isValidSqlDateTime("2024-03-15 14:30:00.123456789") // true
+ * @example isValidSqlDateTime("2024-02-30 14:30:00") // false (February has no 30th; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2023-02-29 14:30:00") // false (2023 has no 29 February; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2024-06-31 00:00:00") // false (June has 30 days; the sqlDateTime pattern matches it)
+ * @example isValidSqlDateTime("2024-03-15 14:30") // false (seconds are required)
+ * @example isValidSqlDateTime("2024-03-15T14:30:00") // false (T separator)
+ * @example isValidSqlDateTime("not a date") // false
+ */
+export function isValidSqlDateTime(value) {
+    return parseSqlDateTime(value) !== "";
+}

package/dist/plain/validate/isValidTime.js

@@ -1,7 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isoStringBody } from "../../internal/isoStringBody.js";
-import { plainTime } from "../../regex/index.js";
-import { isLeapSecond } from "./isLeapSecond.js";
+import { isTimeString } from "../../internal/inputChecks.js";
 /**
  * Return true when `value` is a valid ISO PlainTime string.
  *
@@ -23,18 +20,5 @@ import { isLeapSecond } from "./isLeapSecond.js";
  * @example isValidTime("23:59:60") // false (leap second)
  */
 export function isValidTime(value) {
-    const body = isoStringBody(value);
-    if (isLeapSecond(body)) {
-        return false;
-    }
-    if (!plainTime.test(body)) {
-        return false;
-    }
-    try {
-        Temporal.PlainTime.from(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return isTimeString(value);
 }

package/dist/plain/validate/isValidTimeRange.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidTime } from "./isValidTime.js";
 import { isObject, isOptionsArgument } from "../../internal/isObject.js";
 /**

package/dist/precision/convert/fromNanoseconds.d.ts

@@ -2,25 +2,31 @@
  * Convert nanoseconds since the Unix epoch back to an ISO 8601 string.
  *
  * - Returns a UTC instant string when no time zone is given, and a zoned string
- *   (`"...[America/New_York]"`) when one is.
+ *   (`"...[Asia/Tokyo]"`) when one is.
  * - No disambiguation policy applies: an instant maps to exactly one wall time in a zone,
  *   so DST gaps and overlaps cannot arise on this direction of the conversion.
- * - A time zone, when given, must be a valid IANA identifier. `undefined` is the same as omitting
- *   it (UTC), as TC39 treats an undefined argument as absent.
+ * - A time zone, when given, must be a time zone identifier: an IANA name or a UTC offset to the
+ *   minute. `undefined` is the same as omitting it (UTC), as TC39 treats an undefined argument as
+ *   absent.
  * - Rejects values outside the range `Temporal.Instant` can represent
  *   (±8_640_000_000_000_000_000_000n, i.e. ±10^8 days from the epoch).
  * - **Storage round-trip:** most engines cannot hold nanoseconds — PostgreSQL `timestamptz`
  *   stores microseconds — so writing this value and reading it back breaks equality unless
  *   the caller applies `truncateNanoseconds` to the target precision first.
  * - Returns "" on invalid input.
+ * - An offset with seconds (`-00:44:30`) returns `""`. A written zone cannot carry seconds (RFC
+ *   9557 §4.1), so the result could not name it. Pass the IANA name, or call
+ *   `fromOffsetInstant({ instant, offset })` for the local time with its full offset and no
+ *   bracket.
  *
  * @param nanoseconds nanoseconds since the Unix epoch (bigint)
- * @param timeZone optional IANA name or UTC offset; omitted or `undefined` is UTC
+ * @param timeZone optional IANA name or a UTC offset to the minute (what `isValidTimeZone`
+ *   accepts); omitted or `undefined` is UTC
  * @returns ISO 8601 instant string (UTC), zoned ISO 8601 string when a timeZone is given, or "" on invalid input
  *
  * @example fromNanoseconds(0n) // "1970-01-01T00:00:00Z"
  * @example fromNanoseconds(1710072000123456789n) // "2024-03-10T12:00:00.123456789Z"
- * @example fromNanoseconds(1710072000123456789n, "America/New_York") // "2024-03-10T08:00:00.123456789-04:00[America/New_York]"
+ * @example fromNanoseconds(1710072000123456789n, "Asia/Tokyo") // "2024-03-10T21:00:00.123456789+09:00[Asia/Tokyo]"
  * @example fromNanoseconds(-1000000000n) // "1969-12-31T23:59:59Z"
  * @example fromNanoseconds(0n, "Not/AZone") // ""
  * @example fromNanoseconds(0n, undefined) // "1970-01-01T00:00:00Z" — undefined is the same as omitted

package/dist/precision/convert/fromNanoseconds.js

@@ -1,29 +1,35 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidEpochNanoseconds } from "../../internal/index.js";
 import { isValidTimeZone } from "../../zoned/validate/index.js";
 /**
  * Convert nanoseconds since the Unix epoch back to an ISO 8601 string.
  *
  * - Returns a UTC instant string when no time zone is given, and a zoned string
- *   (`"...[America/New_York]"`) when one is.
+ *   (`"...[Asia/Tokyo]"`) when one is.
  * - No disambiguation policy applies: an instant maps to exactly one wall time in a zone,
  *   so DST gaps and overlaps cannot arise on this direction of the conversion.
- * - A time zone, when given, must be a valid IANA identifier. `undefined` is the same as omitting
- *   it (UTC), as TC39 treats an undefined argument as absent.
+ * - A time zone, when given, must be a time zone identifier: an IANA name or a UTC offset to the
+ *   minute. `undefined` is the same as omitting it (UTC), as TC39 treats an undefined argument as
+ *   absent.
  * - Rejects values outside the range `Temporal.Instant` can represent
  *   (±8_640_000_000_000_000_000_000n, i.e. ±10^8 days from the epoch).
  * - **Storage round-trip:** most engines cannot hold nanoseconds — PostgreSQL `timestamptz`
  *   stores microseconds — so writing this value and reading it back breaks equality unless
  *   the caller applies `truncateNanoseconds` to the target precision first.
  * - Returns "" on invalid input.
+ * - An offset with seconds (`-00:44:30`) returns `""`. A written zone cannot carry seconds (RFC
+ *   9557 §4.1), so the result could not name it. Pass the IANA name, or call
+ *   `fromOffsetInstant({ instant, offset })` for the local time with its full offset and no
+ *   bracket.
  *
  * @param nanoseconds nanoseconds since the Unix epoch (bigint)
- * @param timeZone optional IANA name or UTC offset; omitted or `undefined` is UTC
+ * @param timeZone optional IANA name or a UTC offset to the minute (what `isValidTimeZone`
+ *   accepts); omitted or `undefined` is UTC
  * @returns ISO 8601 instant string (UTC), zoned ISO 8601 string when a timeZone is given, or "" on invalid input
  *
  * @example fromNanoseconds(0n) // "1970-01-01T00:00:00Z"
  * @example fromNanoseconds(1710072000123456789n) // "2024-03-10T12:00:00.123456789Z"
- * @example fromNanoseconds(1710072000123456789n, "America/New_York") // "2024-03-10T08:00:00.123456789-04:00[America/New_York]"
+ * @example fromNanoseconds(1710072000123456789n, "Asia/Tokyo") // "2024-03-10T21:00:00.123456789+09:00[Asia/Tokyo]"
  * @example fromNanoseconds(-1000000000n) // "1969-12-31T23:59:59Z"
  * @example fromNanoseconds(0n, "Not/AZone") // ""
  * @example fromNanoseconds(0n, undefined) // "1970-01-01T00:00:00Z" — undefined is the same as omitted

package/dist/precision/convert/toNanoseconds.d.ts

@@ -32,8 +32,8 @@
  * @example toNanoseconds("1970-01-01T00:00:00Z") // 0n
  * @example toNanoseconds("2024-03-10T12:00:00.123456789Z") // 1710072000123456789n
  * @example toNanoseconds("1969-12-31T23:59:59Z") // -1000000000n
- * @example toNanoseconds("2024-03-10T12:00:00-05:00[America/New_York]") // 1710090000000000000n
- * @example toNanoseconds("2024-03-10T12:00:00+05:00[America/New_York]") // 1710054000000000000n — the offset decides, the zone is not checked
+ * @example toNanoseconds("2024-03-10T12:00:00+05:30[Asia/Kolkata]") // 1710052200000000000n
+ * @example toNanoseconds("2024-03-10T12:00:00+05:00[Asia/Kolkata]") // 1710054000000000000n — the offset decides, the zone is not checked
  * @example toNanoseconds("1960-01-01T00:20:00-00:45[Africa/Monrovia]") // -315615330000000000n — the zone's −00:44:30, which `-00:45` rounds
  * @example toNanoseconds("2024-03-10T12:00:00") // 0n — no offset designator
  * @example toNanoseconds("20240310T120000Z") // 0n — basic format

package/dist/precision/convert/toNanoseconds.js

@@ -33,8 +33,8 @@ import { parseInstantNanoseconds } from "../../internal/index.js";
  * @example toNanoseconds("1970-01-01T00:00:00Z") // 0n
  * @example toNanoseconds("2024-03-10T12:00:00.123456789Z") // 1710072000123456789n
  * @example toNanoseconds("1969-12-31T23:59:59Z") // -1000000000n
- * @example toNanoseconds("2024-03-10T12:00:00-05:00[America/New_York]") // 1710090000000000000n
- * @example toNanoseconds("2024-03-10T12:00:00+05:00[America/New_York]") // 1710054000000000000n — the offset decides, the zone is not checked
+ * @example toNanoseconds("2024-03-10T12:00:00+05:30[Asia/Kolkata]") // 1710052200000000000n
+ * @example toNanoseconds("2024-03-10T12:00:00+05:00[Asia/Kolkata]") // 1710054000000000000n — the offset decides, the zone is not checked
  * @example toNanoseconds("1960-01-01T00:20:00-00:45[Africa/Monrovia]") // -315615330000000000n — the zone's −00:44:30, which `-00:45` rounds
  * @example toNanoseconds("2024-03-10T12:00:00") // 0n — no offset designator
  * @example toNanoseconds("20240310T120000Z") // 0n — basic format

package/dist/precision/index.d.ts

@@ -1,4 +1,4 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
 export * from "./convert/index.js";
 export * from "./format/index.js";

package/dist/precision/index.js

@@ -1,5 +1,5 @@
-// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
-export * from "@js-temporal/polyfill";
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
 export * from "./convert/index.js";
 export * from "./format/index.js";

package/dist/precision/validate/isValidInstant.d.ts

@@ -35,7 +35,7 @@
  *
  * @example isValidInstant("2024-03-10T12:00:00Z") // true
  * @example isValidInstant("1970-01-01T00:00:00Z") // true — the epoch, where toNanoseconds returns 0n
- * @example isValidInstant("2024-03-10T12:00:00-05:00[America/New_York]") // true
+ * @example isValidInstant("2024-03-10T12:00:00+05:30[Asia/Kolkata]") // true
  * @example isValidInstant("2024-03-10T12:00:00Z[Not/AZone]") // true — the zone annotation is not checked
  * @example isValidInstant("2024-03-10T12:00:00-05:00") // true — isValidUtc says false
  * @example isValidInstant("2024-03-10 12:00:00Z") // false — space separator (extended format only)

package/dist/precision/validate/isValidInstant.js

@@ -36,7 +36,7 @@ import { parseInstantNanoseconds } from "../../internal/index.js";
  *
  * @example isValidInstant("2024-03-10T12:00:00Z") // true
  * @example isValidInstant("1970-01-01T00:00:00Z") // true — the epoch, where toNanoseconds returns 0n
- * @example isValidInstant("2024-03-10T12:00:00-05:00[America/New_York]") // true
+ * @example isValidInstant("2024-03-10T12:00:00+05:30[Asia/Kolkata]") // true
  * @example isValidInstant("2024-03-10T12:00:00Z[Not/AZone]") // true — the zone annotation is not checked
  * @example isValidInstant("2024-03-10T12:00:00-05:00") // true — isValidUtc says false
  * @example isValidInstant("2024-03-10 12:00:00Z") // false — space separator (extended format only)

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

@@ -3,13 +3,13 @@
  * and reads — the zoned sibling of `calendarDate` (regex/calendar-date.ts):
  *
  *   <date>T<time><offset>[<timeZone>][u-ca=<id>]
- *   2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]
+ *   2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]
  *
  * This is exactly `Temporal.ZonedDateTime#toString()` for a non-ISO calendar. The digits are ISO
  * and the calendar annotation follows the time zone annotation, in RFC 9557 §4.1 order. The date,
  * time and offset are ISO 8601 extended format with an upper-case `Z`. The date
  * half and the annotation are the same groups as `calendarDate`'s. The offset is optional; the
- * time zone annotation may carry RFC 9557's critical flag (`[!America/New_York]`), and so may the
+ * time zone annotation may carry RFC 9557's critical flag (`[!Asia/Jerusalem]`), and so may the
  * calendar annotation.
  *
  * A match proves shape only: `internal/calendarZonedString.ts` hands the string to
@@ -23,8 +23,8 @@
  * Capture groups: 1 year, 2 month, 3 day, 4 time, 5 offset (optional), 6 time zone annotation
  * (with its critical flag, if any), 7 calendar critical flag (`"!"` or undefined), 8 calendar id.
  *
- * @example calendarZonedDateTime.test("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]") // true
- * @example calendarZonedDateTime.test("2024-02-24T14:30:00-05:00[u-ca=hebrew][America/New_York]") // false (calendar before zone)
+ * @example calendarZonedDateTime.test("2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]") // true
+ * @example calendarZonedDateTime.test("2024-02-24T14:30:00+02:00[u-ca=hebrew][Asia/Jerusalem]") // false (calendar before zone)
  * @example calendarZonedDateTime.test("2024-03-15T14:30:00Z[UTC]") // false (no calendar annotation)
  */
 export declare const calendarZonedDateTime: RegExp;

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

@@ -3,13 +3,13 @@
  * and reads — the zoned sibling of `calendarDate` (regex/calendar-date.ts):
  *
  *   <date>T<time><offset>[<timeZone>][u-ca=<id>]
- *   2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]
+ *   2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]
  *
  * This is exactly `Temporal.ZonedDateTime#toString()` for a non-ISO calendar. The digits are ISO
  * and the calendar annotation follows the time zone annotation, in RFC 9557 §4.1 order. The date,
  * time and offset are ISO 8601 extended format with an upper-case `Z`. The date
  * half and the annotation are the same groups as `calendarDate`'s. The offset is optional; the
- * time zone annotation may carry RFC 9557's critical flag (`[!America/New_York]`), and so may the
+ * time zone annotation may carry RFC 9557's critical flag (`[!Asia/Jerusalem]`), and so may the
  * calendar annotation.
  *
  * A match proves shape only: `internal/calendarZonedString.ts` hands the string to
@@ -23,8 +23,8 @@
  * Capture groups: 1 year, 2 month, 3 day, 4 time, 5 offset (optional), 6 time zone annotation
  * (with its critical flag, if any), 7 calendar critical flag (`"!"` or undefined), 8 calendar id.
  *
- * @example calendarZonedDateTime.test("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]") // true
- * @example calendarZonedDateTime.test("2024-02-24T14:30:00-05:00[u-ca=hebrew][America/New_York]") // false (calendar before zone)
+ * @example calendarZonedDateTime.test("2024-02-24T14:30:00+02:00[Asia/Jerusalem][u-ca=hebrew]") // true
+ * @example calendarZonedDateTime.test("2024-02-24T14:30:00+02:00[u-ca=hebrew][Asia/Jerusalem]") // false (calendar before zone)
  * @example calendarZonedDateTime.test("2024-03-15T14:30:00Z[UTC]") // false (no calendar annotation)
  */
 export const calendarZonedDateTime = /^(\d{4}|\+\d{6}|-(?!0{6})\d{6})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T(\d{2}:\d{2}(?::\d{2}(?:[.,]\d{1,9})?)?)((?:[+-]\d{2}:\d{2}(?::\d{2}(?:[.,]\d{1,9})?)?)|Z)?\[(!?[^[\]=!]+)\]\[(!)?u-ca=([A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)\]$/;

package/dist/regex/epcis.d.ts

@@ -0,0 +1,60 @@
+/**
+ * RegExp matching a GS1 EPCIS 2.0 `eventTimeZoneOffset`: the `pattern` the EPCIS JSON schema
+ * (https://ref.gs1.org/standards/epcis/epcis-json-schema.json, a normative artefact of EPCIS 2.0 /
+ * ISO/IEC 19987) gives for the field, verbatim: `^([+]|[-])((0[0-9]|1[0-3]):([0-5][0-9])|14:00)$`.
+ *
+ * - The pattern is the JSON binding's. The XML binding's XSD types the same field as a bare
+ *   `xsd:string` and gives no pattern.
+ * - The rule both bindings carry is the standard's prose, EPCIS Standard Release 2.0 §7.4.1
+ *   (https://ref.gs1.org/standards/epcis/): the value "SHALL be a string consisting of the
+ *   character '+' or the character '-', followed by two digits whose value is within the range
+ *   00 through 14 (inclusive), followed by a colon character ':', followed by two digits whose
+ *   value is within the range 00 through 59 (inclusive), except that if the value of the first
+ *   two digits is 14, the value of the second two digits must be 00." The pattern is that
+ *   sentence as a regular expression.
+ * - `±HH:MM` from `-13:59` through `+13:59`, plus `±14:00`. GS1 published the grammar, so it is
+ *   neither loosened nor tightened here: `-14:00` matches because the sign group is independent
+ *   of the `14:00` alternative, and `-00:00` matches.
+ * - `Z` does not match: it is `eventTime`'s designator, and this field records the offset in
+ *   force where the event happened. `+0200` (no colon) and `+02` (hours only) do not match.
+ * - Shape only. `parseEpcisEvent` reads the value through Temporal, and returns `-00:00` as
+ *   `+00:00`. To check a value that may not be a string, use `isValidEpcisTimeZoneOffset`: for a
+ *   string it gives this pattern's answer.
+ *
+ * Capture groups: 1 sign, 2 the hours-and-minutes or `14:00`, 3 hours, 4 minutes (3 and 4 are
+ * `undefined` for `14:00`).
+ *
+ * @example epcisTimeZoneOffset.test("-05:00") // true
+ * @example epcisTimeZoneOffset.test("+14:00") // true
+ * @example epcisTimeZoneOffset.test("+14:01") // false (past the range GS1 allows)
+ * @example epcisTimeZoneOffset.test("Z")      // false (a designator, not an offset)
+ * @example epcisTimeZoneOffset.test("+0200")  // false (no colon)
+ */
+export declare const epcisTimeZoneOffset: RegExp;
+/**
+ * RegExp matching a GS1 EPCIS 2.0 `eventTime` (and `recordTime`): the `DateTimeStamp` pattern of
+ * the EPCIS XSD (https://ref.gs1.org/standards/epcis/epcglobal-epcis-2_0.xsd, a normative
+ * artefact of EPCIS 2.0 / ISO/IEC 19987), verbatim and anchored.
+ *
+ * - The pattern is the XML binding's. The JSON schema types the same field as a string with
+ *   `format: date-time` and gives no pattern, so this is the stricter of the two bindings.
+ * - A date-time with seconds required, an optional fraction of any length, then `Z` or an offset
+ *   in the same range as `epcisTimeZoneOffset`.
+ * - GS1 published the grammar, so it is neither loosened nor tightened here: four-digit years
+ *   only, upper-case `T` and `Z`, a colon in the offset, no space separator.
+ * - Shape only; calendar validity is Temporal's (`2023-02-29T00:00:00Z` matches and
+ *   `Temporal.Instant.from` rejects it). To check that a string is a real `eventTime`, use
+ *   `isValidEpcisEventTime`: this pattern also matches a day that does not exist and a fraction
+ *   longer than nine digits.
+ *
+ * Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second, 7 fraction with its
+ * period (optional), 8 `Z` or the offset, 9 the offset, 10 sign, 11 hours-and-minutes or
+ * `14:00`, 12 hours, 13 minutes.
+ *
+ * @example epcisEventTime.test("2024-06-15T14:30:00Z")           // true
+ * @example epcisEventTime.test("2024-06-15T14:30:00.123-05:00")  // true
+ * @example epcisEventTime.test("2024-06-15T14:30Z")              // false (seconds are required)
+ * @example epcisEventTime.test("2024-06-15T14:30:00")            // false (Z or an offset is required)
+ * @example epcisEventTime.test("2024-06-15T14:30:00+15:00")      // false (offset past the range GS1 allows)
+ */
+export declare const epcisEventTime: RegExp;

package/dist/regex/epcis.js

@@ -0,0 +1,60 @@
+/**
+ * RegExp matching a GS1 EPCIS 2.0 `eventTimeZoneOffset`: the `pattern` the EPCIS JSON schema
+ * (https://ref.gs1.org/standards/epcis/epcis-json-schema.json, a normative artefact of EPCIS 2.0 /
+ * ISO/IEC 19987) gives for the field, verbatim: `^([+]|[-])((0[0-9]|1[0-3]):([0-5][0-9])|14:00)$`.
+ *
+ * - The pattern is the JSON binding's. The XML binding's XSD types the same field as a bare
+ *   `xsd:string` and gives no pattern.
+ * - The rule both bindings carry is the standard's prose, EPCIS Standard Release 2.0 §7.4.1
+ *   (https://ref.gs1.org/standards/epcis/): the value "SHALL be a string consisting of the
+ *   character '+' or the character '-', followed by two digits whose value is within the range
+ *   00 through 14 (inclusive), followed by a colon character ':', followed by two digits whose
+ *   value is within the range 00 through 59 (inclusive), except that if the value of the first
+ *   two digits is 14, the value of the second two digits must be 00." The pattern is that
+ *   sentence as a regular expression.
+ * - `±HH:MM` from `-13:59` through `+13:59`, plus `±14:00`. GS1 published the grammar, so it is
+ *   neither loosened nor tightened here: `-14:00` matches because the sign group is independent
+ *   of the `14:00` alternative, and `-00:00` matches.
+ * - `Z` does not match: it is `eventTime`'s designator, and this field records the offset in
+ *   force where the event happened. `+0200` (no colon) and `+02` (hours only) do not match.
+ * - Shape only. `parseEpcisEvent` reads the value through Temporal, and returns `-00:00` as
+ *   `+00:00`. To check a value that may not be a string, use `isValidEpcisTimeZoneOffset`: for a
+ *   string it gives this pattern's answer.
+ *
+ * Capture groups: 1 sign, 2 the hours-and-minutes or `14:00`, 3 hours, 4 minutes (3 and 4 are
+ * `undefined` for `14:00`).
+ *
+ * @example epcisTimeZoneOffset.test("-05:00") // true
+ * @example epcisTimeZoneOffset.test("+14:00") // true
+ * @example epcisTimeZoneOffset.test("+14:01") // false (past the range GS1 allows)
+ * @example epcisTimeZoneOffset.test("Z")      // false (a designator, not an offset)
+ * @example epcisTimeZoneOffset.test("+0200")  // false (no colon)
+ */
+export const epcisTimeZoneOffset = /^([+]|[-])((0[0-9]|1[0-3]):([0-5][0-9])|14:00)$/;
+/**
+ * RegExp matching a GS1 EPCIS 2.0 `eventTime` (and `recordTime`): the `DateTimeStamp` pattern of
+ * the EPCIS XSD (https://ref.gs1.org/standards/epcis/epcglobal-epcis-2_0.xsd, a normative
+ * artefact of EPCIS 2.0 / ISO/IEC 19987), verbatim and anchored.
+ *
+ * - The pattern is the XML binding's. The JSON schema types the same field as a string with
+ *   `format: date-time` and gives no pattern, so this is the stricter of the two bindings.
+ * - A date-time with seconds required, an optional fraction of any length, then `Z` or an offset
+ *   in the same range as `epcisTimeZoneOffset`.
+ * - GS1 published the grammar, so it is neither loosened nor tightened here: four-digit years
+ *   only, upper-case `T` and `Z`, a colon in the offset, no space separator.
+ * - Shape only; calendar validity is Temporal's (`2023-02-29T00:00:00Z` matches and
+ *   `Temporal.Instant.from` rejects it). To check that a string is a real `eventTime`, use
+ *   `isValidEpcisEventTime`: this pattern also matches a day that does not exist and a fraction
+ *   longer than nine digits.
+ *
+ * Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second, 7 fraction with its
+ * period (optional), 8 `Z` or the offset, 9 the offset, 10 sign, 11 hours-and-minutes or
+ * `14:00`, 12 hours, 13 minutes.
+ *
+ * @example epcisEventTime.test("2024-06-15T14:30:00Z")           // true
+ * @example epcisEventTime.test("2024-06-15T14:30:00.123-05:00")  // true
+ * @example epcisEventTime.test("2024-06-15T14:30Z")              // false (seconds are required)
+ * @example epcisEventTime.test("2024-06-15T14:30:00")            // false (Z or an offset is required)
+ * @example epcisEventTime.test("2024-06-15T14:30:00+15:00")      // false (offset past the range GS1 allows)
+ */
+export const epcisEventTime = /^([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|(([+]|[-])((0[0-9]|1[0-3]):([0-5][0-9])|14:00)))$/;

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

@@ -1,13 +1,15 @@
 /**
- * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttp` emits and
+ * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttpDate` 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
+ *   the obsolete rfc850-date and asctime-date do not match this pattern. `parseHttpDate` reads all
  *   three.
- * - The day name is not checked against the date; `parseHttp` does check it.
+ * - The day name is not checked against the date; `parseHttpDate` does check it.
+ * - To check that a string is a real HTTP-date, use `isValidHttpDate`: this pattern also matches
+ *   a day that does not exist and an hour out of range.
  *
  * Capture groups: 1 day-of-week, 2 day, 3 month, 4 year, 5 hour, 6 minute, 7 second.
  *
@@ -15,6 +17,6 @@
  * @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)
+ * @example httpDate.test("Wednesday, 09-Jun-21 10:18:14 GMT") // false (rfc850-date: parseHttpDate reads it)
  */
 export declare const httpDate: RegExp;

package/dist/regex/http-date.js

@@ -1,13 +1,15 @@
 /**
- * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttp` emits and
+ * RegExp matching RFC 9110 §5.6.7 IMF-fixdate — the only form GMT's `formatHttpDate` 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
+ *   the obsolete rfc850-date and asctime-date do not match this pattern. `parseHttpDate` reads all
  *   three.
- * - The day name is not checked against the date; `parseHttp` does check it.
+ * - The day name is not checked against the date; `parseHttpDate` does check it.
+ * - To check that a string is a real HTTP-date, use `isValidHttpDate`: this pattern also matches
+ *   a day that does not exist and an hour out of range.
  *
  * Capture groups: 1 day-of-week, 2 day, 3 month, 4 year, 5 hour, 6 minute, 7 second.
  *
@@ -15,6 +17,6 @@
  * @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)
+ * @example httpDate.test("Wednesday, 09-Jun-21 10:18:14 GMT") // false (rfc850-date: parseHttpDate 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,8 +1,9 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calendar-date.js";
 export * from "./calendar-zoned-date-time.js";
 export * from "./date.js";
 export * from "./date-time.js";
+export * from "./epcis.js";
 export * from "./http-date.js";
 export * from "./leap-second.js";
 export * from "./nanoseconds.js";

package/dist/regex/index.js

@@ -1,9 +1,10 @@
-// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
-export * from "@js-temporal/polyfill";
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calendar-date.js";
 export * from "./calendar-zoned-date-time.js";
 export * from "./date.js";
 export * from "./date-time.js";
+export * from "./epcis.js";
 export * from "./http-date.js";
 export * from "./leap-second.js";
 export * from "./nanoseconds.js";