@northguild/gmt 1.18.0 → 1.20.0

package/dist/zoned/interval/splitIntervalByUnitZoned.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 { addToZoned, formatZonedInCalendar, parseCalendarZonedPairForArithmetic, resolveDurationUnit, tileByUnit, } from "../../internal/index.js";
 import { isValidDateTimeDurationUnit } from "../../plain/validate/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/isValidCalendarZonedDateTime.js";
@@ -17,7 +17,8 @@ import { minSlicesForSpan } from "../../internal/splitStep.js";
  *   lands on February 29, March 31, April 30. Temporal's `add` constrains a day the month lacks
  *   to the month's last day, and stepping from that boundary would keep the shortened day
  *   (February 29, then March 29).
- * - Comparison: Luxon's `Interval.splitBy` computes each boundary from the start the same way.
+ * - Each calendar-unit boundary is `start.add(amount × k)` with Temporal's
+ *   `overflow: "constrain"` (TC39 Temporal `add`), never a step from the previous boundary.
  * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
  *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
  *   `Number.MAX_SAFE_INTEGER`.

package/dist/zoned/interval/validate/isValidCalendarZonedInterval.d.ts

@@ -24,8 +24,8 @@
  * @returns true if start and end form a valid zoned interval, or false on invalid input
  *
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
- * @example isValidCalendarZonedInterval("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", "2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]") // true
- * @example isValidCalendarZonedInterval("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", "2024-03-25T14:30:00-04:00[America/New_York][u-ca=islamic-civil]") // true (mixed calendars accepted)
+ * @example isValidCalendarZonedInterval("2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]", "2024-03-25T14:30:00+00:00[Europe/London][u-ca=hebrew]") // true
+ * @example isValidCalendarZonedInterval("2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]", "2024-03-25T14:30:00+00:00[Europe/London][u-ca=islamic-civil]") // true (mixed calendars accepted)
  * @example isValidCalendarZonedInterval("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T10:00:00+00:00[UTC]") // false (start after end)
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=hebrew]", "2024-12-31T23:59:59+00:00[UTC]") // true (RFC 9557; mixed calendars accepted)
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[u-ca=hebrew][UTC]", "2024-12-31T23:59:59+00:00[UTC]") // false (calendar before the zone)

package/dist/zoned/interval/validate/isValidCalendarZonedInterval.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../../internal/temporal.js";
 import { parseCalendarZonedValue } from "../../../internal/index.js";
 /**
  * Return true if `start` and `end` form a valid GMT zoned interval — both parseable as bare ISO
@@ -26,8 +26,8 @@ import { parseCalendarZonedValue } from "../../../internal/index.js";
  * @returns true if start and end form a valid zoned interval, or false on invalid input
  *
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
- * @example isValidCalendarZonedInterval("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", "2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]") // true
- * @example isValidCalendarZonedInterval("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", "2024-03-25T14:30:00-04:00[America/New_York][u-ca=islamic-civil]") // true (mixed calendars accepted)
+ * @example isValidCalendarZonedInterval("2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]", "2024-03-25T14:30:00+00:00[Europe/London][u-ca=hebrew]") // true
+ * @example isValidCalendarZonedInterval("2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]", "2024-03-25T14:30:00+00:00[Europe/London][u-ca=islamic-civil]") // true (mixed calendars accepted)
  * @example isValidCalendarZonedInterval("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T10:00:00+00:00[UTC]") // false (start after end)
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=hebrew]", "2024-12-31T23:59:59+00:00[UTC]") // true (RFC 9557; mixed calendars accepted)
  * @example isValidCalendarZonedInterval("2024-01-01T10:00:00+00:00[u-ca=hebrew][UTC]", "2024-12-31T23:59:59+00:00[UTC]") // false (calendar before the zone)

package/dist/zoned/interval/validate/isValidZonedInterval.d.ts

@@ -16,7 +16,7 @@
  * @returns true if start and end form a valid zoned interval, or false on invalid input
  *
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
- * @example isValidZonedInterval("2024-06-15T12:00:00-04:00[America/New_York]", "2024-06-15T12:00:00-04:00[America/New_York]") // true
+ * @example isValidZonedInterval("2024-06-15T12:00:00+02:00[Africa/Johannesburg]", "2024-06-15T12:00:00+02:00[Africa/Johannesburg]") // true
  * @example isValidZonedInterval("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T10:00:00+00:00[UTC]") // false
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=iso8601]", "2024-12-31T23:59:59+00:00[UTC][foo=bar]") // true (ISO calendar and elective annotations)
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=hebrew]", "2024-12-31T23:59:59+00:00[UTC]") // false (non-ISO calendar: use isValidCalendarZonedInterval)

package/dist/zoned/interval/validate/isValidZonedInterval.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../../internal/temporal.js";
 import { zonedDateTimeFrom } from "../../../internal/index.js";
 import { isValidZonedDateTime } from "../../validate/isValidZonedDateTime.js";
 /**
@@ -19,7 +19,7 @@ import { isValidZonedDateTime } from "../../validate/isValidZonedDateTime.js";
  * @returns true if start and end form a valid zoned interval, or false on invalid input
  *
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC]", "2024-12-31T23:59:59+00:00[UTC]") // true
- * @example isValidZonedInterval("2024-06-15T12:00:00-04:00[America/New_York]", "2024-06-15T12:00:00-04:00[America/New_York]") // true
+ * @example isValidZonedInterval("2024-06-15T12:00:00+02:00[Africa/Johannesburg]", "2024-06-15T12:00:00+02:00[Africa/Johannesburg]") // true
  * @example isValidZonedInterval("2024-12-31T23:59:59+00:00[UTC]", "2024-01-01T10:00:00+00:00[UTC]") // false
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=iso8601]", "2024-12-31T23:59:59+00:00[UTC][foo=bar]") // true (ISO calendar and elective annotations)
  * @example isValidZonedInterval("2024-01-01T10:00:00+00:00[UTC][u-ca=hebrew]", "2024-12-31T23:59:59+00:00[UTC]") // false (non-ISO calendar: use isValidCalendarZonedInterval)

package/dist/zoned/map/mapZonedDatesInRange.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 { isValidZonedDateTime } from "../validate/index.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";

package/dist/zoned/map/mapZonedHoursInDay.d.ts

@@ -13,7 +13,7 @@
  * @returns array of zoned ISO 8601 strings for each hour in the day
  *
  * @example mapZonedHoursInDay("2024-02-29T12:34:56.789+00:00[UTC]") // ["2024-02-29T00:00:00+00:00[UTC]", "2024-02-29T01:00:00+00:00[UTC]", ..., "2024-02-29T23:00:00+00:00[UTC]"]
- * @example mapZonedHoursInDay("2024-03-10T12:34:56.789-04:00[America/New_York]") // ["2024-03-10T00:00:00-05:00[America/New_York]", ...] (23 entries; 2 AM is skipped — the anchor is after the spring-forward, so its offset is -04:00)
+ * @example mapZonedHoursInDay("2024-03-31T12:34:56.789+01:00[Europe/London]") // ["2024-03-31T00:00:00+00:00[Europe/London]", ...] (23 entries; 1 AM is skipped — the anchor is after the spring-forward, so its offset is +01:00)
  * @example mapZonedHoursInDay("2024-09-08T12:00:00-03:00[America/Santiago]") // ["2024-09-08T01:00:00-03:00[America/Santiago]", ..., "2024-09-08T23:00:00-03:00[America/Santiago]"] (23 entries; midnight is skipped)
  * @example mapZonedHoursInDay("invalid") // []
  */

package/dist/zoned/map/mapZonedHoursInDay.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidZonedDateTime } from "../validate/index.js";
 import { addToZoned, zonedDateTimeFrom, zonedStartOfDay } from "../../internal/index.js";
 /**
@@ -16,7 +16,7 @@ import { addToZoned, zonedDateTimeFrom, zonedStartOfDay } from "../../internal/i
  * @returns array of zoned ISO 8601 strings for each hour in the day
  *
  * @example mapZonedHoursInDay("2024-02-29T12:34:56.789+00:00[UTC]") // ["2024-02-29T00:00:00+00:00[UTC]", "2024-02-29T01:00:00+00:00[UTC]", ..., "2024-02-29T23:00:00+00:00[UTC]"]
- * @example mapZonedHoursInDay("2024-03-10T12:34:56.789-04:00[America/New_York]") // ["2024-03-10T00:00:00-05:00[America/New_York]", ...] (23 entries; 2 AM is skipped — the anchor is after the spring-forward, so its offset is -04:00)
+ * @example mapZonedHoursInDay("2024-03-31T12:34:56.789+01:00[Europe/London]") // ["2024-03-31T00:00:00+00:00[Europe/London]", ...] (23 entries; 1 AM is skipped — the anchor is after the spring-forward, so its offset is +01:00)
  * @example mapZonedHoursInDay("2024-09-08T12:00:00-03:00[America/Santiago]") // ["2024-09-08T01:00:00-03:00[America/Santiago]", ..., "2024-09-08T23:00:00-03:00[America/Santiago]"] (23 entries; midnight is skipped)
  * @example mapZonedHoursInDay("invalid") // []
  */

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

@@ -10,7 +10,7 @@
  * @returns offset string (e.g. "-04:00"), or "" on invalid input
  *
  * @example getZonedOffset("2024-02-29T12:34:56.789+00:00[UTC]") // "+00:00"
- * @example getZonedOffset("2024-07-15T12:00:00-04:00[America/New_York]") // "-04:00"
+ * @example getZonedOffset("2024-07-15T12:00:00+05:30[Asia/Kolkata]") // "+05:30"
  * @example getZonedOffset("2024-05-15T12:00:00+05:45[Asia/Kathmandu]") // "+05:45"
  * @example getZonedOffset("invalid") // ""
  */

package/dist/zoned/parse/getZonedOffset.js

@@ -12,7 +12,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @returns offset string (e.g. "-04:00"), or "" on invalid input
  *
  * @example getZonedOffset("2024-02-29T12:34:56.789+00:00[UTC]") // "+00:00"
- * @example getZonedOffset("2024-07-15T12:00:00-04:00[America/New_York]") // "-04:00"
+ * @example getZonedOffset("2024-07-15T12:00:00+05:30[Asia/Kolkata]") // "+05:30"
  * @example getZonedOffset("2024-05-15T12:00:00+05:45[Asia/Kathmandu]") // "+05:45"
  * @example getZonedOffset("invalid") // ""
  */

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

@@ -5,12 +5,12 @@
  *
  * | Member | Description |
  * | --- | --- |
- * | `minutes` | Whole-minute offset (e.g. `-240` for `-04:00`). |
- * | `nanoseconds` | Raw `offsetNanoseconds` from Temporal (e.g. `-14400000000000`). |
+ * | `minutes` | Whole-minute offset (e.g. `-180` for `-03:00`). |
+ * | `nanoseconds` | Raw `offsetNanoseconds` from Temporal (e.g. `-10800000000000`). |
  *
  * @example
  * import { getZonedOffsetAs } from "@northguild/gmt/zoned";
- * getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "minutes");
+ * getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "minutes");
  */
 export type ZonedOffsetUnit = "minutes" | "nanoseconds" | "minute" | "nanosecond";
 /**
@@ -31,11 +31,11 @@ export type ZonedOffsetUnit = "minutes" | "nanoseconds" | "minute" | "nanosecond
  * @param unit "minutes" | "nanoseconds" (or the singular "minute" | "nanosecond")
  * @returns the offset in the requested unit, or null on invalid input
  *
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "minutes") // -240
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "minutes") // -180
  * @example getZonedOffsetAs("2024-05-15T12:00:00+05:45[Asia/Kathmandu]", "minutes") // 345
  * @example getZonedOffsetAs("2024-02-29T12:00:00+00:00[UTC]", "nanoseconds") // 0
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "nanoseconds") // -14400000000000
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "minute") // -240 (singular unit name)
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "nanoseconds") // -10800000000000
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "minute") // -180 (singular unit name)
  * @example getZonedOffsetAs("invalid", "minutes") // null
  * @example getZonedOffsetAs("2024-02-29T12:00:00+00:00[UTC]", "fortnights" as never) // null
  */

package/dist/zoned/parse/getZonedOffsetAs.js

@@ -25,11 +25,11 @@ function isValidZonedOffsetUnit(unit) {
  * @param unit "minutes" | "nanoseconds" (or the singular "minute" | "nanosecond")
  * @returns the offset in the requested unit, or null on invalid input
  *
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "minutes") // -240
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "minutes") // -180
  * @example getZonedOffsetAs("2024-05-15T12:00:00+05:45[Asia/Kathmandu]", "minutes") // 345
  * @example getZonedOffsetAs("2024-02-29T12:00:00+00:00[UTC]", "nanoseconds") // 0
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "nanoseconds") // -14400000000000
- * @example getZonedOffsetAs("2024-07-15T12:00:00-04:00[America/New_York]", "minute") // -240 (singular unit name)
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "nanoseconds") // -10800000000000
+ * @example getZonedOffsetAs("2024-07-15T12:00:00-03:00[America/Sao_Paulo]", "minute") // -180 (singular unit name)
  * @example getZonedOffsetAs("invalid", "minutes") // null
  * @example getZonedOffsetAs("2024-02-29T12:00:00+00:00[UTC]", "fortnights" as never) // null
  */

package/dist/zoned/parse/parseDateTimeFromZoned.js

@@ -1,4 +1,4 @@
-import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { hasSecond60 } from "../../plain/validate/hasSecond60.js";
 import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 /**
@@ -15,7 +15,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @example parseDateTimeFromZoned("invalid") // ""
  */
 export const parseDateTimeFromZoned = (value) => {
-    if (!isValidZonedDateTime(value) || isLeapSecond(value)) {
+    if (!isValidZonedDateTime(value) || hasSecond60(value)) {
         return "";
     }
     try {

package/dist/zoned/parse/parseRfc2822.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { readRfc5322DateTime } from "../../internal/rfc5322DateTime.js";
 /**
  * Parse an RFC 5322 (RFC 2822) date-time string — the fixed grammar email

package/dist/zoned/parse/parseRfc3339.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { rfc3339DateTime } from "../../regex/index.js";
 /**
  * Parse a strict RFC 3339 datetime string into a zoned ISO 8601 datetime

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

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "../../internal/temporal.js";
 /**
  * Units supported by `parseUnitFromZoned` when extracting a value from a zoned
  * ISO string. Includes `timeZone` for reading the zone identifier. Each Temporal unit is also
@@ -8,7 +8,7 @@ import type { Temporal } from "@js-temporal/polyfill";
  *
  * | Member | Description |
  * | --- | --- |
- * | `year` | Full year, no padding (e.g. `2024`). |
+ * | `year` | Four digits (e.g. `2024`, `0005`); a sign and six digits outside 0000–9999 (e.g. `+010000`). |
  * | `month` | Zero-padded 2 (e.g. `03`). |
  * | `week` | Week-of-year, 1–53 (`weekStartsOn`-controlled). |
  * | `day` | Zero-padded 2. |
@@ -34,6 +34,8 @@ export type ZonedParseUnit = Temporal.SmallestUnit<"year" | "month" | "week" | "
  * - `unit` accepts the singular or plural name of a Temporal unit (`"hour"` or `"hours"`), as Temporal
  *   does; `"dayOfWeek"` has no plural.
  * - 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 zoned ISO 8601 datetime string
  * @param unit unit to extract
@@ -41,6 +43,7 @@ export type ZonedParseUnit = Temporal.SmallestUnit<"year" | "month" | "week" | "
  * @returns string representation of the requested unit or "" when invalid
  *
  * @example parseUnitFromZoned("2024-02-29T12:34:56.789+00:00[UTC]", "year") // "2024"
+ * @example parseUnitFromZoned("0005-06-01T12:30:00+00:00[UTC]", "year") // "0005"
  * @example parseUnitFromZoned("2024-02-29T12:34:56.789+00:00[UTC]", "milliseconds") // "789"
  * @example parseUnitFromZoned("2024-12-31T12:00:00+00:00[UTC]", "week", { weekStartsOn: "sunday" }) // "1"
  * @example parseUnitFromZoned("invalid", "year") // ""

package/dist/zoned/parse/parseUnitFromZoned.js

@@ -4,6 +4,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
 import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
 import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 function isValidZonedUnit(unit) {
     return [
         "year",
@@ -28,6 +29,8 @@ function isValidZonedUnit(unit) {
  * - `unit` accepts the singular or plural name of a Temporal unit (`"hour"` or `"hours"`), as Temporal
  *   does; `"dayOfWeek"` has no plural.
  * - 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 zoned ISO 8601 datetime string
  * @param unit unit to extract
@@ -35,6 +38,7 @@ function isValidZonedUnit(unit) {
  * @returns string representation of the requested unit or "" when invalid
  *
  * @example parseUnitFromZoned("2024-02-29T12:34:56.789+00:00[UTC]", "year") // "2024"
+ * @example parseUnitFromZoned("0005-06-01T12:30:00+00:00[UTC]", "year") // "0005"
  * @example parseUnitFromZoned("2024-02-29T12:34:56.789+00:00[UTC]", "milliseconds") // "789"
  * @example parseUnitFromZoned("2024-12-31T12:00:00+00:00[UTC]", "week", { weekStartsOn: "sunday" }) // "1"
  * @example parseUnitFromZoned("invalid", "year") // ""
@@ -56,7 +60,7 @@ export function parseUnitFromZoned(value, unit, optionsArg) {
             const zonedDateTime = zonedDateTimeFrom(value);
             switch (resolvedUnit) {
                 case "year":
-                    return zonedDateTime.year.toString();
+                    return isoYearString(zonedDateTime.year);
                 case "month":
                     return zonedDateTime.month.toString().padStart(2, "0");
                 case "week":

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

@@ -1,13 +1,15 @@
 /**
  * Return the year for a given ISO 8601 zoned datetime string.
  *
- * - Returns string for year.
+ * - 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 zoned datetime string
- * @returns Year as string or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "2024"
+ * @example parseYearFromZoned("0005-06-01T12:30:00+00:00[UTC]") // "0005"
  * @example parseYearFromZoned("invalid") // ""
  */
 export declare function parseYearFromZoned(value: string): string;

package/dist/zoned/parse/parseYearFromZoned.js

@@ -1,15 +1,18 @@
 import { isValidZonedDateTime } from "../validate/index.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
+import { isoYearString } from "../../internal/isoYearString.js";
 /**
  * Return the year for a given ISO 8601 zoned datetime string.
  *
- * - Returns string for year.
+ * - 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 zoned datetime string
- * @returns Year as string or "" on invalid input
+ * @returns the year as four digits, or a sign and six digits outside 0000–9999, or "" on invalid input
  *
  * @example parseYearFromZoned("2024-03-15T14:30:45.123+00:00[UTC]") // "2024"
+ * @example parseYearFromZoned("0005-06-01T12:30:00+00:00[UTC]") // "0005"
  * @example parseYearFromZoned("invalid") // ""
  */
 export function parseYearFromZoned(value) {
@@ -18,7 +21,7 @@ export function parseYearFromZoned(value) {
     }
     try {
         const zonedDateTime = zonedDateTimeFrom(value);
-        return zonedDateTime.year.toString();
+        return isoYearString(zonedDateTime.year);
     }
     catch {
         return "";

package/dist/zoned/validate/hasDaylightSaving.d.ts

@@ -17,13 +17,14 @@
  *   2016 on, although its clocks went forward in March 2016.
  * - Read from the runtime's time zone data, so the answer can change when that data does.
  * - Returns false for an invalid timeZone, an invalid `at`, an options argument that is not an
- *   object, and a fixed offset.
+ *   object, and a fixed UTC offset, with or without seconds (`"+05:30"`, `"-00:44:30"`).
  *
- * @param timeZone timeZone identifier to check
+ * @param timeZone IANA name or UTC offset: a time zone identifier (`+05:30`, `+0530`, `-08`) or a
+ *   stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param options optional setting for the reference instant
  * @returns boolean indicating whether the timeZone observes DST, or false on invalid input
  *
- * @example hasDaylightSaving("America/New_York", { at: "2024-01-15T12:00:00Z" }) // true
+ * @example hasDaylightSaving("Europe/London", { at: "2024-01-15T12:00:00Z" }) // true
  * @example hasDaylightSaving("Australia/Sydney", { at: "2024-06-15T12:00:00Z" }) // true (winter; the next period begins in October)
  * @example hasDaylightSaving("Asia/Tokyo", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Europe/Istanbul", { at: "2015-06-15T12:00:00Z" }) // true
@@ -33,7 +34,8 @@
  * @example hasDaylightSaving("UTC", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("+05:00", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Invalid/Zone", { at: "2024-01-15T12:00:00Z" }) // false
- * @example hasDaylightSaving("America/New_York", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("Australia/Sydney", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("-00:44:30", { at: "1970-01-01T12:00:00Z" }) // false (a fixed offset)
  */
 export declare function hasDaylightSaving(timeZone: string, options?: {
     /**

package/dist/zoned/validate/hasDaylightSaving.js

@@ -1,6 +1,5 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isOptionsArgument, observesDaylightTime, parseInstantNanoseconds, } from "../../internal/index.js";
-import { isValidTimeZone } from "./isValidTimeZone.js";
+import { Temporal } from "../../internal/temporal.js";
+import { isOptionsArgument, observesDaylightTime, parseInstantNanoseconds, zoneFrame, } from "../../internal/index.js";
 /**
  * Check whether a timeZone observes daylight saving time at a reference instant.
  *
@@ -20,13 +19,14 @@ import { isValidTimeZone } from "./isValidTimeZone.js";
  *   2016 on, although its clocks went forward in March 2016.
  * - Read from the runtime's time zone data, so the answer can change when that data does.
  * - Returns false for an invalid timeZone, an invalid `at`, an options argument that is not an
- *   object, and a fixed offset.
+ *   object, and a fixed UTC offset, with or without seconds (`"+05:30"`, `"-00:44:30"`).
  *
- * @param timeZone timeZone identifier to check
+ * @param timeZone IANA name or UTC offset: a time zone identifier (`+05:30`, `+0530`, `-08`) or a
+ *   stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param options optional setting for the reference instant
  * @returns boolean indicating whether the timeZone observes DST, or false on invalid input
  *
- * @example hasDaylightSaving("America/New_York", { at: "2024-01-15T12:00:00Z" }) // true
+ * @example hasDaylightSaving("Europe/London", { at: "2024-01-15T12:00:00Z" }) // true
  * @example hasDaylightSaving("Australia/Sydney", { at: "2024-06-15T12:00:00Z" }) // true (winter; the next period begins in October)
  * @example hasDaylightSaving("Asia/Tokyo", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Europe/Istanbul", { at: "2015-06-15T12:00:00Z" }) // true
@@ -36,22 +36,28 @@ import { isValidTimeZone } from "./isValidTimeZone.js";
  * @example hasDaylightSaving("UTC", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("+05:00", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Invalid/Zone", { at: "2024-01-15T12:00:00Z" }) // false
- * @example hasDaylightSaving("America/New_York", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("Australia/Sydney", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("-00:44:30", { at: "1970-01-01T12:00:00Z" }) // false (a fixed offset)
  */
 export function hasDaylightSaving(timeZone, options) {
-    if (!isValidTimeZone(timeZone) || !isOptionsArgument(options)) {
+    const frame = zoneFrame(timeZone);
+    // A stored offset with seconds is a fixed offset: it observes no daylight time, as "-00:45"
+    // observes none.
+    if (frame === null ||
+        frame.shiftNanoseconds !== 0n ||
+        !isOptionsArgument(options)) {
         return false;
     }
     try {
         const at = options?.at;
         if (at === undefined) {
-            return observesDaylightTime(Temporal.Now.zonedDateTimeISO(timeZone));
+            return observesDaylightTime(Temporal.Now.zonedDateTimeISO(frame.timeZone));
         }
         const epochNanoseconds = parseInstantNanoseconds(at);
         if (epochNanoseconds === null) {
             return false;
         }
-        return observesDaylightTime(Temporal.Instant.fromEpochNanoseconds(epochNanoseconds).toZonedDateTimeISO(timeZone));
+        return observesDaylightTime(Temporal.Instant.fromEpochNanoseconds(epochNanoseconds).toZonedDateTimeISO(frame.timeZone));
     }
     catch {
         return false;

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

@@ -1,5 +1,7 @@
 export * from "./hasDaylightSaving.js";
 export * from "./isValidCalendarZonedDateTime.js";
+export * from "./isValidRfc2822DateTime.js";
+export * from "./isValidRfc3339DateTime.js";
 export * from "./isValidTimeZone.js";
 export * from "./isValidZonedDateTime.js";
 export * from "./isValidZonedRange.js";

package/dist/zoned/validate/index.js

@@ -1,5 +1,7 @@
 export * from "./hasDaylightSaving.js";
 export * from "./isValidCalendarZonedDateTime.js";
+export * from "./isValidRfc2822DateTime.js";
+export * from "./isValidRfc3339DateTime.js";
 export * from "./isValidTimeZone.js";
 export * from "./isValidZonedDateTime.js";
 export * from "./isValidZonedRange.js";

package/dist/zoned/validate/isValidCalendarZonedDateTime.d.ts

@@ -1,7 +1,7 @@
 /**
  * Return true if `value` is a valid GMT ZonedDateTime string: a bare ISO zoned datetime
- * ("2024-10-03T14:30:45-04:00[America/New_York]") or an RFC 9557 calendar-annotated one
- * ("2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]"), as
+ * ("2024-10-03T14:30:45+02:00[Africa/Johannesburg]") or an RFC 9557 calendar-annotated one
+ * ("2024-10-03T14:30:45+02:00[Africa/Johannesburg][u-ca=hebrew]"), as
  * `Temporal.ZonedDateTime#toString()` and `convertZonedToCalendar` write it.
  *
  * - Parallel to `isValidZonedDateTime`, which accepts `[u-ca=iso8601]` and rejects every other
@@ -32,14 +32,14 @@
  * @param value candidate zoned datetime string, optionally calendar-annotated
  * @returns boolean indicating validity
  *
- * @example isValidCalendarZonedDateTime("2024-10-03T14:30:45-04:00[America/New_York]") // true
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]") // true
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[America/New_York][foo=bar][u-ca=hebrew]") // true (elective annotation ignored)
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[u-ca=hebrew][America/New_York]") // false (calendar before zone)
+ * @example isValidCalendarZonedDateTime("2024-10-03T14:30:45+02:00[Africa/Johannesburg]") // true
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[Africa/Johannesburg][u-ca=hebrew]") // true
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[Africa/Johannesburg][foo=bar][u-ca=hebrew]") // true (elective annotation ignored)
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[u-ca=hebrew][Africa/Johannesburg]") // false (calendar before zone)
  * @example isValidCalendarZonedDateTime("2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese;era=heisei]") // false (not RFC 9557)
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+03:00[America/New_York][u-ca=hebrew]") // false (offset wrong for the zone)
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+03:00[Africa/Johannesburg][u-ca=hebrew]") // false (offset wrong for the zone)
  * @example isValidCalendarZonedDateTime("2024-06-30T23:59:60+00:00[UTC]") // false (leap second)
- * @example isValidCalendarZonedDateTime("2024-02-24 14:30:00-05:00[America/New_York][u-ca=hebrew]") // false (space separator)
+ * @example isValidCalendarZonedDateTime("2024-02-24 14:30:00+02:00[Africa/Johannesburg][u-ca=hebrew]") // false (space separator)
  * @example isValidCalendarZonedDateTime("invalid") // false
  */
 export declare function isValidCalendarZonedDateTime(value: string): boolean;

package/dist/zoned/validate/isValidCalendarZonedDateTime.js

@@ -1,8 +1,8 @@
 import { parseCalendarZonedValue } from "../../internal/index.js";
 /**
  * Return true if `value` is a valid GMT ZonedDateTime string: a bare ISO zoned datetime
- * ("2024-10-03T14:30:45-04:00[America/New_York]") or an RFC 9557 calendar-annotated one
- * ("2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]"), as
+ * ("2024-10-03T14:30:45+02:00[Africa/Johannesburg]") or an RFC 9557 calendar-annotated one
+ * ("2024-10-03T14:30:45+02:00[Africa/Johannesburg][u-ca=hebrew]"), as
  * `Temporal.ZonedDateTime#toString()` and `convertZonedToCalendar` write it.
  *
  * - Parallel to `isValidZonedDateTime`, which accepts `[u-ca=iso8601]` and rejects every other
@@ -33,14 +33,14 @@ import { parseCalendarZonedValue } from "../../internal/index.js";
  * @param value candidate zoned datetime string, optionally calendar-annotated
  * @returns boolean indicating validity
  *
- * @example isValidCalendarZonedDateTime("2024-10-03T14:30:45-04:00[America/New_York]") // true
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]") // true
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[America/New_York][foo=bar][u-ca=hebrew]") // true (elective annotation ignored)
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00-05:00[u-ca=hebrew][America/New_York]") // false (calendar before zone)
+ * @example isValidCalendarZonedDateTime("2024-10-03T14:30:45+02:00[Africa/Johannesburg]") // true
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[Africa/Johannesburg][u-ca=hebrew]") // true
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[Africa/Johannesburg][foo=bar][u-ca=hebrew]") // true (elective annotation ignored)
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+02:00[u-ca=hebrew][Africa/Johannesburg]") // false (calendar before zone)
  * @example isValidCalendarZonedDateTime("2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese;era=heisei]") // false (not RFC 9557)
- * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+03:00[America/New_York][u-ca=hebrew]") // false (offset wrong for the zone)
+ * @example isValidCalendarZonedDateTime("2024-02-24T14:30:00+03:00[Africa/Johannesburg][u-ca=hebrew]") // false (offset wrong for the zone)
  * @example isValidCalendarZonedDateTime("2024-06-30T23:59:60+00:00[UTC]") // false (leap second)
- * @example isValidCalendarZonedDateTime("2024-02-24 14:30:00-05:00[America/New_York][u-ca=hebrew]") // false (space separator)
+ * @example isValidCalendarZonedDateTime("2024-02-24 14:30:00+02:00[Africa/Johannesburg][u-ca=hebrew]") // false (space separator)
  * @example isValidCalendarZonedDateTime("invalid") // false
  */
 export function isValidCalendarZonedDateTime(value) {

package/dist/zoned/validate/isValidRfc2822DateTime.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Return true when `value` is a real RFC 5322 (RFC 2822) date-time: the date an email `Date:`
+ * header carries, such as `Fri, 15 Mar 2024 14:30:00 -0400`.
+ *
+ * - True exactly when `parseRfc2822` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Reads what a conformant receiver must**, which is more than the strict `rfc2822DateTime`
+ *   pattern matches: RFC 5322 §3.3 folding white space, comments, names in any case and a year of
+ *   more than four digits, and the §4 obsolete syntax (2- and 3-digit years, military and other
+ *   alphabetic zones). `parseRfc2822` lists each form.
+ * - Checks the calendar as well as the shape. The pattern matches a day that does not exist:
+ *   `31 Feb`, `29 Feb 2023` and `31 Jun` are false here.
+ * - **The day-of-week must match the date.** RFC 5322 §3.3: "the day-of-week (if included) MUST be
+ *   the day implied by the date". The pattern does not check it.
+ * - False for an hour above 23, a minute above 59, zone minutes above 59 and an offset of 24
+ *   hours or more, all of which the pattern matches. False for a second of 60: GMT rejects leap
+ *   seconds.
+ * - False for a non-string. Read the value with `parseRfc2822`; write one with `formatRfc2822`.
+ *
+ * @param value candidate RFC 5322 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0400") // true
+ * @example isValidRfc2822DateTime("5 Jan 2024 09:00:00 GMT") // true (no day-of-week, 1-digit day)
+ * @example isValidRfc2822DateTime("fri,15 Mar 24 14:30 -0400 (EDT)") // true (obsolete 2-digit year, comment; the rfc2822DateTime pattern does not match it)
+ * @example isValidRfc2822DateTime("Sat, 15 Mar 2024 14:30:00 -0400") // false (15 Mar 2024 was a Friday; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Wed, 29 Feb 2023 14:30:00 -0400") // false (2023 has no 29 February; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0460") // false (zone minutes above 59; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00") // false (no zone)
+ * @example isValidRfc2822DateTime("not a date") // false
+ */
+export declare function isValidRfc2822DateTime(value: string): boolean;

package/dist/zoned/validate/isValidRfc2822DateTime.js

@@ -0,0 +1,35 @@
+import { parseRfc2822 } from "../parse/parseRfc2822.js";
+/**
+ * Return true when `value` is a real RFC 5322 (RFC 2822) date-time: the date an email `Date:`
+ * header carries, such as `Fri, 15 Mar 2024 14:30:00 -0400`.
+ *
+ * - True exactly when `parseRfc2822` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Reads what a conformant receiver must**, which is more than the strict `rfc2822DateTime`
+ *   pattern matches: RFC 5322 §3.3 folding white space, comments, names in any case and a year of
+ *   more than four digits, and the §4 obsolete syntax (2- and 3-digit years, military and other
+ *   alphabetic zones). `parseRfc2822` lists each form.
+ * - Checks the calendar as well as the shape. The pattern matches a day that does not exist:
+ *   `31 Feb`, `29 Feb 2023` and `31 Jun` are false here.
+ * - **The day-of-week must match the date.** RFC 5322 §3.3: "the day-of-week (if included) MUST be
+ *   the day implied by the date". The pattern does not check it.
+ * - False for an hour above 23, a minute above 59, zone minutes above 59 and an offset of 24
+ *   hours or more, all of which the pattern matches. False for a second of 60: GMT rejects leap
+ *   seconds.
+ * - False for a non-string. Read the value with `parseRfc2822`; write one with `formatRfc2822`.
+ *
+ * @param value candidate RFC 5322 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0400") // true
+ * @example isValidRfc2822DateTime("5 Jan 2024 09:00:00 GMT") // true (no day-of-week, 1-digit day)
+ * @example isValidRfc2822DateTime("fri,15 Mar 24 14:30 -0400 (EDT)") // true (obsolete 2-digit year, comment; the rfc2822DateTime pattern does not match it)
+ * @example isValidRfc2822DateTime("Sat, 15 Mar 2024 14:30:00 -0400") // false (15 Mar 2024 was a Friday; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Wed, 29 Feb 2023 14:30:00 -0400") // false (2023 has no 29 February; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0460") // false (zone minutes above 59; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00") // false (no zone)
+ * @example isValidRfc2822DateTime("not a date") // false
+ */
+export function isValidRfc2822DateTime(value) {
+    return parseRfc2822(value) !== "";
+}