@gobrand/tiempo 3.1.3 → 3.2.0

package/dist/chunk-4YCEFGZA.js

@@ -0,0 +1,61 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/businessDays.ts
+function isWeekendDay(dayOfWeek) {
+  return dayOfWeek >= 6;
+}
+function addWeekdays(start, days) {
+  if (!Number.isInteger(days)) {
+    throw new RangeError("Business day counts must be integers");
+  }
+  const step = days < 0 ? -1 : 1;
+  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));
+  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });
+  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0; ) {
+    result = result.add({ days: step });
+    if (!isWeekendDay(result.dayOfWeek)) remaining--;
+  }
+  return result;
+}
+function isoDate(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();
+  return Temporal.PlainDate.from(date.toString()).withCalendar("iso8601");
+}
+function addBusinessDaysSkipping(start, days, holidays) {
+  let result = addWeekdays(start, days);
+  const dates = weekdayHolidays(holidays);
+  if (dates.length === 0 || days === 0) return result;
+  const step = days < 0 ? -1 : 1;
+  for (let from = isoDate(start); ; ) {
+    const to = isoDate(result);
+    const skipped = dates.filter(
+      (date) => step > 0 ? Temporal.PlainDate.compare(date, from) > 0 && Temporal.PlainDate.compare(date, to) <= 0 : Temporal.PlainDate.compare(date, from) < 0 && Temporal.PlainDate.compare(date, to) >= 0
+    ).length;
+    if (skipped === 0) return result;
+    from = to;
+    result = addWeekdays(result, step * skipped);
+  }
+}
+function weekdayHolidays(holidays) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const holiday of holidays) {
+    const date = isoDate(holiday);
+    if (!isWeekendDay(date.dayOfWeek)) unique.set(date.toString(), date);
+  }
+  return [...unique.values()];
+}
+
+export {
+  isWeekendDay,
+  addWeekdays,
+  isoDate,
+  addBusinessDaysSkipping,
+  weekdayHolidays
+};
+//# sourceMappingURL=chunk-4YCEFGZA.js.map

package/dist/chunk-4YCEFGZA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/businessDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\n/**\n * @internal\n * Saturday (6) and Sunday (7) in Temporal's Monday-based dayOfWeek.\n */\nexport function isWeekendDay(dayOfWeek: number): boolean {\n  return dayOfWeek >= 6;\n}\n\n/**\n * @internal\n * Adds days counting only Monday–Friday. The result keeps the input's type,\n * time of day, and timezone.\n */\nexport function addWeekdays<T extends { dayOfWeek: number; add(duration: { days: number }): T }>(\n  start: T,\n  days: number\n): T {\n  if (!Number.isInteger(days)) {\n    throw new RangeError('Business day counts must be integers');\n  }\n  const step = days < 0 ? -1 : 1;\n  // Any 7 consecutive days hold exactly 5 weekdays, so jump whole weeks. Keep\n  // at least one business day to walk so a weekend landing is never returned.\n  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));\n  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });\n  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0;) {\n    result = result.add({ days: step });\n    if (!isWeekendDay(result.dayOfWeek)) remaining--;\n  }\n  return result;\n}\n\n/**\n * @internal\n * The calendar date of a value as an ISO PlainDate from this library's\n * Temporal implementation. Instant uses UTC; ZonedDateTime uses its timezone.\n */\nexport function isoDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): Temporal.PlainDate {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();\n  return Temporal.PlainDate.from(date.toString()).withCalendar('iso8601');\n}\n\n/**\n * @internal\n * Adds days counting only Monday–Friday that are not holidays. Holidays are\n * matched by ISO date; those on weekends are already skipped.\n */\nexport function addBusinessDaysSkipping<\n  T extends (Temporal.ZonedDateTime | Temporal.PlainDate) & {\n    add(duration: { days: number }): T;\n  }\n>(start: T, days: number, holidays: readonly Temporal.PlainDate[]): T {\n  let result = addWeekdays<T>(start, days);\n  const dates = weekdayHolidays(holidays);\n  if (dates.length === 0 || days === 0) return result;\n\n  // Each holiday passed over pushes the result one more business day along.\n  // Repeat until a stretch passes no holiday, which also leaves the result off one.\n  const step = days < 0 ? -1 : 1;\n  for (let from = isoDate(start); ;) {\n    const to = isoDate(result);\n    const skipped = dates.filter((date) =>\n      step > 0\n        ? Temporal.PlainDate.compare(date, from) > 0 && Temporal.PlainDate.compare(date, to) <= 0\n        : Temporal.PlainDate.compare(date, from) < 0 && Temporal.PlainDate.compare(date, to) >= 0\n    ).length;\n    if (skipped === 0) return result;\n    from = to;\n    result = addWeekdays<T>(result, step * skipped);\n  }\n}\n\n/**\n * @internal\n * Distinct holidays that fall Monday–Friday, as ISO PlainDates.\n */\nexport function weekdayHolidays(holidays: readonly Temporal.PlainDate[]): Temporal.PlainDate[] {\n  const unique = new Map<string, Temporal.PlainDate>();\n  for (const holiday of holidays) {\n    const date = isoDate(holiday);\n    if (!isWeekendDay(date.dayOfWeek)) unique.set(date.toString(), date);\n  }\n  return [...unique.values()];\n}\n"],"mappings":";;;;;;;;;AAOO,SAAS,aAAa,WAA4B;AACvD,SAAO,aAAa;AACtB;AAOO,SAAS,YACd,OACA,MACG;AACH,MAAI,CAAC,OAAO,UAAU,IAAI,GAAG;AAC3B,UAAM,IAAI,WAAW,sCAAsC;AAAA,EAC7D;AACA,QAAM,OAAO,OAAO,IAAI,KAAK;AAG7B,QAAM,YAAY,KAAK,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC;AAClE,MAAI,SAAS,cAAc,IAAI,QAAQ,MAAM,IAAI,EAAE,MAAM,OAAO,YAAY,EAAE,CAAC;AAC/E,WAAS,YAAY,KAAK,IAAI,IAAI,IAAI,YAAY,GAAG,YAAY,KAAI;AACnE,aAAS,OAAO,IAAI,EAAE,MAAM,KAAK,CAAC;AAClC,QAAI,CAAC,aAAa,OAAO,SAAS,EAAG;AAAA,EACvC;AACA,SAAO;AACT;AAOO,SAAS,QACd,OACoB;AACpB,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK,EAAE,YAAY;AACpF,SAAO,SAAS,UAAU,KAAK,KAAK,SAAS,CAAC,EAAE,aAAa,SAAS;AACxE;AAOO,SAAS,wBAId,OAAU,MAAc,UAA4C;AACpE,MAAI,SAAS,YAAe,OAAO,IAAI;AACvC,QAAM,QAAQ,gBAAgB,QAAQ;AACtC,MAAI,MAAM,WAAW,KAAK,SAAS,EAAG,QAAO;AAI7C,QAAM,OAAO,OAAO,IAAI,KAAK;AAC7B,WAAS,OAAO,QAAQ,KAAK,OAAM;AACjC,UAAM,KAAK,QAAQ,MAAM;AACzB,UAAM,UAAU,MAAM;AAAA,MAAO,CAAC,SAC5B,OAAO,IACH,SAAS,UAAU,QAAQ,MAAM,IAAI,IAAI,KAAK,SAAS,UAAU,QAAQ,MAAM,EAAE,KAAK,IACtF,SAAS,UAAU,QAAQ,MAAM,IAAI,IAAI,KAAK,SAAS,UAAU,QAAQ,MAAM,EAAE,KAAK;AAAA,IAC5F,EAAE;AACF,QAAI,YAAY,EAAG,QAAO;AAC1B,WAAO;AACP,aAAS,YAAe,QAAQ,OAAO,OAAO;AAAA,EAChD;AACF;AAMO,SAAS,gBAAgB,UAA+D;AAC7F,QAAM,SAAS,oBAAI,IAAgC;AACnD,aAAW,WAAW,UAAU;AAC9B,UAAM,OAAO,QAAQ,OAAO;AAC5B,QAAI,CAAC,aAAa,KAAK,SAAS,EAAG,QAAO,IAAI,KAAK,SAAS,GAAG,IAAI;AAAA,EACrE;AACA,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC;AAC5B;","names":[]}

package/dist/chunk-6UBFKQIJ.js

@@ -0,0 +1,20 @@
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+
+// src/isSameWeek.ts
+function isSameWeek(date1, date2, options) {
+  const zoned1 = normalizeTemporalInput(date1);
+  const zoned2 = normalizeTemporalInput(date2);
+  const start1 = zoned1.toPlainDate().subtract({ days: daysIntoWeek(zoned1.dayOfWeek, options) });
+  const start2 = zoned2.toPlainDate().subtract({ days: daysIntoWeek(zoned2.dayOfWeek, options) });
+  return start1.toString() === start2.withCalendar(start1.calendarId).toString();
+}
+
+export {
+  isSameWeek
+};
+//# sourceMappingURL=chunk-6UBFKQIJ.js.map

package/dist/chunk-6UBFKQIJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameWeek.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * Returns true if both datetimes fall in the same week.\n * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday\n * @returns true if both dates are in the same week, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same week (both in week 4 of 2025)\n * const monday = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]'); // Monday, Week 4\n * const sunday = Temporal.ZonedDateTime.from('2025-01-26T23:59:59+00:00[UTC]'); // Sunday, Week 4\n *\n * isSameWeek(monday, sunday); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different weeks\n * const week3 = Temporal.ZonedDateTime.from('2025-01-19T23:59:59+00:00[UTC]'); // Sunday, Week 3\n * const week4 = Temporal.ZonedDateTime.from('2025-01-20T00:00:00+00:00[UTC]'); // Monday, Week 4\n *\n * isSameWeek(week3, week4); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar weeks\n * const ny = Temporal.ZonedDateTime.from('2025-01-26T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-27T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local weeks from each person's perspective\n * isSameWeek(ny, tokyo); // false (Week 4 Sun in NY, Week 5 Mon in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameWeek(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Week 5 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameWeek(ny, tokyo.withTimeZone('America/New_York')); // true (both Week 4 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T00:00:00Z'); // Monday, Week 4\n * const instant2 = Temporal.Instant.from('2025-01-26T23:59:59Z'); // Sunday, Week 4\n *\n * isSameWeek(instant1, instant2); // true (both Week 4 2025 in UTC)\n * ```\n *\n * @example\n * ```ts\n * // ISO week years can differ from calendar years\n * // December 29, 2024 is in Week 52 of 2024\n * const dec29 = Temporal.ZonedDateTime.from('2024-12-29T12:00:00+00:00[UTC]');\n * // January 5, 2025 is in Week 1 of 2025\n * const jan5 = Temporal.ZonedDateTime.from('2025-01-05T12:00:00+00:00[UTC]');\n *\n * isSameWeek(dec29, jan5); // false (different ISO weeks)\n * ```\n *\n * @example\n * ```ts\n * // Weeks that start on Sunday\n * const saturday = Temporal.ZonedDateTime.from('2025-01-25T12:00:00+00:00[UTC]');\n * const sunday = Temporal.ZonedDateTime.from('2025-01-26T12:00:00+00:00[UTC]');\n *\n * isSameWeek(saturday, sunday); // true\n * isSameWeek(saturday, sunday, { weekStartsOn: 7 }); // false\n * ```\n */\nexport function isSameWeek(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: WeekOptions\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n  const start1 = zoned1.toPlainDate().subtract({ days: daysIntoWeek(zoned1.dayOfWeek, options) });\n  const start2 = zoned2.toPlainDate().subtract({ days: daysIntoWeek(zoned2.dayOfWeek, options) });\n\n  return start1.toString() === start2.withCalendar(start1.calendarId).toString();\n}\n"],"mappings":";;;;;;;;AAiFO,SAAS,WACd,OACA,OACA,SACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,OAAO,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,OAAO,WAAW,OAAO,EAAE,CAAC;AAC9F,QAAM,SAAS,OAAO,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,OAAO,WAAW,OAAO,EAAE,CAAC;AAE9F,SAAO,OAAO,SAAS,MAAM,OAAO,aAAa,OAAO,UAAU,EAAE,SAAS;AAC/E;","names":[]}

package/dist/chunk-7PH5BPMS.js

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

package/dist/chunk-7PH5BPMS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarDays.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\n\n/**\n * Returns the number of calendar days between two dates, ignoring the time of day.\n * Unlike differenceInDays, which counts complete 24-hour days, 23:00 to 01:00\n * the next morning is one calendar day.\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 days from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const lateTonight = Temporal.ZonedDateTime.from('2025-01-20T23:00:00+01:00[Europe/Madrid]');\n * const earlyTomorrow = Temporal.ZonedDateTime.from('2025-01-21T01:00:00+01:00[Europe/Madrid]');\n *\n * differenceInCalendarDays(earlyTomorrow, lateTonight); // 1\n * differenceInDays(earlyTomorrow, lateTonight); // 0\n * ```\n *\n * @example\n * ```ts\n * const due = Temporal.PlainDate.from('2025-03-01');\n * const today = Temporal.PlainDate.from('2025-02-26');\n *\n * differenceInCalendarDays(due, today); // 3\n * ```\n */\nexport function differenceInCalendarDays(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarDays(\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.until(later, { largestUnit: 'days' }).days;\n}\n"],"mappings":";;;;;AA0CO,SAAS,yBACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,SAAO,QAAQ,MAAM,OAAO,EAAE,aAAa,OAAO,CAAC,EAAE;AACvD;","names":[]}

package/dist/chunk-C7QA4J6V.js

@@ -0,0 +1,14 @@
+import {
+  calendarDates
+} from "./chunk-H43LMOCK.js";
+
+// src/differenceInCalendarYears.ts
+function differenceInCalendarYears(laterDate, earlierDate) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate);
+  return later.year - earlier.year;
+}
+
+export {
+  differenceInCalendarYears
+};
+//# sourceMappingURL=chunk-C7QA4J6V.js.map

package/dist/chunk-C7QA4J6V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarYears.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\n\n/**\n * Returns the number of calendar years between two dates, ignoring the month and\n * day. Unlike differenceInYears, which counts complete years, December 31 to\n * January 1 is one calendar year.\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 years from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const newYearsEve = Temporal.PlainDate.from('2024-12-31');\n * const newYearsDay = Temporal.PlainDate.from('2025-01-01');\n *\n * differenceInCalendarYears(newYearsDay, newYearsEve); // 1\n * differenceInYears(newYearsDay, newYearsEve); // 0\n * ```\n */\nexport function differenceInCalendarYears(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarYears(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarYears(\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 later.year - earlier.year;\n}\n"],"mappings":";;;;;AAkCO,SAAS,0BACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,SAAO,MAAM,OAAO,QAAQ;AAC9B;","names":[]}

package/dist/chunk-DVZDJ5LM.js

@@ -0,0 +1,33 @@
+import {
+  getEndOfDay
+} from "./chunk-NMMMAMKP.js";
+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/endOfWeek.ts
+function endOfWeek(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.add({ days: 6 - daysIntoWeek(input.dayOfWeek, weekOptions) });
+  }
+  const zonedDateTime = isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
+  return getEndOfDay(
+    zonedDateTime.add({ days: 6 - daysIntoWeek(zonedDateTime.dayOfWeek, weekOptions) })
+  );
+}
+
+export {
+  endOfWeek
+};
+//# sourceMappingURL=chunk-DVZDJ5LM.js.map

package/dist/chunk-DVZDJ5LM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * Returns the last boundary of the week.\n * Weeks start on Monday and end on Sunday (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 last day of the week at 23:59:59.999999999, 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 end = endOfWeek(instant);\n * // 2025-01-26T23:59:59.999999999+00:00[UTC] (next Sunday)\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 end = endOfWeek(zoned);\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date);\n * // 2025-01-26 (next Sunday)\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 end = endOfWeek(date, 'America/New_York');\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // Weeks that start on Sunday end on Saturday\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date, { weekStartsOn: 7 });\n * // 2025-01-25 (next Saturday)\n * ```\n */\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: WeekOptions\n): Temporal.ZonedDateTime;\nexport function endOfWeek(input: Temporal.PlainDate, options?: WeekOptions): Temporal.PlainDate;\nexport function endOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone,\n  options?: WeekOptions\n): Temporal.ZonedDateTime;\nexport function endOfWeek(\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.add({ days: 6 - daysIntoWeek(input.dayOfWeek, weekOptions) });\n  }\n\n  const zonedDateTime = isPlainDate(input)\n    ? plainDateToZonedDateTime(input, timezone!)\n    : normalizeTemporalInput(input);\n\n  return getEndOfDay(\n    zonedDateTime.add({ days: 6 - daysIntoWeek(zonedDateTime.dayOfWeek, weekOptions) })\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkEO,SAAS,UACd,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,IAAI,EAAE,MAAM,IAAI,aAAa,MAAM,WAAW,WAAW,EAAE,CAAC;AAAA,EAC3E;AAEA,QAAM,gBAAgB,YAAY,KAAK,IACnC,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAEhC,SAAO;AAAA,IACL,cAAc,IAAI,EAAE,MAAM,IAAI,aAAa,cAAc,WAAW,WAAW,EAAE,CAAC;AAAA,EACpF;AACF;","names":[]}

package/dist/{chunk-AOODDNHA.js → chunk-DYIISNVW.js}

@@ -4,6 +4,9 @@ import {
 import {
   isPlainDateAfter
 } from "./chunk-ADPVFELS.js";
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
 import {
   normalizeTemporalInput
 } from "./chunk-Q6QLOUXJ.js";
@@ -12,15 +15,17 @@ import {
 } from "./chunk-BSVOJYJ7.js";
 
 // src/eachWeekOfInterval.ts
-function eachWeekOfInterval(interval) {
+function eachWeekOfInterval(interval, options) {
   if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
     if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
       throw new TypeError("PlainDate intervals require two PlainDate endpoints");
     }
     if (isPlainDateAfter(interval.start, interval.end)) return [];
     const end = interval.end.withCalendar(interval.start.calendarId);
-    const last = end.subtract({ days: end.dayOfWeek - 1 });
-    let current2 = interval.start.subtract({ days: interval.start.dayOfWeek - 1 });
+    const last = end.subtract({ days: daysIntoWeek(end.dayOfWeek, options) });
+    let current2 = interval.start.subtract({
+      days: daysIntoWeek(interval.start.dayOfWeek, options)
+    });
     const dates = [];
     while (isPlainDateBefore(current2, last)) {
       dates.push(current2);
@@ -32,15 +37,12 @@ function eachWeekOfInterval(interval) {
   const startZoned = normalizeTemporalInput(interval.start);
   const endZoned = normalizeTemporalInput(interval.end);
   if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
-  const timezone = startZoned.timeZoneId;
-  const daysToSubtractStart = startZoned.dayOfWeek - 1;
-  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();
-  const endInTimezone = endZoned.withTimeZone(timezone);
-  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;
-  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();
+  const startOfFirstWeek = startZoned.subtract({ days: daysIntoWeek(startZoned.dayOfWeek, options) }).startOfDay();
+  const endInTimezone = endZoned.withTimeZone(startZoned.timeZoneId);
+  const startOfLastWeek = endInTimezone.subtract({ days: daysIntoWeek(endInTimezone.dayOfWeek, options) }).startOfDay();
   const weeks = [];
-  let current = startMonday;
-  while (current.epochNanoseconds <= endMonday.epochNanoseconds) {
+  let current = startOfFirstWeek;
+  while (current.epochNanoseconds <= startOfLastWeek.epochNanoseconds) {
     weeks.push(current);
     current = current.add({ weeks: 1 });
   }
@@ -50,4 +52,4 @@ function eachWeekOfInterval(interval) {
 export {
   eachWeekOfInterval
 };
-//# sourceMappingURL=chunk-AOODDNHA.js.map
+//# sourceMappingURL=chunk-DYIISNVW.js.map

package/dist/chunk-DYIISNVW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachWeekOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * PlainDate endpoints return date-only period starts in the start calendar.\n * Mixed date-only/timeline endpoints are rejected. Reversed endpoints return [].\n *\n * Returns an array of ZonedDateTime objects for each week within the interval.\n * Each element represents the first moment of the week (midnight on its first day).\n * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.\n * The interval is inclusive of both start and end weeks.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday\n * @returns Array of ZonedDateTime at the start of each week in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00+00:00[UTC]'); // Monday\n * const end = Temporal.ZonedDateTime.from('2025-01-22T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Week 2\n * //   2025-01-13T00:00:00+00:00[UTC],  // Week 3\n * //   2025-01-20T00:00:00+00:00[UTC]   // Week 4\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Mid-week start\n * const start = Temporal.ZonedDateTime.from('2025-01-08T10:00:00+00:00[UTC]'); // Wednesday\n * const end = Temporal.ZonedDateTime.from('2025-01-15T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Monday of week containing Jan 8\n * //   2025-01-13T00:00:00+00:00[UTC]   // Monday of week containing Jan 15\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-12-25T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T00:00:00+00:00[UTC]');\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2024-12-23T00:00:00+00:00[UTC],  // Monday of week containing Dec 25\n * //   2024-12-30T00:00:00+00:00[UTC],  // Monday of week containing Dec 30\n * //   2025-01-06T00:00:00+00:00[UTC]   // Monday of week containing Jan 8\n * // ]\n * ```\n */\nexport function eachWeekOfInterval(\n  interval: { start: Temporal.PlainDate; end: Temporal.PlainDate },\n  options?: WeekOptions\n): Temporal.PlainDate[];\nexport function eachWeekOfInterval(\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime;\n    end: Temporal.Instant | Temporal.ZonedDateTime;\n  },\n  options?: WeekOptions\n): Temporal.ZonedDateTime[];\nexport function eachWeekOfInterval(\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n    end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  },\n  options?: WeekOptions\n): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    const end = interval.end.withCalendar(interval.start.calendarId);\n    const last = end.subtract({ days: daysIntoWeek(end.dayOfWeek, options) });\n    let current = interval.start.subtract({\n      days: daysIntoWeek(interval.start.dayOfWeek, options)\n    });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ weeks: 1 });\n    }\n    dates.push(current);\n    return dates;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const startOfFirstWeek = startZoned\n    .subtract({ days: daysIntoWeek(startZoned.dayOfWeek, options) })\n    .startOfDay();\n  const endInTimezone = endZoned.withTimeZone(startZoned.timeZoneId);\n  const startOfLastWeek = endInTimezone\n    .subtract({ days: daysIntoWeek(endInTimezone.dayOfWeek, options) })\n    .startOfDay();\n\n  const weeks: Temporal.ZonedDateTime[] = [];\n  let current = startOfFirstWeek;\n\n  while (current.epochNanoseconds <= startOfLastWeek.epochNanoseconds) {\n    weeks.push(current);\n    current = current.add({ weeks: 1 });\n  }\n\n  return weeks;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyEO,SAAS,mBACd,UAIA,SACiD;AACjD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,UAAM,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAC/D,UAAM,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,IAAI,WAAW,OAAO,EAAE,CAAC;AACxE,QAAIA,WAAU,SAAS,MAAM,SAAS;AAAA,MACpC,MAAM,aAAa,SAAS,MAAM,WAAW,OAAO;AAAA,IACtD,CAAC;AACD,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAKA,QAAO;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,mBAAmB,WACtB,SAAS,EAAE,MAAM,aAAa,WAAW,WAAW,OAAO,EAAE,CAAC,EAC9D,WAAW;AACd,QAAM,gBAAgB,SAAS,aAAa,WAAW,UAAU;AACjE,QAAM,kBAAkB,cACrB,SAAS,EAAE,MAAM,aAAa,cAAc,WAAW,OAAO,EAAE,CAAC,EACjE,WAAW;AAEd,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,gBAAgB,kBAAkB;AACnE,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":["current"]}

package/dist/{chunk-6QZUAJVF.js → chunk-GOJ45AG7.js}

@@ -1,6 +1,6 @@
 import {
   isWeekendDay
-} from "./chunk-K7CLBBBM.js";
+} from "./chunk-4YCEFGZA.js";
 import {
   normalizeTemporalInput
 } from "./chunk-Q6QLOUXJ.js";
@@ -17,4 +17,4 @@ function isWeekend(input) {
 export {
   isWeekend
 };
-//# sourceMappingURL=chunk-6QZUAJVF.js.map
+//# sourceMappingURL=chunk-GOJ45AG7.js.map

package/dist/chunk-H43LMOCK.js

@@ -0,0 +1,26 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/calendarDates.ts
+function calendarDates(laterDate, earlierDate) {
+  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {
+    throw new TypeError("PlainDate differences require two PlainDate values");
+  }
+  const later = dateOf(laterDate);
+  const earlier = dateOf(earlierDate);
+  return [later.withCalendar(earlier.calendarId), earlier];
+}
+function dateOf(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();
+  return Temporal.PlainDate.from(date.toString());
+}
+
+export {
+  calendarDates
+};
+//# sourceMappingURL=chunk-H43LMOCK.js.map

package/dist/chunk-H43LMOCK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/calendarDates.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\n/**\n * @internal\n * The calendar dates behind a differenceInCalendar* pair: PlainDates as given,\n * Instants by their UTC date, ZonedDateTimes by the date in their own timezone.\n * Both come back in this implementation and in the earlier date's calendar.\n */\nexport function calendarDates(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): [later: Temporal.PlainDate, earlier: Temporal.PlainDate] {\n  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {\n    throw new TypeError('PlainDate differences require two PlainDate values');\n  }\n  const later = dateOf(laterDate);\n  const earlier = dateOf(earlierDate);\n  return [later.withCalendar(earlier.calendarId), earlier];\n}\n\nfunction dateOf(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): Temporal.PlainDate {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();\n  // A canonical string brings dates from another Temporal implementation across.\n  return Temporal.PlainDate.from(date.toString());\n}\n"],"mappings":";;;;;;;;;AASO,SAAS,cACd,WACA,aAC0D;AAC1D,MAAI,YAAY,SAAS,MAAM,YAAY,WAAW,GAAG;AACvD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,QAAM,QAAQ,OAAO,SAAS;AAC9B,QAAM,UAAU,OAAO,WAAW;AAClC,SAAO,CAAC,MAAM,aAAa,QAAQ,UAAU,GAAG,OAAO;AACzD;AAEA,SAAS,OACP,OACoB;AACpB,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK,EAAE,YAAY;AAEpF,SAAO,SAAS,UAAU,KAAK,KAAK,SAAS,CAAC;AAChD;","names":[]}

package/dist/chunk-HH2HTC44.js

@@ -0,0 +1,87 @@
+// src/shared/formatTokens.ts
+function consumeToken(formatStr, start, char) {
+  if (char === "M" && start + 1 < formatStr.length && formatStr[start + 1] === "o") {
+    return "Mo";
+  }
+  if (char === "d" && start + 1 < formatStr.length && formatStr[start + 1] === "o") {
+    return "do";
+  }
+  let end = start;
+  while (end < formatStr.length && formatStr[end] === char) {
+    end++;
+  }
+  const count = end - start;
+  const validTokens = [
+    "GGGGG",
+    "GGGG",
+    "GGG",
+    "GG",
+    "G",
+    "yyyy",
+    "yyy",
+    "yy",
+    "y",
+    "QQQQQ",
+    "QQQQ",
+    "QQQ",
+    "QQ",
+    "Q",
+    "MMMMM",
+    "MMMM",
+    "MMM",
+    "MM",
+    "M",
+    "dd",
+    "d",
+    "EEEEEE",
+    "EEEEE",
+    "EEEE",
+    "EEE",
+    "EE",
+    "E",
+    "aaaaa",
+    "aaaa",
+    "aaa",
+    "aa",
+    "a",
+    "HH",
+    "H",
+    "hh",
+    "h",
+    "mm",
+    "m",
+    "ss",
+    "s",
+    "SSS",
+    "SS",
+    "S",
+    "XXXXX",
+    "XXXX",
+    "XXX",
+    "XX",
+    "X",
+    "xxxxx",
+    "xxxx",
+    "xxx",
+    "xx",
+    "x",
+    "zzzz",
+    "zzz",
+    "zz",
+    "z",
+    "T",
+    "t"
+  ];
+  for (let len = Math.min(count, 6); len > 0; len--) {
+    const candidate = char.repeat(len);
+    if (validTokens.includes(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export {
+  consumeToken
+};
+//# sourceMappingURL=chunk-HH2HTC44.js.map

package/dist/chunk-HH2HTC44.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/formatTokens.ts"],"sourcesContent":["/**\n * @internal\n * Reads the format token that starts at `start`, or null if `char` does not\n * start one. A run of one letter longer than any token splits into several,\n * longest first. Shared by format and parse so both read a pattern the same way.\n */\nexport function consumeToken(formatStr: string, start: number, char: string): string | null {\n  // Special case for 'Mo' and 'do' - these end with 'o'\n  if (char === 'M' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'Mo';\n  }\n  if (char === 'd' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'do';\n  }\n\n  // Count how many consecutive identical characters\n  let end = start;\n  while (end < formatStr.length && formatStr[end] === char) {\n    end++;\n  }\n  const count = end - start;\n\n  // Check if this is a valid token pattern\n  const validTokens = [\n    'GGGGG',\n    'GGGG',\n    'GGG',\n    'GG',\n    'G',\n    'yyyy',\n    'yyy',\n    'yy',\n    'y',\n    'QQQQQ',\n    'QQQQ',\n    'QQQ',\n    'QQ',\n    'Q',\n    'MMMMM',\n    'MMMM',\n    'MMM',\n    'MM',\n    'M',\n    'dd',\n    'd',\n    'EEEEEE',\n    'EEEEE',\n    'EEEE',\n    'EEE',\n    'EE',\n    'E',\n    'aaaaa',\n    'aaaa',\n    'aaa',\n    'aa',\n    'a',\n    'HH',\n    'H',\n    'hh',\n    'h',\n    'mm',\n    'm',\n    'ss',\n    's',\n    'SSS',\n    'SS',\n    'S',\n    'XXXXX',\n    'XXXX',\n    'XXX',\n    'XX',\n    'X',\n    'xxxxx',\n    'xxxx',\n    'xxx',\n    'xx',\n    'x',\n    'zzzz',\n    'zzz',\n    'zz',\n    'z',\n    'T',\n    't'\n  ];\n\n  // Try to match from longest to shortest\n  for (let len = Math.min(count, 6); len > 0; len--) {\n    const candidate = char.repeat(len);\n    if (validTokens.includes(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n"],"mappings":";AAMO,SAAS,aAAa,WAAmB,OAAe,MAA6B;AAE1F,MAAI,SAAS,OAAO,QAAQ,IAAI,UAAU,UAAU,UAAU,QAAQ,CAAC,MAAM,KAAK;AAChF,WAAO;AAAA,EACT;AACA,MAAI,SAAS,OAAO,QAAQ,IAAI,UAAU,UAAU,UAAU,QAAQ,CAAC,MAAM,KAAK;AAChF,WAAO;AAAA,EACT;AAGA,MAAI,MAAM;AACV,SAAO,MAAM,UAAU,UAAU,UAAU,GAAG,MAAM,MAAM;AACxD;AAAA,EACF;AACA,QAAM,QAAQ,MAAM;AAGpB,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAGA,WAAS,MAAM,KAAK,IAAI,OAAO,CAAC,GAAG,MAAM,GAAG,OAAO;AACjD,UAAM,YAAY,KAAK,OAAO,GAAG;AACjC,QAAI,YAAY,SAAS,SAAS,GAAG;AACnC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-IDB3R3G5.js

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

package/dist/chunk-IDB3R3G5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nextDay.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 next date that falls on the given day of the week, always after\n * the input: next Friday from a Friday is a week later.\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 next date on that day of the week\n *\n * @example\n * ```ts\n * const wednesday = Temporal.PlainDate.from('2025-01-22');\n *\n * nextDay(wednesday, 5).toString(); // \"2025-01-24\"\n * nextDay(wednesday, 3).toString(); // \"2025-01-29\"\n * ```\n *\n * @example\n * ```ts\n * // Keeps the wall-clock time across a DST change\n * const fridayEvening = Temporal.ZonedDateTime.from('2025-03-07T18:00:00-05:00[America/New_York]');\n *\n * nextDay(fridayEvening, 1).toString(); // \"2025-03-10T18:00:00-04:00[America/New_York]\"\n * ```\n */\nexport function nextDay(input: Temporal.PlainDate, day: DayOfWeek): Temporal.PlainDate;\nexport function nextDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  day: DayOfWeek\n): Temporal.ZonedDateTime;\nexport function nextDay(\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.add({ days: ((day - value.dayOfWeek + 6) % 7) + 1 });\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,QACd,OACA,KAC6C;AAC7C,kBAAgB,KAAK,KAAK;AAC1B,QAAM,QAAQ,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACvE,SAAO,MAAM,IAAI,EAAE,OAAQ,MAAM,MAAM,YAAY,KAAK,IAAK,EAAE,CAAC;AAClE;","names":[]}

package/dist/chunk-IIEHQPKE.js

@@ -0,0 +1,36 @@
+import {
+  isBefore
+} from "./chunk-BMX7CIRD.js";
+import {
+  isAfter
+} from "./chunk-CDKIT7D3.js";
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate,
+  isPlainTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/isWithinInterval.ts
+function isWithinInterval(date, interval) {
+  const { start, end } = interval;
+  if ([date, start, end].some((value) => isPlainDate(value) || isPlainTime(value))) {
+    const afterStart = compare(date, start) >= 0;
+    const beforeEnd = compare(date, end) <= 0;
+    if (isPlainTime(start) && compare(start, end) > 0) return afterStart || beforeEnd;
+    return afterStart && beforeEnd;
+  }
+  const normalizedDate = normalizeTemporalInput(date);
+  const normalizedStart = normalizeTemporalInput(start);
+  const normalizedEnd = normalizeTemporalInput(end);
+  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);
+}
+
+export {
+  isWithinInterval
+};
+//# sourceMappingURL=chunk-IIEHQPKE.js.map

package/dist/chunk-IIEHQPKE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isWithinInterval.ts"],"sourcesContent":["import { type Temporal, isPlainDate, isPlainTime } from './shared/temporal';\nimport { compare, type Comparable, type Timeline } from './shared/compare';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { isAfter } from './shared/isAfter';\n\n/**\n * Returns true if the given value is within the interval (inclusive of start and end).\n *\n * Instants and ZonedDateTimes compare by the moment they represent, not by\n * calendar date/time. PlainDates compare by date. PlainTimes compare by\n * wall-clock time, and an interval whose start is later than its end wraps\n * past midnight: 22:00 to 02:00 contains 23:30 and 01:00. A reversed timeline\n * or PlainDate interval contains nothing.\n *\n * Mixing PlainDate, PlainTime, and timeline values throws a TypeError.\n *\n * @param date - The value to check\n * @param interval - The interval with start and end values of the same kind\n * @returns true if the value is within the interval, false otherwise\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date outside the interval\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // false\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval start (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(start, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval end (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(end, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const start = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-07T00:00:00Z');\n * const date = Temporal.Instant.from('2025-01-03T00:00:00Z');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+09:00[Asia/Tokyo]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Dates\n * const start = Temporal.PlainDate.from('2025-07-01');\n * const end = Temporal.PlainDate.from('2025-07-15');\n *\n * isWithinInterval(Temporal.PlainDate.from('2025-07-15'), { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Opening hours that run past midnight\n * const start = Temporal.PlainTime.from('22:00');\n * const end = Temporal.PlainTime.from('02:00');\n *\n * isWithinInterval(Temporal.PlainTime.from('23:30'), { start, end }); // true\n * isWithinInterval(Temporal.PlainTime.from('01:00'), { start, end }); // true\n * isWithinInterval(Temporal.PlainTime.from('12:00'), { start, end }); // false\n * ```\n */\nexport function isWithinInterval(\n  date: Temporal.PlainDate,\n  interval: { start: Temporal.PlainDate; end: Temporal.PlainDate }\n): boolean;\nexport function isWithinInterval(\n  date: Temporal.PlainTime,\n  interval: { start: Temporal.PlainTime; end: Temporal.PlainTime }\n): boolean;\nexport function isWithinInterval(\n  date: Temporal.Instant | Temporal.ZonedDateTime,\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime;\n    end: Temporal.Instant | Temporal.ZonedDateTime;\n  }\n): boolean;\nexport function isWithinInterval(\n  date: Comparable,\n  interval: { start: Comparable; end: Comparable }\n): boolean {\n  const { start, end } = interval;\n  if ([date, start, end].some((value) => isPlainDate(value) || isPlainTime(value))) {\n    const afterStart = compare(date, start) >= 0;\n    const beforeEnd = compare(date, end) <= 0;\n    if (isPlainTime(start) && compare(start, end) > 0) return afterStart || beforeEnd;\n    return afterStart && beforeEnd;\n  }\n\n  const normalizedDate = normalizeTemporalInput(date as Timeline);\n  const normalizedStart = normalizeTemporalInput(start as Timeline);\n  const normalizedEnd = normalizeTemporalInput(end as Timeline);\n\n  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiHO,SAAS,iBACd,MACA,UACS;AACT,QAAM,EAAE,OAAO,IAAI,IAAI;AACvB,MAAI,CAAC,MAAM,OAAO,GAAG,EAAE,KAAK,CAAC,UAAU,YAAY,KAAK,KAAK,YAAY,KAAK,CAAC,GAAG;AAChF,UAAM,aAAa,QAAQ,MAAM,KAAK,KAAK;AAC3C,UAAM,YAAY,QAAQ,MAAM,GAAG,KAAK;AACxC,QAAI,YAAY,KAAK,KAAK,QAAQ,OAAO,GAAG,IAAI,EAAG,QAAO,cAAc;AACxE,WAAO,cAAc;AAAA,EACvB;AAEA,QAAM,iBAAiB,uBAAuB,IAAgB;AAC9D,QAAM,kBAAkB,uBAAuB,KAAiB;AAChE,QAAM,gBAAgB,uBAAuB,GAAe;AAE5D,SAAO,CAAC,SAAS,gBAAgB,eAAe,KAAK,CAAC,QAAQ,gBAAgB,aAAa;AAC7F;","names":[]}

package/dist/{chunk-OVBZ2NBB.js → chunk-K7SY2MAX.js}

@@ -1,13 +1,15 @@
 import {
   isWeekendDay,
-  isoDate
-} from "./chunk-K7CLBBBM.js";
+  isoDate,
+  weekdayHolidays
+} from "./chunk-4YCEFGZA.js";
 import {
+  Temporal,
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
 
 // src/differenceInBusinessDays.ts
-function differenceInBusinessDays(laterDate, earlierDate) {
+function differenceInBusinessDays(laterDate, earlierDate, holidays = []) {
   if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {
     throw new TypeError("PlainDate differences require two PlainDate values");
   }
@@ -21,10 +23,14 @@ function differenceInBusinessDays(laterDate, earlierDate) {
     if (!isWeekendDay(day.dayOfWeek)) count++;
     day = day.add({ days: 1 });
   }
+  const end = from.add({ days: span });
+  count -= weekdayHolidays(holidays).filter(
+    (date) => Temporal.PlainDate.compare(date, from) >= 0 && Temporal.PlainDate.compare(date, end) < 0
+  ).length;
   return days < 0 && count !== 0 ? -count : count;
 }
 
 export {
   differenceInBusinessDays
 };
-//# sourceMappingURL=chunk-OVBZ2NBB.js.map
+//# sourceMappingURL=chunk-K7SY2MAX.js.map

package/dist/chunk-K7SY2MAX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInBusinessDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isWeekendDay, isoDate, weekdayHolidays } from './shared/businessDays';\n\n/**\n * Returns the number of business days (Monday–Friday) from earlierDate up to\n * laterDate: the earlier date counts, the later date does not. Dates in\n * `holidays` are not counted. Swapping the arguments negates the result.\n *\n * Only calendar dates matter; times of day are ignored. Instant inputs use\n * their UTC date and ZonedDateTime inputs use their own timezone's date.\n * Convert both to one timezone first to count from a single perspective.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @param holidays - Dates that are not business days, matched by date\n * @returns Business days between the dates (negative if laterDate is earlier)\n *\n * @example\n * ```ts\n * const friday = Temporal.PlainDate.from('2025-01-24');\n * const nextFriday = Temporal.PlainDate.from('2025-01-31');\n *\n * differenceInBusinessDays(nextFriday, friday); // 5\n * differenceInBusinessDays(friday, nextFriday); // -5\n * differenceInBusinessDays(nextFriday, friday, [Temporal.PlainDate.from('2025-01-27')]); // 4\n * ```\n */\nexport function differenceInBusinessDays(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  holidays?: readonly Temporal.PlainDate[]\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  holidays?: readonly Temporal.PlainDate[]\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  holidays: readonly Temporal.PlainDate[] = []\n): number {\n  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {\n    throw new TypeError('PlainDate differences require two PlainDate values');\n  }\n  const later = isoDate(laterDate);\n  const earlier = isoDate(earlierDate);\n  const days = earlier.until(later, { largestUnit: 'days' }).days;\n  const [from, span] = days < 0 ? [later, -days] : [earlier, days];\n\n  // Every full week holds five business days; walk the remainder.\n  const fullWeeks = Math.trunc(span / 7);\n  let count = fullWeeks * 5;\n  for (let day = from.add({ days: fullWeeks * 7 }), i = fullWeeks * 7; i < span; i++) {\n    if (!isWeekendDay(day.dayOfWeek)) count++;\n    day = day.add({ days: 1 });\n  }\n  const end = from.add({ days: span });\n  count -= weekdayHolidays(holidays).filter(\n    (date) =>\n      Temporal.PlainDate.compare(date, from) >= 0 && Temporal.PlainDate.compare(date, end) < 0\n  ).length;\n  return days < 0 && count !== 0 ? -count : count;\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,yBACd,WACA,aACA,WAA0C,CAAC,GACnC;AACR,MAAI,YAAY,SAAS,MAAM,YAAY,WAAW,GAAG;AACvD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,OAAO,QAAQ,MAAM,OAAO,EAAE,aAAa,OAAO,CAAC,EAAE;AAC3D,QAAM,CAAC,MAAM,IAAI,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI;AAG/D,QAAM,YAAY,KAAK,MAAM,OAAO,CAAC;AACrC,MAAI,QAAQ,YAAY;AACxB,WAAS,MAAM,KAAK,IAAI,EAAE,MAAM,YAAY,EAAE,CAAC,GAAG,IAAI,YAAY,GAAG,IAAI,MAAM,KAAK;AAClF,QAAI,CAAC,aAAa,IAAI,SAAS,EAAG;AAClC,UAAM,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;AAAA,EAC3B;AACA,QAAM,MAAM,KAAK,IAAI,EAAE,MAAM,KAAK,CAAC;AACnC,WAAS,gBAAgB,QAAQ,EAAE;AAAA,IACjC,CAAC,SACC,SAAS,UAAU,QAAQ,MAAM,IAAI,KAAK,KAAK,SAAS,UAAU,QAAQ,MAAM,GAAG,IAAI;AAAA,EAC3F,EAAE;AACF,SAAO,OAAO,KAAK,UAAU,IAAI,CAAC,QAAQ;AAC5C;","names":[]}

package/dist/chunk-KZYWHHAQ.js

@@ -0,0 +1,19 @@
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  calendarDates
+} from "./chunk-H43LMOCK.js";
+
+// src/differenceInCalendarWeeks.ts
+function differenceInCalendarWeeks(laterDate, earlierDate, options) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate);
+  const laterStart = later.subtract({ days: daysIntoWeek(later.dayOfWeek, options) });
+  const earlierStart = earlier.subtract({ days: daysIntoWeek(earlier.dayOfWeek, options) });
+  return earlierStart.until(laterStart, { largestUnit: "days" }).days / 7;
+}
+
+export {
+  differenceInCalendarWeeks
+};
+//# sourceMappingURL=chunk-KZYWHHAQ.js.map

package/dist/chunk-KZYWHHAQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarWeeks.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * Returns the number of week boundaries crossed between two dates, ignoring the\n * day within the week. Weeks start on Monday (ISO 8601) unless `weekStartsOn`\n * says otherwise.\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 * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday\n * @returns Calendar weeks from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const sunday = Temporal.PlainDate.from('2025-01-26');\n * const monday = Temporal.PlainDate.from('2025-01-27');\n *\n * differenceInCalendarWeeks(monday, sunday); // 1\n * differenceInCalendarWeeks(monday, sunday, { weekStartsOn: 7 }); // 0\n * ```\n */\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: WeekOptions\n): number;\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: WeekOptions\n): number;\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: WeekOptions\n): number {\n  const [later, earlier] = calendarDates(laterDate, earlierDate);\n  const laterStart = later.subtract({ days: daysIntoWeek(later.dayOfWeek, options) });\n  const earlierStart = earlier.subtract({ days: daysIntoWeek(earlier.dayOfWeek, options) });\n  return earlierStart.until(laterStart, { largestUnit: 'days' }).days / 7;\n}\n"],"mappings":";;;;;;;;AAsCO,SAAS,0BACd,WACA,aACA,SACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,QAAM,aAAa,MAAM,SAAS,EAAE,MAAM,aAAa,MAAM,WAAW,OAAO,EAAE,CAAC;AAClF,QAAM,eAAe,QAAQ,SAAS,EAAE,MAAM,aAAa,QAAQ,WAAW,OAAO,EAAE,CAAC;AACxF,SAAO,aAAa,MAAM,YAAY,EAAE,aAAa,OAAO,CAAC,EAAE,OAAO;AACxE;","names":[]}

package/dist/chunk-M2XB72L5.js

@@ -0,0 +1,17 @@
+// src/shared/week.ts
+function assertDayOfWeek(day, name) {
+  if (!Number.isInteger(day) || day < 1 || day > 7) {
+    throw new RangeError(`${name} must be 1 (Monday) through 7 (Sunday), got ${day}`);
+  }
+}
+function daysIntoWeek(dayOfWeek, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  assertDayOfWeek(weekStartsOn, "weekStartsOn");
+  return (dayOfWeek - weekStartsOn + 7) % 7;
+}
+
+export {
+  assertDayOfWeek,
+  daysIntoWeek
+};
+//# sourceMappingURL=chunk-M2XB72L5.js.map

package/dist/chunk-M2XB72L5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/week.ts"],"sourcesContent":["/**\n * Day of the week, numbered as Temporal numbers it: 1 = Monday … 7 = Sunday.\n */\nexport type DayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;\n\n/**\n * Options for functions that need to know where a week begins.\n */\nexport interface WeekOptions {\n  /**\n   * The first day of the week: 1 = Monday … 7 = Sunday.\n   * @default 1 (Monday, as in ISO 8601)\n   */\n  weekStartsOn?: DayOfWeek;\n}\n\n/**\n * @internal\n * Checks a day-of-week argument. date-fns numbers Sunday 0; Temporal numbers it 7,\n * so 0 is rejected rather than silently meaning something else.\n */\nexport function assertDayOfWeek(day: number, name: string): asserts day is DayOfWeek {\n  if (!Number.isInteger(day) || day < 1 || day > 7) {\n    throw new RangeError(`${name} must be 1 (Monday) through 7 (Sunday), got ${day}`);\n  }\n}\n\n/**\n * @internal\n * Days from the start of the week to a given day of the week (0–6).\n */\nexport function daysIntoWeek(dayOfWeek: number, options: WeekOptions | undefined): number {\n  const weekStartsOn = options?.weekStartsOn ?? 1;\n  assertDayOfWeek(weekStartsOn, 'weekStartsOn');\n  return (dayOfWeek - weekStartsOn + 7) % 7;\n}\n"],"mappings":";AAqBO,SAAS,gBAAgB,KAAa,MAAwC;AACnF,MAAI,CAAC,OAAO,UAAU,GAAG,KAAK,MAAM,KAAK,MAAM,GAAG;AAChD,UAAM,IAAI,WAAW,GAAG,IAAI,+CAA+C,GAAG,EAAE;AAAA,EAClF;AACF;AAMO,SAAS,aAAa,WAAmB,SAA0C;AACxF,QAAM,eAAe,SAAS,gBAAgB;AAC9C,kBAAgB,cAAc,cAAc;AAC5C,UAAQ,YAAY,eAAe,KAAK;AAC1C;","names":[]}

package/dist/chunk-OMUK2MOH.js

@@ -0,0 +1,19 @@
+import {
+  quarterOfMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  calendarDates
+} from "./chunk-H43LMOCK.js";
+
+// src/differenceInCalendarQuarters.ts
+function differenceInCalendarQuarters(laterDate, earlierDate) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate).map(
+    (date) => date.withCalendar("iso8601")
+  );
+  return (later.year - earlier.year) * 4 + quarterOfMonth(later.month) - quarterOfMonth(earlier.month);
+}
+
+export {
+  differenceInCalendarQuarters
+};
+//# sourceMappingURL=chunk-OMUK2MOH.js.map

package/dist/chunk-OMUK2MOH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarQuarters.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\nimport { quarterOfMonth } from './shared/quarter';\n\n/**\n * Returns the number of calendar quarters between two dates, ignoring the\n * position within the quarter. Quarters follow ISO months: Q1 is January–March.\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 quarters from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const endOfQ1 = Temporal.PlainDate.from('2025-03-31');\n * const startOfQ2 = Temporal.PlainDate.from('2025-04-01');\n *\n * differenceInCalendarQuarters(startOfQ2, endOfQ1); // 1\n * differenceInQuarters(startOfQ2, endOfQ1); // 0\n * ```\n */\nexport function differenceInCalendarQuarters(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarQuarters(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarQuarters(\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).map((date) =>\n    date.withCalendar('iso8601')\n  ) as [Temporal.PlainDate, Temporal.PlainDate];\n  return (\n    (later.year - earlier.year) * 4 + quarterOfMonth(later.month) - quarterOfMonth(earlier.month)\n  );\n}\n"],"mappings":";;;;;;;;AAkCO,SAAS,6BACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW,EAAE;AAAA,IAAI,CAAC,SAClE,KAAK,aAAa,SAAS;AAAA,EAC7B;AACA,UACG,MAAM,OAAO,QAAQ,QAAQ,IAAI,eAAe,MAAM,KAAK,IAAI,eAAe,QAAQ,KAAK;AAEhG;","names":[]}