@northguild/gmt 1.19.0 → 1.20.0

package/dist/zoned/convert/convertPlainDateTimeToZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../../plain/validate/index.js";
 import { isValidTimeZone } from "../validate/index.js";
 import { isoStringBody, zonedDateTimeFrom } from "../../internal/index.js";
@@ -22,13 +22,13 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * @param optionsArg optional settings for the precision of the output string and for resolving a DST gap or overlap
  * @returns zoned ISO 8601 datetime string or "" when invalid
  *
- * @example convertPlainDateTimeToZoned("2024-02-29T14:30:45", "America/New_York") // "2024-02-29T14:30:45.000-05:00[America/New_York]"
+ * @example convertPlainDateTimeToZoned("2024-02-29T14:30:45", "Asia/Tokyo") // "2024-02-29T14:30:45.000+09:00[Asia/Tokyo]"
  * @example convertPlainDateTimeToZoned("2024-02-29T14:30:45.123456789", "UTC") // "2024-02-29T14:30:45.123+00:00[UTC]"
  * @example convertPlainDateTimeToZoned("2024-02-29T14:30:45.123456789", "UTC", { smallestUnit: "nanoseconds" }) // "2024-02-29T14:30:45.123456789+00:00[UTC]"
- * @example convertPlainDateTimeToZoned("invalid", "America/New_York") // ""
- * @example convertPlainDateTimeToZoned("2024-03-10T02:30:00", "America/New_York", { disambiguation: "earlier" }) // "2024-03-10T01:30:00.000-05:00[America/New_York]" (spring-forward gap)
- * @example convertPlainDateTimeToZoned("2024-11-03T01:30:00", "America/New_York", { disambiguation: "later" }) // "2024-11-03T01:30:00.000-05:00[America/New_York]" (fall-back overlap)
- * @example convertPlainDateTimeToZoned("2024-03-10T02:30:00", "America/New_York", { disambiguation: "reject" }) // ""
+ * @example convertPlainDateTimeToZoned("invalid", "Asia/Kolkata") // ""
+ * @example convertPlainDateTimeToZoned("2024-10-06T02:30:00", "Australia/Sydney", { disambiguation: "earlier" }) // "2024-10-06T01:30:00.000+10:00[Australia/Sydney]" (spring-forward gap)
+ * @example convertPlainDateTimeToZoned("2024-10-27T01:30:00", "Europe/London", { disambiguation: "later" }) // "2024-10-27T01:30:00.000+00:00[Europe/London]" (fall-back overlap)
+ * @example convertPlainDateTimeToZoned("2024-10-06T02:30:00", "Australia/Sydney", { disambiguation: "reject" }) // ""
  */
 export function convertPlainDateTimeToZoned(value, timeZone, optionsArg) {
     try {

package/dist/zoned/convert/convertZonedToCalendar.d.ts

@@ -26,12 +26,12 @@ import type { CalendarSystem } from "../../types/index.js";
  *   "indian" | "ethiopic" | "ethioaa" | "coptic")
  * @returns RFC 9557 zoned datetime string, or "" on invalid input
  *
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "hebrew") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]", "iso8601") // "2024-10-03T14:30:45-04:00[America/New_York]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "japanese") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=japanese]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "roc") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=roc]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[Europe/London]", "hebrew") // "2024-10-03T14:30:45+01:00[Europe/London][u-ca=hebrew]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[Europe/London][u-ca=hebrew]", "iso8601") // "2024-10-03T14:30:45+01:00[Europe/London]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+09:00[Asia/Tokyo]", "japanese") // "2024-10-03T14:30:45+09:00[Asia/Tokyo][u-ca=japanese]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+08:00[Asia/Taipei]", "roc") // "2024-10-03T14:30:45+08:00[Asia/Taipei][u-ca=roc]"
  * @example convertZonedToCalendar("+275760-09-13T00:00:00+00:00[UTC]", "hebrew") // "+275760-09-13T00:00:00+00:00[UTC][u-ca=hebrew]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[u-ca=hebrew][America/New_York]", "iso8601") // "" (calendar before zone is not RFC 9557)
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[u-ca=hebrew][Europe/London]", "iso8601") // "" (calendar before zone is not RFC 9557)
  * @example convertZonedToCalendar("invalid", "hebrew") // ""
  */
 export declare function convertZonedToCalendar(value: string, calendar: CalendarSystem): string;

package/dist/zoned/convert/convertZonedToCalendar.js

@@ -27,12 +27,12 @@ import { isValidCalendarZonedDateTime } from "../validate/index.js";
  *   "indian" | "ethiopic" | "ethioaa" | "coptic")
  * @returns RFC 9557 zoned datetime string, or "" on invalid input
  *
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "hebrew") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York][u-ca=hebrew]", "iso8601") // "2024-10-03T14:30:45-04:00[America/New_York]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "japanese") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=japanese]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[America/New_York]", "roc") // "2024-10-03T14:30:45-04:00[America/New_York][u-ca=roc]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[Europe/London]", "hebrew") // "2024-10-03T14:30:45+01:00[Europe/London][u-ca=hebrew]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[Europe/London][u-ca=hebrew]", "iso8601") // "2024-10-03T14:30:45+01:00[Europe/London]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+09:00[Asia/Tokyo]", "japanese") // "2024-10-03T14:30:45+09:00[Asia/Tokyo][u-ca=japanese]"
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+08:00[Asia/Taipei]", "roc") // "2024-10-03T14:30:45+08:00[Asia/Taipei][u-ca=roc]"
  * @example convertZonedToCalendar("+275760-09-13T00:00:00+00:00[UTC]", "hebrew") // "+275760-09-13T00:00:00+00:00[UTC][u-ca=hebrew]"
- * @example convertZonedToCalendar("2024-10-03T14:30:45-04:00[u-ca=hebrew][America/New_York]", "iso8601") // "" (calendar before zone is not RFC 9557)
+ * @example convertZonedToCalendar("2024-10-03T14:30:45+01:00[u-ca=hebrew][Europe/London]", "iso8601") // "" (calendar before zone is not RFC 9557)
  * @example convertZonedToCalendar("invalid", "hebrew") // ""
  */
 export function convertZonedToCalendar(value, calendar) {

package/dist/zoned/convert/convertZonedToPlainDateTime.d.ts

@@ -11,9 +11,9 @@
  * @param value zoned ISO 8601 datetime string
  * @returns plain datetime string or "" on invalid input
  *
- * @example convertZonedToPlainDateTime("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45.123"
- * @example convertZonedToPlainDateTime("2024-11-03T01:30:00-05:00[America/New_York]") // "2024-11-03T01:30:00" (the second 01:30, EST)
- * @example convertZonedToPlainDateTime("2024-11-03T01:30:00-04:00[America/New_York]") // "2024-11-03T01:30:00" (the first 01:30, EDT)
+ * @example convertZonedToPlainDateTime("2024-02-29T14:30:45.123-03:00[America/Sao_Paulo]") // "2024-02-29T14:30:45.123"
+ * @example convertZonedToPlainDateTime("2024-10-27T01:30:00+00:00[Europe/London]") // "2024-10-27T01:30:00" (the second 01:30, GMT)
+ * @example convertZonedToPlainDateTime("2024-10-27T01:30:00+01:00[Europe/London]") // "2024-10-27T01:30:00" (the first 01:30, BST)
  * @example convertZonedToPlainDateTime("invalid") // ""
  */
 export declare function convertZonedToPlainDateTime(value: string): string;

package/dist/zoned/convert/convertZonedToPlainDateTime.js

@@ -13,9 +13,9 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value zoned ISO 8601 datetime string
  * @returns plain datetime string or "" on invalid input
  *
- * @example convertZonedToPlainDateTime("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45.123"
- * @example convertZonedToPlainDateTime("2024-11-03T01:30:00-05:00[America/New_York]") // "2024-11-03T01:30:00" (the second 01:30, EST)
- * @example convertZonedToPlainDateTime("2024-11-03T01:30:00-04:00[America/New_York]") // "2024-11-03T01:30:00" (the first 01:30, EDT)
+ * @example convertZonedToPlainDateTime("2024-02-29T14:30:45.123-03:00[America/Sao_Paulo]") // "2024-02-29T14:30:45.123"
+ * @example convertZonedToPlainDateTime("2024-10-27T01:30:00+00:00[Europe/London]") // "2024-10-27T01:30:00" (the second 01:30, GMT)
+ * @example convertZonedToPlainDateTime("2024-10-27T01:30:00+01:00[Europe/London]") // "2024-10-27T01:30:00" (the first 01:30, BST)
  * @example convertZonedToPlainDateTime("invalid") // ""
  */
 export function convertZonedToPlainDateTime(value) {

package/dist/zoned/convert/convertZonedToZoned.d.ts

@@ -12,7 +12,7 @@
  * @param timeZone target IANA name or a UTC offset to the minute (what `isValidTimeZone` accepts)
  * @returns zoned ISO 8601 string in target timeZone or "" when invalid
  *
- * @example convertZonedToZoned("2024-02-29T12:34:56.789+00:00[UTC]", "America/New_York") // "2024-02-29T07:34:56.789-05:00[America/New_York]"
- * @example convertZonedToZoned("invalid", "America/New_York") // ""
+ * @example convertZonedToZoned("2024-02-29T12:34:56.789+00:00[UTC]", "Asia/Kolkata") // "2024-02-29T18:04:56.789+05:30[Asia/Kolkata]"
+ * @example convertZonedToZoned("invalid", "Asia/Kolkata") // ""
  */
 export declare function convertZonedToZoned(value: string, timeZone: string): string;

package/dist/zoned/convert/convertZonedToZoned.js

@@ -14,8 +14,8 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param timeZone target IANA name or a UTC offset to the minute (what `isValidTimeZone` accepts)
  * @returns zoned ISO 8601 string in target timeZone or "" when invalid
  *
- * @example convertZonedToZoned("2024-02-29T12:34:56.789+00:00[UTC]", "America/New_York") // "2024-02-29T07:34:56.789-05:00[America/New_York]"
- * @example convertZonedToZoned("invalid", "America/New_York") // ""
+ * @example convertZonedToZoned("2024-02-29T12:34:56.789+00:00[UTC]", "Asia/Kolkata") // "2024-02-29T18:04:56.789+05:30[Asia/Kolkata]"
+ * @example convertZonedToZoned("invalid", "Asia/Kolkata") // ""
  */
 export function convertZonedToZoned(value, timeZone) {
     if (!isValidZonedDateTime(value) || !isValidTimeZone(timeZone)) {

package/dist/zoned/format/formatCalendarZoned.d.ts

@@ -14,8 +14,9 @@ export interface FormatCalendarZonedOptions {
     reference?: string | number;
     /**
      * The length of the time-of-day part, as the `timeStyle` of `Intl.DateTimeFormat`. `"short"`
-     * writes hours and minutes, `"medium"` adds seconds, `"long"` adds the short time zone name
-     * ("EDT") and `"full"` the long one ("Eastern Daylight Time"). Any other value returns `""`.
+     * writes hours and minutes, `"medium"` adds seconds, `"long"` adds the locale's short zone
+     * name ("BST" in en-GB, "GMT+1" in en-US) and `"full"` the long one ("British Summer Time" in
+     * English). Any other value returns `""`.
      *
      * @defaultValue `"short"`
      */
@@ -23,7 +24,7 @@ export interface FormatCalendarZonedOptions {
 }
 /**
  * Format a zoned date-time as a relative day label plus time-of-day, e.g.
- * "Tomorrow at 2:30 PM" — the zoned counterpart of `formatCalendar`. See
+ * "tomorrow at 14:30" — the zoned counterpart of `formatCalendar`. See
  * that function's JSDoc for the day-label/threshold/connector design; this
  * variant differs only in reading `value`'s IANA timezone for both the
  * calendar-day comparison and the rendered clock time.
@@ -35,10 +36,10 @@ export interface FormatCalendarZonedOptions {
  * @param options optional settings for the reference moment and the time style
  * @returns the formatted calendar string, or "" on invalid input
  *
- * @example formatCalendarZoned("2026-03-16T14:30:00-04:00[America/New_York]", "en-US", { reference: "2026-03-15T09:00:00-04:00[America/New_York]" }) // "tomorrow at 2:30 PM"
+ * @example formatCalendarZoned("2026-03-16T14:30:00+00:00[Europe/London]", "en-GB", { reference: "2026-03-15T09:00:00+00:00[Europe/London]" }) // "tomorrow at 14:30"
  * @example formatCalendarZoned("2026-03-16T14:30:00+01:00[Europe/Berlin]", "de-DE", { reference: "2026-03-15T09:00:00+01:00[Europe/Berlin]" }) // "morgen um 14:30"
  * @example formatCalendarZoned("not-a-date") // ""
- * @example formatCalendarZoned("2024-03-16T14:30:00-04:00[America/New_York]", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00-04:00[America/New_York]" }) // "demain à 14:30"
- * @example formatCalendarZoned("2024-03-12T10:00:00-04:00[America/New_York]", "en-US", null as never) // "" (null options)
+ * @example formatCalendarZoned("2024-03-16T14:30:00+02:00[Africa/Johannesburg]", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00+02:00[Africa/Johannesburg]" }) // "demain à 14:30"
+ * @example formatCalendarZoned("2024-03-12T10:00:00+09:00[Asia/Tokyo]", "ja-JP", null as never) // "" (null options)
  */
 export declare function formatCalendarZoned(value: string, locale?: string | string[], options?: FormatCalendarZonedOptions): string;

package/dist/zoned/format/formatCalendarZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 import { formatCalendarDays } from "../../internal/formatCalendarDays.js";
 import { isValidUtc } from "../../utc/validate/index.js";
@@ -8,7 +8,7 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
 import { isObject } from "../../internal/isObject.js";
 /**
  * Format a zoned date-time as a relative day label plus time-of-day, e.g.
- * "Tomorrow at 2:30 PM" — the zoned counterpart of `formatCalendar`. See
+ * "tomorrow at 14:30" — the zoned counterpart of `formatCalendar`. See
  * that function's JSDoc for the day-label/threshold/connector design; this
  * variant differs only in reading `value`'s IANA timezone for both the
  * calendar-day comparison and the rendered clock time.
@@ -20,11 +20,11 @@ import { isObject } from "../../internal/isObject.js";
  * @param options optional settings for the reference moment and the time style
  * @returns the formatted calendar string, or "" on invalid input
  *
- * @example formatCalendarZoned("2026-03-16T14:30:00-04:00[America/New_York]", "en-US", { reference: "2026-03-15T09:00:00-04:00[America/New_York]" }) // "tomorrow at 2:30 PM"
+ * @example formatCalendarZoned("2026-03-16T14:30:00+00:00[Europe/London]", "en-GB", { reference: "2026-03-15T09:00:00+00:00[Europe/London]" }) // "tomorrow at 14:30"
  * @example formatCalendarZoned("2026-03-16T14:30:00+01:00[Europe/Berlin]", "de-DE", { reference: "2026-03-15T09:00:00+01:00[Europe/Berlin]" }) // "morgen um 14:30"
  * @example formatCalendarZoned("not-a-date") // ""
- * @example formatCalendarZoned("2024-03-16T14:30:00-04:00[America/New_York]", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00-04:00[America/New_York]" }) // "demain à 14:30"
- * @example formatCalendarZoned("2024-03-12T10:00:00-04:00[America/New_York]", "en-US", null as never) // "" (null options)
+ * @example formatCalendarZoned("2024-03-16T14:30:00+02:00[Africa/Johannesburg]", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00+02:00[Africa/Johannesburg]" }) // "demain à 14:30"
+ * @example formatCalendarZoned("2024-03-12T10:00:00+09:00[Asia/Tokyo]", "ja-JP", null as never) // "" (null options)
  */
 export function formatCalendarZoned(value, locale, options = {}) {
     try {

package/dist/zoned/format/formatRelativeZoned.d.ts

@@ -65,11 +65,11 @@ export interface FormatRelativeZonedOptions {
  * @param options optional settings for the wording, the display unit, rounding and the reference moment
  * @returns the formatted relative-time string, or "" on invalid input
  *
- * @example formatRelativeZoned("2023-12-29T00:00:00+00:00[UTC]", "en-US", { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "2 months ago"
- * @example formatRelativeZoned("2026-03-08T01:00:00-05:00[America/New_York]", "en-US", { reference: "2026-03-07T01:00:00-05:00[America/New_York]" }) // "tomorrow"
+ * @example formatRelativeZoned("2023-12-29T00:00:00+00:00[UTC]", "en-GB", { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "2 months ago"
+ * @example formatRelativeZoned("2026-03-08T01:00:00+05:30[Asia/Kolkata]", "en-IN", { reference: "2026-03-07T01:00:00+05:30[Asia/Kolkata]" }) // "tomorrow"
  * @example formatRelativeZoned("2026-01-15T00:00:00+00:00[UTC]", "en-US", { reference: "2026-01-15T10:30:00+00:00[UTC]", roundingMethod: "floor" }) // "11 hours ago" (−10.5 hours floors to −11; the default rounds to 10)
  * @example formatRelativeZoned("not-a-date") // ""
  * @example formatRelativeZoned("2024-02-28T23:30:00+00:00[UTC]", ["fr-FR", "en-US"], { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "il y a 30 minutes"
- * @example formatRelativeZoned("2024-03-12T10:00:00-04:00[America/New_York]", "en-US", null as never) // "" (null options)
+ * @example formatRelativeZoned("2024-03-12T10:00:00+02:00[Africa/Johannesburg]", "de-DE", null as never) // "" (null options)
  */
 export declare function formatRelativeZoned(value: string, locale?: string | string[], options?: FormatRelativeZonedOptions): string;

package/dist/zoned/format/formatRelativeZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { durationTotal, zonedDateTimeFrom } from "../../internal/index.js";
 import { formatRelativeDuration } from "../../internal/formatRelativeDuration.js";
 import { isValidUtc } from "../../utc/validate/index.js";
@@ -24,12 +24,12 @@ import { isObject } from "../../internal/isObject.js";
  * @param options optional settings for the wording, the display unit, rounding and the reference moment
  * @returns the formatted relative-time string, or "" on invalid input
  *
- * @example formatRelativeZoned("2023-12-29T00:00:00+00:00[UTC]", "en-US", { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "2 months ago"
- * @example formatRelativeZoned("2026-03-08T01:00:00-05:00[America/New_York]", "en-US", { reference: "2026-03-07T01:00:00-05:00[America/New_York]" }) // "tomorrow"
+ * @example formatRelativeZoned("2023-12-29T00:00:00+00:00[UTC]", "en-GB", { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "2 months ago"
+ * @example formatRelativeZoned("2026-03-08T01:00:00+05:30[Asia/Kolkata]", "en-IN", { reference: "2026-03-07T01:00:00+05:30[Asia/Kolkata]" }) // "tomorrow"
  * @example formatRelativeZoned("2026-01-15T00:00:00+00:00[UTC]", "en-US", { reference: "2026-01-15T10:30:00+00:00[UTC]", roundingMethod: "floor" }) // "11 hours ago" (−10.5 hours floors to −11; the default rounds to 10)
  * @example formatRelativeZoned("not-a-date") // ""
  * @example formatRelativeZoned("2024-02-28T23:30:00+00:00[UTC]", ["fr-FR", "en-US"], { reference: "2024-02-29T00:00:00+00:00[UTC]" }) // "il y a 30 minutes"
- * @example formatRelativeZoned("2024-03-12T10:00:00-04:00[America/New_York]", "en-US", null as never) // "" (null options)
+ * @example formatRelativeZoned("2024-03-12T10:00:00+02:00[Africa/Johannesburg]", "de-DE", null as never) // "" (null options)
  */
 export function formatRelativeZoned(value, locale, options = {}) {
     try {

package/dist/zoned/format/formatRfc2822.d.ts

@@ -21,12 +21,12 @@
  *   grammar (`"-0044.5"`, `"00-1"`). For the value itself use
  *   `Temporal.ZonedDateTime#toString()`.
  *
- * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-04:00[America/New_York]")
+ * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00+05:30[Asia/Kolkata]")
  * @returns RFC 5322 date-time string, or "" on invalid input, a sub-minute offset or a negative year
  *
- * @example formatRfc2822("2024-03-15T14:30:00-04:00[America/New_York]") // "Fri, 15 Mar 2024 14:30:00 -0400"
+ * @example formatRfc2822("2024-03-15T14:30:00+05:30[Asia/Kolkata]") // "Fri, 15 Mar 2024 14:30:00 +0530"
  * @example formatRfc2822("2024-01-05T09:00:00+00:00[UTC]") // "Fri, 05 Jan 2024 09:00:00 +0000"
- * @example formatRfc2822("2024-03-15T14:30:00.999-04:00[America/New_York]") // "Fri, 15 Mar 2024 14:30:00 -0400"
+ * @example formatRfc2822("2024-03-15T14:30:00.999+05:30[Asia/Kolkata]") // "Fri, 15 Mar 2024 14:30:00 +0530"
  * @example formatRfc2822("1969-12-31T23:15:30-00:45[Africa/Monrovia]") // "" (offset −00:44:30)
  * @example formatRfc2822("-000001-06-15T12:00:00+00:00[UTC]") // ""
  * @example Temporal.ZonedDateTime.from("-000001-06-15T12:00:00+00:00[UTC]").toString() // "-000001-06-15T12:00:00+00:00[UTC]"

package/dist/zoned/format/formatRfc2822.js

@@ -25,12 +25,12 @@ const NANOSECONDS_PER_MINUTE = 60_000_000_000;
  *   grammar (`"-0044.5"`, `"00-1"`). For the value itself use
  *   `Temporal.ZonedDateTime#toString()`.
  *
- * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-04:00[America/New_York]")
+ * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00+05:30[Asia/Kolkata]")
  * @returns RFC 5322 date-time string, or "" on invalid input, a sub-minute offset or a negative year
  *
- * @example formatRfc2822("2024-03-15T14:30:00-04:00[America/New_York]") // "Fri, 15 Mar 2024 14:30:00 -0400"
+ * @example formatRfc2822("2024-03-15T14:30:00+05:30[Asia/Kolkata]") // "Fri, 15 Mar 2024 14:30:00 +0530"
  * @example formatRfc2822("2024-01-05T09:00:00+00:00[UTC]") // "Fri, 05 Jan 2024 09:00:00 +0000"
- * @example formatRfc2822("2024-03-15T14:30:00.999-04:00[America/New_York]") // "Fri, 15 Mar 2024 14:30:00 -0400"
+ * @example formatRfc2822("2024-03-15T14:30:00.999+05:30[Asia/Kolkata]") // "Fri, 15 Mar 2024 14:30:00 +0530"
  * @example formatRfc2822("1969-12-31T23:15:30-00:45[Africa/Monrovia]") // "" (offset −00:44:30)
  * @example formatRfc2822("-000001-06-15T12:00:00+00:00[UTC]") // ""
  * @example Temporal.ZonedDateTime.from("-000001-06-15T12:00:00+00:00[UTC]").toString() // "-000001-06-15T12:00:00+00:00[UTC]"

package/dist/zoned/format/formatRfc3339.d.ts

@@ -23,10 +23,10 @@
  *   different instant, and years outside 0000–9999 were written in expanded form. For either
  *   string use `Temporal.ZonedDateTime#toString({ timeZoneName: "never" })`.
  *
- * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-04:00[America/New_York]")
+ * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-03:00[America/Sao_Paulo]")
  * @returns RFC 3339 datetime string, or "" on invalid input or a year outside 0000–9999
  *
- * @example formatRfc3339("2024-03-15T14:30:00-04:00[America/New_York]") // "2024-03-15T14:30:00-04:00"
+ * @example formatRfc3339("2024-03-15T14:30:00-03:00[America/Sao_Paulo]") // "2024-03-15T14:30:00-03:00"
  * @example formatRfc3339("2024-03-15T14:30:00Z[UTC]") // "2024-03-15T14:30:00+00:00"
  * @example formatRfc3339("1969-12-31T23:15:30-00:45[Africa/Monrovia]") // "1970-01-01T00:00:00+00:00" (offset −00:44:30)
  * @example formatRfc3339("+010000-01-01T00:00:00+00:00[UTC]") // ""

package/dist/zoned/format/formatRfc3339.js

@@ -26,10 +26,10 @@ const NANOSECONDS_PER_MINUTE = 60_000_000_000;
  *   different instant, and years outside 0000–9999 were written in expanded form. For either
  *   string use `Temporal.ZonedDateTime#toString({ timeZoneName: "never" })`.
  *
- * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-04:00[America/New_York]")
+ * @param value zoned ISO 8601 datetime string (e.g. "2024-03-15T14:30:00-03:00[America/Sao_Paulo]")
  * @returns RFC 3339 datetime string, or "" on invalid input or a year outside 0000–9999
  *
- * @example formatRfc3339("2024-03-15T14:30:00-04:00[America/New_York]") // "2024-03-15T14:30:00-04:00"
+ * @example formatRfc3339("2024-03-15T14:30:00-03:00[America/Sao_Paulo]") // "2024-03-15T14:30:00-03:00"
  * @example formatRfc3339("2024-03-15T14:30:00Z[UTC]") // "2024-03-15T14:30:00+00:00"
  * @example formatRfc3339("1969-12-31T23:15:30-00:45[Africa/Monrovia]") // "1970-01-01T00:00:00+00:00" (offset −00:44:30)
  * @example formatRfc3339("+010000-01-01T00:00:00+00:00[UTC]") // ""

package/dist/zoned/format/formatTimeZoneName.d.ts

@@ -4,14 +4,14 @@
  *
  * @remarks Members:
  *
- * | Member | Example (America/New_York) | Description |
+ * | Member | Example (Australia/Sydney, en-AU) | Description |
  * | --- | --- | --- |
- * | `short` | `EST`/`EDT` | Abbreviated zone name; seasonal for DST zones. |
- * | `long` | `Eastern Standard Time` | Full zone name; seasonal for DST zones. |
- * | `shortOffset` | `GMT-5` | Short UTC offset; seasonal. |
- * | `longOffset` | `GMT-05:00` | Zero-padded UTC offset; seasonal. |
- * | `shortGeneric` | `ET` | Season-independent generic abbreviation. |
- * | `longGeneric` | `Eastern Time` | Season-independent generic full name. |
+ * | `short` | `AEST`/`AEDT` | Abbreviated zone name; seasonal for DST zones. |
+ * | `long` | `Australian Eastern Standard Time` | Full zone name; seasonal for DST zones. |
+ * | `shortOffset` | `GMT+10` | Short UTC offset; seasonal. |
+ * | `longOffset` | `GMT+10:00` | Zero-padded UTC offset; seasonal. |
+ * | `shortGeneric` | `AET` | Season-independent generic abbreviation. |
+ * | `longGeneric` | `Australian Eastern Time` | Season-independent generic full name. |
  *
  * @example
  * import { TimeZoneNameStyle } from "@northguild/gmt/zoned";
@@ -34,16 +34,16 @@ export interface FormatTimeZoneNameOptions {
  * Return the localized display name for an IANA timeZone.
  *
  * - `options.style` covers every `Intl.DateTimeFormatOptions` `timeZoneName`
- *   value: "short" (EST), "long" (Eastern Standard Time), "shortOffset"
- *   (GMT-5), "longOffset" (GMT-05:00), "shortGeneric" (ET), "longGeneric"
- *   (Eastern Time).
+ *   value: "short" (AEST), "long" (Australian Eastern Standard Time),
+ *   "shortOffset" (GMT+10), "longOffset" (GMT+10:00), "shortGeneric" (AET),
+ *   "longGeneric" (Australian Eastern Time).
  * - "short"/"long"/"shortOffset"/"longOffset" name the zone's *current*
  *   offset — for a DST-observing zone the label flips between standard and
  *   daylight names depending on when this is called, since there's no
  *   instant parameter to pin it to (this matches how
  *   `Intl.DateTimeFormat.prototype.format()` itself defaults to "now" when
  *   called with no argument). "shortGeneric"/"longGeneric" are
- *   season-independent (e.g. "ET", "Eastern Time") and don't have this
+ *   season-independent (e.g. "AET", "Australian Eastern Time") and don't have this
  *   issue — prefer them for a name that won't change twice a year.
  * - Output depends on runtime ICU data.
  * - Returns "" for an invalid timeZone or locale.
@@ -53,16 +53,16 @@ export interface FormatTimeZoneNameOptions {
  *   Node, throw a RangeError exception"). Pass the IANA name.
  *
  * @param timeZone IANA name or a UTC offset to the minute (what `isValidTimeZone` accepts)
- * @param locale BCP 47 locale tag (e.g. "en-US"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns ""
+ * @param locale BCP 47 locale tag (e.g. "en-AU", "ja-JP"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns ""
  * @param options optional setting for the form of the name
  * @returns localized zone name, or "" on invalid input
  *
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "shortGeneric" }) // "ET"
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "longGeneric" }) // "Eastern Time"
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "shortOffset" }) // "GMT-4" or "GMT-5", depending on the current date
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "shortGeneric" }) // "AET"
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "longGeneric" }) // "Australian Eastern Time"
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "shortOffset" }) // "GMT+10" or "GMT+11", depending on the current date
  * @example formatTimeZoneName("Asia/Tokyo", "ja-JP", { style: "longGeneric" }) // "日本標準時"
- * @example formatTimeZoneName("Invalid/Zone", "en-US") // ""
- * @example formatTimeZoneName("America/New_York", "!!!") // ""
+ * @example formatTimeZoneName("Invalid/Zone", "en-GB") // ""
+ * @example formatTimeZoneName("Australia/Sydney", "!!!") // ""
  * @example formatTimeZoneName("Europe/Berlin", ["fr-FR", "en-US"], { style: "longGeneric" }) // "heure d’Europe centrale"
  */
 export declare function formatTimeZoneName(timeZone: string, locale: string | string[], options?: FormatTimeZoneNameOptions): string;

package/dist/zoned/format/formatTimeZoneName.js

@@ -1,4 +1,5 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { cachedFormatter } from "../../internal/formatterCache.js";
+import { Temporal } from "../../internal/temporal.js";
 import { resolveRequiredLocale } from "../../internal/resolveLocale.js";
 import { isValidTimeZone } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
@@ -7,16 +8,16 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * Return the localized display name for an IANA timeZone.
  *
  * - `options.style` covers every `Intl.DateTimeFormatOptions` `timeZoneName`
- *   value: "short" (EST), "long" (Eastern Standard Time), "shortOffset"
- *   (GMT-5), "longOffset" (GMT-05:00), "shortGeneric" (ET), "longGeneric"
- *   (Eastern Time).
+ *   value: "short" (AEST), "long" (Australian Eastern Standard Time),
+ *   "shortOffset" (GMT+10), "longOffset" (GMT+10:00), "shortGeneric" (AET),
+ *   "longGeneric" (Australian Eastern Time).
  * - "short"/"long"/"shortOffset"/"longOffset" name the zone's *current*
  *   offset — for a DST-observing zone the label flips between standard and
  *   daylight names depending on when this is called, since there's no
  *   instant parameter to pin it to (this matches how
  *   `Intl.DateTimeFormat.prototype.format()` itself defaults to "now" when
  *   called with no argument). "shortGeneric"/"longGeneric" are
- *   season-independent (e.g. "ET", "Eastern Time") and don't have this
+ *   season-independent (e.g. "AET", "Australian Eastern Time") and don't have this
  *   issue — prefer them for a name that won't change twice a year.
  * - Output depends on runtime ICU data.
  * - Returns "" for an invalid timeZone or locale.
@@ -26,16 +27,16 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  *   Node, throw a RangeError exception"). Pass the IANA name.
  *
  * @param timeZone IANA name or a UTC offset to the minute (what `isValidTimeZone` accepts)
- * @param locale BCP 47 locale tag (e.g. "en-US"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns ""
+ * @param locale BCP 47 locale tag (e.g. "en-AU", "ja-JP"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns ""
  * @param options optional setting for the form of the name
  * @returns localized zone name, or "" on invalid input
  *
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "shortGeneric" }) // "ET"
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "longGeneric" }) // "Eastern Time"
- * @example formatTimeZoneName("America/New_York", "en-US", { style: "shortOffset" }) // "GMT-4" or "GMT-5", depending on the current date
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "shortGeneric" }) // "AET"
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "longGeneric" }) // "Australian Eastern Time"
+ * @example formatTimeZoneName("Australia/Sydney", "en-AU", { style: "shortOffset" }) // "GMT+10" or "GMT+11", depending on the current date
  * @example formatTimeZoneName("Asia/Tokyo", "ja-JP", { style: "longGeneric" }) // "日本標準時"
- * @example formatTimeZoneName("Invalid/Zone", "en-US") // ""
- * @example formatTimeZoneName("America/New_York", "!!!") // ""
+ * @example formatTimeZoneName("Invalid/Zone", "en-GB") // ""
+ * @example formatTimeZoneName("Australia/Sydney", "!!!") // ""
  * @example formatTimeZoneName("Europe/Berlin", ["fr-FR", "en-US"], { style: "longGeneric" }) // "heure d’Europe centrale"
  */
 export function formatTimeZoneName(timeZone, locale, options) {
@@ -51,7 +52,7 @@ export function formatTimeZoneName(timeZone, locale, options) {
             return "";
         try {
             const style = optionOrDefault(options?.style, "long");
-            const formatter = new Intl.DateTimeFormat(resolvedLocale, {
+            const formatter = cachedFormatter("DateTimeFormat", resolvedLocale, {
                 timeZone,
                 timeZoneName: style,
                 hour: "numeric",

package/dist/zoned/format/formatZonedDateTime.d.ts

@@ -19,20 +19,20 @@ import type { DateTimeFormatOptions } from "../../types/index.js";
  *   options value formats with the defaults, as `Intl.DateTimeFormat` does).
  *
  * @param value zoned ISO 8601 datetime string
- * @param locale optional locale tag (e.g. "en-US"), or a preference list of tags (ECMA-402)
+ * @param locale optional locale tag (e.g. "en-GB", "ja-JP"), or a preference list of tags (ECMA-402)
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized string or "" when invalid
  *
- * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "en-US", { dateStyle: "long", timeStyle: "long" }) // "February 29, 2024 at 12:34:56 PM UTC"
+ * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "de-DE", { dateStyle: "long", timeStyle: "long" }) // "29. Februar 2024 um 12:34:56 UTC"
  * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "en-GB", { dateStyle: "short", timeStyle: "short" }) // "29/02/2024, 12:34"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { era: "long" }) // "2/3/2024 Anno Domini, 2:30:45 PM EST"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { era: "long", year: "numeric", month: "numeric", day: "numeric" }) // "2/3/2024 Anno Domini" — the pre-1.16.0 text
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { timeZone: "Asia/Tokyo" }) // "" — a ZonedDateTime keeps its own zone
- * @example formatUtc("2024-02-03T19:30:45Z", "en-US", { timeZone: "Asia/Tokyo", includeTimeZoneName: true }) // "2/4/2024, 4:30:45 AM GMT+9" — the same instant in another zone
- * @example formatZonedDateTime("invalid", "en-US") // "" (invalid input)
+ * @example formatZonedDateTime("2024-02-03T14:30:45+09:00[Asia/Tokyo]", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
+ * @example formatZonedDateTime("2024-02-03T14:30:45+09:00[Asia/Tokyo]", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { era: "long" }) // "03/02/2024 Anno Domini, 14:30:45 GMT"
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { era: "long", year: "numeric", month: "numeric", day: "numeric" }) // "03/02/2024 Anno Domini" — the pre-1.16.0 text
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { timeZone: "Asia/Tokyo" }) // "" — a ZonedDateTime keeps its own zone
+ * @example formatUtc("2024-02-03T14:30:45Z", "en-GB", { timeZone: "Asia/Tokyo", includeTimeZoneName: true }) // "03/02/2024, 23:30:45 GMT+9" — the same instant in another zone
+ * @example formatZonedDateTime("invalid", "pt-BR") // "" (invalid input)
  * @example formatZonedDateTime("2024-02-03T14:30:45+01:00[Europe/Paris]", ["fr-FR", "en-US"], { dateStyle: "short", timeStyle: "short" }) // "03/02/2024 14:30"
- * @example formatZonedDateTime("2024-02-03T14:30:00-05:00[America/New_York]", "en-US", null as never) // "" (null options, as ECMA-402 rejects them)
+ * @example formatZonedDateTime("2024-02-03T14:30:00+05:30[Asia/Kolkata]", "hi-IN", null as never) // "" (null options, as ECMA-402 rejects them)
  */
 export declare function formatZonedDateTime(value: string, locale?: string | string[], options?: DateTimeFormatOptions): string;

package/dist/zoned/format/formatZonedDateTime.js

@@ -1,3 +1,4 @@
+import { cachedFormatter } from "../../internal/formatterCache.js";
 import { normalizeDateTime, zonedDateTimeFrom } from "../../internal/index.js";
 import { instantFormatOptions } from "../../internal/instantFormatOptions.js";
 import { isValidZonedDateTime } from "../validate/index.js";
@@ -22,21 +23,21 @@ import { readDateTimeFormatOptions } from "../../internal/readDateTimeFormatOpti
  *   options value formats with the defaults, as `Intl.DateTimeFormat` does).
  *
  * @param value zoned ISO 8601 datetime string
- * @param locale optional locale tag (e.g. "en-US"), or a preference list of tags (ECMA-402)
+ * @param locale optional locale tag (e.g. "en-GB", "ja-JP"), or a preference list of tags (ECMA-402)
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized string or "" when invalid
  *
- * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "en-US", { dateStyle: "long", timeStyle: "long" }) // "February 29, 2024 at 12:34:56 PM UTC"
+ * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "de-DE", { dateStyle: "long", timeStyle: "long" }) // "29. Februar 2024 um 12:34:56 UTC"
  * @example formatZonedDateTime("2024-02-29T12:34:56.789+00:00[UTC]", "en-GB", { dateStyle: "short", timeStyle: "short" }) // "29/02/2024, 12:34"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { era: "long" }) // "2/3/2024 Anno Domini, 2:30:45 PM EST"
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { era: "long", year: "numeric", month: "numeric", day: "numeric" }) // "2/3/2024 Anno Domini" — the pre-1.16.0 text
- * @example formatZonedDateTime("2024-02-03T14:30:45-05:00[America/New_York]", "en-US", { timeZone: "Asia/Tokyo" }) // "" — a ZonedDateTime keeps its own zone
- * @example formatUtc("2024-02-03T19:30:45Z", "en-US", { timeZone: "Asia/Tokyo", includeTimeZoneName: true }) // "2/4/2024, 4:30:45 AM GMT+9" — the same instant in another zone
- * @example formatZonedDateTime("invalid", "en-US") // "" (invalid input)
+ * @example formatZonedDateTime("2024-02-03T14:30:45+09:00[Asia/Tokyo]", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
+ * @example formatZonedDateTime("2024-02-03T14:30:45+09:00[Asia/Tokyo]", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { era: "long" }) // "03/02/2024 Anno Domini, 14:30:45 GMT"
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { era: "long", year: "numeric", month: "numeric", day: "numeric" }) // "03/02/2024 Anno Domini" — the pre-1.16.0 text
+ * @example formatZonedDateTime("2024-02-03T14:30:45+00:00[Europe/London]", "en-GB", { timeZone: "Asia/Tokyo" }) // "" — a ZonedDateTime keeps its own zone
+ * @example formatUtc("2024-02-03T14:30:45Z", "en-GB", { timeZone: "Asia/Tokyo", includeTimeZoneName: true }) // "03/02/2024, 23:30:45 GMT+9" — the same instant in another zone
+ * @example formatZonedDateTime("invalid", "pt-BR") // "" (invalid input)
  * @example formatZonedDateTime("2024-02-03T14:30:45+01:00[Europe/Paris]", ["fr-FR", "en-US"], { dateStyle: "short", timeStyle: "short" }) // "03/02/2024 14:30"
- * @example formatZonedDateTime("2024-02-03T14:30:00-05:00[America/New_York]", "en-US", null as never) // "" (null options, as ECMA-402 rejects them)
+ * @example formatZonedDateTime("2024-02-03T14:30:00+05:30[Asia/Kolkata]", "hi-IN", null as never) // "" (null options, as ECMA-402 rejects them)
  */
 export function formatZonedDateTime(value, locale, options) {
     // ECMA-402 CoerceOptionsToObject: null options throw TypeError, so they are invalid input.
@@ -56,7 +57,7 @@ export function formatZonedDateTime(value, locale, options) {
         if (resolved === null) {
             return "";
         }
-        return normalizeDateTime(new Intl.DateTimeFormat(locale, resolved).format(zonedDateTime.epochMilliseconds));
+        return normalizeDateTime(cachedFormatter("DateTimeFormat", locale, resolved).format(zonedDateTime.epochMilliseconds));
     }
     catch {
         return "";

package/dist/zoned/format/formatZonedRange.d.ts

@@ -24,14 +24,14 @@ import type { DateTimeFormatOptions } from "../../types/index.js";
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized range string or "" when invalid
  *
- * @example formatZonedRange("2024-02-29T12:00:00.000+00:00[UTC]", "2024-02-29T14:00:00.000+00:00[UTC]", "en-US", { dateStyle: "long", timeStyle: "short" }) // "February 29, 2024, 12:00 - 2:00 PM"
+ * @example formatZonedRange("2024-02-29T12:00:00.000+00:00[UTC]", "2024-02-29T14:00:00.000+00:00[UTC]", "de-DE", { dateStyle: "long", timeStyle: "short" }) // "29. Februar 2024, 12:00-14:00 Uhr"
  * @example formatZonedRange("2024-02-29T12:00:00.000+00:00[UTC]", "2024-02-29T14:00:00.000+00:00[UTC]", "en-GB", { dateStyle: "short", timeStyle: "short" }) // "29/02/2024, 12:00-14:00"
- * @example formatZonedRange("2024-02-03T14:30:45-05:00[America/New_York]", "2024-02-03T15:30:45-05:00[America/New_York]", "zh-CN", { year: "numeric", month: "long" }) // "2024年2月"
- * @example formatZonedRange("2024-02-03T14:30:45-05:00[America/New_York]", "2024-02-03T15:30:45-05:00[America/New_York]", "en-US", { era: "long" }) // "2/3/2024 Anno Domini, 2:30:45 PM - 3:30:45 PM"
- * @example formatZonedRange("2024-02-29T10:00:00-05:00[America/New_York]", "2024-02-29T12:00:00-05:00[America/New_York]", "en-US", { hour: "numeric", timeZone: "UTC" }) // "" — a ZonedDateTime keeps its own zone
- * @example formatZonedRange("2024-02-29T10:00:00-05:00[America/New_York]", "2024-02-29T12:00:00-05:00[America/New_York]", "en-US", { hour: "numeric", minute: "numeric", timeZoneName: "short" }) // "10:00 AM - 12:00 PM EST" — the pre-1.16.0 text
- * @example formatZonedRange("invalid", "2024-02-29T14:00:00.000+00:00[UTC]", "en-US") // "" (invalid input)
+ * @example formatZonedRange("2024-02-03T14:30:45+08:00[Asia/Shanghai]", "2024-02-03T15:30:45+08:00[Asia/Shanghai]", "zh-CN", { year: "numeric", month: "long" }) // "2024年2月"
+ * @example formatZonedRange("2024-02-03T14:30:45+00:00[Europe/London]", "2024-02-03T15:30:45+00:00[Europe/London]", "en-GB", { era: "long" }) // "03/02/2024 Anno Domini, 14:30:45 - 15:30:45"
+ * @example formatZonedRange("2024-02-29T10:00:00+09:00[Asia/Tokyo]", "2024-02-29T12:00:00+09:00[Asia/Tokyo]", "ja-JP", { hour: "numeric", timeZone: "UTC" }) // "" — a ZonedDateTime keeps its own zone
+ * @example formatZonedRange("2024-02-29T10:00:00+00:00[Europe/London]", "2024-02-29T12:00:00+00:00[Europe/London]", "en-GB", { hour: "numeric", minute: "numeric", timeZoneName: "short" }) // "10:00-12:00 GMT" — the pre-1.16.0 text
+ * @example formatZonedRange("invalid", "2024-02-29T14:00:00.000+00:00[UTC]", "fr-FR") // "" (invalid input)
  * @example formatZonedRange("2024-02-03T14:30:45+01:00[Europe/Paris]", "2024-02-03T16:46:15+01:00[Europe/Paris]", ["fr-FR", "en-US"], { dateStyle: "short", timeStyle: "short" }) // "03/02/2024, 14:30 - 16:46"
- * @example formatZonedRange("2024-02-03T14:30:00-05:00[America/New_York]", "2024-02-05T17:00:00-05:00[America/New_York]", "en-US", null as never) // "" (null options, as ECMA-402 rejects them)
+ * @example formatZonedRange("2024-02-03T14:30:00-03:00[America/Sao_Paulo]", "2024-02-05T17:00:00-03:00[America/Sao_Paulo]", "pt-BR", null as never) // "" (null options, as ECMA-402 rejects them)
  */
 export declare function formatZonedRange(from: string, to: string, locale?: string | string[], options?: DateTimeFormatOptions): string;