@northguild/gmt 1.14.2

package/dist/zoned/parse/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./parseDateFromZoned.js";
+export * from "./parseDateTimeFromZoned.js";
+export * from "./parseDayFromZoned.js";
+export * from "./parseDayOfWeekFromZoned.js";
+export * from "./getZonedOffset.js";
+export * from "./getZonedOffsetAs.js";
+export * from "./parseHourFromZoned.js";
+export * from "./parseMicrosecondFromZoned.js";
+export * from "./parseMillisecondFromZoned.js";
+export * from "./parseMinuteFromZoned.js";
+export * from "./parseMonthFromZoned.js";
+export * from "./parseNanosecondFromZoned.js";
+export * from "./parseRfc2822.js";
+export * from "./parseRfc3339.js";
+export * from "./parseSecondFromZoned.js";
+export * from "./parseTimeFromZoned.js";
+export * from "./parseTimeZoneFromZoned.js";
+export * from "./parseUnitFromZoned.js";
+export * from "./parseWeekFromZoned.js";
+export * from "./parseYearFromZoned.js";

package/dist/zoned/parse/index.js

@@ -0,0 +1,20 @@
+export * from "./parseDateFromZoned.js";
+export * from "./parseDateTimeFromZoned.js";
+export * from "./parseDayFromZoned.js";
+export * from "./parseDayOfWeekFromZoned.js";
+export * from "./getZonedOffset.js";
+export * from "./getZonedOffsetAs.js";
+export * from "./parseHourFromZoned.js";
+export * from "./parseMicrosecondFromZoned.js";
+export * from "./parseMillisecondFromZoned.js";
+export * from "./parseMinuteFromZoned.js";
+export * from "./parseMonthFromZoned.js";
+export * from "./parseNanosecondFromZoned.js";
+export * from "./parseRfc2822.js";
+export * from "./parseRfc3339.js";
+export * from "./parseSecondFromZoned.js";
+export * from "./parseTimeFromZoned.js";
+export * from "./parseTimeZoneFromZoned.js";
+export * from "./parseUnitFromZoned.js";
+export * from "./parseWeekFromZoned.js";
+export * from "./parseYearFromZoned.js";

package/dist/zoned/parse/parseDateFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extract the plain date portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts date components from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @param value zoned ISO 8601 datetime string
+ * @returns plain ISO date string (YYYY-MM-DD) or "" when invalid
+ *
+ * @example parseDateFromZoned("2024-02-29T12:34:56.789+00:00[UTC]") // "2024-02-29"
+ * @example parseDateFromZoned("invalid") // ""
+ */
+export declare function parseDateFromZoned(value: string): string;

package/dist/zoned/parse/parseDateFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Extract the plain date portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts date components from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @param value zoned ISO 8601 datetime string
+ * @returns plain ISO date string (YYYY-MM-DD) or "" when invalid
+ *
+ * @example parseDateFromZoned("2024-02-29T12:34:56.789+00:00[UTC]") // "2024-02-29"
+ * @example parseDateFromZoned("invalid") // ""
+ */
+export function parseDateFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime?.toPlainDate().toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseDateTimeFromZoned.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parse a zoned datetime and return the plain local datetime portion as an ISO plain datetime string.
+ *
+ * - Uses Temporal.ZonedDateTime.from to parse.
+ * - Rejects leap seconds.
+ * - Returns "" for invalid input.
+ *
+ * @param value zoned ISO 8601 datetime string
+ * @returns plain local datetime string or "" when invalid
+ *
+ * @example parseDateTimeFromZoned("2024-02-29T12:34:56.789+00:00[UTC]") // "2024-02-29T12:34:56.789"
+ * @example parseDateTimeFromZoned("invalid") // ""
+ */
+export declare const parseDateTimeFromZoned: (value: string) => string;

package/dist/zoned/parse/parseDateTimeFromZoned.js

@@ -0,0 +1,27 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Parse a zoned datetime and return the plain local datetime portion as an ISO plain datetime string.
+ *
+ * - Uses Temporal.ZonedDateTime.from to parse.
+ * - Rejects leap seconds.
+ * - Returns "" for invalid input.
+ *
+ * @param value zoned ISO 8601 datetime string
+ * @returns plain local datetime string or "" when invalid
+ *
+ * @example parseDateTimeFromZoned("2024-02-29T12:34:56.789+00:00[UTC]") // "2024-02-29T12:34:56.789"
+ * @example parseDateTimeFromZoned("invalid") // ""
+ */
+export const parseDateTimeFromZoned = (value) => {
+    if (!isValidZonedDateTime(value) || isLeapSecond(value)) {
+        return "";
+    }
+    try {
+        return Temporal.ZonedDateTime.from(value).toPlainDateTime().toString();
+    }
+    catch {
+        return "";
+    }
+};

package/dist/zoned/parse/parseDayFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the day (1-31) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for day.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Day (01-31) or "" on invalid input
+ *
+ * @example parseDayFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "15"
+ * @example parseDayFromZoned("invalid") // ""
+ */
+export declare function parseDayFromZoned(value: string): string;

package/dist/zoned/parse/parseDayFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the day (1-31) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for day.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Day (01-31) or "" on invalid input
+ *
+ * @example parseDayFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "15"
+ * @example parseDayFromZoned("invalid") // ""
+ */
+export function parseDayFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.day.toString().padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseDayOfWeekFromZoned.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Return the day of the week (1-7, Monday-Sunday) from a zoned datetime string.
+ *
+ * - Returns number 1-7 for valid input.
+ * - Monday=1 through Sunday=7.
+ * - Returns null for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Day of week (1-7) or null on invalid input
+ *
+ * @example parseDayOfWeekFromZoned("2024-03-15T14:30:45+00:00[UTC]") // 5 (Friday)
+ * @example parseDayOfWeekFromZoned("invalid") // null
+ */
+export declare function parseDayOfWeekFromZoned(value: string): number | null;

package/dist/zoned/parse/parseDayOfWeekFromZoned.js

@@ -0,0 +1,27 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the day of the week (1-7, Monday-Sunday) from a zoned datetime string.
+ *
+ * - Returns number 1-7 for valid input.
+ * - Monday=1 through Sunday=7.
+ * - Returns null for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Day of week (1-7) or null on invalid input
+ *
+ * @example parseDayOfWeekFromZoned("2024-03-15T14:30:45+00:00[UTC]") // 5 (Friday)
+ * @example parseDayOfWeekFromZoned("invalid") // null
+ */
+export function parseDayOfWeekFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return null;
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.dayOfWeek;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/zoned/parse/parseHourFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the hour (0-23) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for hour.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Hour (00-23) or "" on invalid input
+ *
+ * @example parseHourFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "14"
+ * @example parseHourFromZoned("invalid") // ""
+ */
+export declare function parseHourFromZoned(value: string): string;

package/dist/zoned/parse/parseHourFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the hour (0-23) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for hour.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Hour (00-23) or "" on invalid input
+ *
+ * @example parseHourFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "14"
+ * @example parseHourFromZoned("invalid") // ""
+ */
+export function parseHourFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.hour.toString().padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseMicrosecondFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the microsecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for microsecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123456+00:00[UTC]")
+ * @returns Microsecond (000-999) or "" on invalid input
+ *
+ * @example parseMicrosecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseMicrosecondFromZoned("invalid") // ""
+ */
+export declare function parseMicrosecondFromZoned(value: string): string;

package/dist/zoned/parse/parseMicrosecondFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the microsecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for microsecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123456+00:00[UTC]")
+ * @returns Microsecond (000-999) or "" on invalid input
+ *
+ * @example parseMicrosecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseMicrosecondFromZoned("invalid") // ""
+ */
+export function parseMicrosecondFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return (zonedDateTime.microsecond ?? 0).toString().padStart(3, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseMillisecondFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the millisecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for millisecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Millisecond (000-999) or "" on invalid input
+ *
+ * @example parseMillisecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseMillisecondFromZoned("invalid") // ""
+ */
+export declare function parseMillisecondFromZoned(value: string): string;

package/dist/zoned/parse/parseMillisecondFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the millisecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for millisecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Millisecond (000-999) or "" on invalid input
+ *
+ * @example parseMillisecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseMillisecondFromZoned("invalid") // ""
+ */
+export function parseMillisecondFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.millisecond.toString().padStart(3, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseMinuteFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the minute (0-59) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for minute.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Minute (00-59) or "" on invalid input
+ *
+ * @example parseMinuteFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "30"
+ * @example parseMinuteFromZoned("invalid") // ""
+ */
+export declare function parseMinuteFromZoned(value: string): string;

package/dist/zoned/parse/parseMinuteFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the minute (0-59) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for minute.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Minute (00-59) or "" on invalid input
+ *
+ * @example parseMinuteFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "30"
+ * @example parseMinuteFromZoned("invalid") // ""
+ */
+export function parseMinuteFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.minute.toString().padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseMonthFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the month (1-12) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for month.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Month (01-12) or "" on invalid input
+ *
+ * @example parseMonthFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "03"
+ * @example parseMonthFromZoned("invalid") // ""
+ */
+export declare function parseMonthFromZoned(value: string): string;

package/dist/zoned/parse/parseMonthFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the month (1-12) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for month.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Month (01-12) or "" on invalid input
+ *
+ * @example parseMonthFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "03"
+ * @example parseMonthFromZoned("invalid") // ""
+ */
+export function parseMonthFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.month.toString().padStart(2, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseNanosecondFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the nanosecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for nanosecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123456789+00:00[UTC]")
+ * @returns Nanosecond (000-999) or "" on invalid input
+ *
+ * @example parseNanosecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseNanosecondFromZoned("invalid") // ""
+ */
+export declare function parseNanosecondFromZoned(value: string): string;

package/dist/zoned/parse/parseNanosecondFromZoned.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return the nanosecond (0-999) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for nanosecond.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123456789+00:00[UTC]")
+ * @returns Nanosecond (000-999) or "" on invalid input
+ *
+ * @example parseNanosecondFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "123"
+ * @example parseNanosecondFromZoned("invalid") // ""
+ */
+export function parseNanosecondFromZoned(value) {
+    if (!isValidZonedDateTime(value)) {
+        return "";
+    }
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return (zonedDateTime.nanosecond ?? 0).toString().padStart(3, "0");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseRfc2822.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parse an RFC 5322 (RFC 2822) date-time string — the fixed grammar email
+ * `Date:` headers use — into a zoned ISO 8601 datetime string.
+ *
+ * - **Decoding, not display.** Accepts English weekday/month abbreviations
+ *   only, per the fixed grammar (see `formatRfc2822`'s JSDoc and roadmap
+ *   Decision 1).
+ * - Accepts a leading day-of-week (not cross-validated against the computed
+ *   date, the same deliberate scope limit `parseDateTimeWithPattern`/J11
+ *   uses for its `EEEE`/`EEE` tokens) and an optional `:ss` seconds field.
+ * - Accepts a 1- or 2-digit day (the formal grammar's `1*2DIGIT`), unlike
+ *   `parseHttp`/`parseSql`, which both require exactly 2 digits.
+ * - Accepts a numeric `+HHMM`/`-HHMM` offset or one of RFC 5322's obsolete
+ *   named zones (`GMT`, `UT`, and the eight North American zones); any other
+ *   obs-zone letter is unrecognized and rejected.
+ * - The resulting offset becomes the zoned string's time zone identifier
+ *   (e.g. `-05:00`), since RFC 2822 carries no IANA zone name to recover.
+ *
+ * @param value RFC 5322 date-time string (e.g. "Fri, 15 Mar 2024 14:30:00 -0400")
+ * @returns zoned ISO 8601 datetime string, or "" on invalid input
+ *
+ * @example parseRfc2822("Fri, 15 Mar 2024 14:30:00 -0400") // "2024-03-15T14:30:00-04:00[-04:00]"
+ * @example parseRfc2822("5 Jan 2024 09:00:00 GMT") // "2024-01-05T09:00:00+00:00[+00:00]"
+ * @example parseRfc2822("not a date") // ""
+ */
+export declare function parseRfc2822(value: string): string;

package/dist/zoned/parse/parseRfc2822.js

@@ -0,0 +1,71 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { ENGLISH_MONTH_NAMES } from "../../internal/index.js";
+import { rfc2822DateTime } from "../../regex/index.js";
+// RFC 5322 §4.3 "obsolete date and time" — named zones an email parser must
+// still accept even though `formatRfc2822` never emits them. Any obs-zone
+// single-letter military zone outside this table is unrecognized ("" per
+// the spec's own admission that those are ambiguous) and rejected.
+const NAMED_ZONE_OFFSETS = {
+    UT: "+0000",
+    GMT: "+0000",
+    EST: "-0500",
+    EDT: "-0400",
+    CST: "-0600",
+    CDT: "-0500",
+    MST: "-0700",
+    MDT: "-0600",
+    PST: "-0800",
+    PDT: "-0700",
+};
+/**
+ * Parse an RFC 5322 (RFC 2822) date-time string — the fixed grammar email
+ * `Date:` headers use — into a zoned ISO 8601 datetime string.
+ *
+ * - **Decoding, not display.** Accepts English weekday/month abbreviations
+ *   only, per the fixed grammar (see `formatRfc2822`'s JSDoc and roadmap
+ *   Decision 1).
+ * - Accepts a leading day-of-week (not cross-validated against the computed
+ *   date, the same deliberate scope limit `parseDateTimeWithPattern`/J11
+ *   uses for its `EEEE`/`EEE` tokens) and an optional `:ss` seconds field.
+ * - Accepts a 1- or 2-digit day (the formal grammar's `1*2DIGIT`), unlike
+ *   `parseHttp`/`parseSql`, which both require exactly 2 digits.
+ * - Accepts a numeric `+HHMM`/`-HHMM` offset or one of RFC 5322's obsolete
+ *   named zones (`GMT`, `UT`, and the eight North American zones); any other
+ *   obs-zone letter is unrecognized and rejected.
+ * - The resulting offset becomes the zoned string's time zone identifier
+ *   (e.g. `-05:00`), since RFC 2822 carries no IANA zone name to recover.
+ *
+ * @param value RFC 5322 date-time string (e.g. "Fri, 15 Mar 2024 14:30:00 -0400")
+ * @returns zoned ISO 8601 datetime string, or "" on invalid input
+ *
+ * @example parseRfc2822("Fri, 15 Mar 2024 14:30:00 -0400") // "2024-03-15T14:30:00-04:00[-04:00]"
+ * @example parseRfc2822("5 Jan 2024 09:00:00 GMT") // "2024-01-05T09:00:00+00:00[+00:00]"
+ * @example parseRfc2822("not a date") // ""
+ */
+export function parseRfc2822(value) {
+    if (typeof value !== "string")
+        return "";
+    const match = rfc2822DateTime.exec(value);
+    if (match === null)
+        return "";
+    const [, , dayStr, monthName, yearStr, hourStr, minuteStr, secondStr, zone] = match;
+    const monthIndex = ENGLISH_MONTH_NAMES.indexOf(monthName);
+    if (monthIndex === -1)
+        return "";
+    const numericOffset = NAMED_ZONE_OFFSETS[zone] ?? zone;
+    const offset = `${numericOffset.slice(0, 3)}:${numericOffset.slice(3)}`;
+    try {
+        const plainDateTime = Temporal.PlainDateTime.from({
+            year: Number(yearStr),
+            month: monthIndex + 1,
+            day: Number(dayStr),
+            hour: Number(hourStr),
+            minute: Number(minuteStr),
+            second: secondStr === undefined ? 0 : Number(secondStr),
+        }, { overflow: "reject" });
+        return plainDateTime.toZonedDateTime(offset).toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseRfc3339.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Parse a strict RFC 3339 datetime string into a zoned ISO 8601 datetime
+ * string.
+ *
+ * - Accepts `T`, `t`, or a single space as the date/time separator (all
+ *   three are valid RFC 3339, unlike GMT's own zoned strings which always
+ *   use `T`) and either `Z`/`z` or a numeric `±HH:MM` offset.
+ * - RFC 3339 carries no IANA zone name, so the parsed offset becomes the
+ *   result's time zone identifier too (e.g. `Z` → `+00:00[+00:00]`) — the
+ *   same fixed-offset-as-zone convention `parseRfc2822` uses.
+ * - Rejects GMT's own bracketed zoned strings (`...+00:00[UTC]`) — that
+ *   annotation is not valid RFC 3339 input; use `Temporal.ZonedDateTime.from`
+ *   / `isValidZonedDateTime` directly for GMT's native format instead.
+ *
+ * @param value RFC 3339 datetime string (e.g. "2024-03-15T14:30:00-04:00")
+ * @returns zoned ISO 8601 datetime string, or "" on invalid input
+ *
+ * @example parseRfc3339("2024-03-15T14:30:00-04:00") // "2024-03-15T14:30:00-04:00[-04:00]"
+ * @example parseRfc3339("2024-03-15T14:30:00Z") // "2024-03-15T14:30:00+00:00[+00:00]"
+ * @example parseRfc3339("2024-03-15T14:30:00+00:00[UTC]") // "" (bracket annotation not valid RFC 3339)
+ * @example parseRfc3339("not a date") // ""
+ */
+export declare function parseRfc3339(value: string): string;

package/dist/zoned/parse/parseRfc3339.js

@@ -0,0 +1,42 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { rfc3339DateTime } from "../../regex/index.js";
+/**
+ * Parse a strict RFC 3339 datetime string into a zoned ISO 8601 datetime
+ * string.
+ *
+ * - Accepts `T`, `t`, or a single space as the date/time separator (all
+ *   three are valid RFC 3339, unlike GMT's own zoned strings which always
+ *   use `T`) and either `Z`/`z` or a numeric `±HH:MM` offset.
+ * - RFC 3339 carries no IANA zone name, so the parsed offset becomes the
+ *   result's time zone identifier too (e.g. `Z` → `+00:00[+00:00]`) — the
+ *   same fixed-offset-as-zone convention `parseRfc2822` uses.
+ * - Rejects GMT's own bracketed zoned strings (`...+00:00[UTC]`) — that
+ *   annotation is not valid RFC 3339 input; use `Temporal.ZonedDateTime.from`
+ *   / `isValidZonedDateTime` directly for GMT's native format instead.
+ *
+ * @param value RFC 3339 datetime string (e.g. "2024-03-15T14:30:00-04:00")
+ * @returns zoned ISO 8601 datetime string, or "" on invalid input
+ *
+ * @example parseRfc3339("2024-03-15T14:30:00-04:00") // "2024-03-15T14:30:00-04:00[-04:00]"
+ * @example parseRfc3339("2024-03-15T14:30:00Z") // "2024-03-15T14:30:00+00:00[+00:00]"
+ * @example parseRfc3339("2024-03-15T14:30:00+00:00[UTC]") // "" (bracket annotation not valid RFC 3339)
+ * @example parseRfc3339("not a date") // ""
+ */
+export function parseRfc3339(value) {
+    if (typeof value !== "string")
+        return "";
+    const match = rfc3339DateTime.exec(value);
+    if (match === null)
+        return "";
+    const [, year, month, day, hour, minute, second, fraction, offsetToken] = match;
+    const offset = offsetToken === "Z" || offsetToken === "z" ? "+00:00" : offsetToken;
+    const isoDateTime = `${year}-${month}-${day}T${hour}:${minute}:${second}${fraction ?? ""}`;
+    try {
+        return Temporal.PlainDateTime.from(isoDateTime)
+            .toZonedDateTime(offset)
+            .toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/zoned/parse/parseSecondFromZoned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the second (0-59) from a zoned datetime string.
+ *
+ * - Returns zero-padded string for second.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO zoned datetime string (e.g., "2024-03-15T14:30:45.123+00:00[UTC]")
+ * @returns Second (00-59) or "" on invalid input
+ *
+ * @example parseSecondFromZoned("2024-03-15T14:30:45+00:00[UTC]") // "45"
+ * @example parseSecondFromZoned("invalid") // ""
+ */
+export declare function parseSecondFromZoned(value: string): string;