@gobrand/tiempo 3.1.3 → 3.2.0

package/dist/chunk-PLPGYCQQ.js

@@ -0,0 +1,28 @@
+import {
+  plainDateToZonedDateTime
+} from "./chunk-2AID4P2C.js";
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/startOfWeek.ts
+function startOfWeek(input, timezoneOrOptions, options) {
+  const timezone = typeof timezoneOrOptions === "string" ? timezoneOrOptions : void 0;
+  const weekOptions = typeof timezoneOrOptions === "string" ? options : timezoneOrOptions;
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.subtract({ days: daysIntoWeek(input.dayOfWeek, weekOptions) });
+  }
+  const zonedDateTime = isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
+  return zonedDateTime.subtract({ days: daysIntoWeek(zonedDateTime.dayOfWeek, weekOptions) }).startOfDay();
+}
+
+export {
+  startOfWeek
+};
+//# sourceMappingURL=chunk-PLPGYCQQ.js.map

package/dist/chunk-PLPGYCQQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * Returns the first boundary of the week.\n * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday\n * @returns The first day of the week at 00:00, or that date for PlainDate input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const start = startOfWeek(instant);\n * // 2025-01-20T00:00:00+00:00[UTC] (same day, it's already Monday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const start = startOfWeek(zoned);\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date);\n * // 2025-01-20 (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // Weeks that start on Sunday\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, { weekStartsOn: 7 });\n * // 2025-01-19 (previous Sunday)\n * ```\n */\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: WeekOptions\n): Temporal.ZonedDateTime;\nexport function startOfWeek(input: Temporal.PlainDate, options?: WeekOptions): Temporal.PlainDate;\nexport function startOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone,\n  options?: WeekOptions\n): Temporal.ZonedDateTime;\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezoneOrOptions?: Timezone | WeekOptions,\n  options?: WeekOptions\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  const timezone = typeof timezoneOrOptions === 'string' ? timezoneOrOptions : undefined;\n  const weekOptions = typeof timezoneOrOptions === 'string' ? options : timezoneOrOptions;\n\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.subtract({ days: daysIntoWeek(input.dayOfWeek, weekOptions) });\n  }\n\n  const zonedDateTime = isPlainDate(input)\n    ? plainDateToZonedDateTime(input, timezone!)\n    : normalizeTemporalInput(input);\n\n  return zonedDateTime\n    .subtract({ days: daysIntoWeek(zonedDateTime.dayOfWeek, weekOptions) })\n    .startOfDay();\n}\n"],"mappings":";;;;;;;;;;;;;;AAiEO,SAAS,YACd,OACA,mBACA,SAC6C;AAC7C,QAAM,WAAW,OAAO,sBAAsB,WAAW,oBAAoB;AAC7E,QAAM,cAAc,OAAO,sBAAsB,WAAW,UAAU;AAEtE,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,SAAS,EAAE,MAAM,aAAa,MAAM,WAAW,WAAW,EAAE,CAAC;AAAA,EAC5E;AAEA,QAAM,gBAAgB,YAAY,KAAK,IACnC,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAEhC,SAAO,cACJ,SAAS,EAAE,MAAM,aAAa,cAAc,WAAW,WAAW,EAAE,CAAC,EACrE,WAAW;AAChB;","names":[]}

package/dist/chunk-R6D3Y5NV.js

@@ -0,0 +1,17 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/areIntervalsOverlapping.ts
+function areIntervalsOverlapping(left, right, options) {
+  if (compare(left.start, left.end) > 0 || compare(right.start, right.end) > 0) {
+    throw new RangeError("Interval start must not be after its end");
+  }
+  const limit = options?.inclusive ? 0 : -1;
+  return compare(left.start, right.end) <= limit && compare(right.start, left.end) <= limit;
+}
+
+export {
+  areIntervalsOverlapping
+};
+//# sourceMappingURL=chunk-R6D3Y5NV.js.map

package/dist/chunk-R6D3Y5NV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/areIntervalsOverlapping.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Timeline } from './shared/compare';\n\n/**\n * Returns true if two intervals share any time.\n *\n * By default an interval that ends exactly where the other starts does not\n * overlap it, so back-to-back bookings are allowed. Pass `{ inclusive: true }`\n * to count a shared endpoint, as for inclusive date ranges.\n *\n * Instants and ZonedDateTimes compare by the moment they represent. PlainDate\n * intervals compare by date. Mixing PlainDate and timeline endpoints throws a\n * TypeError; an interval whose start is after its end throws a RangeError.\n *\n * @param left - The first interval\n * @param right - The second interval\n * @param options - `inclusive`: count intervals that only touch as overlapping\n * @returns true if the intervals overlap\n *\n * @example\n * ```ts\n * const meeting = {\n *   start: Temporal.ZonedDateTime.from('2025-01-20T09:00:00+01:00[Europe/Madrid]'),\n *   end: Temporal.ZonedDateTime.from('2025-01-20T10:00:00+01:00[Europe/Madrid]')\n * };\n * const call = {\n *   start: Temporal.Instant.from('2025-01-20T08:30:00Z'), // 09:30 in Madrid\n *   end: Temporal.Instant.from('2025-01-20T09:30:00Z')\n * };\n *\n * areIntervalsOverlapping(meeting, call); // true\n * ```\n *\n * @example\n * ```ts\n * const firstStay = { start: Temporal.PlainDate.from('2025-07-01'), end: Temporal.PlainDate.from('2025-07-04') };\n * const nextStay = { start: Temporal.PlainDate.from('2025-07-04'), end: Temporal.PlainDate.from('2025-07-08') };\n *\n * areIntervalsOverlapping(firstStay, nextStay); // false\n * areIntervalsOverlapping(firstStay, nextStay, { inclusive: true }); // true\n * ```\n */\nexport function areIntervalsOverlapping(\n  left: { start: Temporal.PlainDate; end: Temporal.PlainDate },\n  right: { start: Temporal.PlainDate; end: Temporal.PlainDate },\n  options?: { inclusive?: boolean }\n): boolean;\nexport function areIntervalsOverlapping(\n  left: { start: Timeline; end: Timeline },\n  right: { start: Timeline; end: Timeline },\n  options?: { inclusive?: boolean }\n): boolean;\nexport function areIntervalsOverlapping(\n  left: { start: Timeline | Temporal.PlainDate; end: Timeline | Temporal.PlainDate },\n  right: { start: Timeline | Temporal.PlainDate; end: Timeline | Temporal.PlainDate },\n  options?: { inclusive?: boolean }\n): boolean {\n  if (compare(left.start, left.end) > 0 || compare(right.start, right.end) > 0) {\n    throw new RangeError('Interval start must not be after its end');\n  }\n  const limit = options?.inclusive ? 0 : -1;\n  return compare(left.start, right.end) <= limit && compare(right.start, left.end) <= limit;\n}\n"],"mappings":";;;;;AAoDO,SAAS,wBACd,MACA,OACA,SACS;AACT,MAAI,QAAQ,KAAK,OAAO,KAAK,GAAG,IAAI,KAAK,QAAQ,MAAM,OAAO,MAAM,GAAG,IAAI,GAAG;AAC5E,UAAM,IAAI,WAAW,0CAA0C;AAAA,EACjE;AACA,QAAM,QAAQ,SAAS,YAAY,IAAI;AACvC,SAAO,QAAQ,KAAK,OAAO,MAAM,GAAG,KAAK,SAAS,QAAQ,MAAM,OAAO,KAAK,GAAG,KAAK;AACtF;","names":[]}

package/dist/chunk-U6VFT2A5.js

@@ -0,0 +1,14 @@
+import {
+  calendarDates
+} from "./chunk-H43LMOCK.js";
+
+// src/differenceInCalendarMonths.ts
+function differenceInCalendarMonths(laterDate, earlierDate) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate);
+  return earlier.with({ day: 1 }).until(later.with({ day: 1 }), { largestUnit: "months" }).months;
+}
+
+export {
+  differenceInCalendarMonths
+};
+//# sourceMappingURL=chunk-U6VFT2A5.js.map

package/dist/chunk-U6VFT2A5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarMonths.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\n\n/**\n * Returns the number of calendar months between two dates, ignoring the day of\n * the month. Unlike differenceInMonths, which counts complete months, January 31\n * to February 1 is one calendar month.\n *\n * PlainDate inputs are compared as given. Instant inputs use their UTC date and\n * ZonedDateTime inputs use the date in their own timezone; convert both to one\n * timezone first to count from a single point of view. Mixing a PlainDate with\n * an Instant or ZonedDateTime throws a TypeError.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @returns Calendar months from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const jan31 = Temporal.PlainDate.from('2025-01-31');\n * const feb1 = Temporal.PlainDate.from('2025-02-01');\n *\n * differenceInCalendarMonths(feb1, jan31); // 1\n * differenceInMonths(feb1, jan31); // 0\n * ```\n */\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): number {\n  const [later, earlier] = calendarDates(laterDate, earlierDate);\n  return earlier.with({ day: 1 }).until(later.with({ day: 1 }), { largestUnit: 'months' }).months;\n}\n"],"mappings":";;;;;AAkCO,SAAS,2BACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,SAAO,QAAQ,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,aAAa,SAAS,CAAC,EAAE;AAC3F;","names":[]}

package/dist/chunk-XMEPH226.js

@@ -0,0 +1,21 @@
+import {
+  assertDayOfWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/previousDay.ts
+function previousDay(input, day) {
+  assertDayOfWeek(day, "day");
+  const value = isPlainDate(input) ? input : normalizeTemporalInput(input);
+  return value.subtract({ days: (value.dayOfWeek - day + 6) % 7 + 1 });
+}
+
+export {
+  previousDay
+};
+//# sourceMappingURL=chunk-XMEPH226.js.map

package/dist/chunk-XMEPH226.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/previousDay.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { assertDayOfWeek, type DayOfWeek } from './shared/week';\n\n/**\n * Returns the previous date that falls on the given day of the week, always\n * before the input: previous Monday from a Monday is a week earlier.\n *\n * Days are numbered as Temporal numbers them: 1 = Monday … 7 = Sunday.\n * PlainDate inputs stay dates. Instant inputs are read in UTC and ZonedDateTime\n * inputs keep their timezone; both keep their wall-clock time.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param day - The day of the week to find, 1 = Monday … 7 = Sunday\n * @returns The previous date on that day of the week\n *\n * @example\n * ```ts\n * const wednesday = Temporal.PlainDate.from('2025-01-22');\n *\n * previousDay(wednesday, 1).toString(); // \"2025-01-20\"\n * previousDay(wednesday, 3).toString(); // \"2025-01-15\"\n * previousDay(wednesday, 7).toString(); // \"2025-01-19\"\n * ```\n */\nexport function previousDay(input: Temporal.PlainDate, day: DayOfWeek): Temporal.PlainDate;\nexport function previousDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  day: DayOfWeek\n): Temporal.ZonedDateTime;\nexport function previousDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  day: DayOfWeek\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  assertDayOfWeek(day, 'day');\n  const value = isPlainDate(input) ? input : normalizeTemporalInput(input);\n  return value.subtract({ days: ((value.dayOfWeek - day + 6) % 7) + 1 });\n}\n"],"mappings":";;;;;;;;;;;AA8BO,SAAS,YACd,OACA,KAC6C;AAC7C,kBAAgB,KAAK,KAAK;AAC1B,QAAM,QAAQ,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACvE,SAAO,MAAM,SAAS,EAAE,OAAQ,MAAM,YAAY,MAAM,KAAK,IAAK,EAAE,CAAC;AACvE;","names":[]}

package/dist/{chunk-NGS5UKDW.js → chunk-ZNRTNR2Q.js}

@@ -1,9 +1,9 @@
-import {
-  quarterStartMonth
-} from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
 } from "./chunk-TCB3IDJM.js";
+import {
+  quarterStartMonth
+} from "./chunk-XS2HUADA.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -24,4 +24,4 @@ function startOfQuarter(input, timezone) {
 export {
   startOfQuarter
 };
-//# sourceMappingURL=chunk-NGS5UKDW.js.map
+//# sourceMappingURL=chunk-ZNRTNR2Q.js.map

package/dist/differenceInBusinessDays.d.ts

@@ -1,8 +1,8 @@
-import { type Temporal } from './shared/temporal.js';
+import { Temporal } from './shared/temporal.js';
 /**
  * Returns the number of business days (Monday–Friday) from earlierDate up to
- * laterDate: the earlier date counts, the later date does not. Holidays are
- * not considered. Swapping the arguments negates the result.
+ * laterDate: the earlier date counts, the later date does not. Dates in
+ * `holidays` are not counted. Swapping the arguments negates the result.
  *
  * Only calendar dates matter; times of day are ignored. Instant inputs use
  * their UTC date and ZonedDateTime inputs use their own timezone's date.
@@ -10,6 +10,7 @@ import { type Temporal } from './shared/temporal.js';
  *
  * @param laterDate - The later date
  * @param earlierDate - The earlier date
+ * @param holidays - Dates that are not business days, matched by date
  * @returns Business days between the dates (negative if laterDate is earlier)
  *
  * @example
@@ -19,8 +20,9 @@ import { type Temporal } from './shared/temporal.js';
  *
  * differenceInBusinessDays(nextFriday, friday); // 5
  * differenceInBusinessDays(friday, nextFriday); // -5
+ * differenceInBusinessDays(nextFriday, friday, [Temporal.PlainDate.from('2025-01-27')]); // 4
  * ```
  */
-export declare function differenceInBusinessDays(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
-export declare function differenceInBusinessDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+export declare function differenceInBusinessDays(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate, holidays?: readonly Temporal.PlainDate[]): number;
+export declare function differenceInBusinessDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime, holidays?: readonly Temporal.PlainDate[]): number;
 //# sourceMappingURL=differenceInBusinessDays.d.ts.map

package/dist/differenceInBusinessDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInBusinessDays.d.ts","sourceRoot":"","sources":["../src/differenceInBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}
+{"version":3,"file":"differenceInBusinessDays.d.ts","sourceRoot":"","sources":["../src/differenceInBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,EAC/B,QAAQ,CAAC,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACvC,MAAM,CAAC;AACV,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,QAAQ,CAAC,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACvC,MAAM,CAAC"}

package/dist/differenceInBusinessDays.js

@@ -1,7 +1,7 @@
 import {
   differenceInBusinessDays
-} from "./chunk-OVBZ2NBB.js";
-import "./chunk-K7CLBBBM.js";
+} from "./chunk-K7SY2MAX.js";
+import "./chunk-4YCEFGZA.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/differenceInCalendarDays.d.ts

@@ -0,0 +1,35 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Returns the number of calendar days between two dates, ignoring the time of day.
+ * Unlike differenceInDays, which counts complete 24-hour days, 23:00 to 01:00
+ * the next morning is one calendar day.
+ *
+ * PlainDate inputs are compared as given. Instant inputs use their UTC date and
+ * ZonedDateTime inputs use the date in their own timezone; convert both to one
+ * timezone first to count from a single point of view. Mixing a PlainDate with
+ * an Instant or ZonedDateTime throws a TypeError.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @returns Calendar days from earlierDate to laterDate; negative if laterDate is earlier
+ *
+ * @example
+ * ```ts
+ * const lateTonight = Temporal.ZonedDateTime.from('2025-01-20T23:00:00+01:00[Europe/Madrid]');
+ * const earlyTomorrow = Temporal.ZonedDateTime.from('2025-01-21T01:00:00+01:00[Europe/Madrid]');
+ *
+ * differenceInCalendarDays(earlyTomorrow, lateTonight); // 1
+ * differenceInDays(earlyTomorrow, lateTonight); // 0
+ * ```
+ *
+ * @example
+ * ```ts
+ * const due = Temporal.PlainDate.from('2025-03-01');
+ * const today = Temporal.PlainDate.from('2025-02-26');
+ *
+ * differenceInCalendarDays(due, today); // 3
+ * ```
+ */
+export declare function differenceInCalendarDays(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
+export declare function differenceInCalendarDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInCalendarDays.d.ts.map

package/dist/differenceInCalendarDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInCalendarDays.d.ts","sourceRoot":"","sources":["../src/differenceInCalendarDays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}

package/dist/differenceInCalendarDays.js

@@ -0,0 +1,10 @@
+import {
+  differenceInCalendarDays
+} from "./chunk-7PH5BPMS.js";
+import "./chunk-H43LMOCK.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInCalendarDays
+};
+//# sourceMappingURL=differenceInCalendarDays.js.map

package/dist/differenceInCalendarDays.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInCalendarMonths.d.ts

@@ -0,0 +1,27 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Returns the number of calendar months between two dates, ignoring the day of
+ * the month. Unlike differenceInMonths, which counts complete months, January 31
+ * to February 1 is one calendar month.
+ *
+ * PlainDate inputs are compared as given. Instant inputs use their UTC date and
+ * ZonedDateTime inputs use the date in their own timezone; convert both to one
+ * timezone first to count from a single point of view. Mixing a PlainDate with
+ * an Instant or ZonedDateTime throws a TypeError.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @returns Calendar months from earlierDate to laterDate; negative if laterDate is earlier
+ *
+ * @example
+ * ```ts
+ * const jan31 = Temporal.PlainDate.from('2025-01-31');
+ * const feb1 = Temporal.PlainDate.from('2025-02-01');
+ *
+ * differenceInCalendarMonths(feb1, jan31); // 1
+ * differenceInMonths(feb1, jan31); // 0
+ * ```
+ */
+export declare function differenceInCalendarMonths(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
+export declare function differenceInCalendarMonths(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInCalendarMonths.d.ts.map

package/dist/differenceInCalendarMonths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInCalendarMonths.d.ts","sourceRoot":"","sources":["../src/differenceInCalendarMonths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}

package/dist/differenceInCalendarMonths.js

@@ -0,0 +1,10 @@
+import {
+  differenceInCalendarMonths
+} from "./chunk-U6VFT2A5.js";
+import "./chunk-H43LMOCK.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInCalendarMonths
+};
+//# sourceMappingURL=differenceInCalendarMonths.js.map

package/dist/differenceInCalendarMonths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInCalendarQuarters.d.ts

@@ -0,0 +1,26 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Returns the number of calendar quarters between two dates, ignoring the
+ * position within the quarter. Quarters follow ISO months: Q1 is January–March.
+ *
+ * PlainDate inputs are compared as given. Instant inputs use their UTC date and
+ * ZonedDateTime inputs use the date in their own timezone; convert both to one
+ * timezone first to count from a single point of view. Mixing a PlainDate with
+ * an Instant or ZonedDateTime throws a TypeError.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @returns Calendar quarters from earlierDate to laterDate; negative if laterDate is earlier
+ *
+ * @example
+ * ```ts
+ * const endOfQ1 = Temporal.PlainDate.from('2025-03-31');
+ * const startOfQ2 = Temporal.PlainDate.from('2025-04-01');
+ *
+ * differenceInCalendarQuarters(startOfQ2, endOfQ1); // 1
+ * differenceInQuarters(startOfQ2, endOfQ1); // 0
+ * ```
+ */
+export declare function differenceInCalendarQuarters(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
+export declare function differenceInCalendarQuarters(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInCalendarQuarters.d.ts.map

package/dist/differenceInCalendarQuarters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInCalendarQuarters.d.ts","sourceRoot":"","sources":["../src/differenceInCalendarQuarters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIlD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}

package/dist/differenceInCalendarQuarters.js

@@ -0,0 +1,11 @@
+import {
+  differenceInCalendarQuarters
+} from "./chunk-OMUK2MOH.js";
+import "./chunk-XS2HUADA.js";
+import "./chunk-H43LMOCK.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInCalendarQuarters
+};
+//# sourceMappingURL=differenceInCalendarQuarters.js.map

package/dist/differenceInCalendarQuarters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInCalendarWeeks.d.ts

@@ -0,0 +1,29 @@
+import type { Temporal } from './shared/temporal.js';
+import { type WeekOptions } from './shared/week.js';
+/**
+ * Returns the number of week boundaries crossed between two dates, ignoring the
+ * day within the week. Weeks start on Monday (ISO 8601) unless `weekStartsOn`
+ * says otherwise.
+ *
+ * PlainDate inputs are compared as given. Instant inputs use their UTC date and
+ * ZonedDateTime inputs use the date in their own timezone; convert both to one
+ * timezone first to count from a single point of view. Mixing a PlainDate with
+ * an Instant or ZonedDateTime throws a TypeError.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday
+ * @returns Calendar weeks from earlierDate to laterDate; negative if laterDate is earlier
+ *
+ * @example
+ * ```ts
+ * const sunday = Temporal.PlainDate.from('2025-01-26');
+ * const monday = Temporal.PlainDate.from('2025-01-27');
+ *
+ * differenceInCalendarWeeks(monday, sunday); // 1
+ * differenceInCalendarWeeks(monday, sunday, { weekStartsOn: 7 }); // 0
+ * ```
+ */
+export declare function differenceInCalendarWeeks(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate, options?: WeekOptions): number;
+export declare function differenceInCalendarWeeks(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime, options?: WeekOptions): number;
+//# sourceMappingURL=differenceInCalendarWeeks.d.ts.map

package/dist/differenceInCalendarWeeks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInCalendarWeeks.d.ts","sourceRoot":"","sources":["../src/differenceInCalendarWeeks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,EAC/B,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC;AACV,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC"}

package/dist/differenceInCalendarWeeks.js

@@ -0,0 +1,11 @@
+import {
+  differenceInCalendarWeeks
+} from "./chunk-KZYWHHAQ.js";
+import "./chunk-M2XB72L5.js";
+import "./chunk-H43LMOCK.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInCalendarWeeks
+};
+//# sourceMappingURL=differenceInCalendarWeeks.js.map

package/dist/differenceInCalendarWeeks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInCalendarYears.d.ts

@@ -0,0 +1,27 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Returns the number of calendar years between two dates, ignoring the month and
+ * day. Unlike differenceInYears, which counts complete years, December 31 to
+ * January 1 is one calendar year.
+ *
+ * PlainDate inputs are compared as given. Instant inputs use their UTC date and
+ * ZonedDateTime inputs use the date in their own timezone; convert both to one
+ * timezone first to count from a single point of view. Mixing a PlainDate with
+ * an Instant or ZonedDateTime throws a TypeError.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @returns Calendar years from earlierDate to laterDate; negative if laterDate is earlier
+ *
+ * @example
+ * ```ts
+ * const newYearsEve = Temporal.PlainDate.from('2024-12-31');
+ * const newYearsDay = Temporal.PlainDate.from('2025-01-01');
+ *
+ * differenceInCalendarYears(newYearsDay, newYearsEve); // 1
+ * differenceInYears(newYearsDay, newYearsEve); // 0
+ * ```
+ */
+export declare function differenceInCalendarYears(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
+export declare function differenceInCalendarYears(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInCalendarYears.d.ts.map

package/dist/differenceInCalendarYears.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInCalendarYears.d.ts","sourceRoot":"","sources":["../src/differenceInCalendarYears.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}

package/dist/differenceInCalendarYears.js

@@ -0,0 +1,10 @@
+import {
+  differenceInCalendarYears
+} from "./chunk-C7QA4J6V.js";
+import "./chunk-H43LMOCK.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInCalendarYears
+};
+//# sourceMappingURL=differenceInCalendarYears.js.map

package/dist/differenceInCalendarYears.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/eachWeekOfInterval.d.ts

@@ -1,18 +1,20 @@
 import { Temporal } from './shared/temporal.js';
+import { type WeekOptions } from './shared/week.js';
 /**
  * PlainDate endpoints return date-only period starts in the start calendar.
  * Mixed date-only/timeline endpoints are rejected. Reversed endpoints return [].
  *
  * Returns an array of ZonedDateTime objects for each week within the interval.
- * Each element represents the first moment of the week (Monday at midnight).
- * Uses ISO 8601 week definition: weeks start on Monday.
+ * Each element represents the first moment of the week (midnight on its first day).
+ * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.
  * The interval is inclusive of both start and end weeks.
  *
  * For Instant inputs, UTC is used as the timezone.
  * For ZonedDateTime inputs, the timezone of the start date is preserved.
  *
  * @param interval - The interval with start and end datetimes
- * @returns Array of ZonedDateTime at start of each week (Monday) in the interval
+ * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday
+ * @returns Array of ZonedDateTime at the start of each week in the interval
  *
  * @example
  * ```ts
@@ -57,9 +59,9 @@ import { Temporal } from './shared/temporal.js';
 export declare function eachWeekOfInterval(interval: {
     start: Temporal.PlainDate;
     end: Temporal.PlainDate;
-}): Temporal.PlainDate[];
+}, options?: WeekOptions): Temporal.PlainDate[];
 export declare function eachWeekOfInterval(interval: {
     start: Temporal.Instant | Temporal.ZonedDateTime;
     end: Temporal.Instant | Temporal.ZonedDateTime;
-}): Temporal.ZonedDateTime[];
+}, options?: WeekOptions): Temporal.ZonedDateTime[];
 //# sourceMappingURL=eachWeekOfInterval.d.ts.map

package/dist/eachWeekOfInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eachWeekOfInterval.d.ts","sourceRoot":"","sources":["../src/eachWeekOfInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAK1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAC1B,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC;CACzB,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC;AACzB,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;IACjD,GAAG,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;CAChD,GAAG,QAAQ,CAAC,aAAa,EAAE,CAAC"}
+{"version":3,"file":"eachWeekOfInterval.d.ts","sourceRoot":"","sources":["../src/eachWeekOfInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAI1D,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,SAAS,EAAE,CAAC;AACxB,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE;IACR,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;IACjD,GAAG,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;CAChD,EACD,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,aAAa,EAAE,CAAC"}

package/dist/eachWeekOfInterval.js

@@ -1,8 +1,9 @@
 import {
   eachWeekOfInterval
-} from "./chunk-AOODDNHA.js";
+} from "./chunk-DYIISNVW.js";
 import "./chunk-ZM32S3YU.js";
 import "./chunk-ADPVFELS.js";
+import "./chunk-M2XB72L5.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/endOfQuarter.js

@@ -1,10 +1,10 @@
 import {
   endOfQuarter
-} from "./chunk-MXYAZTDE.js";
-import "./chunk-XS2HUADA.js";
+} from "./chunk-4FQCY75E.js";
 import "./chunk-TCB3IDJM.js";
 import "./chunk-NMMMAMKP.js";
 import "./chunk-2AID4P2C.js";
+import "./chunk-XS2HUADA.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/endOfWeek.d.ts

@@ -1,12 +1,14 @@
 import { type Temporal } from './shared/temporal.js';
 import type { Timezone } from './types.js';
+import { type WeekOptions } from './shared/week.js';
 /**
- * Returns the last boundary of the week (Sunday).
- * Uses ISO 8601 week definition: weeks end on Sunday.
+ * Returns the last boundary of the week.
+ * Weeks start on Monday and end on Sunday (ISO 8601) unless `weekStartsOn` says otherwise.
  * PlainDate inputs stay in calendar space unless a timezone is provided.
  *
- * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
- * @returns ZonedDateTime at Sunday 23:59:59.999999999
+ * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate
+ * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday
+ * @returns The last day of the week at 23:59:59.999999999, or that date for PlainDate input
  *
  * @example
  * ```ts
@@ -39,8 +41,16 @@ import type { Timezone } from './types.js';
  * const end = endOfWeek(date, 'America/New_York');
  * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)
  * ```
+ *
+ * @example
+ * ```ts
+ * // Weeks that start on Sunday end on Saturday
+ * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday
+ * const end = endOfWeek(date, { weekStartsOn: 7 });
+ * // 2025-01-25 (next Saturday)
+ * ```
  */
-export declare function endOfWeek(input: Temporal.Instant | Temporal.ZonedDateTime): Temporal.ZonedDateTime;
-export declare function endOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;
-export declare function endOfWeek(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;
+export declare function endOfWeek(input: Temporal.Instant | Temporal.ZonedDateTime, options?: WeekOptions): Temporal.ZonedDateTime;
+export declare function endOfWeek(input: Temporal.PlainDate, options?: WeekOptions): Temporal.PlainDate;
+export declare function endOfWeek(input: Temporal.PlainDate, timezone: Timezone, options?: WeekOptions): Temporal.ZonedDateTime;
 //# sourceMappingURL=endOfWeek.d.ts.map

package/dist/endOfWeek.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endOfWeek.d.ts","sourceRoot":"","sources":["../src/endOfWeek.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;AACzE,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAAC,aAAa,CAAC"}
+{"version":3,"file":"endOfWeek.d.ts","sourceRoot":"","sources":["../src/endOfWeek.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC;AAChG,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,aAAa,CAAC"}

package/dist/endOfWeek.js

@@ -1,8 +1,9 @@
 import {
   endOfWeek
-} from "./chunk-2TISXHHK.js";
+} from "./chunk-DVZDJ5LM.js";
 import "./chunk-NMMMAMKP.js";
 import "./chunk-2AID4P2C.js";
+import "./chunk-M2XB72L5.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,mBAAmB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAmB,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEjF,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,sBAAsB,GAAG;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAA;CAAE,GACtD,MAAM,CAAC;AACV,wBAAgB,MAAM,CACpB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAAC"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,mBAAmB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAmB,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAGjF,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,sBAAsB,GAAG;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAA;CAAE,GACtD,MAAM,CAAC;AACV,wBAAgB,MAAM,CACpB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAAC"}

package/dist/format.js

@@ -1,6 +1,7 @@
 import {
   format
-} from "./chunk-BYPHFTFD.js";
+} from "./chunk-2LT2XOAL.js";
+import "./chunk-HH2HTC44.js";
 import "./chunk-TWXUGWYX.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";