@northguild/gmt 1.18.0 → 1.19.0

package/dist/plain/parse/parseTimeWithPattern.js

@@ -66,6 +66,7 @@ export function parseTimeWithPattern(value, pattern, locale) {
             return "";
         if (typeof pattern !== "string")
             return "";
+        // A time pattern has no year token, so no two-digit-year window applies.
         const fields = parseValueWithPattern(value, pattern, locale, TIME_PATTERN_FIELDS);
         if (fields === null)
             return "";

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

@@ -9,6 +9,8 @@ import { Temporal } from "@js-temporal/polyfill";
  * - `optionsArg` must be an object or omitted: `null` or any other primitive returns "", as
  *   Temporal's GetOptionsObject rejects it.
  * - Returns "" for invalid input.
+ * - The `"year"` unit is written as Temporal writes a year: four digits (`"2024"`, `"0005"`), or a
+ *   sign and six digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  *
  * @param value ISO PlainDate string
  * @param unit unit to extract from the date
@@ -16,6 +18,7 @@ import { Temporal } from "@js-temporal/polyfill";
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDate("2024-03-15", "year") // "2024"
+ * @example parseUnitFromDate("0005-06-01", "year") // "0005"
  * @example parseUnitFromDate("2024-03-15", "month") // "03"
  * @example parseUnitFromDate("2024-03-15", "day") // "15"
  * @example parseUnitFromDate("2024-03-15", "week") // "11"

package/dist/plain/parse/parseUnitFromDate.js

@@ -4,6 +4,7 @@ import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDate } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return a specific date unit extracted from a PlainDate string.
  *
@@ -14,6 +15,8 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * - `optionsArg` must be an object or omitted: `null` or any other primitive returns "", as
  *   Temporal's GetOptionsObject rejects it.
  * - Returns "" for invalid input.
+ * - The `"year"` unit is written as Temporal writes a year: four digits (`"2024"`, `"0005"`), or a
+ *   sign and six digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  *
  * @param value ISO PlainDate string
  * @param unit unit to extract from the date
@@ -21,6 +24,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDate("2024-03-15", "year") // "2024"
+ * @example parseUnitFromDate("0005-06-01", "year") // "0005"
  * @example parseUnitFromDate("2024-03-15", "month") // "03"
  * @example parseUnitFromDate("2024-03-15", "day") // "15"
  * @example parseUnitFromDate("2024-03-15", "week") // "11"
@@ -44,7 +48,7 @@ export function parseUnitFromDate(value, unit, optionsArg) {
             const date = Temporal.PlainDate.from(value);
             switch (resolveDateTimeUnit(unit)) {
                 case "year":
-                    return date.year.toString();
+                    return isoYearString(date.year);
                 case "month":
                     return date.month.toString().padStart(2, "0");
                 case "day":

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

@@ -11,6 +11,8 @@ import { Temporal } from "@js-temporal/polyfill";
  * - `optionsArg` must be an object or omitted: `null` or any other primitive returns "", as
  *   Temporal's GetOptionsObject rejects it.
  * - Returns "" for invalid input.
+ * - The `"year"` unit is written as Temporal writes a year: four digits (`"2024"`, `"0005"`), or a
+ *   sign and six digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  *
  * @param value ISO PlainDateTime string
  * @param unit unit to extract from the datetime
@@ -18,6 +20,7 @@ import { Temporal } from "@js-temporal/polyfill";
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "year") // "2024"
+ * @example parseUnitFromDateTime("0005-06-01T12:30:00", "year") // "0005"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "week") // "11"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hour") // "14"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "millisecond") // "123"

package/dist/plain/parse/parseUnitFromDateTime.js

@@ -5,6 +5,7 @@ import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDateTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return a specific unit extracted from a PlainDateTime string.
  *
@@ -17,6 +18,8 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * - `optionsArg` must be an object or omitted: `null` or any other primitive returns "", as
  *   Temporal's GetOptionsObject rejects it.
  * - Returns "" for invalid input.
+ * - The `"year"` unit is written as Temporal writes a year: four digits (`"2024"`, `"0005"`), or a
+ *   sign and six digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  *
  * @param value ISO PlainDateTime string
  * @param unit unit to extract from the datetime
@@ -24,6 +27,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "year") // "2024"
+ * @example parseUnitFromDateTime("0005-06-01T12:30:00", "year") // "0005"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "week") // "11"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hour") // "14"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "millisecond") // "123"
@@ -45,7 +49,7 @@ export function parseUnitFromDateTime(value, unit, optionsArg) {
             const dateTime = Temporal.PlainDateTime.from(value);
             switch (resolveDateTimeUnit(unit)) {
                 case "year":
-                    return dateTime.year.toString();
+                    return isoYearString(dateTime.year);
                 case "month":
                     return dateTime.month.toString().padStart(2, "0");
                 case "day":

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

@@ -1,13 +1,16 @@
 /**
  * Return the year for a given ISO 8601 date string.
  *
- * - Returns the year as a string (e.g., "2024").
+ * - Returns the year as Temporal writes it: four digits (`"2024"`, `"0005"`), or a sign and six
+ *   digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  * - Returns "" for invalid input.
  *
  * @param value ISO date string
- * @returns Year (YYYY) or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromDate("2024-03-15") // "2024"
+ * @example parseYearFromDate("0005-06-01") // "0005"
+ * @example parseYearFromDate("+010000-01-01") // "+010000"
  * @example parseYearFromDate("invalid") // ""
  */
 export declare function parseYearFromDate(value: string): string;

package/dist/plain/parse/parseYearFromDate.js

@@ -1,15 +1,19 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidDate } from "../validate/index.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return the year for a given ISO 8601 date string.
  *
- * - Returns the year as a string (e.g., "2024").
+ * - Returns the year as Temporal writes it: four digits (`"2024"`, `"0005"`), or a sign and six
+ *   digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  * - Returns "" for invalid input.
  *
  * @param value ISO date string
- * @returns Year (YYYY) or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromDate("2024-03-15") // "2024"
+ * @example parseYearFromDate("0005-06-01") // "0005"
+ * @example parseYearFromDate("+010000-01-01") // "+010000"
  * @example parseYearFromDate("invalid") // ""
  */
 export function parseYearFromDate(value) {
@@ -17,7 +21,7 @@ export function parseYearFromDate(value) {
         return "";
     try {
         const date = Temporal.PlainDate.from(value);
-        return date.year.toString();
+        return isoYearString(date.year);
     }
     catch {
         return "";

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

@@ -1,13 +1,15 @@
 /**
  * Return the year for a given ISO 8601 datetime string.
  *
- * - Returns the year as a string (e.g., "2024").
+ * - Returns the year as Temporal writes it: four digits (`"2024"`, `"0005"`), or a sign and six
+ *   digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  * - Returns "" for invalid input.
  *
  * @param value ISO datetime string
- * @returns Year (YYYY) or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromDateTime("2024-03-15T12:30:00") // "2024"
+ * @example parseYearFromDateTime("0005-06-01T12:30:00") // "0005"
  * @example parseYearFromDateTime("invalid") // ""
  */
 export declare function parseYearFromDateTime(value: string): string;

package/dist/plain/parse/parseYearFromDateTime.js

@@ -1,15 +1,18 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidDateTime } from "../validate/index.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return the year for a given ISO 8601 datetime string.
  *
- * - Returns the year as a string (e.g., "2024").
+ * - Returns the year as Temporal writes it: four digits (`"2024"`, `"0005"`), or a sign and six
+ *   digits outside 0000–9999 (`"+010000"`, `"-000005"`).
  * - Returns "" for invalid input.
  *
  * @param value ISO datetime string
- * @returns Year (YYYY) or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromDateTime("2024-03-15T12:30:00") // "2024"
+ * @example parseYearFromDateTime("0005-06-01T12:30:00") // "0005"
  * @example parseYearFromDateTime("invalid") // ""
  */
 export function parseYearFromDateTime(value) {
@@ -17,7 +20,7 @@ export function parseYearFromDateTime(value) {
         return "";
     try {
         const dateTime = Temporal.PlainDateTime.from(value);
-        return dateTime.year.toString();
+        return isoYearString(dateTime.year);
     }
     catch {
         return "";

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

@@ -12,6 +12,7 @@ export * from "./isValidDateTimeRange.js";
 export * from "./isValidDateTimeUnit.js";
 export * from "./isValidDateUnit.js";
 export * from "./isValidIsoDateLike.js";
+export * from "./isValidSqlDateTime.js";
 export * from "./isValidTime.js";
 export * from "./isValidTimeCycleField.js";
 export * from "./isValidTimeDurationUnit.js";

package/dist/plain/validate/index.js

@@ -12,6 +12,7 @@ export * from "./isValidDateTimeRange.js";
 export * from "./isValidDateTimeUnit.js";
 export * from "./isValidDateUnit.js";
 export * from "./isValidIsoDateLike.js";
+export * from "./isValidSqlDateTime.js";
 export * from "./isValidTime.js";
 export * from "./isValidTimeCycleField.js";
 export * from "./isValidTimeDurationUnit.js";

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/precision/convert/fromNanoseconds.d.ts

@@ -5,17 +5,23 @@
  *   (`"...[America/New_York]"`) 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"

package/dist/precision/convert/fromNanoseconds.js

@@ -8,17 +8,23 @@ import { isValidTimeZone } from "../../zoned/validate/index.js";
  *   (`"...[America/New_York]"`) 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"

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

@@ -3,6 +3,7 @@ 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

@@ -4,6 +4,7 @@ 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/rfc-2822.d.ts

@@ -13,6 +13,8 @@
  *   `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.
+ * - To check that a string is a real RFC 5322 date-time, use `isValidRfc2822DateTime`: this
+ *   pattern also matches a day that does not exist and an hour or zone out of range.
  *
  * 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.

package/dist/regex/rfc-2822.js

@@ -13,6 +13,8 @@
  *   `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.
+ * - To check that a string is a real RFC 5322 date-time, use `isValidRfc2822DateTime`: this
+ *   pattern also matches a day that does not exist and an hour or zone out of range.
  *
  * 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.

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

@@ -11,7 +11,9 @@
  *   `: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`.
+ *   `Temporal.PlainDateTime.from(...).toZonedDateTime(offset)` in `parseRfc3339`. To check that a
+ *   string is a real RFC 3339 date-time, use `isValidRfc3339DateTime`: this pattern also matches
+ *   a day that does not exist, such as 29 February 2023.
  * - Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second,
  *   7 fractional (optional), 8 offset.
  *

package/dist/regex/rfc-3339.js

@@ -11,7 +11,9 @@
  *   `: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`.
+ *   `Temporal.PlainDateTime.from(...).toZonedDateTime(offset)` in `parseRfc3339`. To check that a
+ *   string is a real RFC 3339 date-time, use `isValidRfc3339DateTime`: this pattern also matches
+ *   a day that does not exist, such as 29 February 2023.
  * - Capture groups: 1 year, 2 month, 3 day, 4 hour, 5 minute, 6 second,
  *   7 fractional (optional), 8 offset.
  *

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

@@ -16,7 +16,8 @@
  * - 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`.
+ *   `parseSqlDateTime`. To check that a string is a real SQL timestamp literal, use
+ *   `isValidSqlDateTime`: this pattern also matches a day that does not exist, such as 30 February.
  *
  * Capture groups: 1 month, 2 day, 3 hour. The year, minute, second and fraction are not
  * captured.

package/dist/regex/sql-date-time.js

@@ -16,7 +16,8 @@
  * - 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`.
+ *   `parseSqlDateTime`. To check that a string is a real SQL timestamp literal, use
+ *   `isValidSqlDateTime`: this pattern also matches a day that does not exist, such as 30 February.
  *
  * Capture groups: 1 month, 2 day, 3 hour. The year, minute, second and fraction are not
  * captured.