@northguild/gmt 1.19.0 → 1.20.0

package/dist/plain/chop/chopDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../validate/index.js";
 /**
  * Return the PlainTime portion extracted from an ISO PlainDateTime string.

package/dist/plain/chop/chopMilliseconds.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime, isValidTime } from "../validate/index.js";
 /**
  * Return a string with millisecond precision removed from a PlainDateTime or PlainTime value.

package/dist/plain/chop/chopSeconds.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime, isValidTime } from "../validate/index.js";
 /**
  * Return an ISO string with second precision removed from a PlainDateTime or PlainTime value.

package/dist/plain/chop/chopTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../validate/index.js";
 /**
  * Return the PlainDate portion extracted from an ISO PlainDateTime string.

package/dist/plain/compare/areDateTimesEqual.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../validate/index.js";
 /**
  * Return true if two PlainDateTime ISO strings represent the same instant of local date/time components.

package/dist/plain/compare/areDateTimesEqualBy.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 /**
  * Compare two ISO datetime strings for equality at a given unit.
  *
@@ -6,8 +6,6 @@ import { Temporal } from "@js-temporal/polyfill";
  *   `"month"` requires the same month AND year — March 2023 and March 2024 are
  *   NOT equal by month. A calendar month is a year and a month together, as in
  *   Temporal's `PlainYearMonth`, not a bare month-of-year number.
- * - Comparison: date-fns's `isSameMonth` and Luxon's `dt.hasSame(other, "month")`
- *   give the same answer.
  * - Supports the full `Temporal.DateUnit | Temporal.TimeUnit` range, down to
  *   `"nanosecond"`.
  * - `unit` accepts the singular or plural name (`"day"` or `"days"`), as Temporal does.
@@ -16,7 +14,7 @@ import { Temporal } from "@js-temporal/polyfill";
  *   digits cannot change which bucket a value is in. That ignored option was removed in 1.16.0; to
  *   compare more coarsely, pass a coarser unit (0 digits is `"second"`, 3 is `"millisecond"`).
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isSameDay(a, b)` → `areDateTimesEqualBy(a, b, "day")`
  * - `isSameHour(a, b)` → `areDateTimesEqualBy(a, b, "hour")`
  * - `isSameMinute(a, b)` → `areDateTimesEqualBy(a, b, "minute")`

package/dist/plain/compare/areDateTimesEqualBy.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
 import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { startOfDateTime } from "../calculate/startOfDateTime.js";
@@ -11,8 +11,6 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  *   `"month"` requires the same month AND year — March 2023 and March 2024 are
  *   NOT equal by month. A calendar month is a year and a month together, as in
  *   Temporal's `PlainYearMonth`, not a bare month-of-year number.
- * - Comparison: date-fns's `isSameMonth` and Luxon's `dt.hasSame(other, "month")`
- *   give the same answer.
  * - Supports the full `Temporal.DateUnit | Temporal.TimeUnit` range, down to
  *   `"nanosecond"`.
  * - `unit` accepts the singular or plural name (`"day"` or `"days"`), as Temporal does.
@@ -21,7 +19,7 @@ import { isOptionsArgument } from "../../internal/isObject.js";
  *   digits cannot change which bucket a value is in. That ignored option was removed in 1.16.0; to
  *   compare more coarsely, pass a coarser unit (0 digits is `"second"`, 3 is `"millisecond"`).
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isSameDay(a, b)` → `areDateTimesEqualBy(a, b, "day")`
  * - `isSameHour(a, b)` → `areDateTimesEqualBy(a, b, "hour")`
  * - `isSameMinute(a, b)` → `areDateTimesEqualBy(a, b, "minute")`

package/dist/plain/compare/areDatesEqual.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidIsoDateLike } from "../validate/index.js";
 /**
  * Compare two ISO date-like strings for equality, ignoring time components.

package/dist/plain/compare/areDatesEqualBy.d.ts

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 /**
  * Compare two ISO date strings for equality at a given calendar unit.
  *
@@ -8,8 +8,6 @@ import { Temporal } from "@js-temporal/polyfill";
  *   Temporal's `PlainYearMonth`, not a bare month-of-year number. This is a
  *   common point of confusion for callers expecting a bare "same month-of-year"
  *   comparison.
- * - Comparison: date-fns's `isSameMonth` and Luxon's `dt.hasSame(other, "month")`
- *   give the same answer.
  * - `"day"` matches `areDatesEqual` for PlainDate inputs only: `areDatesEqual` also accepts
  *   PlainDateTime strings (`areDatesEqual("2024-01-01", "2024-01-01T10:00")` is `true`), while this
  *   function accepts PlainDate strings only (`areDatesEqualBy` with those inputs and `"day"` is
@@ -18,9 +16,11 @@ import { Temporal } from "@js-temporal/polyfill";
  * - `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)` → `areDatesEqualBy(a, b, "day")`
- * - `isSameWeek(a, b, options)` → `areDatesEqualBy(a, b, "week", { weekStartsOn })`
+ * - `isSameWeek(a, b)` → `areDatesEqualBy(a, b, "week", { weekStartsOn: "sunday" })`: date-fns
+ *   starts the week on Sunday (`weekStartsOn: 0`) by default, GMT on Monday
+ * - `isSameWeek(a, b, { weekStartsOn: 1 })` → `areDatesEqualBy(a, b, "week")`
  * - `isSameMonth(a, b)` → `areDatesEqualBy(a, b, "month")`
  * - `isSameYear(a, b)` → `areDatesEqualBy(a, b, "year")`
  *

package/dist/plain/compare/areDatesEqualBy.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
 import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { startOfDate } from "../calculate/startOfDate.js";
@@ -15,8 +15,6 @@ const supported = ["year", "month", "week", "day"];
  *   Temporal's `PlainYearMonth`, not a bare month-of-year number. This is a
  *   common point of confusion for callers expecting a bare "same month-of-year"
  *   comparison.
- * - Comparison: date-fns's `isSameMonth` and Luxon's `dt.hasSame(other, "month")`
- *   give the same answer.
  * - `"day"` matches `areDatesEqual` for PlainDate inputs only: `areDatesEqual` also accepts
  *   PlainDateTime strings (`areDatesEqual("2024-01-01", "2024-01-01T10:00")` is `true`), while this
  *   function accepts PlainDate strings only (`areDatesEqualBy` with those inputs and `"day"` is
@@ -25,9 +23,11 @@ const supported = ["year", "month", "week", "day"];
  * - `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)` → `areDatesEqualBy(a, b, "day")`
- * - `isSameWeek(a, b, options)` → `areDatesEqualBy(a, b, "week", { weekStartsOn })`
+ * - `isSameWeek(a, b)` → `areDatesEqualBy(a, b, "week", { weekStartsOn: "sunday" })`: date-fns
+ *   starts the week on Sunday (`weekStartsOn: 0`) by default, GMT on Monday
+ * - `isSameWeek(a, b, { weekStartsOn: 1 })` → `areDatesEqualBy(a, b, "week")`
  * - `isSameMonth(a, b)` → `areDatesEqualBy(a, b, "month")`
  * - `isSameYear(a, b)` → `areDatesEqualBy(a, b, "year")`
  *

package/dist/plain/compare/areTimesEqual.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidTime } from "../validate/index.js";
 /**
  * Return true if two PlainTime ISO strings represent the same time components.

package/dist/plain/compare/isAfterDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDate } from "../validate/index.js";
 /**
  * Return true if the first ISO PlainDate string represents a date after the second.

package/dist/plain/compare/isAfterDateTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../validate/index.js";
 /**
  * Return true when `value1` is strictly after `value2` for PlainDateTime values.

package/dist/plain/compare/isAfterTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidTime } from "../validate/index.js";
 /**
  * Return true when `value1` is strictly after `value2` for PlainTime values.

package/dist/plain/compare/isBeforeDate.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDate } from "../validate/index.js";
 /**
  * Return true when `value1` is strictly before `value2` for PlainDate values.

package/dist/plain/compare/isBeforeDateTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidDateTime } from "../validate/index.js";
 /**
  * Return true when `value1` is strictly before `value2` for PlainDateTime values.

package/dist/plain/compare/isBeforeTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isValidTime } from "../validate/index.js";
 /**
  * Return true when `value1` is strictly before `value2` for PlainTime values.

package/dist/plain/compare/isBetweenDate.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 { isValidDate } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
 import { optionOrDefault } from "../../internal/optionOrDefault.js";

package/dist/plain/compare/isBetweenDateTime.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 { isValidDateTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
 import { optionOrDefault } from "../../internal/optionOrDefault.js";

package/dist/plain/compare/isBetweenTime.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 { isValidTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
 import { optionOrDefault } from "../../internal/optionOrDefault.js";

package/dist/plain/compare/isBusinessDay.d.ts

@@ -25,8 +25,8 @@ import type { BusinessCalendar } from "../../types/index.js";
  *
  * @example isBusinessDay("2024-02-05") // true (Monday)
  * @example isBusinessDay("2024-02-10") // false (Saturday)
- * @example isBusinessDay("2024-07-04", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // false (holiday)
- * @example isBusinessDay("2024-07-05", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // true
+ * @example isBusinessDay("2024-07-04", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // false (holiday)
+ * @example isBusinessDay("2024-07-05", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // true
  * @example isBusinessDay("2024-07-07", { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // true (Sunday is a working day there)
  * @example isBusinessDay("2024-07-05", { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // false (Friday is weekend there)
  * @example isBusinessDay("invalid") // false

package/dist/plain/compare/isBusinessDay.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { isBusinessDate, resolveBusinessCalendar, } from "../../internal/businessCalendar.js";
 import { isValidDate } from "../validate/index.js";
 /**
@@ -27,8 +27,8 @@ import { isValidDate } from "../validate/index.js";
  *
  * @example isBusinessDay("2024-02-05") // true (Monday)
  * @example isBusinessDay("2024-02-10") // false (Saturday)
- * @example isBusinessDay("2024-07-04", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // false (holiday)
- * @example isBusinessDay("2024-07-05", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "America/New_York" }) // true
+ * @example isBusinessDay("2024-07-04", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // false (holiday)
+ * @example isBusinessDay("2024-07-05", { weekend: [6, 7], holidays: ["2024-07-04"], timeZone: "Africa/Kigali" }) // true
  * @example isBusinessDay("2024-07-07", { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // true (Sunday is a working day there)
  * @example isBusinessDay("2024-07-05", { weekend: [5, 6], holidays: [], timeZone: "Asia/Riyadh" }) // false (Friday is weekend there)
  * @example isBusinessDay("invalid") // false

package/dist/plain/compare/isRelativeDay.d.ts

@@ -14,7 +14,7 @@
  * - `offsetDays` must be an integer; non-integer or non-finite values return false.
  * - Returns false if `value` is invalid or the system timeZone is unavailable.
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isToday(value)` → `isRelativeDay(value, 0)`
  * - `isYesterday(value)` → `isRelativeDay(value, -1)`
  * - `isTomorrow(value)` → `isRelativeDay(value, 1)`

package/dist/plain/compare/isRelativeDay.js

@@ -18,7 +18,7 @@ import { areDatesEqual } from "./areDatesEqual.js";
  * - `offsetDays` must be an integer; non-integer or non-finite values return false.
  * - Returns false if `value` is invalid or the system timeZone is unavailable.
  *
- * Mapping from date-fns:
+ * Migrating from date-fns:
  * - `isToday(value)` → `isRelativeDay(value, 0)`
  * - `isYesterday(value)` → `isRelativeDay(value, -1)`
  * - `isTomorrow(value)` → `isRelativeDay(value, 1)`

package/dist/plain/compare/isThisUnit.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "../../internal/temporal.js";
 /**
  * Return true when `value` falls in the same `unit` as today, per the
  * system clock and system timeZone.
@@ -7,7 +7,7 @@ import type { Temporal } from "@js-temporal/polyfill";
  *   the same `Temporal.DateUnit` `areDatesEqualBy` uses.
  * - `"day"` is equivalent to `isRelativeDay(value, 0)`.
  * - `locale` only affects the `"week"` case — which day the week starts on
- *   varies by locale (e.g. en-US: Sunday, fr-FR: Monday). When `unit` is
+ *   varies by locale (e.g. fr-FR: Monday, pt-BR: Sunday). When `unit` is
  *   `"week"` and `locale` is given, the comparison uses `getLocaleStartOfWeek`
  *   instead of the ISO Monday-start default `areDatesEqualBy` otherwise uses.
  * - Compares against `getToday()`, so this depends on the **system clock and
@@ -21,14 +21,16 @@ import type { Temporal } from "@js-temporal/polyfill";
  *   unit, so an invalid locale returns false for `"day"`, `"month"` and `"year"` too.
  * - **Compatibility:** before 1.16.0 an invalid locale was ignored for every unit but `"week"`.
  *
- * Mapping from date-fns:
- * - `isThisWeek(value, options)` → `isThisUnit(value, "week", locale)`
+ * Migrating from date-fns:
+ * - `isThisWeek(value)` → `isThisUnit(value, "week", "pt-BR")`, or any locale whose week starts on
+ *   Sunday: date-fns starts the week on Sunday (`weekStartsOn: 0`) by default, GMT on Monday
+ * - `isThisWeek(value, { weekStartsOn: 1 })` → `isThisUnit(value, "week")`
  * - `isThisMonth(value)` → `isThisUnit(value, "month")`
  * - `isThisYear(value)` → `isThisUnit(value, "year")`
  *
  * @param value ISO PlainDate 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. "fr-FR", ["pt-BR", "fr-FR"])
  * @returns true if `value` falls in the same `unit` as today, false on an unsupported unit or invalid input
  *
  * @example isThisUnit("2024-03-15", "month") // true, if today is any day in March 2024
@@ -39,6 +41,6 @@ import type { Temporal } from "@js-temporal/polyfill";
  * @example isThisUnit("2024-03-15", "week", "not-a-locale-!!") // false (invalid locale)
  * @example isThisUnit("2024-03-15", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
  * @example isThisUnit("2024-03-15", "months") // true, if today is any day in March 2024
- * @example isThisUnit("2024-02-25", "week", ["en-US", "fr-FR"]) // true, if today is 2024-02-29 (en-US Sunday-start week)
+ * @example isThisUnit("2024-02-25", "week", ["pt-BR", "fr-FR"]) // true, if today is 2024-02-29 (pt-BR Sunday-start week)
  */
 export declare function isThisUnit(value: string, unit: Temporal.SmallestUnit<Temporal.DateUnit>, locale?: string | string[]): boolean;

package/dist/plain/compare/isThisUnit.js

@@ -12,7 +12,7 @@ import { areDatesEqualBy } from "./areDatesEqualBy.js";
  *   the same `Temporal.DateUnit` `areDatesEqualBy` uses.
  * - `"day"` is equivalent to `isRelativeDay(value, 0)`.
  * - `locale` only affects the `"week"` case — which day the week starts on
- *   varies by locale (e.g. en-US: Sunday, fr-FR: Monday). When `unit` is
+ *   varies by locale (e.g. fr-FR: Monday, pt-BR: Sunday). When `unit` is
  *   `"week"` and `locale` is given, the comparison uses `getLocaleStartOfWeek`
  *   instead of the ISO Monday-start default `areDatesEqualBy` otherwise uses.
  * - Compares against `getToday()`, so this depends on the **system clock and
@@ -26,14 +26,16 @@ import { areDatesEqualBy } from "./areDatesEqualBy.js";
  *   unit, so an invalid locale returns false for `"day"`, `"month"` and `"year"` too.
  * - **Compatibility:** before 1.16.0 an invalid locale was ignored for every unit but `"week"`.
  *
- * Mapping from date-fns:
- * - `isThisWeek(value, options)` → `isThisUnit(value, "week", locale)`
+ * Migrating from date-fns:
+ * - `isThisWeek(value)` → `isThisUnit(value, "week", "pt-BR")`, or any locale whose week starts on
+ *   Sunday: date-fns starts the week on Sunday (`weekStartsOn: 0`) by default, GMT on Monday
+ * - `isThisWeek(value, { weekStartsOn: 1 })` → `isThisUnit(value, "week")`
  * - `isThisMonth(value)` → `isThisUnit(value, "month")`
  * - `isThisYear(value)` → `isThisUnit(value, "year")`
  *
  * @param value ISO PlainDate 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. "fr-FR", ["pt-BR", "fr-FR"])
  * @returns true if `value` falls in the same `unit` as today, false on an unsupported unit or invalid input
  *
  * @example isThisUnit("2024-03-15", "month") // true, if today is any day in March 2024
@@ -44,7 +46,7 @@ import { areDatesEqualBy } from "./areDatesEqualBy.js";
  * @example isThisUnit("2024-03-15", "week", "not-a-locale-!!") // false (invalid locale)
  * @example isThisUnit("2024-03-15", "day", "not-a-locale-!!") // false (invalid locale, for every unit)
  * @example isThisUnit("2024-03-15", "months") // true, if today is any day in March 2024
- * @example isThisUnit("2024-02-25", "week", ["en-US", "fr-FR"]) // true, if today is 2024-02-29 (en-US Sunday-start week)
+ * @example isThisUnit("2024-02-25", "week", ["pt-BR", "fr-FR"]) // true, if today is 2024-02-29 (pt-BR Sunday-start week)
  */
 export function isThisUnit(value, unit, locale) {
     try {

package/dist/plain/compare/isWeekend.d.ts

@@ -2,8 +2,8 @@
  * Return true when `value` falls on a weekend day 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,
- *   he-IL/ar-SA: Fri/Sat).
+ *   numbers count as "weekend" for the locale (e.g. fr-FR: Sat/Sun,
+ *   he-IL/ar-SA: Fri/Sat, hi-IN: Sun).
  * - Falls back to Saturday/Sunday if the runtime's `weekInfo` data doesn't
  *   resolve a weekend for the locale.
  * - Returns false if `value` is invalid or `locale` is not a well-formed BCP 47 tag
@@ -12,13 +12,13 @@
  *   default locale, as ECMA-402 `ResolveLocale` requires.
  *
  * @param value ISO PlainDate 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. "fr-FR", "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` is a weekend day in `locale`, false on invalid input
  *
- * @example isWeekend("2024-02-03", "en-US") // true (Saturday, en-US weekend is Sat/Sun)
+ * @example isWeekend("2024-02-03", "fr-FR") // true (Saturday, fr-FR weekend is Sat/Sun)
  * @example isWeekend("2024-02-02", "he-IL") // true (Friday, he-IL weekend is Fri/Sat)
  * @example isWeekend("2024-02-04", "he-IL") // false (Sunday, not part of he-IL's weekend)
- * @example isWeekend("invalid", "en-US") // false
+ * @example isWeekend("invalid", "ja-JP") // false
  * @example isWeekend("2024-02-03", "not-a-locale-!!") // false
  * @example isWeekend("2024-05-17", ["ar-EG", "fr-FR"]) // true (Friday is an ar-EG weekend day)
  */

package/dist/plain/compare/isWeekend.js

@@ -1,12 +1,12 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { getLocaleWeekendDays } from "../../internal/index.js";
 import { isValidDate } from "../validate/index.js";
 /**
  * Return true when `value` falls on a weekend day 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,
- *   he-IL/ar-SA: Fri/Sat).
+ *   numbers count as "weekend" for the locale (e.g. fr-FR: Sat/Sun,
+ *   he-IL/ar-SA: Fri/Sat, hi-IN: Sun).
  * - Falls back to Saturday/Sunday if the runtime's `weekInfo` data doesn't
  *   resolve a weekend for the locale.
  * - Returns false if `value` is invalid or `locale` is not a well-formed BCP 47 tag
@@ -15,13 +15,13 @@ import { isValidDate } from "../validate/index.js";
  *   default locale, as ECMA-402 `ResolveLocale` requires.
  *
  * @param value ISO PlainDate 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. "fr-FR", "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` is a weekend day in `locale`, false on invalid input
  *
- * @example isWeekend("2024-02-03", "en-US") // true (Saturday, en-US weekend is Sat/Sun)
+ * @example isWeekend("2024-02-03", "fr-FR") // true (Saturday, fr-FR weekend is Sat/Sun)
  * @example isWeekend("2024-02-02", "he-IL") // true (Friday, he-IL weekend is Fri/Sat)
  * @example isWeekend("2024-02-04", "he-IL") // false (Sunday, not part of he-IL's weekend)
- * @example isWeekend("invalid", "en-US") // false
+ * @example isWeekend("invalid", "ja-JP") // false
  * @example isWeekend("2024-02-03", "not-a-locale-!!") // false
  * @example isWeekend("2024-05-17", ["ar-EG", "fr-FR"]) // true (Friday is an ar-EG weekend day)
  */

package/dist/plain/format/formatCalendar.d.ts

@@ -29,8 +29,6 @@ export interface FormatCalendarOptions extends CalendarOptions {
  *   `timeStyle` string with no relative wording. The one-week limit is
  *   GMT's own rule, not a standard's: from 7 days out a date is easier to
  *   place than a day count.
- * - Comparison: Moment's `.calendar()` switches to a date at the same
- *   distance (its `sameElse` case); its wording inside the week differs.
  * - The connector between the day label and the time is read from CLDR's
  *   own combined date+time pattern for the locale (see
  *   `internal/joinDateTimeConnector.ts`), not hardcoded — this is what lets
@@ -47,10 +45,10 @@ export interface FormatCalendarOptions extends CalendarOptions {
  * @param options What the value is compared with and how the time is written
  * @returns the formatted calendar string, or "" on invalid input
  *
- * @example formatCalendar("2026-03-16T14:30:00", "en-US", { reference: "2026-03-15T09:00:00" }) // "tomorrow at 2:30 PM"
- * @example formatCalendar("2026-03-08T14:30:00", "en-US", { reference: "2026-03-15T09:00:00" }) // "March 8, 2026 at 2:30 PM" (7 days out — beyond the threshold, absolute fallback)
+ * @example formatCalendar("2026-03-16T14:30:00", "en-GB", { reference: "2026-03-15T09:00:00" }) // "tomorrow at 14:30"
+ * @example formatCalendar("2026-03-08T14:30:00", "pt-BR", { reference: "2026-03-15T09:00:00" }) // "8 de março de 2026 às 14:30" (7 days out — beyond the threshold, absolute fallback)
  * @example formatCalendar("not-a-date") // ""
  * @example formatCalendar("2024-03-16T14:30:00", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00" }) // "demain à 14:30"
- * @example formatCalendar("2024-03-12T10:00:00", "en-US", null as never) // "" (null options)
+ * @example formatCalendar("2024-03-12T10:00:00", "zh-CN", null as never) // "" (null options)
  */
 export declare function formatCalendar(value: string, locale?: string | string[], options?: FormatCalendarOptions): string;

package/dist/plain/format/formatCalendar.js

@@ -1,5 +1,6 @@
+import { cachedFormatter } from "../../internal/formatterCache.js";
 // 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 { joinDateTimeConnector, normalizeDateTime } from "../../internal/index.js";
 import { plainTimeStyle } from "../../internal/plainFormatOptions.js";
 import { isValidDateTime } from "../validate/index.js";
@@ -24,8 +25,6 @@ const ABS_DAY_THRESHOLD = 6;
  *   `timeStyle` string with no relative wording. The one-week limit is
  *   GMT's own rule, not a standard's: from 7 days out a date is easier to
  *   place than a day count.
- * - Comparison: Moment's `.calendar()` switches to a date at the same
- *   distance (its `sameElse` case); its wording inside the week differs.
  * - The connector between the day label and the time is read from CLDR's
  *   own combined date+time pattern for the locale (see
  *   `internal/joinDateTimeConnector.ts`), not hardcoded — this is what lets
@@ -42,11 +41,11 @@ const ABS_DAY_THRESHOLD = 6;
  * @param options What the value is compared with and how the time is written
  * @returns the formatted calendar string, or "" on invalid input
  *
- * @example formatCalendar("2026-03-16T14:30:00", "en-US", { reference: "2026-03-15T09:00:00" }) // "tomorrow at 2:30 PM"
- * @example formatCalendar("2026-03-08T14:30:00", "en-US", { reference: "2026-03-15T09:00:00" }) // "March 8, 2026 at 2:30 PM" (7 days out — beyond the threshold, absolute fallback)
+ * @example formatCalendar("2026-03-16T14:30:00", "en-GB", { reference: "2026-03-15T09:00:00" }) // "tomorrow at 14:30"
+ * @example formatCalendar("2026-03-08T14:30:00", "pt-BR", { reference: "2026-03-15T09:00:00" }) // "8 de março de 2026 às 14:30" (7 days out — beyond the threshold, absolute fallback)
  * @example formatCalendar("not-a-date") // ""
  * @example formatCalendar("2024-03-16T14:30:00", ["fr-FR", "en-US"], { reference: "2024-03-15T09:00:00" }) // "demain à 14:30"
- * @example formatCalendar("2024-03-12T10:00:00", "en-US", null as never) // "" (null options)
+ * @example formatCalendar("2024-03-12T10:00:00", "zh-CN", null as never) // "" (null options)
  */
 export function formatCalendar(value, locale, options = {}) {
     try {
@@ -69,19 +68,21 @@ export function formatCalendar(value, locale, options = {}) {
             // "long"/"full" are outside the type but reachable from JS; their zone
             // name would describe the UTC anchor, not the value. Temporal's
             // PlainDateTime format drops timeZoneName (AdjustDateTimeStyleFormat).
-            const timeStyle = plainTimeStyle(optionOrDefault(options.timeStyle, "short"));
+            // GetOption converts the value once (ToString), so `new String("long")`
+            // is mapped as "long" is; a symbol throws, and that is invalid input.
+            const timeStyle = plainTimeStyle(`${optionOrDefault(options.timeStyle, "short")}`);
             // Plain values carry no timezone. UTC is an arbitrary but stable anchor
             // for reusing Intl's part-level formatting — any fixed zone reproduces
             // the same wall-clock fields since there's no real zone to get wrong.
             const epochMilliseconds = target.toZonedDateTime("UTC").epochMilliseconds;
             if (Math.abs(diffDays) > ABS_DAY_THRESHOLD) {
-                return normalizeDateTime(new Intl.DateTimeFormat(locale, {
+                return normalizeDateTime(cachedFormatter("DateTimeFormat", locale, {
                     dateStyle: "long",
                     timeStyle,
                     timeZone: "UTC",
                 }).format(epochMilliseconds));
             }
-            const dayLabel = new Intl.RelativeTimeFormat(locale, {
+            const dayLabel = cachedFormatter("RelativeTimeFormat", locale, {
                 numeric: "auto",
             }).format(diffDays, "day");
             return normalizeDateTime(joinDateTimeConnector(epochMilliseconds, "UTC", locale, dayLabel, timeStyle));

package/dist/plain/format/formatDate.d.ts

@@ -22,13 +22,13 @@ import type { DateTimeFormatOptions } from "../../types/index.js";
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized date string or "" on invalid input
  *
- * @example formatDate("2024-03-15", "en-US", { year: "numeric", month: "long", day: "numeric" }) // "March 15, 2024"
+ * @example formatDate("2024-03-15", "pt-BR", { year: "numeric", month: "long", day: "numeric" }) // "15 de março de 2024"
  * @example formatDate("2024-03-15", "de-DE", { year: "numeric", month: "long", day: "numeric" }) // "15. März 2024"
  * @example formatDate("2024-02-03", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
  * @example formatDate("2024-02-03", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
- * @example formatDate("2024-02-03", "en-US", { timeZoneName: "long" }) // "2/3/2024"
- * @example formatDate("2024-02-03", "en-US", { dateStyle: "short", timeStyle: "short" }) // "" — a PlainDate has no time
- * @example formatDate("2024-02-03", "en-US", { dateStyle: "short" }) // "2/3/24" — the pre-1.16.0 text
+ * @example formatDate("2024-02-03", "hi-IN", { timeZoneName: "long" }) // "3/2/2024"
+ * @example formatDate("2024-02-03", "en-GB", { dateStyle: "short", timeStyle: "short" }) // "" — a PlainDate has no time
+ * @example formatDate("2024-02-03", "en-GB", { dateStyle: "short" }) // "03/02/2024" — the pre-1.16.0 text
  * @example formatDate("invalid") // ""
  * @example formatDate("2024-02-03", ["fr-FR", "en-US"], { year: "numeric", month: "2-digit", day: "2-digit" }) // "03/02/2024" (the first listed locale)
  */

package/dist/plain/format/formatDate.js

@@ -1,8 +1,9 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { normalizeDateTime } from "../../internal/index.js";
 import { plainDateFormatOptions } from "../../internal/plainFormatOptions.js";
 import { isValidDate } from "../validate/index.js";
 import { readDateTimeFormatOptions } from "../../internal/readDateTimeFormatOptions.js";
+import { cachedFormatter, checkFormatterArguments, } from "../../internal/formatterCache.js";
 /**
  * Return a localized string for a PlainDate ISO input using Intl options.
  *
@@ -26,13 +27,13 @@ import { readDateTimeFormatOptions } from "../../internal/readDateTimeFormatOpti
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized date string or "" on invalid input
  *
- * @example formatDate("2024-03-15", "en-US", { year: "numeric", month: "long", day: "numeric" }) // "March 15, 2024"
+ * @example formatDate("2024-03-15", "pt-BR", { year: "numeric", month: "long", day: "numeric" }) // "15 de março de 2024"
  * @example formatDate("2024-03-15", "de-DE", { year: "numeric", month: "long", day: "numeric" }) // "15. März 2024"
  * @example formatDate("2024-02-03", "ja-JP-u-ca-japanese", { year: "numeric", month: "long" }) // "令和6年2月"
  * @example formatDate("2024-02-03", "ja-JP-u-ca-japanese", { year: "numeric", month: "numeric" }) // "R6/2" — the pre-1.16.0 text
- * @example formatDate("2024-02-03", "en-US", { timeZoneName: "long" }) // "2/3/2024"
- * @example formatDate("2024-02-03", "en-US", { dateStyle: "short", timeStyle: "short" }) // "" — a PlainDate has no time
- * @example formatDate("2024-02-03", "en-US", { dateStyle: "short" }) // "2/3/24" — the pre-1.16.0 text
+ * @example formatDate("2024-02-03", "hi-IN", { timeZoneName: "long" }) // "3/2/2024"
+ * @example formatDate("2024-02-03", "en-GB", { dateStyle: "short", timeStyle: "short" }) // "" — a PlainDate has no time
+ * @example formatDate("2024-02-03", "en-GB", { dateStyle: "short" }) // "03/02/2024" — the pre-1.16.0 text
  * @example formatDate("invalid") // ""
  * @example formatDate("2024-02-03", ["fr-FR", "en-US"], { year: "numeric", month: "2-digit", day: "2-digit" }) // "03/02/2024" (the first listed locale)
  */
@@ -47,7 +48,7 @@ export function formatDate(value, locale, options) {
         // widths are kept. Constructing with the caller's options first surfaces
         // the TypeError or RangeError Intl.DateTimeFormat raises for invalid ones.
         const read = readDateTimeFormatOptions(options);
-        new Intl.DateTimeFormat(locale, read);
+        checkFormatterArguments("DateTimeFormat", locale, read);
         // CreateDateTimeFormat: required ~date~ with a timeStyle is a TypeError.
         if (read.timeStyle !== undefined) {
             return "";
@@ -57,7 +58,7 @@ export function formatDate(value, locale, options) {
             return "";
         }
         const epochMilliseconds = Temporal.PlainDate.from(value).toZonedDateTime("UTC").epochMilliseconds;
-        return normalizeDateTime(new Intl.DateTimeFormat(locale, resolved).format(epochMilliseconds));
+        return normalizeDateTime(cachedFormatter("DateTimeFormat", locale, resolved).format(epochMilliseconds));
     }
     catch {
         return "";

package/dist/plain/format/formatDateRange.d.ts

@@ -24,10 +24,10 @@ import type { DateTimeFormatOptions } from "../../types/index.js";
  * @param options optional Intl.DateTimeFormatOptions
  * @returns localized range string or "" when invalid
  *
- * @example formatDateRange("2024-02-03", "2024-02-05", "en-US", { dateStyle: "long" }) // "February 3 - 5, 2024"
- * @example formatDateRange("2024-02-03", "2024-06-10", "en-US", { dateStyle: "long" }) // "February 3 - June 10, 2024"
- * @example formatDateRange("2024-02-03", "2024-02-05", "en-US", { timeZoneName: "short" }) // "2/3/2024 - 2/5/2024"
- * @example formatDateRange("invalid", "2024-02-05", "en-US") // "" (invalid input)
+ * @example formatDateRange("2024-02-03", "2024-02-05", "en-GB", { dateStyle: "long" }) // "3 - 5 February 2024"
+ * @example formatDateRange("2024-02-03", "2024-06-10", "pt-BR", { dateStyle: "long" }) // "3 de fevereiro - 10 de junho de 2024"
+ * @example formatDateRange("2024-02-03", "2024-02-05", "hi-IN", { timeZoneName: "short" }) // "3/2/2024 - 5/2/2024"
+ * @example formatDateRange("invalid", "2024-02-05", "ja-JP") // "" (invalid input)
  * @example formatDateRange("2024-02-03", "2024-02-05", ["fr-FR", "en-US"], { dateStyle: "long" }) // "3-5 février 2024" (GMT writes range dashes as ASCII hyphens)
  */
 export declare function formatDateRange(start: string, end: string, locale?: string | string[], options?: DateTimeFormatOptions): string;