@northguild/gmt 1.14.2

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

@@ -0,0 +1,18 @@
+/**
+ * Return a zoned ISO 8601 datetime string with `amount` business days subtracted from `value`.
+ *
+ * - Uses fixed ISO Monday–Friday business days (no locale awareness).
+ * - Saturday and Sunday are skipped during the count.
+ * - Preserves the original time component through the operation.
+ * - Returns "" on invalid input.
+ *
+ * @param value ISO 8601 zoned datetime string
+ * @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("invalid", 1) // ""
+ */
+export declare function subtractZonedBusinessDays(value: string, amount: number): string;

package/dist/zoned/calculate/subtractZonedBusinessDays.js

@@ -0,0 +1,28 @@
+import { adjustZonedBusinessDays, isValidAmount } from "../../internal/index.js";
+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).
+ * - Saturday and Sunday are skipped during the count.
+ * - Preserves the original time component through the operation.
+ * - Returns "" on invalid input.
+ *
+ * @param value ISO 8601 zoned datetime string
+ * @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("invalid", 1) // ""
+ */
+export function subtractZonedBusinessDays(value, amount) {
+    if (!isValidZonedDateTime(value) || !isValidAmount(amount)) {
+        return "";
+    }
+    if (amount === 0) {
+        return value;
+    }
+    return adjustZonedBusinessDays(value, -1, Math.abs(amount));
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Extracts the local time portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts time components (hour, minute, second, subsecond) from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export declare function chopZonedDate(value: string): string;

package/dist/zoned/chop/chopZonedDate.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Extracts the local time portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts time components (hour, minute, second, subsecond) from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export function chopZonedDate(value) {
+    if (!isValidZonedDateTime(value))
+        return "";
+    try {
+        return Temporal.ZonedDateTime.from(value).toPlainTime().toString();
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Extracts the IANA timeZone identifier from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts timezone id from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO 8601 zoned datetime string
+ * @returns IANA timeZone id (e.g. Europe/Paris) or "" for invalid
+ *
+ * @example chopZonedDateTime("2024-02-29T12:30:45+01:00[Europe/Paris]") // "Europe/Paris"
+ * @example chopZonedDateTime("invalid") // ""
+ */
+export declare function chopZonedDateTime(value: string): string;

package/dist/zoned/chop/chopZonedDateTime.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Extracts the IANA timeZone identifier from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts timezone id from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO 8601 zoned datetime string
+ * @returns IANA timeZone id (e.g. Europe/Paris) or "" for invalid
+ *
+ * @example chopZonedDateTime("2024-02-29T12:30:45+01:00[Europe/Paris]") // "Europe/Paris"
+ * @example chopZonedDateTime("invalid") // ""
+ */
+export function chopZonedDateTime(value) {
+    const validZonedDateTime = isValidZonedDateTime(value);
+    if (!validZonedDateTime)
+        return "";
+    try {
+        const zonedDateTime = Temporal.ZonedDateTime.from(value);
+        return zonedDateTime.timeZoneId;
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Returns the zoned datetime string rounded/truncated to second precision.
+ *
+ * - Removes millisecond precision.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export declare function chopZonedMilliseconds(value: string): string;

package/dist/zoned/chop/chopZonedMilliseconds.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Returns the zoned datetime string rounded/truncated to second precision.
+ *
+ * - Removes millisecond precision.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export function chopZonedMilliseconds(value) {
+    if (!isValidZonedDateTime(value))
+        return "";
+    try {
+        return Temporal.ZonedDateTime.from(value).toString({
+            smallestUnit: "second",
+        });
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Returns the zoned datetime string truncated to minute precision.
+ *
+ * - Removes seconds and milliseconds.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export declare function chopZonedSeconds(value: string): string;

package/dist/zoned/chop/chopZonedSeconds.js

@@ -0,0 +1,26 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Returns the zoned datetime string truncated to minute precision.
+ *
+ * - Removes seconds and milliseconds.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export function chopZonedSeconds(value) {
+    if (!isValidZonedDateTime(value))
+        return "";
+    try {
+        return Temporal.ZonedDateTime.from(value).toString({
+            smallestUnit: "minute",
+        });
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Extracts the local date portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts date components (year, month, day) from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export declare function chopZonedTime(value: string): string;

package/dist/zoned/chop/chopZonedTime.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Extracts the local date portion from an ISO 8601 zoned datetime string.
+ *
+ * - Extracts date components (year, month, day) from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export function chopZonedTime(value) {
+    if (!isValidZonedDateTime(value))
+        return "";
+    try {
+        return Temporal.ZonedDateTime.from(value).toPlainDate().toString();
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Returns the local plain datetime (date + time) extracted from a zoned datetime string.
+ *
+ * - Extracts both date and time components from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export declare function chopZonedTimezone(value: string): string;

package/dist/zoned/chop/chopZonedTimezone.js

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/isValidZonedDateTime.js";
+/**
+ * Returns the local plain datetime (date + time) extracted from a zoned datetime string.
+ *
+ * - Extracts both date and time components from a ZonedDateTime.
+ * - Returns "" for invalid input.
+ *
+ * @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("invalid") // ""
+ */
+export function chopZonedTimezone(value) {
+    if (!isValidZonedDateTime(value))
+        return "";
+    try {
+        return Temporal.ZonedDateTime.from(value).toPlainDateTime().toString();
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from "./chopZonedDate.js";
+export * from "./chopZonedDateTime.js";
+export * from "./chopZonedMilliseconds.js";
+export * from "./chopZonedSeconds.js";
+export * from "./chopZonedTime.js";
+export * from "./chopZonedTimezone.js";

package/dist/zoned/chop/index.js

@@ -0,0 +1,6 @@
+export * from "./chopZonedDate.js";
+export * from "./chopZonedDateTime.js";
+export * from "./chopZonedMilliseconds.js";
+export * from "./chopZonedSeconds.js";
+export * from "./chopZonedTime.js";
+export * from "./chopZonedTimezone.js";

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

@@ -0,0 +1,15 @@
+/**
+ * Compare two zoned datetime strings for exact local-field equality.
+ *
+ * - Inputs must be valid ISO 8601 zoned datetime strings.
+ * - Returns `true` when year/month/day/hour/minute/second/millisecond/microsecond/nanosecond and IANA timeZone id all match; otherwise `false`.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns boolean indicating whether the two zoned datetimes are equal
+ *
+ * @example areZonedEqual("2024-02-29T12:34:56.789+00:00[UTC]", "2024-02-29T12:34:56.789+00:00[UTC]") // true
+ * @example areZonedEqual("invalid", "2024-02-29T12:34:56.789+00:00[UTC]") // false
+ */
+export declare function areZonedEqual(value1: string, value2: string): boolean;

package/dist/zoned/compare/areZonedEqual.js

@@ -0,0 +1,45 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Compare two zoned datetime strings for exact local-field equality.
+ *
+ * - Inputs must be valid ISO 8601 zoned datetime strings.
+ * - Returns `true` when year/month/day/hour/minute/second/millisecond/microsecond/nanosecond and IANA timeZone id all match; otherwise `false`.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns boolean indicating whether the two zoned datetimes are equal
+ *
+ * @example areZonedEqual("2024-02-29T12:34:56.789+00:00[UTC]", "2024-02-29T12:34:56.789+00:00[UTC]") // true
+ * @example areZonedEqual("invalid", "2024-02-29T12:34:56.789+00:00[UTC]") // false
+ */
+export function areZonedEqual(value1, value2) {
+    if (!isValidZonedDateTime(value1) || !isValidZonedDateTime(value2)) {
+        return false;
+    }
+    let zonedDateTime1;
+    let zonedDateTime2;
+    try {
+        zonedDateTime1 = Temporal.ZonedDateTime.from(value1);
+        zonedDateTime2 = Temporal.ZonedDateTime.from(value2);
+    }
+    catch {
+        return false;
+    }
+    try {
+        return (zonedDateTime1.year === zonedDateTime2.year &&
+            zonedDateTime1.month === zonedDateTime2.month &&
+            zonedDateTime1.day === zonedDateTime2.day &&
+            zonedDateTime1.hour === zonedDateTime2.hour &&
+            zonedDateTime1.minute === zonedDateTime2.minute &&
+            zonedDateTime1.second === zonedDateTime2.second &&
+            zonedDateTime1.millisecond === zonedDateTime2.millisecond &&
+            zonedDateTime1.microsecond === zonedDateTime2.microsecond &&
+            zonedDateTime1.nanosecond === zonedDateTime2.nanosecond &&
+            zonedDateTime1.timeZoneId === zonedDateTime2.timeZoneId);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { DateTimeUnit } from "../../types/index.js";
+/**
+ * Compare two zoned ISO datetime strings for equality at a given unit.
+ *
+ * - Equality is measured on each value's own local wall-clock fields (its own
+ *   time zone), not on the underlying instant or time zone identifier — the
+ *   same instant can be "the same day" in one zone and a different day in
+ *   another, and this function answers per each value's own zone, the way
+ *   Luxon's `dt.hasSame(other, unit)` does for zoned `DateTime`s.
+ * - `"month"` requires the same month AND year, matching `areDateTimesEqualBy`.
+ * - Returns false for an unsupported unit or invalid input.
+ *
+ * Mapping from date-fns (Decision 5, `context/roadmap/issues/J.md`):
+ * - `isSameDay(a, b)` → `areZonedEqualBy(a, b, "day")`
+ * - `isSameMonth(a, b)` → `areZonedEqualBy(a, b, "month")`
+ * - `isSameYear(a, b)` → `areZonedEqualBy(a, b, "year")`
+ *
+ * @param value1 first zoned ISO datetime string
+ * @param value2 second zoned ISO datetime string
+ * @param unit Temporal.DateUnit | Temporal.TimeUnit to compare by
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday")
+ * @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-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("invalid", "2024-03-15T10:00:00-04:00[America/New_York]", "day") // false
+ */
+export declare function areZonedEqualBy(value1: string, value2: string, unit: DateTimeUnit, optionsArg?: {
+    weekStartsOn?: "monday" | "sunday";
+}): boolean;

package/dist/zoned/compare/areZonedEqualBy.js

@@ -0,0 +1,49 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTimeUnit } from "../../plain/validate/index.js";
+import { startOfZoned } from "../calculate/startOfZoned.js";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Compare two zoned ISO datetime strings for equality at a given unit.
+ *
+ * - Equality is measured on each value's own local wall-clock fields (its own
+ *   time zone), not on the underlying instant or time zone identifier — the
+ *   same instant can be "the same day" in one zone and a different day in
+ *   another, and this function answers per each value's own zone, the way
+ *   Luxon's `dt.hasSame(other, unit)` does for zoned `DateTime`s.
+ * - `"month"` requires the same month AND year, matching `areDateTimesEqualBy`.
+ * - Returns false for an unsupported unit or invalid input.
+ *
+ * Mapping from date-fns (Decision 5, `context/roadmap/issues/J.md`):
+ * - `isSameDay(a, b)` → `areZonedEqualBy(a, b, "day")`
+ * - `isSameMonth(a, b)` → `areZonedEqualBy(a, b, "month")`
+ * - `isSameYear(a, b)` → `areZonedEqualBy(a, b, "year")`
+ *
+ * @param value1 first zoned ISO datetime string
+ * @param value2 second zoned ISO datetime string
+ * @param unit Temporal.DateUnit | Temporal.TimeUnit to compare by
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday")
+ * @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-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("invalid", "2024-03-15T10:00:00-04:00[America/New_York]", "day") // false
+ */
+export function areZonedEqualBy(value1, value2, unit, optionsArg) {
+    if (!isValidZonedDateTime(value1) ||
+        !isValidZonedDateTime(value2) ||
+        !isValidDateTimeUnit(unit)) {
+        return false;
+    }
+    try {
+        const start1 = startOfZoned(value1, unit, optionsArg);
+        const start2 = startOfZoned(value2, unit, optionsArg);
+        if (start1 === "" || start2 === "")
+            return false;
+        const local1 = Temporal.ZonedDateTime.from(start1).toPlainDateTime();
+        const local2 = Temporal.ZonedDateTime.from(start2).toPlainDateTime();
+        return Temporal.PlainDateTime.compare(local1, local2) === 0;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,12 @@
+export * from "./areZonedEqual.js";
+export * from "./areZonedEqualBy.js";
+export * from "./isAfterZoned.js";
+export * from "./isBeforeZoned.js";
+export * from "./isBetweenZoned.js";
+export * from "./isInDaylightSaving.js";
+export * from "./isZonedBusinessDay.js";
+export * from "./isZonedFuture.js";
+export * from "./isZonedPast.js";
+export * from "./isZonedRelativeDay.js";
+export * from "./isZonedThisUnit.js";
+export * from "./isZonedWeekend.js";

package/dist/zoned/compare/index.js

@@ -0,0 +1,12 @@
+export * from "./areZonedEqual.js";
+export * from "./areZonedEqualBy.js";
+export * from "./isAfterZoned.js";
+export * from "./isBeforeZoned.js";
+export * from "./isBetweenZoned.js";
+export * from "./isInDaylightSaving.js";
+export * from "./isZonedBusinessDay.js";
+export * from "./isZonedFuture.js";
+export * from "./isZonedPast.js";
+export * from "./isZonedRelativeDay.js";
+export * from "./isZonedThisUnit.js";
+export * from "./isZonedWeekend.js";

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

@@ -0,0 +1,15 @@
+/**
+ * Return whether `value1` represents an instant strictly after `value2`.
+ *
+ * - Both inputs must be valid zoned ISO 8601 datetime strings.
+ * - Comparison is performed using Temporal.Instant (same instant semantics), so differing timeZone representations but the same instant will compare as equal.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns `true` if `value1` is after `value2`, otherwise `false`
+ *
+ * @example isAfterZoned("2024-02-29T12:34:56.789+00:00[UTC]", "2024-02-29T12:34:56.788+00:00[UTC]") // true
+ * @example isAfterZoned("invalid", "2024-02-29T12:34:56.789+00:00[UTC]") // false
+ */
+export declare function isAfterZoned(value1: string, value2: string): boolean;

package/dist/zoned/compare/isAfterZoned.js

@@ -0,0 +1,36 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return whether `value1` represents an instant strictly after `value2`.
+ *
+ * - Both inputs must be valid zoned ISO 8601 datetime strings.
+ * - Comparison is performed using Temporal.Instant (same instant semantics), so differing timeZone representations but the same instant will compare as equal.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns `true` if `value1` is after `value2`, otherwise `false`
+ *
+ * @example isAfterZoned("2024-02-29T12:34:56.789+00:00[UTC]", "2024-02-29T12:34:56.788+00:00[UTC]") // true
+ * @example isAfterZoned("invalid", "2024-02-29T12:34:56.789+00:00[UTC]") // false
+ */
+export function isAfterZoned(value1, value2) {
+    if (!isValidZonedDateTime(value1) || !isValidZonedDateTime(value2)) {
+        return false;
+    }
+    let zonedDateTime1;
+    let zonedDateTime2;
+    try {
+        zonedDateTime1 = Temporal.ZonedDateTime.from(value1);
+        zonedDateTime2 = Temporal.ZonedDateTime.from(value2);
+    }
+    catch {
+        return false;
+    }
+    try {
+        return (Temporal.Instant.compare(zonedDateTime1.toInstant(), zonedDateTime2.toInstant()) === 1);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Return whether `value1` represents an instant strictly before `value2`.
+ *
+ * - Both inputs must be valid zoned ISO 8601 datetime strings.
+ * - Comparison is performed using Temporal.Instant (same instant semantics), so differing timeZone representations but the same instant will compare as equal.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns `true` if `value1` is before `value2`, otherwise `false`
+ *
+ * @example isBeforeZoned("2024-03-17T14:30:45-05:00[America/New_York]", "2024-03-17T15:30:45-05:00[America/New_York]") // true
+ * @example isBeforeZoned("invalid", "2024-03-17T14:30:45-05:00[America/New_York]") // false
+ */
+export declare function isBeforeZoned(value1: string, value2: string): boolean;

package/dist/zoned/compare/isBeforeZoned.js

@@ -0,0 +1,36 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidZonedDateTime } from "../validate/index.js";
+/**
+ * Return whether `value1` represents an instant strictly before `value2`.
+ *
+ * - Both inputs must be valid zoned ISO 8601 datetime strings.
+ * - Comparison is performed using Temporal.Instant (same instant semantics), so differing timeZone representations but the same instant will compare as equal.
+ * - Invalid inputs return `false`.
+ *
+ * @param value1 first zoned datetime string
+ * @param value2 second zoned datetime string
+ * @returns `true` if `value1` is before `value2`, otherwise `false`
+ *
+ * @example isBeforeZoned("2024-03-17T14:30:45-05:00[America/New_York]", "2024-03-17T15:30:45-05:00[America/New_York]") // true
+ * @example isBeforeZoned("invalid", "2024-03-17T14:30:45-05:00[America/New_York]") // false
+ */
+export function isBeforeZoned(value1, value2) {
+    if (!isValidZonedDateTime(value1) || !isValidZonedDateTime(value2)) {
+        return false;
+    }
+    let zonedDateTime1;
+    let zonedDateTime2;
+    try {
+        zonedDateTime1 = Temporal.ZonedDateTime.from(value1);
+        zonedDateTime2 = Temporal.ZonedDateTime.from(value2);
+    }
+    catch {
+        return false;
+    }
+    try {
+        return (Temporal.Instant.compare(zonedDateTime1.toInstant(), zonedDateTime2.toInstant()) === -1);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Return true when `zoned` is between `start` and `end` (inclusive by default).
+ *
+ * - Validates inputs and then compares using Temporal.Instant (same instant semantics).
+ * - Returns false for invalid inputs.
+ *
+ * @param zoned ISO ZonedDateTime string to check
+ * @param start ISO ZonedDateTime string for the start of the range
+ * @param end ISO ZonedDateTime string for the end of the range
+ * @param options optional: inclusiveStart (boolean), inclusiveEnd (boolean)
+ * @returns boolean indicating whether zoned is between start and end
+ *
+ * @example isBetweenZoned("2024-02-29T12:00:00+00:00[UTC]", "2024-02-29T11:00:00+00:00[UTC]", "2024-02-29T13:00:00+00:00[UTC]") // true
+ * @example isBetweenZoned("invalid", "2024-02-29T11:00:00+00:00[UTC]", "2024-02-29T13:00:00+00:00[UTC]") // false
+ */
+export declare function isBetweenZoned(zoned: string, start: string, end: string, options?: {
+    inclusiveStart?: boolean;
+    inclusiveEnd?: boolean;
+}): boolean;