@northguild/gmt 1.19.0 → 1.20.0

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

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 /**
  * Round an ISO 8601 zoned datetime string to the specified unit.
  *
@@ -11,20 +11,22 @@ import { Temporal } from "@js-temporal/polyfill";
  *   coarser, 3 digits for "millisecond", 6 for "microsecond" and 9 for "nanosecond", so the
  *   result never hides the precision the unit asked for.
  * - Note: Temporal's `ZonedDateTime.prototype.round` takes no `disambiguation` or `offset` options.
- * - Follows TC39 `ZonedDateTime.round`, which rounds the wall clock and re-resolves it in the
- *   zone. Across a transition the result can land after the input or on another local date —
- *   `Pacific/Chatham` "2024-09-29T03:50:00+13:45" truncated to the hour gives 04:00+13:45, 15
- *   minutes later. Use `floorToZone` for a boundary that never exceeds the instant.
+ * - Follows TC39 `ZonedDateTime.round`. Below the day it rounds the wall clock and re-resolves it
+ *   in the zone, so across a transition the result can land after the input or on another local
+ *   date — `Pacific/Chatham` "2024-09-29T03:50:00+13:45" truncated to the hour gives 04:00+13:45,
+ *   15 minutes later. To the day it rounds between the start of the input's date and the start of
+ *   the next, so `"floor"` and `"trunc"` never leave the input's date, even when a clock change
+ *   makes that date start twice. Use `floorToZone` for a boundary that never exceeds the instant.
  *
  * @param value ISO 8601 zoned datetime string
  * @param options the unit to round to, with an optional increment and rounding mode
  * @returns Rounded ISO 8601 zoned datetime string, or "" on invalid input
  *
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "hour" }) // "2024-06-15T13:00:00-04:00[America/New_York]"
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "minute", roundingIncrement: 15 }) // "2024-06-15T12:30:00-04:00[America/New_York]"
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "hour" }) // "2024-06-15T13:00:00+02:00[Africa/Johannesburg]"
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "minute", roundingIncrement: 15 }) // "2024-06-15T12:30:00+02:00[Africa/Johannesburg]"
  * @example roundZoned("2024-09-29T03:50:00+13:45[Pacific/Chatham]", { smallestUnit: "hour", roundingMode: "trunc" }) // "2024-09-29T04:00:00+13:45[Pacific/Chatham]" (after the input — TC39 wall-clock rounding)
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "hours" }) // "2024-06-15T13:00:00-04:00[America/New_York]" (plural unit name)
- * @example roundZoned("2024-06-15T12:34:56.123456789-04:00[America/New_York]", { smallestUnit: "millisecond" }) // "2024-06-15T12:34:56.123-04:00[America/New_York]" (precision follows the unit)
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "hours" }) // "2024-06-15T13:00:00+02:00[Africa/Johannesburg]" (plural unit name)
+ * @example roundZoned("2024-06-15T12:34:56.123456789+02:00[Africa/Johannesburg]", { smallestUnit: "millisecond" }) // "2024-06-15T12:34:56.123+02:00[Africa/Johannesburg]" (precision follows the unit)
  * @example roundZoned("invalid", { smallestUnit: "hour" }) // ""
  */
 export declare function roundZoned(value: string, options: {

package/dist/zoned/calculate/roundZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { defaultFractionalDigits, isObject, resolveDateTimeUnit, roundZonedDateTime, zonedDateTimeFrom, } from "../../internal/index.js";
 import { isValidZonedDateTime } from "../validate/index.js";
 const ZONED_ROUNDING_UNITS = [
@@ -26,20 +26,22 @@ function isZonedRoundingUnit(unit) {
  *   coarser, 3 digits for "millisecond", 6 for "microsecond" and 9 for "nanosecond", so the
  *   result never hides the precision the unit asked for.
  * - Note: Temporal's `ZonedDateTime.prototype.round` takes no `disambiguation` or `offset` options.
- * - Follows TC39 `ZonedDateTime.round`, which rounds the wall clock and re-resolves it in the
- *   zone. Across a transition the result can land after the input or on another local date —
- *   `Pacific/Chatham` "2024-09-29T03:50:00+13:45" truncated to the hour gives 04:00+13:45, 15
- *   minutes later. Use `floorToZone` for a boundary that never exceeds the instant.
+ * - Follows TC39 `ZonedDateTime.round`. Below the day it rounds the wall clock and re-resolves it
+ *   in the zone, so across a transition the result can land after the input or on another local
+ *   date — `Pacific/Chatham` "2024-09-29T03:50:00+13:45" truncated to the hour gives 04:00+13:45,
+ *   15 minutes later. To the day it rounds between the start of the input's date and the start of
+ *   the next, so `"floor"` and `"trunc"` never leave the input's date, even when a clock change
+ *   makes that date start twice. Use `floorToZone` for a boundary that never exceeds the instant.
  *
  * @param value ISO 8601 zoned datetime string
  * @param options the unit to round to, with an optional increment and rounding mode
  * @returns Rounded ISO 8601 zoned datetime string, or "" on invalid input
  *
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "hour" }) // "2024-06-15T13:00:00-04:00[America/New_York]"
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "minute", roundingIncrement: 15 }) // "2024-06-15T12:30:00-04:00[America/New_York]"
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "hour" }) // "2024-06-15T13:00:00+02:00[Africa/Johannesburg]"
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "minute", roundingIncrement: 15 }) // "2024-06-15T12:30:00+02:00[Africa/Johannesburg]"
  * @example roundZoned("2024-09-29T03:50:00+13:45[Pacific/Chatham]", { smallestUnit: "hour", roundingMode: "trunc" }) // "2024-09-29T04:00:00+13:45[Pacific/Chatham]" (after the input — TC39 wall-clock rounding)
- * @example roundZoned("2024-06-15T12:34:56-04:00[America/New_York]", { smallestUnit: "hours" }) // "2024-06-15T13:00:00-04:00[America/New_York]" (plural unit name)
- * @example roundZoned("2024-06-15T12:34:56.123456789-04:00[America/New_York]", { smallestUnit: "millisecond" }) // "2024-06-15T12:34:56.123-04:00[America/New_York]" (precision follows the unit)
+ * @example roundZoned("2024-06-15T12:34:56+02:00[Africa/Johannesburg]", { smallestUnit: "hours" }) // "2024-06-15T13:00:00+02:00[Africa/Johannesburg]" (plural unit name)
+ * @example roundZoned("2024-06-15T12:34:56.123456789+02:00[Africa/Johannesburg]", { smallestUnit: "millisecond" }) // "2024-06-15T12:34:56.123+02:00[Africa/Johannesburg]" (precision follows the unit)
  * @example roundZoned("invalid", { smallestUnit: "hour" }) // ""
  */
 export function roundZoned(value, options) {

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`.
@@ -36,13 +36,13 @@ 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-04:00[America/New_York]", { hour: "9" }) // "" (not converted)
+ * @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" | "era" | "eraYear">, options?: {

package/dist/zoned/calculate/setZoned.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+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";
@@ -39,13 +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-04:00[America/New_York]", { hour: "9" }) // "" (not converted)
+ * @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) {

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

@@ -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 {

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;