@zag-js/date-utils 1.34.1 → 1.35.0

package/dist/align.d.mts

@@ -0,0 +1,8 @@
+import * as _internationalized_date from '@internationalized/date';
+import { DateDuration } from '@internationalized/date';
+import { DateValue, DateAlignment } from './types.mjs';
+
+declare function alignDate(date: DateValue, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): _internationalized_date.DateValue;
+declare function alignStartDate(date: DateValue, startDate: DateValue, endDate: DateValue, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+
+export { alignDate, alignStartDate };

package/dist/align.d.ts

@@ -0,0 +1,8 @@
+import * as _internationalized_date from '@internationalized/date';
+import { DateDuration } from '@internationalized/date';
+import { DateValue, DateAlignment } from './types.js';
+
+declare function alignDate(date: DateValue, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): _internationalized_date.DateValue;
+declare function alignStartDate(date: DateValue, startDate: DateValue, endDate: DateValue, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+
+export { alignDate, alignStartDate };

package/dist/align.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/align.ts
+var align_exports = {};
+__export(align_exports, {
+  alignDate: () => alignDate,
+  alignStartDate: () => alignStartDate
+});
+module.exports = __toCommonJS(align_exports);
+var import_constrain = require("./constrain.cjs");
+function alignDate(date, alignment, duration, locale, min, max) {
+  switch (alignment) {
+    case "start":
+      return (0, import_constrain.alignStart)(date, duration, locale, min, max);
+    case "end":
+      return (0, import_constrain.alignEnd)(date, duration, locale, min, max);
+    case "center":
+    default:
+      return (0, import_constrain.alignCenter)(date, duration, locale, min, max);
+  }
+}
+function alignStartDate(date, startDate, endDate, duration, locale, min, max) {
+  if (date.compare(startDate) < 0) {
+    return (0, import_constrain.alignEnd)(date, duration, locale, min, max);
+  }
+  if (date.compare(endDate) > 0) {
+    return (0, import_constrain.alignStart)(date, duration, locale, min, max);
+  }
+  return startDate;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignDate,
+  alignStartDate
+});

package/dist/align.mjs

@@ -0,0 +1,26 @@
+// src/align.ts
+import { alignCenter, alignEnd, alignStart } from "./constrain.mjs";
+function alignDate(date, alignment, duration, locale, min, max) {
+  switch (alignment) {
+    case "start":
+      return alignStart(date, duration, locale, min, max);
+    case "end":
+      return alignEnd(date, duration, locale, min, max);
+    case "center":
+    default:
+      return alignCenter(date, duration, locale, min, max);
+  }
+}
+function alignStartDate(date, startDate, endDate, duration, locale, min, max) {
+  if (date.compare(startDate) < 0) {
+    return alignEnd(date, duration, locale, min, max);
+  }
+  if (date.compare(endDate) > 0) {
+    return alignStart(date, duration, locale, min, max);
+  }
+  return startDate;
+}
+export {
+  alignDate,
+  alignStartDate
+};

package/dist/assertion.d.mts

@@ -0,0 +1,10 @@
+import { DateValue, DateAvailableFn } from './types.mjs';
+import '@internationalized/date';
+
+declare function isDateEqual(dateA: DateValue | null | undefined, dateB?: DateValue | null): boolean;
+declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateOutsideRange(date: DateValue, startDate?: DateValue | null, endDate?: DateValue | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+
+export { isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid };

package/dist/assertion.d.ts

@@ -0,0 +1,10 @@
+import { DateValue, DateAvailableFn } from './types.js';
+import '@internationalized/date';
+
+declare function isDateEqual(dateA: DateValue | null | undefined, dateB?: DateValue | null): boolean;
+declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateOutsideRange(date: DateValue, startDate?: DateValue | null, endDate?: DateValue | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+
+export { isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid };

package/dist/assertion.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/assertion.ts
+var assertion_exports = {};
+__export(assertion_exports, {
+  isDateEqual: () => isDateEqual,
+  isDateOutsideRange: () => isDateOutsideRange,
+  isDateUnavailable: () => isDateUnavailable,
+  isNextRangeInvalid: () => isNextRangeInvalid,
+  isPreviousRangeInvalid: () => isPreviousRangeInvalid
+});
+module.exports = __toCommonJS(assertion_exports);
+var import_date = require("@internationalized/date");
+function isDateEqual(dateA, dateB) {
+  if (dateA == null || dateB == null) return dateA === dateB;
+  return (0, import_date.isSameDay)(dateA, dateB);
+}
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
+  if (!date) return false;
+  if (isUnavailable?.(date, locale)) return true;
+  return isDateOutsideRange(date, minValue, maxValue);
+}
+function isDateOutsideRange(date, startDate, endDate) {
+  return startDate != null && date.compare(startDate) < 0 || endDate != null && date.compare(endDate) > 0;
+}
+function isPreviousRangeInvalid(startDate, minValue, maxValue) {
+  const prevDate = startDate.subtract({ days: 1 });
+  return (0, import_date.isSameDay)(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+  const nextDate = endDate.add({ days: 1 });
+  return (0, import_date.isSameDay)(nextDate, endDate) || isDateOutsideRange(nextDate, minValue, maxValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDateEqual,
+  isDateOutsideRange,
+  isDateUnavailable,
+  isNextRangeInvalid,
+  isPreviousRangeInvalid
+});

package/dist/assertion.mjs

@@ -0,0 +1,29 @@
+// src/assertion.ts
+import { isSameDay } from "@internationalized/date";
+function isDateEqual(dateA, dateB) {
+  if (dateA == null || dateB == null) return dateA === dateB;
+  return isSameDay(dateA, dateB);
+}
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
+  if (!date) return false;
+  if (isUnavailable?.(date, locale)) return true;
+  return isDateOutsideRange(date, minValue, maxValue);
+}
+function isDateOutsideRange(date, startDate, endDate) {
+  return startDate != null && date.compare(startDate) < 0 || endDate != null && date.compare(endDate) > 0;
+}
+function isPreviousRangeInvalid(startDate, minValue, maxValue) {
+  const prevDate = startDate.subtract({ days: 1 });
+  return isSameDay(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+  const nextDate = endDate.add({ days: 1 });
+  return isSameDay(nextDate, endDate) || isDateOutsideRange(nextDate, minValue, maxValue);
+}
+export {
+  isDateEqual,
+  isDateOutsideRange,
+  isDateUnavailable,
+  isNextRangeInvalid,
+  isPreviousRangeInvalid
+};

package/dist/constrain.d.mts

@@ -0,0 +1,9 @@
+import { DateValue, DateDuration } from '@internationalized/date';
+
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+
+export { alignCenter, alignEnd, alignStart, constrainStart, constrainValue };

package/dist/constrain.d.ts

@@ -0,0 +1,9 @@
+import { DateValue, DateDuration } from '@internationalized/date';
+
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue<T extends DateValue>(date: T, minValue?: DateValue, maxValue?: DateValue): T;
+
+export { alignCenter, alignEnd, alignStart, constrainStart, constrainValue };

package/dist/constrain.js

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constrain.ts
+var constrain_exports = {};
+__export(constrain_exports, {
+  alignCenter: () => alignCenter,
+  alignEnd: () => alignEnd,
+  alignStart: () => alignStart,
+  constrainStart: () => constrainStart,
+  constrainValue: () => constrainValue
+});
+module.exports = __toCommonJS(constrain_exports);
+var import_date = require("@internationalized/date");
+function alignCenter(date, duration, locale, min, max) {
+  const halfDuration = {};
+  for (let prop in duration) {
+    const key = prop;
+    const value = duration[key];
+    if (value == null) continue;
+    halfDuration[key] = Math.floor(value / 2);
+    if (halfDuration[key] > 0 && value % 2 === 0) {
+      halfDuration[key]--;
+    }
+  }
+  const aligned = alignStart(date, duration, locale).subtract(halfDuration);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignStart(date, duration, locale, min, max) {
+  let aligned = date;
+  if (duration.years) {
+    aligned = (0, import_date.startOfYear)(date);
+  } else if (duration.months) {
+    aligned = (0, import_date.startOfMonth)(date);
+  } else if (duration.weeks) {
+    aligned = (0, import_date.startOfWeek)(date, locale);
+  }
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignEnd(date, duration, locale, min, max) {
+  let d = { ...duration };
+  if (d.days) {
+    d.days--;
+  } else if (d.weeks) {
+    d.weeks--;
+  } else if (d.months) {
+    d.months--;
+  } else if (d.years) {
+    d.years--;
+  }
+  let aligned = alignStart(date, duration, locale).subtract(d);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function constrainStart(date, aligned, duration, locale, min, max) {
+  if (min && date.compare(min) >= 0) {
+    aligned = (0, import_date.maxDate)(aligned, alignStart((0, import_date.toCalendarDate)(min), duration, locale));
+  }
+  if (max && date.compare(max) <= 0) {
+    aligned = (0, import_date.minDate)(aligned, alignEnd((0, import_date.toCalendarDate)(max), duration, locale));
+  }
+  return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+  const dateOnly = (0, import_date.toCalendarDate)(date);
+  const minOnly = minValue ? (0, import_date.toCalendarDate)(minValue) : void 0;
+  const maxOnly = maxValue ? (0, import_date.toCalendarDate)(maxValue) : void 0;
+  let constrainedDateOnly = dateOnly;
+  if (minOnly) {
+    constrainedDateOnly = (0, import_date.maxDate)(constrainedDateOnly, minOnly);
+  }
+  if (maxOnly) {
+    constrainedDateOnly = (0, import_date.minDate)(constrainedDateOnly, maxOnly);
+  }
+  if (constrainedDateOnly.compare(dateOnly) === 0) {
+    return date;
+  }
+  if ("hour" in date) {
+    return date.set({
+      year: constrainedDateOnly.year,
+      month: constrainedDateOnly.month,
+      day: constrainedDateOnly.day
+    });
+  }
+  return constrainedDateOnly;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignCenter,
+  alignEnd,
+  alignStart,
+  constrainStart,
+  constrainValue
+});

package/dist/constrain.mjs

@@ -0,0 +1,87 @@
+// src/constrain.ts
+import {
+  maxDate,
+  minDate,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toCalendarDate
+} from "@internationalized/date";
+function alignCenter(date, duration, locale, min, max) {
+  const halfDuration = {};
+  for (let prop in duration) {
+    const key = prop;
+    const value = duration[key];
+    if (value == null) continue;
+    halfDuration[key] = Math.floor(value / 2);
+    if (halfDuration[key] > 0 && value % 2 === 0) {
+      halfDuration[key]--;
+    }
+  }
+  const aligned = alignStart(date, duration, locale).subtract(halfDuration);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignStart(date, duration, locale, min, max) {
+  let aligned = date;
+  if (duration.years) {
+    aligned = startOfYear(date);
+  } else if (duration.months) {
+    aligned = startOfMonth(date);
+  } else if (duration.weeks) {
+    aligned = startOfWeek(date, locale);
+  }
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignEnd(date, duration, locale, min, max) {
+  let d = { ...duration };
+  if (d.days) {
+    d.days--;
+  } else if (d.weeks) {
+    d.weeks--;
+  } else if (d.months) {
+    d.months--;
+  } else if (d.years) {
+    d.years--;
+  }
+  let aligned = alignStart(date, duration, locale).subtract(d);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function constrainStart(date, aligned, duration, locale, min, max) {
+  if (min && date.compare(min) >= 0) {
+    aligned = maxDate(aligned, alignStart(toCalendarDate(min), duration, locale));
+  }
+  if (max && date.compare(max) <= 0) {
+    aligned = minDate(aligned, alignEnd(toCalendarDate(max), duration, locale));
+  }
+  return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+  const dateOnly = toCalendarDate(date);
+  const minOnly = minValue ? toCalendarDate(minValue) : void 0;
+  const maxOnly = maxValue ? toCalendarDate(maxValue) : void 0;
+  let constrainedDateOnly = dateOnly;
+  if (minOnly) {
+    constrainedDateOnly = maxDate(constrainedDateOnly, minOnly);
+  }
+  if (maxOnly) {
+    constrainedDateOnly = minDate(constrainedDateOnly, maxOnly);
+  }
+  if (constrainedDateOnly.compare(dateOnly) === 0) {
+    return date;
+  }
+  if ("hour" in date) {
+    return date.set({
+      year: constrainedDateOnly.year,
+      month: constrainedDateOnly.month,
+      day: constrainedDateOnly.day
+    });
+  }
+  return constrainedDateOnly;
+}
+export {
+  alignCenter,
+  alignEnd,
+  alignStart,
+  constrainStart,
+  constrainValue
+};

package/dist/date-month.d.mts

@@ -0,0 +1,23 @@
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
+
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+    value: T;
+    short: string;
+    long: string;
+    narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+    value: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+    short: string;
+    long: string;
+    narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"], referenceDate?: DateValue): string[];
+declare function getWeekOfYear(date: DateValue, locale: string): number;
+
+export { getDaysInWeek, getEndOfWeek, getMonthDays, getMonthNames, getStartOfWeek, getWeekDays, getWeekOfYear, getWeekdayFormats };

package/dist/date-month.d.ts

@@ -0,0 +1,23 @@
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
+
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+    value: T;
+    short: string;
+    long: string;
+    narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+    value: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+    short: string;
+    long: string;
+    narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"], referenceDate?: DateValue): string[];
+declare function getWeekOfYear(date: DateValue, locale: string): number;
+
+export { getDaysInWeek, getEndOfWeek, getMonthDays, getMonthNames, getStartOfWeek, getWeekDays, getWeekOfYear, getWeekdayFormats };

package/dist/date-month.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/date-month.ts
+var date_month_exports = {};
+__export(date_month_exports, {
+  getDaysInWeek: () => getDaysInWeek,
+  getEndOfWeek: () => getEndOfWeek,
+  getMonthDays: () => getMonthDays,
+  getMonthNames: () => getMonthNames,
+  getStartOfWeek: () => getStartOfWeek,
+  getWeekDays: () => getWeekDays,
+  getWeekOfYear: () => getWeekOfYear,
+  getWeekdayFormats: () => getWeekdayFormats
+});
+module.exports = __toCommonJS(date_month_exports);
+var import_date = require("@internationalized/date");
+var daysOfTheWeek = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+function normalizeFirstDayOfWeek(firstDayOfWeek) {
+  return firstDayOfWeek != null ? daysOfTheWeek[firstDayOfWeek] : void 0;
+}
+function getStartOfWeek(date, locale, firstDayOfWeek) {
+  const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+  return (0, import_date.startOfWeek)(date, locale, firstDay);
+}
+function getEndOfWeek(date, locale, firstDayOfWeek = 0) {
+  const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+  return (0, import_date.endOfWeek)(date, locale, firstDay);
+}
+function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
+  const weekDate = from.add({ weeks: weekIndex });
+  const dates = [];
+  let date = getStartOfWeek(weekDate, locale, firstDayOfWeek);
+  while (dates.length < 7) {
+    dates.push(date);
+    let nextDate = date.add({ days: 1 });
+    if ((0, import_date.isSameDay)(date, nextDate)) break;
+    date = nextDate;
+  }
+  return dates;
+}
+function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
+  const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+  const monthWeeks = numOfWeeks ?? (0, import_date.getWeeksInMonth)(from, locale, firstDay);
+  const weeks = [...new Array(monthWeeks).keys()];
+  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
+}
+function getWeekdayFormats(locale, timeZone) {
+  const longFormat = new import_date.DateFormatter(locale, { weekday: "long", timeZone });
+  const shortFormat = new import_date.DateFormatter(locale, { weekday: "short", timeZone });
+  const narrowFormat = new import_date.DateFormatter(locale, { weekday: "narrow", timeZone });
+  return (value) => {
+    const date = value instanceof Date ? value : value.toDate(timeZone);
+    return {
+      value,
+      short: shortFormat.format(date),
+      long: longFormat.format(date),
+      narrow: narrowFormat.format(date)
+    };
+  };
+}
+function getWeekDays(date, startOfWeekProp, timeZone, locale) {
+  const firstDayOfWeek = getStartOfWeek(date, locale, startOfWeekProp);
+  const weeks = [...new Array(7).keys()];
+  const format = getWeekdayFormats(locale, timeZone);
+  return weeks.map((index) => format(firstDayOfWeek.add({ days: index })));
+}
+function getMonthNames(locale, format = "long", referenceDate) {
+  if (!referenceDate || referenceDate.calendar.identifier === "gregory" || referenceDate.calendar.identifier === "iso8601") {
+    const date = new Date(2021, 0, 1);
+    const monthNames2 = [];
+    for (let i = 0; i < 12; i++) {
+      monthNames2.push(date.toLocaleString(locale, { month: format }));
+      date.setMonth(date.getMonth() + 1);
+    }
+    return monthNames2;
+  }
+  const monthCount = referenceDate.calendar.getMonthsInYear(referenceDate);
+  const formatter = new import_date.DateFormatter(locale, {
+    month: format,
+    calendar: referenceDate.calendar.identifier
+  });
+  const monthNames = [];
+  for (let month = 1; month <= monthCount; month++) {
+    const d = referenceDate.set({ month });
+    monthNames.push(formatter.format(d.toDate("UTC")));
+  }
+  return monthNames;
+}
+function getWeekOfYear(date, locale) {
+  const mondayOfWeek = (0, import_date.startOfWeek)(date, locale, "mon");
+  const year = mondayOfWeek.year;
+  const jan4 = mondayOfWeek.set({ month: 1, day: 4 });
+  const week1Monday = (0, import_date.startOfWeek)(jan4, locale, "mon");
+  const julianMonday = mondayOfWeek.calendar.toJulianDay(mondayOfWeek);
+  const julianWeek1 = week1Monday.calendar.toJulianDay(week1Monday);
+  if (julianMonday >= julianWeek1) {
+    return 1 + Math.floor((julianMonday - julianWeek1) / 7);
+  }
+  const prevJan4 = mondayOfWeek.set({ year: year - 1, month: 1, day: 4 });
+  const prevWeek1Monday = (0, import_date.startOfWeek)(prevJan4, locale, "mon");
+  const julianPrevWeek1 = prevWeek1Monday.calendar.toJulianDay(prevWeek1Monday);
+  return 1 + Math.floor((julianMonday - julianPrevWeek1) / 7);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDaysInWeek,
+  getEndOfWeek,
+  getMonthDays,
+  getMonthNames,
+  getStartOfWeek,
+  getWeekDays,
+  getWeekOfYear,
+  getWeekdayFormats
+});