@northguild/gmt 1.19.0 → 1.20.0

package/dist/zoned/classify/classifyStoredZoned.js

@@ -0,0 +1,177 @@
+import { Temporal } from "../../internal/temporal.js";
+import { formatUtcOffset, isoStringBody, isWithinIsoDaysRange, TIME_ZONE_ANNOTATION, UTC_OFFSET_WITH_SECONDS, writtenOffset, zonedDateTimeFrom, } from "../../internal/index.js";
+import { classifyWall } from "../../internal/earlierOccurrence.js";
+import { hasInstantShape, hasZonedDateTimeShape, } from "../../internal/isoStringBody.js";
+import { hasSecond60 } from "../../plain/validate/hasSecond60.js";
+import { utcOffset } from "../../regex/index.js";
+/** A leading RFC 9557 time zone annotation: `[zone]` or `[!zone]`, with no `=`. */
+const timeZoneAnnotation = new RegExp(`^${TIME_ZONE_ANNOTATION}`);
+/**
+ * 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 function classifyStoredZoned(value) {
+    if (typeof value !== "string" ||
+        hasSecond60(value) ||
+        !hasZonedDateTimeShape(value) ||
+        !hasInstantShape(value)) {
+        return null;
+    }
+    try {
+        return classifyShaped(value);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A `Z` string. It is offsetBehaviour exact (Temporal §6.5.2): no candidate is checked, so the
+ * exact read is the whole answer. It also keeps `Z` strings at the instant-range edge, where an
+ * `ignore` read would resolve the zone's wall clock outside the range.
+ */
+function classifyExact(value) {
+    const exact = zonedDateTimeFrom(value);
+    // A bracketed offset names no place, and Temporal accepts it; GMT does not.
+    if (utcOffset.test(exact.timeZoneId) || exact.calendarId !== "iso8601") {
+        return null;
+    }
+    const instant = exact.toInstant().toString();
+    return { kind: "valid", instant, atStoredOffset: instant };
+}
+/**
+ * The offset as written: `writtenOffset` drops a seconds part of zero, so `-00:45:00` is put back
+ * when the body wrote seconds. Without it a caller could not tell `-00:45:00` (which must match
+ * the zone exactly) from `-00:45` (which may match `-00:44:30`).
+ */
+function withWrittenSeconds(offset, body) {
+    return offset !== null &&
+        offset.length === 6 &&
+        UTC_OFFSET_WITH_SECONDS.test(body)
+        ? `${offset}:00`
+        : offset;
+}
+/** What the stored offset says, or null when it cannot be trusted. */
+function readStored(value, body) {
+    const use = zonedDateTimeFrom(value, { offset: "use" }).toInstant();
+    const storedOffset = withWrittenSeconds(writtenOffset(use, body), body);
+    const wall = Temporal.PlainDateTime.from(body);
+    // Temporal's `prefer` and `reject` refuse a local date outside CheckISODaysRange (§6.5.1
+    // step 7), so the stored offset cannot be checked and the string is not a valid stored time.
+    // `use` accepts that date. TC39's `ignore` accepts it too, but polyfill 0.5.1 throws there, so
+    // the `ignore` read in `classifyShaped` can throw first; `classifyStoredZoned` catches that and
+    // returns the same null.
+    return storedOffset === null || !isWithinIsoDaysRange(wall)
+        ? null
+        : { use, storedOffset, wall };
+}
+/** The classification of a string that passed the shape gate; throws where Temporal throws. */
+function classifyShaped(value) {
+    const body = isoStringBody(value);
+    // Only a time zone annotation makes the string zoned (RFC 9557 §4.1).
+    if (!timeZoneAnnotation.test(value.slice(body.length))) {
+        return null;
+    }
+    if (body.endsWith("Z") || body.endsWith("z")) {
+        return classifyExact(value);
+    }
+    const zoned = zonedDateTimeFrom(value, { offset: "ignore" });
+    // A bracketed offset names no place, and Temporal accepts it; GMT does not.
+    if (utcOffset.test(zoned.timeZoneId) || zoned.calendarId !== "iso8601") {
+        return null;
+    }
+    const stored = readStored(value, body);
+    if (stored === null) {
+        return null;
+    }
+    const { use, storedOffset, wall } = stored;
+    const { kind, earliest, latest } = classifyWall(wall, zoned.timeZoneId);
+    const readings = {
+        earlier: earliest.toInstant().toString(),
+        later: latest.toInstant().toString(),
+        atStoredOffset: use.toString(),
+    };
+    if (kind === "nonexistent") {
+        return { kind, ...readings };
+    }
+    // `reject` is Temporal §6.5.1: the stored offset must match a candidate instant.
+    const matched = matchStoredOffset(value);
+    if (kind === "ambiguous") {
+        return classifyOverlap(matched, readings);
+    }
+    return classifyUnique(matched, readings, storedOffset, earliest);
+}
+/** A repeated wall clock: valid in the overlap when the stored offset picks one of its readings. */
+function classifyOverlap(matched, readings) {
+    return matched === null
+        ? { kind: "ambiguous", ...readings }
+        : { kind: "validInOverlap", instant: matched, ...readings };
+}
+/** A wall clock with one reading: valid when the stored offset matches it, otherwise a mismatch. */
+function classifyUnique(matched, readings, storedOffset, earliest) {
+    if (matched !== null) {
+        return {
+            kind: "valid",
+            instant: matched,
+            atStoredOffset: readings.atStoredOffset,
+        };
+    }
+    const zoneOffset = formatUtcOffset(BigInt(earliest.offsetNanoseconds));
+    return zoneOffset === null
+        ? null
+        : {
+            kind: "offsetMismatch",
+            storedOffset,
+            zoneOffset,
+            atStoredOffset: readings.atStoredOffset,
+            atZoneOffset: readings.earlier,
+        };
+}
+/** The instant the stored offset picks under `offset: "reject"`, or null when nothing matches. */
+function matchStoredOffset(value) {
+    try {
+        return zonedDateTimeFrom(value).toInstant().toString();
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./classifyStoredZoned.js";

package/dist/zoned/classify/index.js

@@ -0,0 +1 @@
+export * from "./classifyStoredZoned.js";

package/dist/zoned/compare/areZonedEqual.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";
 /**

package/dist/zoned/compare/areZonedEqualBy.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import type { DateTimeUnit } from "../../types/index.js";
 /**
  * Compare two zoned ISO datetime strings for equality at a given unit.
@@ -9,21 +9,19 @@ import type { DateTimeUnit } from "../../types/index.js";
  *   another, and this function answers per each value's own zone, because a
  *   `Temporal.ZonedDateTime` reads its calendar and clock fields in its own
  *   time zone.
- * - Comparison: Luxon's `dt.hasSame(other, unit)` also compares the two values'
- *   local times.
  * - Each value's start-of-unit is its real local bucket (see `startOfZoned`), so a bucket a
  *   zone transition shortened is still its own unit: in `Pacific/Chatham` on its 2024
  *   spring-forward, 03:50 and 04:05 are different hours, because the 03:00 hour lasted only
  *   from 03:45 to 04:00.
  * - Two values in the same time zone are equal only when their bucket starts are the same
- *   instant, as in `areUnixEqualBy`: both passes of New York's repeated 01:00 on its 2024
+ *   instant, as in `areUnixEqualBy`: both passes of London's repeated 01:00 on its 2024
  *   fall-back read the same wall clock but are different hours. Values in different zones are
  *   compared by their buckets' local labels, since their instants never line up.
  * - `"month"` requires the same month AND year, matching `areDateTimesEqualBy`.
  * - `unit` accepts the singular or plural name (`"day"` or `"days"`), as Temporal does.
  * - Returns false for an unsupported unit or invalid input.
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isSameDay(a, b)` → `areZonedEqualBy(a, b, "day")`
  * - `isSameMonth(a, b)` → `areZonedEqualBy(a, b, "month")`
  * - `isSameYear(a, b)` → `areZonedEqualBy(a, b, "year")`
@@ -34,11 +32,11 @@ import type { DateTimeUnit } from "../../types/index.js";
  * @param optionsArg optional setting for the week's first day
  * @returns true if both values share the same local start-of-unit boundary, false on an unsupported unit or invalid input
  *
- * @example areZonedEqualBy("2024-03-15T10:00:00-04:00[America/New_York]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "day") // true (both are local March 15 in their own zone)
- * @example areZonedEqualBy("2024-03-15T10:00:00-04:00[America/New_York]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "days") // true (plural unit)
- * @example areZonedEqualBy("2024-03-15T23:30:00-04:00[America/New_York]", "2024-03-16T04:30:00+00:00[UTC]", "day") // false (same instant, different local calendar day per zone)
- * @example areZonedEqualBy("2024-11-03T01:30:00-04:00[America/New_York]", "2024-11-03T01:30:00-05:00[America/New_York]", "hour") // false (both read 01:30, but they sit in the two different real 01:00 hours)
- * @example areZonedEqualBy("invalid", "2024-03-15T10:00:00-04:00[America/New_York]", "day") // false
+ * @example areZonedEqualBy("2024-03-15T10:00:00+09:00[Asia/Tokyo]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "day") // true (both are local March 15 in their own zone)
+ * @example areZonedEqualBy("2024-03-15T10:00:00+09:00[Asia/Tokyo]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "days") // true (plural unit)
+ * @example areZonedEqualBy("2024-03-15T23:30:00-03:00[America/Sao_Paulo]", "2024-03-16T02:30:00+00:00[UTC]", "day") // false (same instant, different local calendar day per zone)
+ * @example areZonedEqualBy("2024-10-27T01:30:00+01:00[Europe/London]", "2024-10-27T01:30:00+00:00[Europe/London]", "hour") // false (both read 01:30, but they sit in the two different real 01:00 hours)
+ * @example areZonedEqualBy("invalid", "2024-03-15T10:00:00+02:00[Africa/Johannesburg]", "day") // false
  */
 export declare function areZonedEqualBy(value1: string, value2: string, unit: Temporal.SmallestUnit<DateTimeUnit>, optionsArg?: {
     /**

package/dist/zoned/compare/areZonedEqualBy.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTimeUnit } from "../../plain/validate/index.js";
 import { startOfZoned } from "../calculate/startOfZoned.js";
 import { isValidZonedDateTime } from "../validate/index.js";
@@ -15,21 +15,19 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  *   another, and this function answers per each value's own zone, because a
  *   `Temporal.ZonedDateTime` reads its calendar and clock fields in its own
  *   time zone.
- * - Comparison: Luxon's `dt.hasSame(other, unit)` also compares the two values'
- *   local times.
  * - Each value's start-of-unit is its real local bucket (see `startOfZoned`), so a bucket a
  *   zone transition shortened is still its own unit: in `Pacific/Chatham` on its 2024
  *   spring-forward, 03:50 and 04:05 are different hours, because the 03:00 hour lasted only
  *   from 03:45 to 04:00.
  * - Two values in the same time zone are equal only when their bucket starts are the same
- *   instant, as in `areUnixEqualBy`: both passes of New York's repeated 01:00 on its 2024
+ *   instant, as in `areUnixEqualBy`: both passes of London's repeated 01:00 on its 2024
  *   fall-back read the same wall clock but are different hours. Values in different zones are
  *   compared by their buckets' local labels, since their instants never line up.
  * - `"month"` requires the same month AND year, matching `areDateTimesEqualBy`.
  * - `unit` accepts the singular or plural name (`"day"` or `"days"`), as Temporal does.
  * - Returns false for an unsupported unit or invalid input.
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isSameDay(a, b)` → `areZonedEqualBy(a, b, "day")`
  * - `isSameMonth(a, b)` → `areZonedEqualBy(a, b, "month")`
  * - `isSameYear(a, b)` → `areZonedEqualBy(a, b, "year")`
@@ -40,11 +38,11 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  * @param optionsArg optional setting for the week's first day
  * @returns true if both values share the same local start-of-unit boundary, false on an unsupported unit or invalid input
  *
- * @example areZonedEqualBy("2024-03-15T10:00:00-04:00[America/New_York]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "day") // true (both are local March 15 in their own zone)
- * @example areZonedEqualBy("2024-03-15T10:00:00-04:00[America/New_York]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "days") // true (plural unit)
- * @example areZonedEqualBy("2024-03-15T23:30:00-04:00[America/New_York]", "2024-03-16T04:30:00+00:00[UTC]", "day") // false (same instant, different local calendar day per zone)
- * @example areZonedEqualBy("2024-11-03T01:30:00-04:00[America/New_York]", "2024-11-03T01:30:00-05:00[America/New_York]", "hour") // false (both read 01:30, but they sit in the two different real 01:00 hours)
- * @example areZonedEqualBy("invalid", "2024-03-15T10:00:00-04:00[America/New_York]", "day") // false
+ * @example areZonedEqualBy("2024-03-15T10:00:00+09:00[Asia/Tokyo]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "day") // true (both are local March 15 in their own zone)
+ * @example areZonedEqualBy("2024-03-15T10:00:00+09:00[Asia/Tokyo]", "2024-03-15T20:00:00+01:00[Europe/Berlin]", "days") // true (plural unit)
+ * @example areZonedEqualBy("2024-03-15T23:30:00-03:00[America/Sao_Paulo]", "2024-03-16T02:30:00+00:00[UTC]", "day") // false (same instant, different local calendar day per zone)
+ * @example areZonedEqualBy("2024-10-27T01:30:00+01:00[Europe/London]", "2024-10-27T01:30:00+00:00[Europe/London]", "hour") // false (both read 01:30, but they sit in the two different real 01:00 hours)
+ * @example areZonedEqualBy("invalid", "2024-03-15T10:00:00+02:00[Africa/Johannesburg]", "day") // false
  */
 export function areZonedEqualBy(value1, value2, unit, optionsArg) {
     try {

package/dist/zoned/compare/isAfterZoned.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";
 /**

package/dist/zoned/compare/isBeforeZoned.d.ts

@@ -9,7 +9,7 @@
  * @param value2 second zoned datetime string
  * @returns `true` if `value1` is before `value2`, otherwise `false`
  *
- * @example isBeforeZoned("2024-03-17T14:30:45-04:00[America/New_York]", "2024-03-17T15:30:45-04:00[America/New_York]") // true
- * @example isBeforeZoned("invalid", "2024-03-17T14:30:45-05:00[America/New_York]") // false
+ * @example isBeforeZoned("2024-03-17T14:30:45+02:00[Africa/Johannesburg]", "2024-03-17T15:30:45+02:00[Africa/Johannesburg]") // true
+ * @example isBeforeZoned("invalid", "2024-03-17T14:30:45+02:00[Africa/Johannesburg]") // false
  */
 export declare function isBeforeZoned(value1: string, value2: string): boolean;

package/dist/zoned/compare/isBeforeZoned.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,8 +12,8 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value2 second zoned datetime string
  * @returns `true` if `value1` is before `value2`, otherwise `false`
  *
- * @example isBeforeZoned("2024-03-17T14:30:45-04:00[America/New_York]", "2024-03-17T15:30:45-04:00[America/New_York]") // true
- * @example isBeforeZoned("invalid", "2024-03-17T14:30:45-05:00[America/New_York]") // false
+ * @example isBeforeZoned("2024-03-17T14:30:45+02:00[Africa/Johannesburg]", "2024-03-17T15:30:45+02:00[Africa/Johannesburg]") // true
+ * @example isBeforeZoned("invalid", "2024-03-17T14:30:45+02:00[Africa/Johannesburg]") // false
  */
 export function isBeforeZoned(value1, value2) {
     if (!isValidZonedDateTime(value1) || !isValidZonedDateTime(value2)) {

package/dist/zoned/compare/isBetweenZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidZonedDateTime } from "../validate/index.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";

package/dist/zoned/compare/isInDaylightSaving.d.ts

@@ -37,8 +37,8 @@
  * @param value zoned ISO 8601 datetime string
  * @returns true if the instant is in daylight saving time, false otherwise or on invalid input
  *
- * @example isInDaylightSaving("2024-07-15T12:00:00-04:00[America/New_York]") // true
- * @example isInDaylightSaving("2024-01-15T12:00:00-05:00[America/New_York]") // false
+ * @example isInDaylightSaving("2024-07-15T12:00:00+01:00[Europe/London]") // true
+ * @example isInDaylightSaving("2024-01-15T12:00:00+00:00[Europe/London]") // false
  * @example isInDaylightSaving("2024-01-15T12:00:00+11:00[Australia/Sydney]") // true (southern-hemisphere summer)
  * @example isInDaylightSaving("2024-07-15T12:00:00+09:00[Asia/Tokyo]") // false (Asia/Tokyo has no DST)
  * @example isInDaylightSaving("2015-07-01T12:00:00+03:00[Europe/Istanbul]") // true (undone 2015-11-08)

package/dist/zoned/compare/isInDaylightSaving.js

@@ -39,8 +39,8 @@ import { isInDaylightTime, zonedDateTimeFrom } from "../../internal/index.js";
  * @param value zoned ISO 8601 datetime string
  * @returns true if the instant is in daylight saving time, false otherwise or on invalid input
  *
- * @example isInDaylightSaving("2024-07-15T12:00:00-04:00[America/New_York]") // true
- * @example isInDaylightSaving("2024-01-15T12:00:00-05:00[America/New_York]") // false
+ * @example isInDaylightSaving("2024-07-15T12:00:00+01:00[Europe/London]") // true
+ * @example isInDaylightSaving("2024-01-15T12:00:00+00:00[Europe/London]") // false
  * @example isInDaylightSaving("2024-01-15T12:00:00+11:00[Australia/Sydney]") // true (southern-hemisphere summer)
  * @example isInDaylightSaving("2024-07-15T12:00:00+09:00[Asia/Tokyo]") // false (Asia/Tokyo has no DST)
  * @example isInDaylightSaving("2015-07-01T12:00:00+03:00[Europe/Istanbul]") // true (undone 2015-11-08)

package/dist/zoned/compare/isZonedBusinessDay.d.ts

@@ -1,8 +1,9 @@
 /**
- * Return true when `value` falls on a Monday–Friday ISO business day in the given timezone.
+ * Return true when `value` falls on a Monday–Friday business day in the given timezone.
  *
- * - Uses the fixed ISO Monday–Friday business-day boundary (Mon=1 … Fri=5),
- *   matching the definition used by `addZonedBusinessDays`/`subtractZonedBusinessDays`.
+ * - Uses a fixed Monday–Friday business week (ISO weekday numbers 1 … 5), matching
+ *   `addZonedBusinessDays`/`subtractZonedBusinessDays`. Saturday–Sunday is CLDR's
+ *   world-default weekend; ISO 8601 numbers the weekdays but defines no weekend.
  * - Locale-agnostic: no `Intl.Locale` lookup and no holiday calendar.
  * - Returns false if `value` is invalid.
  *
@@ -17,9 +18,9 @@
  * @param value ISO 8601 zoned datetime string
  * @returns true if `value` is a Monday–Friday business day, false on invalid input
  *
- * @example isZonedBusinessDay("2024-02-05T10:00:00-05:00[America/New_York]") // true (Monday)
- * @example isZonedBusinessDay("2024-02-10T10:00:00-05:00[America/New_York]") // false (Saturday)
- * @example isZonedBusinessDay("2024-02-04T10:00:00-05:00[America/New_York]") // false (Sunday)
+ * @example isZonedBusinessDay("2024-02-05T10:00:00+05:30[Asia/Kolkata]") // true (Monday)
+ * @example isZonedBusinessDay("2024-02-10T10:00:00+05:30[Asia/Kolkata]") // false (Saturday)
+ * @example isZonedBusinessDay("2024-02-04T10:00:00+05:30[Asia/Kolkata]") // false (Sunday)
  * @example isZonedBusinessDay("invalid") // false
  */
 export declare function isZonedBusinessDay(value: string): boolean;

package/dist/zoned/compare/isZonedBusinessDay.js

@@ -1,10 +1,11 @@
 import { isValidZonedDateTime } from "../validate/index.js";
 import { zonedDateTimeFrom } from "../../internal/index.js";
 /**
- * Return true when `value` falls on a Monday–Friday ISO business day in the given timezone.
+ * Return true when `value` falls on a Monday–Friday business day in the given timezone.
  *
- * - Uses the fixed ISO Monday–Friday business-day boundary (Mon=1 … Fri=5),
- *   matching the definition used by `addZonedBusinessDays`/`subtractZonedBusinessDays`.
+ * - Uses a fixed Monday–Friday business week (ISO weekday numbers 1 … 5), matching
+ *   `addZonedBusinessDays`/`subtractZonedBusinessDays`. Saturday–Sunday is CLDR's
+ *   world-default weekend; ISO 8601 numbers the weekdays but defines no weekend.
  * - Locale-agnostic: no `Intl.Locale` lookup and no holiday calendar.
  * - Returns false if `value` is invalid.
  *
@@ -19,9 +20,9 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param value ISO 8601 zoned datetime string
  * @returns true if `value` is a Monday–Friday business day, false on invalid input
  *
- * @example isZonedBusinessDay("2024-02-05T10:00:00-05:00[America/New_York]") // true (Monday)
- * @example isZonedBusinessDay("2024-02-10T10:00:00-05:00[America/New_York]") // false (Saturday)
- * @example isZonedBusinessDay("2024-02-04T10:00:00-05:00[America/New_York]") // false (Sunday)
+ * @example isZonedBusinessDay("2024-02-05T10:00:00+05:30[Asia/Kolkata]") // true (Monday)
+ * @example isZonedBusinessDay("2024-02-10T10:00:00+05:30[Asia/Kolkata]") // false (Saturday)
+ * @example isZonedBusinessDay("2024-02-04T10:00:00+05:30[Asia/Kolkata]") // false (Sunday)
  * @example isZonedBusinessDay("invalid") // false
  */
 export function isZonedBusinessDay(value) {

package/dist/zoned/compare/isZonedFuture.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";
 /**

package/dist/zoned/compare/isZonedPast.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";
 /**

package/dist/zoned/compare/isZonedRelativeDay.d.ts

@@ -17,8 +17,8 @@
  * @param offsetDays integer number of days from today in `value`'s own timeZone
  * @returns true if `value`'s local day is exactly `offsetDays` days from today in its own timeZone, false on invalid input
  *
- * @example isZonedRelativeDay("2024-03-15T10:00:00-04:00[America/New_York]", 0) // true, if today is 2024-03-15 in America/New_York
- * @example isZonedRelativeDay("2024-03-14T10:00:00-04:00[America/New_York]", -1) // true, if today is 2024-03-15 in America/New_York
+ * @example isZonedRelativeDay("2024-03-15T10:00:00+09:00[Asia/Tokyo]", 0) // true, if today is 2024-03-15 in Asia/Tokyo
+ * @example isZonedRelativeDay("2024-03-14T10:00:00+09:00[Asia/Tokyo]", -1) // true, if today is 2024-03-15 in Asia/Tokyo
  * @example isZonedRelativeDay("2024-03-15T10:00:00+13:00[Pacific/Apia]", 0) // true, when the same instant is "yesterday" in Pacific/Niue
  * @example isZonedRelativeDay("invalid", 0) // false
  */

package/dist/zoned/compare/isZonedRelativeDay.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";
 /**
@@ -20,8 +20,8 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @param offsetDays integer number of days from today in `value`'s own timeZone
  * @returns true if `value`'s local day is exactly `offsetDays` days from today in its own timeZone, false on invalid input
  *
- * @example isZonedRelativeDay("2024-03-15T10:00:00-04:00[America/New_York]", 0) // true, if today is 2024-03-15 in America/New_York
- * @example isZonedRelativeDay("2024-03-14T10:00:00-04:00[America/New_York]", -1) // true, if today is 2024-03-15 in America/New_York
+ * @example isZonedRelativeDay("2024-03-15T10:00:00+09:00[Asia/Tokyo]", 0) // true, if today is 2024-03-15 in Asia/Tokyo
+ * @example isZonedRelativeDay("2024-03-14T10:00:00+09:00[Asia/Tokyo]", -1) // true, if today is 2024-03-15 in Asia/Tokyo
  * @example isZonedRelativeDay("2024-03-15T10:00:00+13:00[Pacific/Apia]", 0) // true, when the same instant is "yesterday" in Pacific/Niue
  * @example isZonedRelativeDay("invalid", 0) // false
  */

package/dist/zoned/compare/isZonedThisUnit.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 /**
  * Return true when `value`'s local calendar day falls in the same `unit` as
  * today, both resolved in `value`'s own IANA timeZone.
@@ -22,15 +22,15 @@ import { Temporal } from "@js-temporal/polyfill";
  *
  * @param value ISO ZonedDateTime string
  * @param unit date unit to compare by ("year" | "month" | "week" | "day", or its plural)
- * @param locale optional BCP 47 locale tag or preference list — sets the "week" start (e.g. "en-US", ["fr-FR", "en-US"])
+ * @param locale optional BCP 47 locale tag or preference list — sets the "week" start (e.g. "pt-BR", ["fr-FR", "en-US"])
  * @returns true if `value`'s local day falls in the same `unit` as today in its own timeZone, false on an unsupported unit or invalid input
  *
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "month") // true, if today is any day in March 2024 in America/New_York
+ * @example isZonedThisUnit("2024-03-15T10:00:00+11:00[Australia/Sydney]", "month") // true, if today is any day in March 2024 in Australia/Sydney
  * @example isZonedThisUnit("2024-02-26T10:00:00+01:00[Europe/Paris]", "week", "fr-FR") // true, if today is 2024-03-01 in Europe/Paris (same fr-FR Monday-start week)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "hour" as never) // false (unsupported unit)
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "hour" as never) // false (unsupported unit)
  * @example isZonedThisUnit("invalid", "month") // false
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "week", "not-a-locale-!!") // false (invalid locale)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "months") // true, if today is any day in March 2024 in America/New_York
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "week", "not-a-locale-!!") // false (invalid locale)
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
+ * @example isZonedThisUnit("2024-03-15T10:00:00+11:00[Australia/Sydney]", "months") // true, if today is any day in March 2024 in Australia/Sydney
  */
 export declare function isZonedThisUnit(value: string, unit: Temporal.SmallestUnit<Temporal.DateUnit>, locale?: string | string[]): boolean;

package/dist/zoned/compare/isZonedThisUnit.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { getLocaleStartOfWeek } from "../../plain/calculate/getLocaleStartOfWeek.js";
 import { areDatesEqualBy } from "../../plain/compare/areDatesEqualBy.js";
 import { isValidDateUnit } from "../../plain/validate/index.js";
@@ -29,16 +29,16 @@ import { resolveLocale } from "../../internal/resolveLocale.js";
  *
  * @param value ISO ZonedDateTime string
  * @param unit date unit to compare by ("year" | "month" | "week" | "day", or its plural)
- * @param locale optional BCP 47 locale tag or preference list — sets the "week" start (e.g. "en-US", ["fr-FR", "en-US"])
+ * @param locale optional BCP 47 locale tag or preference list — sets the "week" start (e.g. "pt-BR", ["fr-FR", "en-US"])
  * @returns true if `value`'s local day falls in the same `unit` as today in its own timeZone, false on an unsupported unit or invalid input
  *
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "month") // true, if today is any day in March 2024 in America/New_York
+ * @example isZonedThisUnit("2024-03-15T10:00:00+11:00[Australia/Sydney]", "month") // true, if today is any day in March 2024 in Australia/Sydney
  * @example isZonedThisUnit("2024-02-26T10:00:00+01:00[Europe/Paris]", "week", "fr-FR") // true, if today is 2024-03-01 in Europe/Paris (same fr-FR Monday-start week)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "hour" as never) // false (unsupported unit)
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "hour" as never) // false (unsupported unit)
  * @example isZonedThisUnit("invalid", "month") // false
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "week", "not-a-locale-!!") // false (invalid locale)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
- * @example isZonedThisUnit("2024-03-15T10:00:00-04:00[America/New_York]", "months") // true, if today is any day in March 2024 in America/New_York
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "week", "not-a-locale-!!") // false (invalid locale)
+ * @example isZonedThisUnit("2024-03-15T10:00:00-03:00[America/Sao_Paulo]", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
+ * @example isZonedThisUnit("2024-03-15T10:00:00+11:00[Australia/Sydney]", "months") // true, if today is any day in March 2024 in Australia/Sydney
  */
 export function isZonedThisUnit(value, unit, locale) {
     try {

package/dist/zoned/compare/isZonedWeekend.d.ts

@@ -2,7 +2,7 @@
  * Return true when `value`'s local calendar day falls on a weekend for `locale`.
  *
  * - Uses `Intl.Locale.prototype.weekInfo` to resolve which ISO weekday
- *   numbers count as "weekend" for the locale (e.g. en-US: Sat/Sun,
+ *   numbers count as "weekend" for the locale (e.g. en-GB: Sat/Sun,
  *   he-IL/ar-SA: Fri/Sat).
  * - Checks the ZonedDateTime's own local day of week — no separate timezone
  *   conversion needed, since `value` already carries its IANA timezone.
@@ -14,14 +14,14 @@
  *   default locale, as ECMA-402 `ResolveLocale` requires.
  *
  * @param value ISO ZonedDateTime string
- * @param locale BCP 47 locale tag (e.g. "en-US", "he-IL"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns false
+ * @param locale BCP 47 locale tag (e.g. "en-GB", "he-IL"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns false
  * @returns true if `value`'s local day is a weekend day in `locale`, false on invalid input
  *
- * @example isZonedWeekend("2024-02-03T10:00:00-05:00[America/New_York]", "en-US") // true (Saturday)
+ * @example isZonedWeekend("2024-02-03T10:00:00+00:00[Europe/London]", "en-GB") // true (Saturday)
  * @example isZonedWeekend("2024-02-02T10:00:00+02:00[Asia/Jerusalem]", "he-IL") // true (Friday, he-IL weekend is Fri/Sat)
  * @example isZonedWeekend("2024-02-04T10:00:00+02:00[Asia/Jerusalem]", "he-IL") // false (Sunday)
- * @example isZonedWeekend("invalid", "en-US") // false
- * @example isZonedWeekend("2024-02-03T10:00:00-05:00[America/New_York]", "not-a-locale-!!") // false
+ * @example isZonedWeekend("invalid", "ja-JP") // false
+ * @example isZonedWeekend("2024-02-03T10:00:00+09:00[Asia/Tokyo]", "not-a-locale-!!") // false
  * @example isZonedWeekend("2024-05-17T12:00:00+02:00[Europe/Berlin]", ["ar-EG", "fr-FR"]) // true
  */
 export declare function isZonedWeekend(value: string, locale: string | string[]): boolean;

package/dist/zoned/compare/isZonedWeekend.js

@@ -4,7 +4,7 @@ import { isValidZonedDateTime } from "../validate/index.js";
  * Return true when `value`'s local calendar day falls on a weekend for `locale`.
  *
  * - Uses `Intl.Locale.prototype.weekInfo` to resolve which ISO weekday
- *   numbers count as "weekend" for the locale (e.g. en-US: Sat/Sun,
+ *   numbers count as "weekend" for the locale (e.g. en-GB: Sat/Sun,
  *   he-IL/ar-SA: Fri/Sat).
  * - Checks the ZonedDateTime's own local day of week — no separate timezone
  *   conversion needed, since `value` already carries its IANA timezone.
@@ -16,14 +16,14 @@ import { isValidZonedDateTime } from "../validate/index.js";
  *   default locale, as ECMA-402 `ResolveLocale` requires.
  *
  * @param value ISO ZonedDateTime string
- * @param locale BCP 47 locale tag (e.g. "en-US", "he-IL"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns false
+ * @param locale BCP 47 locale tag (e.g. "en-GB", "he-IL"), or a preference list of tags (ECMA-402; the first with locale data is read). Required: omitted, or an empty list (which ECMA-402 would resolve to the host default), returns false
  * @returns true if `value`'s local day is a weekend day in `locale`, false on invalid input
  *
- * @example isZonedWeekend("2024-02-03T10:00:00-05:00[America/New_York]", "en-US") // true (Saturday)
+ * @example isZonedWeekend("2024-02-03T10:00:00+00:00[Europe/London]", "en-GB") // true (Saturday)
  * @example isZonedWeekend("2024-02-02T10:00:00+02:00[Asia/Jerusalem]", "he-IL") // true (Friday, he-IL weekend is Fri/Sat)
  * @example isZonedWeekend("2024-02-04T10:00:00+02:00[Asia/Jerusalem]", "he-IL") // false (Sunday)
- * @example isZonedWeekend("invalid", "en-US") // false
- * @example isZonedWeekend("2024-02-03T10:00:00-05:00[America/New_York]", "not-a-locale-!!") // false
+ * @example isZonedWeekend("invalid", "ja-JP") // false
+ * @example isZonedWeekend("2024-02-03T10:00:00+09:00[Asia/Tokyo]", "not-a-locale-!!") // false
  * @example isZonedWeekend("2024-05-17T12:00:00+02:00[Europe/Berlin]", ["ar-EG", "fr-FR"]) // true
  */
 export function isZonedWeekend(value, locale) {

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

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