@northguild/gmt 1.18.0 → 1.20.0

package/dist/zoned/calculate/setZoned.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import type { Disambiguation, Offset, Overflow } from "../../types/index.js";
 /**
  * Return a zoned ISO 8601 datetime string with the given `fields` set on `value`.
@@ -10,10 +10,23 @@ import type { Disambiguation, Offset, Overflow } from "../../types/index.js";
  *   equivalent to `.with()`'s, because Temporal's `ZonedDateTime.prototype.add()` doesn't accept
  *   `disambiguation`/`offset` at all.
  * - `fields` may set any of `year`, `month`, `monthCode`, `day`, `hour`, `minute`, `second`,
- *   `millisecond`, `microsecond`, `nanosecond`, `era`, and/or `eraYear`; omitted fields keep
- *   their current value. An empty object is a no-op. `calendar`, `timeZone`, and `offset` are
- *   deliberately excluded from `fields` — this function only sets date/time components, never
- *   the zone or calendar identity, and `offset` is controlled separately via `options.offset`.
+ *   `millisecond`, `microsecond` and/or `nanosecond`; omitted fields keep their current value. An
+ *   object with no field set, such as `{}` or `{ year: undefined }`, is a no-op.
+ * - Values are not converted: `monthCode` must be a string and every other field an integer number.
+ *   `null`, a numeric string, a boolean or a fraction returns "", where Temporal would convert or
+ *   truncate it. A bigint, `NaN` or an infinity returns "" too. A number too large for its
+ *   field follows `overflow`. A month or day below 1, or a date outside Temporal's range, returns
+ *   "".
+ * - An own key that is not one of these fields, such as a misspelt `yaer`, returns "". So does an
+ *   era, an `offset`, or a `calendar` or `timeZone` property, whether own, inherited or a getter. A
+ *   field is read with a property get, as Temporal reads it, so an inherited or getter field is
+ *   set.
+ * - A Temporal date or time object returns "", as Temporal's `with` refuses one. One whose
+ *   prototype has been replaced with `Object.prototype`, `null` or `Function.prototype` sets
+ *   nothing instead.
+ * - `calendar`, `timeZone`, and `offset` are deliberately excluded from `fields` — this function
+ *   only sets date/time components, never the zone or calendar identity, and `offset` is
+ *   controlled separately via `options.offset`.
  * - **Compatibility:** before 1.16.0 `offset` defaulted to `"ignore"`. Pass `{ offset: "ignore" }`
  *   to keep that resolution.
  * - Returns "" for invalid input.
@@ -23,15 +36,16 @@ import type { Disambiguation, Offset, Overflow } from "../../types/index.js";
  * @param options optional settings for resolving an out-of-range date and the new wall-clock time
  * @returns zoned ISO 8601 string with fields set, or "" on invalid input
  *
- * @example setZoned("2024-03-10T12:00:00-04:00[America/New_York]", { hour: 9 }) // "2024-03-10T09:00:00-04:00[America/New_York]"
- * @example setZoned("2024-01-31T12:00:00-05:00[America/New_York]", { month: 2 }) // "2024-02-29T12:00:00-05:00[America/New_York]" (constrain clamps to the last valid day)
- * @example setZoned("2024-01-31T12:00:00-05:00[America/New_York]", { month: 2 }, { overflow: "reject" }) // ""
- * @example setZoned("2024-03-10T12:00:00-04:00[America/New_York]", {}) // "2024-03-10T12:00:00-04:00[America/New_York]" (empty fields object is a no-op)
- * @example setZoned("2024-11-03T01:45:00-05:00[America/New_York]", { minute: 0 }, { disambiguation: "reject" }) // "2024-11-03T01:00:00-05:00[America/New_York]" (offset defaults to "prefer": the source's -05:00 is still valid, so it is kept and "reject" never fires)
- * @example setZoned("2024-11-03T01:45:00-05:00[America/New_York]", { minute: 0 }, { disambiguation: "reject", offset: "ignore" }) // "" (offset "ignore" re-resolves the repeated 01:00, and "reject" throws)
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { hour: 9 }) // "2024-03-10T09:00:00+09:00[Asia/Tokyo]"
+ * @example setZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", { month: 2 }) // "2024-02-29T12:00:00+05:30[Asia/Kolkata]" (constrain clamps to the last valid day)
+ * @example setZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", { month: 2 }, { overflow: "reject" }) // ""
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", {}) // "2024-03-10T12:00:00+09:00[Asia/Tokyo]" (empty fields object is a no-op)
+ * @example setZoned("2024-10-27T01:45:00+00:00[Europe/London]", { minute: 0 }, { disambiguation: "reject" }) // "2024-10-27T01:00:00+00:00[Europe/London]" (offset defaults to "prefer": the source's +00:00 is still valid, so it is kept and "reject" never fires)
+ * @example setZoned("2024-10-27T01:45:00+00:00[Europe/London]", { minute: 0 }, { disambiguation: "reject", offset: "ignore" }) // "" (offset "ignore" re-resolves the repeated 01:00, and "reject" throws)
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { hour: "9" }) // "" (not converted)
  * @example setZoned("invalid", { hour: 9 }) // ""
  */
-export declare function setZoned(value: string, fields: Omit<Temporal.ZonedDateTimeLike, "calendar" | "timeZone" | "offset">, options?: {
+export declare function setZoned(value: string, fields: Omit<Temporal.ZonedDateTimeLike, "calendar" | "timeZone" | "offset" | "era" | "eraYear">, options?: {
     /**
      * What happens when the result names a day its month does not have, such as setting `month: 2`
      * on 31 January. `"constrain"` clamps to the last valid day; `"reject"` returns `""`.

package/dist/zoned/calculate/setZoned.js

@@ -1,5 +1,5 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { resolveOverflow, withZonedFields, zonedDateTimeFrom, } from "../../internal/index.js";
+import { Temporal } from "../../internal/temporal.js";
+import { DATE_TIME_FIELDS, readSetFields, resolveOverflow, withZonedFields, zonedDateTimeFrom, } from "../../internal/index.js";
 import { isValidZonedDateTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
 import { optionOrDefault } from "../../internal/optionOrDefault.js";
@@ -13,10 +13,23 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  *   equivalent to `.with()`'s, because Temporal's `ZonedDateTime.prototype.add()` doesn't accept
  *   `disambiguation`/`offset` at all.
  * - `fields` may set any of `year`, `month`, `monthCode`, `day`, `hour`, `minute`, `second`,
- *   `millisecond`, `microsecond`, `nanosecond`, `era`, and/or `eraYear`; omitted fields keep
- *   their current value. An empty object is a no-op. `calendar`, `timeZone`, and `offset` are
- *   deliberately excluded from `fields` — this function only sets date/time components, never
- *   the zone or calendar identity, and `offset` is controlled separately via `options.offset`.
+ *   `millisecond`, `microsecond` and/or `nanosecond`; omitted fields keep their current value. An
+ *   object with no field set, such as `{}` or `{ year: undefined }`, is a no-op.
+ * - Values are not converted: `monthCode` must be a string and every other field an integer number.
+ *   `null`, a numeric string, a boolean or a fraction returns "", where Temporal would convert or
+ *   truncate it. A bigint, `NaN` or an infinity returns "" too. A number too large for its
+ *   field follows `overflow`. A month or day below 1, or a date outside Temporal's range, returns
+ *   "".
+ * - An own key that is not one of these fields, such as a misspelt `yaer`, returns "". So does an
+ *   era, an `offset`, or a `calendar` or `timeZone` property, whether own, inherited or a getter. A
+ *   field is read with a property get, as Temporal reads it, so an inherited or getter field is
+ *   set.
+ * - A Temporal date or time object returns "", as Temporal's `with` refuses one. One whose
+ *   prototype has been replaced with `Object.prototype`, `null` or `Function.prototype` sets
+ *   nothing instead.
+ * - `calendar`, `timeZone`, and `offset` are deliberately excluded from `fields` — this function
+ *   only sets date/time components, never the zone or calendar identity, and `offset` is
+ *   controlled separately via `options.offset`.
  * - **Compatibility:** before 1.16.0 `offset` defaulted to `"ignore"`. Pass `{ offset: "ignore" }`
  *   to keep that resolution.
  * - Returns "" for invalid input.
@@ -26,12 +39,13 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * @param options optional settings for resolving an out-of-range date and the new wall-clock time
  * @returns zoned ISO 8601 string with fields set, or "" on invalid input
  *
- * @example setZoned("2024-03-10T12:00:00-04:00[America/New_York]", { hour: 9 }) // "2024-03-10T09:00:00-04:00[America/New_York]"
- * @example setZoned("2024-01-31T12:00:00-05:00[America/New_York]", { month: 2 }) // "2024-02-29T12:00:00-05:00[America/New_York]" (constrain clamps to the last valid day)
- * @example setZoned("2024-01-31T12:00:00-05:00[America/New_York]", { month: 2 }, { overflow: "reject" }) // ""
- * @example setZoned("2024-03-10T12:00:00-04:00[America/New_York]", {}) // "2024-03-10T12:00:00-04:00[America/New_York]" (empty fields object is a no-op)
- * @example setZoned("2024-11-03T01:45:00-05:00[America/New_York]", { minute: 0 }, { disambiguation: "reject" }) // "2024-11-03T01:00:00-05:00[America/New_York]" (offset defaults to "prefer": the source's -05:00 is still valid, so it is kept and "reject" never fires)
- * @example setZoned("2024-11-03T01:45:00-05:00[America/New_York]", { minute: 0 }, { disambiguation: "reject", offset: "ignore" }) // "" (offset "ignore" re-resolves the repeated 01:00, and "reject" throws)
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { hour: 9 }) // "2024-03-10T09:00:00+09:00[Asia/Tokyo]"
+ * @example setZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", { month: 2 }) // "2024-02-29T12:00:00+05:30[Asia/Kolkata]" (constrain clamps to the last valid day)
+ * @example setZoned("2024-01-31T12:00:00+05:30[Asia/Kolkata]", { month: 2 }, { overflow: "reject" }) // ""
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", {}) // "2024-03-10T12:00:00+09:00[Asia/Tokyo]" (empty fields object is a no-op)
+ * @example setZoned("2024-10-27T01:45:00+00:00[Europe/London]", { minute: 0 }, { disambiguation: "reject" }) // "2024-10-27T01:00:00+00:00[Europe/London]" (offset defaults to "prefer": the source's +00:00 is still valid, so it is kept and "reject" never fires)
+ * @example setZoned("2024-10-27T01:45:00+00:00[Europe/London]", { minute: 0 }, { disambiguation: "reject", offset: "ignore" }) // "" (offset "ignore" re-resolves the repeated 01:00, and "reject" throws)
+ * @example setZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { hour: "9" }) // "" (not converted)
  * @example setZoned("invalid", { hour: 9 }) // ""
  */
 export function setZoned(value, fields, options) {
@@ -47,11 +61,14 @@ export function setZoned(value, fields, options) {
         const offset = optionOrDefault(options?.offset, "prefer");
         try {
             const zoned = zonedDateTimeFrom(value);
-            // Temporal.ZonedDateTime.prototype.with() throws on an empty fields object ("no supported
-            // properties found") rather than treating it as a no-op, so short-circuit here.
-            if (Object.keys(fields).length === 0)
+            const set = readSetFields(fields, DATE_TIME_FIELDS);
+            if (set === null)
+                return "";
+            // Only the values readSetFields checked reach Temporal, on both paths of withZonedFields. An
+            // empty result sets nothing: a no-op here, where Temporal's with() would throw.
+            if (Object.keys(set).length === 0)
                 return zoned.toString();
-            return withZonedFields(zoned, fields, {
+            return withZonedFields(zoned, set, {
                 overflow,
                 disambiguation,
                 offset,

package/dist/zoned/calculate/sortZoned.d.ts

@@ -9,9 +9,9 @@
  * @param order "asc" for ascending (earliest first) | "desc" for descending (latest first)
  * @returns Sorted array of zoned datetime strings
  *
- * @example sortZoned(["2024-03-10T12:00:00[America/New_York]", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"]) // ["2024-01-01T08:00:00-05:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]", "2024-03-10T12:00:00-04:00[America/New_York]"]
- * @example sortZoned(["2024-03-10T12:00:00[America/New_York]", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"], "desc") // ["2024-03-10T12:00:00-04:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]", "2024-01-01T08:00:00-05:00[America/New_York]"]
- * @example sortZoned(["invalid", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"]) // ["2024-01-01T08:00:00-05:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]"]
+ * @example sortZoned(["2024-03-10T12:00:00[Australia/Sydney]", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"]) // ["2024-01-01T08:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]", "2024-03-10T12:00:00+11:00[Australia/Sydney]"]
+ * @example sortZoned(["2024-03-10T12:00:00[Australia/Sydney]", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"], "desc") // ["2024-03-10T12:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]", "2024-01-01T08:00:00+11:00[Australia/Sydney]"]
+ * @example sortZoned(["invalid", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"]) // ["2024-01-01T08:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]"]
  * @example sortZoned([]) // []
  */
 export declare function sortZoned(zonedDateTimes: string[], order?: "asc" | "desc"): string[];

package/dist/zoned/calculate/sortZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidZonedDateTime } from "../validate/index.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 /**
@@ -12,9 +12,9 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param order "asc" for ascending (earliest first) | "desc" for descending (latest first)
  * @returns Sorted array of zoned datetime strings
  *
- * @example sortZoned(["2024-03-10T12:00:00[America/New_York]", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"]) // ["2024-01-01T08:00:00-05:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]", "2024-03-10T12:00:00-04:00[America/New_York]"]
- * @example sortZoned(["2024-03-10T12:00:00[America/New_York]", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"], "desc") // ["2024-03-10T12:00:00-04:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]", "2024-01-01T08:00:00-05:00[America/New_York]"]
- * @example sortZoned(["invalid", "2024-01-01T08:00:00[America/New_York]", "2024-02-15T15:30:00[America/New_York]"]) // ["2024-01-01T08:00:00-05:00[America/New_York]", "2024-02-15T15:30:00-05:00[America/New_York]"]
+ * @example sortZoned(["2024-03-10T12:00:00[Australia/Sydney]", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"]) // ["2024-01-01T08:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]", "2024-03-10T12:00:00+11:00[Australia/Sydney]"]
+ * @example sortZoned(["2024-03-10T12:00:00[Australia/Sydney]", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"], "desc") // ["2024-03-10T12:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]", "2024-01-01T08:00:00+11:00[Australia/Sydney]"]
+ * @example sortZoned(["invalid", "2024-01-01T08:00:00[Australia/Sydney]", "2024-02-15T15:30:00[Australia/Sydney]"]) // ["2024-01-01T08:00:00+11:00[Australia/Sydney]", "2024-02-15T15:30:00+11:00[Australia/Sydney]"]
  * @example sortZoned([]) // []
  */
 export function sortZoned(zonedDateTimes, order = "asc") {

package/dist/zoned/calculate/startOfZoned.d.ts

@@ -1,10 +1,10 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "../../internal/temporal.js";
 import type { DateTimeUnit, FractionalDigit } from "../../types/index.js";
 /**
  * Return the start of the specified date-time `unit` for a given zoned ISO 8601 datetime string.
  *
  * - Supports: "year", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond", each also in its plural form (`"days"`), as Temporal accepts.
- * - Returns the real start of the local `unit` containing `value` in its own zone — the same bucket `floorToZone` uses — so the result is never after `value`. A local hour `Pacific/Chatham`'s spring-forward leaves only 15 minutes long starts at 03:45, the second pass of New York's repeated fall-back hour starts at its own 01:00 (−05:00), and a day whose midnight was skipped starts at its first real instant.
+ * - Returns the real start of the local `unit` containing `value` in its own zone — the same bucket `floorToZone` uses — so the result is never after `value`. A local hour `Pacific/Chatham`'s spring-forward leaves only 15 minutes long starts at 03:45, the second pass of London's repeated fall-back hour starts at its own 01:00 (+00:00), and a day whose midnight was skipped starts at its first real instant.
  * - A transition that reopens the previous local date makes that stretch its own bucket. `America/Goose_Bay` fell back at 00:01 on 7 November 2010, re-entering 6 November for 59 minutes, so `2010-11-06T23:30:00-04:00` has a day that starts at 23:01 — consistent with `floorToZone`, `bucketRange` and `intervalCountZoned`.
  * - A midnight repeated on the same date stays one day: `America/Havana`'s 2024-11-03 starts at its first 00:00 (−04:00) and runs 25 hours, matching Temporal's `startOfDay()`.
  * - Takes no `disambiguation` or `offset`: a boundary is always a real instant, as TC39's `startOfDay()`
@@ -19,7 +19,7 @@ import type { DateTimeUnit, FractionalDigit } from "../../types/index.js";
  * @example startOfZoned("2024-02-29T12:34:56+00:00[UTC]", "month") // "2024-02-01T00:00:00+00:00[UTC]"
  * @example startOfZoned("2024-02-29T12:34:56.789+01:00[Europe/Berlin]", "milliseconds") // "2024-02-29T12:34:56.789+01:00[Europe/Berlin]"
  * @example startOfZoned("invalid", "month") // ""
- * @example startOfZoned("2024-11-03T01:45:00-05:00[America/New_York]", "hour") // "2024-11-03T01:00:00-05:00[America/New_York]" (the second, repeated 1am is its own hour)
+ * @example startOfZoned("2024-10-27T01:45:00+00:00[Europe/London]", "hour") // "2024-10-27T01:00:00+00:00[Europe/London]" (the second, repeated 1am is its own hour)
  * @example startOfZoned("2024-09-29T03:50:00+13:45[Pacific/Chatham]", "hour") // "2024-09-29T03:45:00+13:45[Pacific/Chatham]" (local 03:00 never happened; the hour began at the jump)
  * @example startOfZoned("2024-11-03T00:30:00-05:00[America/Havana]", "day") // "2024-11-03T00:00:00-04:00[America/Havana]" (midnight repeated on the same date: one 25-hour day)
  */

package/dist/zoned/calculate/startOfZoned.js

@@ -4,7 +4,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * Return the start of the specified date-time `unit` for a given zoned ISO 8601 datetime string.
  *
  * - Supports: "year", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond", each also in its plural form (`"days"`), as Temporal accepts.
- * - Returns the real start of the local `unit` containing `value` in its own zone — the same bucket `floorToZone` uses — so the result is never after `value`. A local hour `Pacific/Chatham`'s spring-forward leaves only 15 minutes long starts at 03:45, the second pass of New York's repeated fall-back hour starts at its own 01:00 (−05:00), and a day whose midnight was skipped starts at its first real instant.
+ * - Returns the real start of the local `unit` containing `value` in its own zone — the same bucket `floorToZone` uses — so the result is never after `value`. A local hour `Pacific/Chatham`'s spring-forward leaves only 15 minutes long starts at 03:45, the second pass of London's repeated fall-back hour starts at its own 01:00 (+00:00), and a day whose midnight was skipped starts at its first real instant.
  * - A transition that reopens the previous local date makes that stretch its own bucket. `America/Goose_Bay` fell back at 00:01 on 7 November 2010, re-entering 6 November for 59 minutes, so `2010-11-06T23:30:00-04:00` has a day that starts at 23:01 — consistent with `floorToZone`, `bucketRange` and `intervalCountZoned`.
  * - A midnight repeated on the same date stays one day: `America/Havana`'s 2024-11-03 starts at its first 00:00 (−04:00) and runs 25 hours, matching Temporal's `startOfDay()`.
  * - Takes no `disambiguation` or `offset`: a boundary is always a real instant, as TC39's `startOfDay()`
@@ -19,7 +19,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * @example startOfZoned("2024-02-29T12:34:56+00:00[UTC]", "month") // "2024-02-01T00:00:00+00:00[UTC]"
  * @example startOfZoned("2024-02-29T12:34:56.789+01:00[Europe/Berlin]", "milliseconds") // "2024-02-29T12:34:56.789+01:00[Europe/Berlin]"
  * @example startOfZoned("invalid", "month") // ""
- * @example startOfZoned("2024-11-03T01:45:00-05:00[America/New_York]", "hour") // "2024-11-03T01:00:00-05:00[America/New_York]" (the second, repeated 1am is its own hour)
+ * @example startOfZoned("2024-10-27T01:45:00+00:00[Europe/London]", "hour") // "2024-10-27T01:00:00+00:00[Europe/London]" (the second, repeated 1am is its own hour)
  * @example startOfZoned("2024-09-29T03:50:00+13:45[Pacific/Chatham]", "hour") // "2024-09-29T03:45:00+13:45[Pacific/Chatham]" (local 03:00 never happened; the hour began at the jump)
  * @example startOfZoned("2024-11-03T00:30:00-05:00[America/Havana]", "day") // "2024-11-03T00:00:00-04:00[America/Havana]" (midnight repeated on the same date: one 25-hour day)
  */

package/dist/zoned/calculate/subtractZoned.d.ts

@@ -5,7 +5,7 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  * - Uses Temporal.ZonedDateTime.subtract to subtract duration.
  * - Validates duration units and values.
  * - Accepts an RFC 9557 calendar-annotated zoned string (as `convertZonedToCalendar` writes it,
- *   e.g. `"2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]"`), not just a bare ISO string
+ *   e.g. `"2024-03-25T14:30:00+00:00[Europe/London][u-ca=hebrew]"`), not just a bare ISO string
  *   (E7, issue #152). Calendar-unit arithmetic ("subtract 1 month") resolves against that calendar
  *   **and** the DST rules of the zone, in one operation; the result carries the same calendar
  *   annotation. A bare ISO string is the `"iso8601"` calendar and returns a bare ISO string.
@@ -20,9 +20,9 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  *   forward, whatever `disambiguation` said, so "earlier" matched "compatible" and "reject" did not
  *   fail. Pass "compatible" (or omit it) to keep the forward result.
  * - Compatibility: before 1.16.0 a non-"compatible" `disambiguation` re-resolved the final wall
- *   clock (so `- { minutes: 10 }` from `2024-11-03T01:30:00-05:00[America/New_York]` with
- *   "earlier" returned `01:20:00-04:00`, 70 minutes before the input in exact time, instead of
- *   `01:20:00-05:00`). To get that value, re-resolve the result's wall clock:
+ *   clock (so `- { minutes: 10 }` from `2024-10-27T01:30:00+00:00[Europe/London]` with
+ *   "earlier" returned `01:20:00+01:00`, 70 minutes before the input in exact time, instead of
+ *   `01:20:00+00:00`). To get that value, re-resolve the result's wall clock:
  *   `setZoned(result, { hour, minute, second }, { disambiguation, offset: "ignore" })`.
  * - There is no `offset` option (removed in 1.16.0): the intermediate wall clock is resolved from
  *   a plain date-time, which has no UTC offset for it to act on (Temporal
@@ -34,18 +34,18 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  * @param optionsArg optional settings for resolving a DST gap or overlap and an out-of-range date
  * @returns zoned ISO 8601 string on success, or "" on invalid input
  *
- * @example subtractZoned("2024-03-10T12:00:00-04:00[America/New_York]", { days: 5 }) // "2024-03-05T12:00:00-05:00[America/New_York]"
+ * @example subtractZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { days: 5 }) // "2024-03-05T12:00:00+09:00[Asia/Tokyo]"
  * @example subtractZoned("invalid", { days: 5 }) // ""
- * @example subtractZoned("2024-11-04T01:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "later" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example subtractZoned("2024-11-04T01:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
- * @example subtractZoned("2024-03-11T02:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "earlier" }) // "2024-03-10T01:30:00-05:00[America/New_York]" (02:30 on 10 March is in the spring-forward gap; "earlier" moves it back an hour, "compatible" forward to 03:30-04:00)
- * @example subtractZoned("2024-03-11T02:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
- * @example subtractZoned("2024-11-03T01:50:00-05:00[America/New_York]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-11-03T01:40:00-05:00[America/New_York]" (exact time — disambiguation never re-resolves it)
- * @example setZoned(subtractZoned("2024-11-03T01:50:00-05:00[America/New_York]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-11-03T01:40:00-04:00[America/New_York]" (pre-1.16.0 result)
- * @example subtractZoned("2024-03-31T12:00:00-04:00[America/New_York]", { months: 1 }, { overflow: "reject" }) // ""
- * @example subtractZoned("2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]", { months: 1 }) // "2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]" (Adar II -> Adar I, EDT -> EST in one call)
+ * @example subtractZoned("2024-10-28T01:30:00+00:00[Europe/London]", { days: 1 }, { disambiguation: "later" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example subtractZoned("2024-10-28T01:30:00+00:00[Europe/London]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
+ * @example subtractZoned("2024-10-07T02:30:00+11:00[Australia/Sydney]", { days: 1 }, { disambiguation: "earlier" }) // "2024-10-06T01:30:00+10:00[Australia/Sydney]" (02:30 on 6 October is in the spring-forward gap; "earlier" moves it back an hour, "compatible" forward to 03:30+11:00)
+ * @example subtractZoned("2024-10-07T02:30:00+11:00[Australia/Sydney]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
+ * @example subtractZoned("2024-10-27T01:50:00+00:00[Europe/London]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-10-27T01:40:00+00:00[Europe/London]" (exact time — disambiguation never re-resolves it)
+ * @example setZoned(subtractZoned("2024-10-27T01:50:00+00:00[Europe/London]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-10-27T01:40:00+01:00[Europe/London]" (pre-1.16.0 result)
+ * @example subtractZoned("2024-03-31T12:00:00+09:00[Asia/Tokyo]", { months: 1 }, { overflow: "reject" }) // ""
+ * @example subtractZoned("2024-04-04T14:30:00+01:00[Europe/London][u-ca=hebrew]", { months: 1 }) // "2024-03-05T14:30:00+00:00[Europe/London][u-ca=hebrew]" (Adar II -> Adar I, BST -> GMT in one call)
  * @example subtractZoned("2019-05-01T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]", { days: 1 }) // "2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]" (Reiwa 1 -> Heisei 31)
- * @example subtractZoned("2024-03-10T14:30:00-04:00[u-ca=hebrew][America/New_York]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
+ * @example subtractZoned("2024-03-10T14:30:00-03:00[u-ca=hebrew][America/Sao_Paulo]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
  */
 export declare function subtractZoned(value: string, units: Partial<Record<DateTimeDurationUnit, number>>, optionsArg?: {
     /**

package/dist/zoned/calculate/subtractZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { addToZonedDisambiguated, calendarSystemOfZonedValue, formatZonedInCalendar, isValidAmount, parseCalendarZonedValue, resolveOverflow, } from "../../internal/index.js";
+import { addToZonedDisambiguated, calendarSystemOfZonedValue, formatZonedInCalendar, parseCalendarZonedValue, readDurationUnits, resolveOverflow, } from "../../internal/index.js";
 import { isValidDateTimeDurationUnit } from "../../plain/validate/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
@@ -10,7 +10,7 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * - Uses Temporal.ZonedDateTime.subtract to subtract duration.
  * - Validates duration units and values.
  * - Accepts an RFC 9557 calendar-annotated zoned string (as `convertZonedToCalendar` writes it,
- *   e.g. `"2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]"`), not just a bare ISO string
+ *   e.g. `"2024-03-25T14:30:00+00:00[Europe/London][u-ca=hebrew]"`), not just a bare ISO string
  *   (E7, issue #152). Calendar-unit arithmetic ("subtract 1 month") resolves against that calendar
  *   **and** the DST rules of the zone, in one operation; the result carries the same calendar
  *   annotation. A bare ISO string is the `"iso8601"` calendar and returns a bare ISO string.
@@ -25,9 +25,9 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  *   forward, whatever `disambiguation` said, so "earlier" matched "compatible" and "reject" did not
  *   fail. Pass "compatible" (or omit it) to keep the forward result.
  * - Compatibility: before 1.16.0 a non-"compatible" `disambiguation` re-resolved the final wall
- *   clock (so `- { minutes: 10 }` from `2024-11-03T01:30:00-05:00[America/New_York]` with
- *   "earlier" returned `01:20:00-04:00`, 70 minutes before the input in exact time, instead of
- *   `01:20:00-05:00`). To get that value, re-resolve the result's wall clock:
+ *   clock (so `- { minutes: 10 }` from `2024-10-27T01:30:00+00:00[Europe/London]` with
+ *   "earlier" returned `01:20:00+01:00`, 70 minutes before the input in exact time, instead of
+ *   `01:20:00+00:00`). To get that value, re-resolve the result's wall clock:
  *   `setZoned(result, { hour, minute, second }, { disambiguation, offset: "ignore" })`.
  * - There is no `offset` option (removed in 1.16.0): the intermediate wall clock is resolved from
  *   a plain date-time, which has no UTC offset for it to act on (Temporal
@@ -39,18 +39,18 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * @param optionsArg optional settings for resolving a DST gap or overlap and an out-of-range date
  * @returns zoned ISO 8601 string on success, or "" on invalid input
  *
- * @example subtractZoned("2024-03-10T12:00:00-04:00[America/New_York]", { days: 5 }) // "2024-03-05T12:00:00-05:00[America/New_York]"
+ * @example subtractZoned("2024-03-10T12:00:00+09:00[Asia/Tokyo]", { days: 5 }) // "2024-03-05T12:00:00+09:00[Asia/Tokyo]"
  * @example subtractZoned("invalid", { days: 5 }) // ""
- * @example subtractZoned("2024-11-04T01:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "later" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example subtractZoned("2024-11-04T01:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
- * @example subtractZoned("2024-03-11T02:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "earlier" }) // "2024-03-10T01:30:00-05:00[America/New_York]" (02:30 on 10 March is in the spring-forward gap; "earlier" moves it back an hour, "compatible" forward to 03:30-04:00)
- * @example subtractZoned("2024-03-11T02:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
- * @example subtractZoned("2024-11-03T01:50:00-05:00[America/New_York]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-11-03T01:40:00-05:00[America/New_York]" (exact time — disambiguation never re-resolves it)
- * @example setZoned(subtractZoned("2024-11-03T01:50:00-05:00[America/New_York]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-11-03T01:40:00-04:00[America/New_York]" (pre-1.16.0 result)
- * @example subtractZoned("2024-03-31T12:00:00-04:00[America/New_York]", { months: 1 }, { overflow: "reject" }) // ""
- * @example subtractZoned("2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]", { months: 1 }) // "2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]" (Adar II -> Adar I, EDT -> EST in one call)
+ * @example subtractZoned("2024-10-28T01:30:00+00:00[Europe/London]", { days: 1 }, { disambiguation: "later" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example subtractZoned("2024-10-28T01:30:00+00:00[Europe/London]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
+ * @example subtractZoned("2024-10-07T02:30:00+11:00[Australia/Sydney]", { days: 1 }, { disambiguation: "earlier" }) // "2024-10-06T01:30:00+10:00[Australia/Sydney]" (02:30 on 6 October is in the spring-forward gap; "earlier" moves it back an hour, "compatible" forward to 03:30+11:00)
+ * @example subtractZoned("2024-10-07T02:30:00+11:00[Australia/Sydney]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
+ * @example subtractZoned("2024-10-27T01:50:00+00:00[Europe/London]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-10-27T01:40:00+00:00[Europe/London]" (exact time — disambiguation never re-resolves it)
+ * @example setZoned(subtractZoned("2024-10-27T01:50:00+00:00[Europe/London]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-10-27T01:40:00+01:00[Europe/London]" (pre-1.16.0 result)
+ * @example subtractZoned("2024-03-31T12:00:00+09:00[Asia/Tokyo]", { months: 1 }, { overflow: "reject" }) // ""
+ * @example subtractZoned("2024-04-04T14:30:00+01:00[Europe/London][u-ca=hebrew]", { months: 1 }) // "2024-03-05T14:30:00+00:00[Europe/London][u-ca=hebrew]" (Adar II -> Adar I, BST -> GMT in one call)
  * @example subtractZoned("2019-05-01T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]", { days: 1 }) // "2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]" (Reiwa 1 -> Heisei 31)
- * @example subtractZoned("2024-03-10T14:30:00-04:00[u-ca=hebrew][America/New_York]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
+ * @example subtractZoned("2024-03-10T14:30:00-03:00[u-ca=hebrew][America/Sao_Paulo]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
  */
 export function subtractZoned(value, units, optionsArg) {
     try {
@@ -58,11 +58,8 @@ export function subtractZoned(value, units, optionsArg) {
             return "";
         }
         const validZonedDateTime = isValidCalendarZonedDateTime(value);
-        const validUnits = typeof units === "object" &&
-            units !== null &&
-            Object.keys(units).every(isValidDateTimeDurationUnit);
-        const validAmounts = validUnits && Object.values(units).every(isValidAmount);
-        if (!validZonedDateTime || !validUnits || !validAmounts) {
+        const amounts = readDurationUnits(units, isValidDateTimeDurationUnit);
+        if (!validZonedDateTime || amounts === null) {
             return "";
         }
         const disambiguation = optionOrDefault(optionsArg?.disambiguation, "compatible");
@@ -73,7 +70,7 @@ export function subtractZoned(value, units, optionsArg) {
                 return "";
             }
             const zoned = parseCalendarZonedValue(value);
-            const subtracted = addToZonedDisambiguated(zoned, units, -1, {
+            const subtracted = addToZonedDisambiguated(zoned, amounts, -1, {
                 overflow,
                 disambiguation,
             });

package/dist/zoned/calculate/subtractZonedBusinessDays.d.ts

@@ -1,7 +1,8 @@
 /**
  * Return a zoned ISO 8601 datetime string with `amount` business days subtracted from `value`.
  *
- * - Uses fixed ISO Monday–Friday business days (no locale awareness).
+ * - Uses a fixed Monday–Friday business week (no locale awareness). Saturday–Sunday is
+ *   CLDR's world-default weekend; ISO 8601 defines no weekend.
  * - Has no calendar parameter, so no other weekend and no holidays. It is not the
  *   zoned form of the plain `subtractBusinessDays`, which takes a `BusinessCalendar`.
  * - Saturday and Sunday are skipped during the count.
@@ -12,9 +13,9 @@
  * @param amount number of business days to subtract
  * @returns Zoned ISO 8601 datetime string after subtracting business days, or "" on invalid input
  *
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 1) // "2024-03-15T14:30:00-04:00[America/New_York]"
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 2) // "2024-03-14T14:30:00-04:00[America/New_York]"
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 0) // "2024-03-18T14:30:00-04:00[America/New_York]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 1) // "2024-03-15T14:30:00+02:00[Africa/Johannesburg]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 2) // "2024-03-14T14:30:00+02:00[Africa/Johannesburg]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 0) // "2024-03-18T14:30:00+02:00[Africa/Johannesburg]"
  * @example subtractZonedBusinessDays("invalid", 1) // ""
  */
 export declare function subtractZonedBusinessDays(value: string, amount: number): string;

package/dist/zoned/calculate/subtractZonedBusinessDays.js

@@ -4,7 +4,8 @@ import { isValidZonedDateTime } from "../validate/index.js";
 /**
  * Return a zoned ISO 8601 datetime string with `amount` business days subtracted from `value`.
  *
- * - Uses fixed ISO Monday–Friday business days (no locale awareness).
+ * - Uses a fixed Monday–Friday business week (no locale awareness). Saturday–Sunday is
+ *   CLDR's world-default weekend; ISO 8601 defines no weekend.
  * - Has no calendar parameter, so no other weekend and no holidays. It is not the
  *   zoned form of the plain `subtractBusinessDays`, which takes a `BusinessCalendar`.
  * - Saturday and Sunday are skipped during the count.
@@ -15,9 +16,9 @@ import { isValidZonedDateTime } from "../validate/index.js";
  * @param amount number of business days to subtract
  * @returns Zoned ISO 8601 datetime string after subtracting business days, or "" on invalid input
  *
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 1) // "2024-03-15T14:30:00-04:00[America/New_York]"
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 2) // "2024-03-14T14:30:00-04:00[America/New_York]"
- * @example subtractZonedBusinessDays("2024-03-18T14:30:00-04:00[America/New_York]", 0) // "2024-03-18T14:30:00-04:00[America/New_York]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 1) // "2024-03-15T14:30:00+02:00[Africa/Johannesburg]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 2) // "2024-03-14T14:30:00+02:00[Africa/Johannesburg]"
+ * @example subtractZonedBusinessDays("2024-03-18T14:30:00+02:00[Africa/Johannesburg]", 0) // "2024-03-18T14:30:00+02:00[Africa/Johannesburg]"
  * @example subtractZonedBusinessDays("invalid", 1) // ""
  */
 export function subtractZonedBusinessDays(value, amount) {

package/dist/zoned/chop/chopZonedDate.d.ts

@@ -7,7 +7,7 @@
  * @param value ISO 8601 zoned datetime string
  * @returns The local time portion as HH:MM:SS(.SSS) or "" for invalid
  *
- * @example chopZonedDate("2024-02-29T14:30:45.123-05:00[America/New_York]") // "14:30:45.123"
+ * @example chopZonedDate("2024-02-29T14:30:45.123+09:00[Asia/Tokyo]") // "14:30:45.123"
  * @example chopZonedDate("invalid") // ""
  */
 export declare function chopZonedDate(value: string): string;

package/dist/zoned/chop/chopZonedDate.js

@@ -9,7 +9,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns The local time portion as HH:MM:SS(.SSS) or "" for invalid
  *
- * @example chopZonedDate("2024-02-29T14:30:45.123-05:00[America/New_York]") // "14:30:45.123"
+ * @example chopZonedDate("2024-02-29T14:30:45.123+09:00[Asia/Tokyo]") // "14:30:45.123"
  * @example chopZonedDate("invalid") // ""
  */
 export function chopZonedDate(value) {

package/dist/zoned/chop/chopZonedMilliseconds.d.ts

@@ -7,7 +7,7 @@
  * @param value ISO 8601 zoned datetime string
  * @returns Zoned datetime string without milliseconds or "" for invalid
  *
- * @example chopZonedMilliseconds("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45-05:00[America/New_York]"
+ * @example chopZonedMilliseconds("2024-02-29T14:30:45.123+00:00[Europe/London]") // "2024-02-29T14:30:45+00:00[Europe/London]"
  * @example chopZonedMilliseconds("invalid") // ""
  */
 export declare function chopZonedMilliseconds(value: string): string;

package/dist/zoned/chop/chopZonedMilliseconds.js

@@ -9,7 +9,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns Zoned datetime string without milliseconds or "" for invalid
  *
- * @example chopZonedMilliseconds("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45-05:00[America/New_York]"
+ * @example chopZonedMilliseconds("2024-02-29T14:30:45.123+00:00[Europe/London]") // "2024-02-29T14:30:45+00:00[Europe/London]"
  * @example chopZonedMilliseconds("invalid") // ""
  */
 export function chopZonedMilliseconds(value) {

package/dist/zoned/chop/chopZonedSeconds.d.ts

@@ -7,7 +7,7 @@
  * @param value ISO 8601 zoned datetime string
  * @returns Zoned datetime string at minute precision or "" for invalid
  *
- * @example chopZonedSeconds("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30-05:00[America/New_York]"
+ * @example chopZonedSeconds("2024-02-29T14:30:45.123+11:00[Australia/Sydney]") // "2024-02-29T14:30+11:00[Australia/Sydney]"
  * @example chopZonedSeconds("invalid") // ""
  */
 export declare function chopZonedSeconds(value: string): string;

package/dist/zoned/chop/chopZonedSeconds.js

@@ -9,7 +9,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns Zoned datetime string at minute precision or "" for invalid
  *
- * @example chopZonedSeconds("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30-05:00[America/New_York]"
+ * @example chopZonedSeconds("2024-02-29T14:30:45.123+11:00[Australia/Sydney]") // "2024-02-29T14:30+11:00[Australia/Sydney]"
  * @example chopZonedSeconds("invalid") // ""
  */
 export function chopZonedSeconds(value) {

package/dist/zoned/chop/chopZonedTime.d.ts

@@ -7,7 +7,7 @@
  * @param value ISO 8601 zoned datetime string
  * @returns Local date string YYYY-MM-DD or "" for invalid
  *
- * @example chopZonedTime("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29"
+ * @example chopZonedTime("2024-02-29T14:30:45.123-03:00[America/Sao_Paulo]") // "2024-02-29"
  * @example chopZonedTime("invalid") // ""
  */
 export declare function chopZonedTime(value: string): string;

package/dist/zoned/chop/chopZonedTime.js

@@ -9,7 +9,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns Local date string YYYY-MM-DD or "" for invalid
  *
- * @example chopZonedTime("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29"
+ * @example chopZonedTime("2024-02-29T14:30:45.123-03:00[America/Sao_Paulo]") // "2024-02-29"
  * @example chopZonedTime("invalid") // ""
  */
 export function chopZonedTime(value) {

package/dist/zoned/chop/chopZonedTimezone.d.ts

@@ -7,7 +7,7 @@
  * @param value ISO 8601 zoned datetime string
  * @returns Local plain datetime string or "" for invalid
  *
- * @example chopZonedTimezone("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45.123"
+ * @example chopZonedTimezone("2024-02-29T14:30:45.123+05:30[Asia/Kolkata]") // "2024-02-29T14:30:45.123"
  * @example chopZonedTimezone("invalid") // ""
  */
 export declare function chopZonedTimezone(value: string): string;

package/dist/zoned/chop/chopZonedTimezone.js

@@ -9,7 +9,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns Local plain datetime string or "" for invalid
  *
- * @example chopZonedTimezone("2024-02-29T14:30:45.123-05:00[America/New_York]") // "2024-02-29T14:30:45.123"
+ * @example chopZonedTimezone("2024-02-29T14:30:45.123+05:30[Asia/Kolkata]") // "2024-02-29T14:30:45.123"
  * @example chopZonedTimezone("invalid") // ""
  */
 export function chopZonedTimezone(value) {

package/dist/zoned/classify/classifyStoredZoned.d.ts

@@ -0,0 +1,46 @@
+import type { StoredZonedClassification } from "../../types/index.js";
+/**
+ * Says whether a stored RFC 9557 string with both an offset and a zone still names one
+ * instant under this host's time zone rules, and gives every reading when it does not.
+ *
+ * An offset stored next to a zone is a claim about the zone's rules. When the rules change
+ * after the string was written, the offset and the zone can disagree (RFC 9557 §3.4), or the
+ * local time can fall into a new gap or overlap. Each of Temporal's `offset` values
+ * (`use`, `ignore`, `prefer`, `reject`) is one choice among the readings returned.
+ *
+ * Resolution: none. No reading is chosen. An ambiguous or nonexistent local time returns both
+ * its `earlier` and `later` readings, as `disambiguation` names them, and the instant the
+ * stored offset gives.
+ *
+ * - Five kinds. `valid`: the local time occurs once, at the stored offset. `validInOverlap`: it
+ *   occurs twice and the stored offset picks `instant`, which is `earlier` or `later`.
+ *   `offsetMismatch`: it occurs once, but not at the stored offset. `ambiguous`: it occurs
+ *   twice and the stored offset picks neither. `nonexistent`: it falls in a gap.
+ * - Every kind carries `atStoredOffset`, the instant `offset: "use"` gives. It differs from
+ *   `instant` when an offset written to the minute matches a zone offset with seconds
+ *   (`Africa/Monrovia`, `-00:45` for `-00:44:30`). An offset written with seconds must match
+ *   exactly.
+ * - Each reading is a `Temporal.Instant#toString` string ending in `Z`, and each offset is
+ *   `±HH:MM[:SS]`. `storedOffset` keeps the seconds as written, so `-00:45:00` stays
+ *   `-00:45:00`; `zoneOffset` drops a zero seconds part.
+ * - The result depends on the host's tzdb: the same string can be `valid` on one host and
+ *   `offsetMismatch` on another. On Node, `process.versions.tz` names the release. Browsers
+ *   expose no equivalent.
+ * - `…Z[zone]` is always `valid` (Temporal reads `Z` as exact, RFC 9557 §3.4 Figure 2), even
+ *   inside an overlap or a gap. `-00:00` is a numeric offset of zero, as Temporal reads it,
+ *   so it can be an `offsetMismatch`.
+ * - Returns null for a string with no offset, no zone annotation, a bracketed offset in place
+ *   of an IANA zone, an unknown zone, an offset finer than a second, a calendar other than
+ *   `iso8601`, second 60, basic format, a reading outside the instant range, a local date of
+ *   `-271821-04-19` (which Temporal's `prefer` and `reject` refuse), or any non-string input.
+ *
+ * @param value RFC 9557 string with a UTC offset and a bracketed IANA time zone
+ * @returns the classification with every reading as a `Z` instant string, or `null` for any
+ *   other input
+ *
+ * @example classifyStoredZoned("2016-12-01T09:00:00+02:00[Europe/Istanbul]") // { kind: "offsetMismatch", storedOffset: "+02:00", zoneOffset: "+03:00", atStoredOffset: "2016-12-01T07:00:00Z", atZoneOffset: "2016-12-01T06:00:00Z" }
+ * @example classifyStoredZoned("2026-03-29T01:30:00+00:00[Europe/London]") // { kind: "nonexistent", earlier: "2026-03-29T00:30:00Z", later: "2026-03-29T01:30:00Z", atStoredOffset: "2026-03-29T01:30:00Z" }
+ * @example classifyStoredZoned("2026-10-25T01:30:00+01:00[Europe/London]") // { kind: "validInOverlap", instant: "2026-10-25T00:30:00Z", earlier: "2026-10-25T00:30:00Z", later: "2026-10-25T01:30:00Z", atStoredOffset: "2026-10-25T00:30:00Z" }
+ * @example classifyStoredZoned("2026-03-29T01:30:00[Europe/London]") // null
+ */
+export declare function classifyStoredZoned(value: string): StoredZonedClassification | null;