@gobrand/tiempo 3.1.3 → 3.2.1

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/roundToNearestHour.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Options for rounding to nearest hour.\n */\nexport interface RoundToNearestHourOptions {\n  /**\n   * The rounding mode to use.\n   *\n   * Given time 14:20:\n   * - `'round'` → 14:00 (20 min < 30, rounds DOWN to nearest)\n   * - `'ceil'`  → 15:00 (always rounds UP to next hour)\n   * - `'floor'` → 14:00 (always rounds DOWN to current hour)\n   *\n   * Given time 14:40:\n   * - `'round'` → 15:00 (40 min >= 30, rounds UP to nearest)\n   * - `'ceil'`  → 15:00 (always rounds UP to next hour)\n   * - `'floor'` → 14:00 (always rounds DOWN to current hour)\n   *\n   * @default 'round'\n   */\n  mode?: 'round' | 'ceil' | 'floor';\n  /**\n   * Round to the nearest N hours. Must divide evenly into 24.\n   * Valid values: 1, 2, 3, 4, 6, 8, 12\n   * @example nearestTo: 6 rounds to 00:00, 06:00, 12:00, or 18:00\n   */\n  nearestTo?: 1 | 2 | 3 | 4 | 6 | 8 | 12;\n}\n\nconst MODE_TO_ROUNDING_MODE = {\n  round: 'halfExpand',\n  ceil: 'ceil',\n  floor: 'floor'\n} as const;\n\n/**\n * Rounds a datetime to the nearest hour boundary.\n *\n * ## Mode comparison (given 14:20)\n *\n * ```\n * 14:00 ─────────────●───────────────── 15:00\n *                  14:20\n *\n * 'round' → 14:00  (nearest hour - 20 min < 30)\n * 'ceil'  → 15:00  (next hour - always up)\n * 'floor' → 14:00  (current hour - always down)\n * ```\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param options - Rounding options\n * @returns ZonedDateTime rounded to the hour boundary\n *\n * @example\n * ```ts\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:20:00[America/New_York]');\n *\n * roundToNearestHour(time);                     // → 14:00 (nearest)\n * roundToNearestHour(time, { mode: 'ceil' });   // → 15:00 (always up)\n * roundToNearestHour(time, { mode: 'floor' });  // → 14:00 (always down)\n * ```\n *\n * @example\n * ```ts\n * // With 37 minutes (past the halfway point)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:00[America/New_York]');\n *\n * roundToNearestHour(time);                     // → 15:00 (nearest - 37 >= 30)\n * roundToNearestHour(time, { mode: 'ceil' });   // → 15:00 (always up)\n * roundToNearestHour(time, { mode: 'floor' });  // → 14:00 (always down)\n * ```\n *\n * @example\n * ```ts\n * // Round to 6-hour blocks (shift scheduling)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:00:00[America/New_York]');\n *\n * roundToNearestHour(time, { nearestTo: 6 });                    // → 12:00\n * roundToNearestHour(time, { mode: 'ceil', nearestTo: 6 });      // → 18:00\n * roundToNearestHour(time, { mode: 'floor', nearestTo: 6 });     // → 12:00\n * ```\n */\nexport function roundToNearestHour(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: RoundToNearestHourOptions\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  const mode = options?.mode ?? 'round';\n  const nearestTo = options?.nearestTo ?? 1;\n\n  return zonedDateTime.round({\n    smallestUnit: 'hour',\n    roundingMode: MODE_TO_ROUNDING_MODE[mode],\n    roundingIncrement: nearestTo\n  });\n}\n"],"mappings":";;;;;AA+BA,IAAM,wBAAwB;AAAA,EAC5B,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AACT;AAiDO,SAAS,mBACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,QAAM,OAAO,SAAS,QAAQ;AAC9B,QAAM,YAAY,SAAS,aAAa;AAExC,SAAO,cAAc,MAAM;AAAA,IACzB,cAAc;AAAA,IACd,cAAc,sBAAsB,IAAI;AAAA,IACxC,mBAAmB;AAAA,EACrB,CAAC;AACH;","names":[]}

package/dist/{chunk-7IKCDOCT.js → chunk-AEAZ2F2T.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/addSeconds.ts
 function addSeconds(input, seconds) {
@@ -11,4 +11,4 @@ function addSeconds(input, seconds) {
 export {
   addSeconds
 };
-//# sourceMappingURL=chunk-7IKCDOCT.js.map
+//# sourceMappingURL=chunk-AEAZ2F2T.js.map

package/dist/{chunk-3HD7HEN4.js → chunk-APWSLQ47.js}

@@ -1,12 +1,12 @@
 import {
   differenceInDays
-} from "./chunk-JGPTGV5X.js";
+} from "./chunk-MRJNMV4A.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/eachDayOfInterval.ts
 function eachDayOfInterval(interval) {
@@ -39,4 +39,4 @@ function eachDayOfInterval(interval) {
 export {
   eachDayOfInterval
 };
-//# sourceMappingURL=chunk-3HD7HEN4.js.map
+//# sourceMappingURL=chunk-APWSLQ47.js.map

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

@@ -1,26 +1,31 @@
 import {
   isPlainDateBefore
-} from "./chunk-ZM32S3YU.js";
+} from "./chunk-DYDSR35L.js";
 import {
   isPlainDateAfter
-} from "./chunk-ADPVFELS.js";
+} from "./chunk-K6IGDI5W.js";
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.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-AWERPSJ5.js.map

package/dist/chunk-AWERPSJ5.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-32AWWYBF.js → chunk-B7RDUXDN.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/addNanoseconds.ts
 function addNanoseconds(input, nanoseconds) {
@@ -11,4 +11,4 @@ function addNanoseconds(input, nanoseconds) {
 export {
   addNanoseconds
 };
-//# sourceMappingURL=chunk-32AWWYBF.js.map
+//# sourceMappingURL=chunk-B7RDUXDN.js.map

package/dist/{chunk-LQ3EQYIX.js → chunk-BE7CIKP7.js}

@@ -3,7 +3,7 @@ import {
   isInstant,
   isPlainDate,
   isZonedDateTime
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/toPlainDate.ts
 var PLAIN_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
@@ -13,19 +13,25 @@ function toPlainDate(input, timezone) {
   }
   if (input instanceof Date) {
     if (timezone === void 0) {
-      throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
+      throw new Error(
+        "Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string"
+      );
     }
     return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone).toPlainDate();
   }
   if (isInstant(input)) {
     if (timezone === void 0) {
-      throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
+      throw new Error(
+        "Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string"
+      );
     }
     return input.toZonedDateTimeISO(timezone).toPlainDate();
   }
   if (isZonedDateTime(input)) {
     if (timezone === void 0) {
-      throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
+      throw new Error(
+        "Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string"
+      );
     }
     return input.toInstant().toZonedDateTimeISO(timezone).toPlainDate();
   }
@@ -36,7 +42,9 @@ function toPlainDate(input, timezone) {
     if (PLAIN_DATE_PATTERN.test(input)) {
       return Temporal.PlainDate.from(input);
     }
-    throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
+    throw new Error(
+      "Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string"
+    );
   }
   return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);
 }
@@ -44,4 +52,4 @@ function toPlainDate(input, timezone) {
 export {
   toPlainDate
 };
-//# sourceMappingURL=chunk-LQ3EQYIX.js.map
+//# sourceMappingURL=chunk-BE7CIKP7.js.map

package/dist/chunk-BE7CIKP7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toPlainDate.ts"],"sourcesContent":["import { Temporal, isInstant, isZonedDateTime, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\n\n// Pattern to detect plain date strings: YYYY-MM-DD\nconst PLAIN_DATE_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * Parse a plain date or extract the calendar date from a datetime.\n *\n * @param input - A PlainDateLike object, plain date string (YYYY-MM-DD), ZonedDateTime, or datetime input requiring timezone\n * @param timezone - IANA timezone identifier. Required for ISO strings, Date, and Instant inputs.\n * @returns A Temporal.PlainDate representing the calendar date\n *\n * @example\n * ```typescript\n * import { toPlainDate, toZonedTime } from '@gobrand/tiempo';\n *\n * // From PlainDateLike object (no timezone needed)\n * const date = toPlainDate({ year: 2025, month: 1, day: 20 }); // 2025-01-20\n *\n * // From plain date string (no timezone needed)\n * const date2 = toPlainDate(\"2025-01-20\"); // 2025-01-20\n *\n * // From ZonedDateTime (no timezone needed)\n * const zdt = toZonedTime(\"2025-01-20T15:30:00Z\", \"America/New_York\");\n * const date3 = toPlainDate(zdt); // 2025-01-20\n *\n * // From UTC string with timezone\n * const date4 = toPlainDate(\"2025-01-20T15:30:00Z\", \"America/New_York\"); // 2025-01-20\n *\n * // From Date with timezone\n * const jsDate = new Date(\"2025-01-20T15:30:00.000Z\");\n * const date5 = toPlainDate(jsDate, \"Europe/London\"); // 2025-01-20\n *\n * // Date boundary crossing: 23:00 UTC on Jan 20 → Jan 21 in Tokyo\n * const date6 = toPlainDate(\"2025-01-20T23:00:00Z\", \"Asia/Tokyo\"); // 2025-01-21\n * ```\n */\nexport function toPlainDate(input: Temporal.ZonedDateTime): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime,\n  timezone: Timezone\n): Temporal.PlainDate;\nexport function toPlainDate(input: Temporal.PlainDateLike | string): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDateLike,\n  timezone?: Timezone\n): Temporal.PlainDate {\n  // ZonedDateTime without timezone override\n  if (isZonedDateTime(input) && timezone === undefined) {\n    return input.toPlainDate();\n  }\n\n  // Date requires timezone\n  if (input instanceof Date) {\n    if (timezone === undefined) {\n      throw new Error(\n        'Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string'\n      );\n    }\n    return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // Instant requires timezone\n  if (isInstant(input)) {\n    if (timezone === undefined) {\n      throw new Error(\n        'Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string'\n      );\n    }\n    return input.toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // ZonedDateTime with timezone override\n  if (isZonedDateTime(input)) {\n    if (timezone === undefined) {\n      throw new Error(\n        'Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string'\n      );\n    }\n    return input.toInstant().toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // String: ISO datetime (requires timezone) or plain date (no timezone)\n  if (typeof input === 'string') {\n    if (timezone !== undefined) {\n      return Temporal.Instant.from(input).toZonedDateTimeISO(timezone).toPlainDate();\n    }\n    if (PLAIN_DATE_PATTERN.test(input)) {\n      return Temporal.PlainDate.from(input);\n    }\n    throw new Error(\n      'Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string'\n    );\n  }\n\n  // Foreign PlainDate objects expose calendarId, while property bags use calendar.\n  // A canonical string keeps the ISO date and calendar together across implementations.\n  return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);\n}\n"],"mappings":";;;;;;;;AAIA,IAAM,qBAAqB;AAwCpB,SAAS,YACd,OACA,UACoB;AAEpB,MAAI,gBAAgB,KAAK,KAAK,aAAa,QAAW;AACpD,WAAO,MAAM,YAAY;AAAA,EAC3B;AAGA,MAAI,iBAAiB,MAAM;AACzB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,SAAS,QAAQ,KAAK,MAAM,YAAY,CAAC,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EAC7F;AAGA,MAAI,UAAU,KAAK,GAAG;AACpB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,MAAM,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACxD;AAGA,MAAI,gBAAgB,KAAK,GAAG;AAC1B,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,MAAM,UAAU,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACpE;AAGA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,aAAa,QAAW;AAC1B,aAAO,SAAS,QAAQ,KAAK,KAAK,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,IAC/E;AACA,QAAI,mBAAmB,KAAK,KAAK,GAAG;AAClC,aAAO,SAAS,UAAU,KAAK,KAAK;AAAA,IACtC;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAIA,SAAO,SAAS,UAAU,KAAK,YAAY,KAAK,IAAI,MAAM,SAAS,IAAI,KAAK;AAC9E;","names":[]}

package/dist/{chunk-BI42E23Z.js → chunk-BM4OZR7U.js}

@@ -1,12 +1,12 @@
 import {
   isBefore
-} from "./chunk-BMX7CIRD.js";
+} from "./chunk-CMOBOTVN.js";
 import {
   nowZoned
-} from "./chunk-4GEF7B7W.js";
+} from "./chunk-D73HU7YA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/isPast.ts
 function isPast(date) {
@@ -17,4 +17,4 @@ function isPast(date) {
 export {
   isPast
 };
-//# sourceMappingURL=chunk-BI42E23Z.js.map
+//# sourceMappingURL=chunk-BM4OZR7U.js.map

package/dist/{chunk-BI42E23Z.js.map → chunk-BM4OZR7U.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the past.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is before the current instant, false otherwise\n *\n * @example\n * ```ts\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n *\n * isPast(yesterday); // true\n * isPast(tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const pastInstant = Temporal.Now.instant().subtract({ hours: 1 });\n *\n * isPast(pastInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const pastInTokyo = Temporal.ZonedDateTime.from('1970-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isPast(pastInTokyo); // true\n * ```\n */\nexport function isPast(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isBefore(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,OACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,SAAS,OAAO,SAAS,CAAC;AACnC;","names":[]}
+{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the past.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is before the current instant, false otherwise\n *\n * @example\n * ```ts\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n *\n * isPast(yesterday); // true\n * isPast(tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const pastInstant = Temporal.Now.instant().subtract({ hours: 1 });\n *\n * isPast(pastInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const pastInTokyo = Temporal.ZonedDateTime.from('1970-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isPast(pastInTokyo); // true\n * ```\n */\nexport function isPast(date: Temporal.Instant | Temporal.ZonedDateTime): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isBefore(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,OAAO,MAA0D;AAC/E,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,SAAS,OAAO,SAAS,CAAC;AACnC;","names":[]}

package/dist/{chunk-MXYAZTDE.js → chunk-C4LUGHIM.js}

@@ -1,15 +1,15 @@
-import {
-  quarterStartMonth
-} from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-TCB3IDJM.js";
+} from "./chunk-QCIY5PSJ.js";
 import {
   getEndOfDay
-} from "./chunk-NMMMAMKP.js";
+} from "./chunk-7WGGUDW4.js";
+import {
+  quarterStartMonth
+} from "./chunk-XS2HUADA.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/endOfQuarter.ts
 function endOfQuarter(input, timezone) {
@@ -32,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-MXYAZTDE.js.map
+//# sourceMappingURL=chunk-C4LUGHIM.js.map

package/dist/chunk-C4LUGHIM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\nimport { quarterStartMonth } from './shared/quarter';\n\n/**\n * Returns a ZonedDateTime representing the last moment of the quarter\n * (last day of the quarter's ending month at 23:59:59.999999999).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the quarter at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const end = endOfQuarter(instant);\n * // 2025-06-30T23:59:59.999999999+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-02-15T15:30:00-05:00[America/New_York]');\n * const end = endOfQuarter(zoned);\n * // 2025-03-31T23:59:59.999999999-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From a PlainDate in a timezone\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const end = endOfQuarter(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfQuarter(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → last day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    const endMonth = input.with({\n      month: quarterStartMonth(input.month) + 2,\n      day: 1\n    });\n    return endMonth.with({ day: endMonth.daysInMonth });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const endMonth = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month) + 2,\n    day: 1\n  });\n  const lastDay = endMonth.with({ day: endMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;;;;AA4CO,SAAS,aACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,YAAW,MAAM,KAAK;AAAA,MAC1B,OAAO,kBAAkB,MAAM,KAAK,IAAI;AAAA,MACxC,KAAK;AAAA,IACP,CAAC;AACD,WAAOA,UAAS,KAAK,EAAE,KAAKA,UAAS,YAAY,CAAC;AAAA,EACpD;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK,IAAI;AAAA,IAChD,KAAK;AAAA,EACP,CAAC;AACD,QAAM,UAAU,SAAS,KAAK,EAAE,KAAK,SAAS,YAAY,CAAC;AAC3D,SAAO,YAAY,OAAO;AAC5B;","names":["endMonth"]}

package/dist/{chunk-3S6TSXZ3.js → chunk-CCDDXIAC.js}

@@ -1,6 +1,6 @@
 import {
   compare
-} from "./chunk-OMYVTYHI.js";
+} from "./chunk-DAWWOF5W.js";
 
 // src/clamp.ts
 function clamp(value, interval) {
@@ -15,4 +15,4 @@ function clamp(value, interval) {
 export {
   clamp
 };
-//# sourceMappingURL=chunk-3S6TSXZ3.js.map
+//# sourceMappingURL=chunk-CCDDXIAC.js.map

package/dist/{chunk-BMX7CIRD.js → chunk-CMOBOTVN.js}

@@ -6,4 +6,4 @@ function isBefore(date1, date2) {
 export {
   isBefore
 };
-//# sourceMappingURL=chunk-BMX7CIRD.js.map
+//# sourceMappingURL=chunk-CMOBOTVN.js.map

package/dist/chunk-CMOBOTVN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/isBefore.ts"],"sourcesContent":["import type { Temporal } from './temporal';\n\nexport function isBefore(date1: Temporal.ZonedDateTime, date2: Temporal.ZonedDateTime): boolean {\n  return date1.epochNanoseconds < date2.epochNanoseconds;\n}\n"],"mappings":";AAEO,SAAS,SAAS,OAA+B,OAAwC;AAC9F,SAAO,MAAM,mBAAmB,MAAM;AACxC;","names":[]}

package/dist/{chunk-7NGP7SAD.js → chunk-COQJXPPT.js}

@@ -1,16 +1,16 @@
 import {
   isPlainDateBefore
-} from "./chunk-ZM32S3YU.js";
+} from "./chunk-DYDSR35L.js";
 import {
   isPlainDateAfter
-} from "./chunk-ADPVFELS.js";
+} from "./chunk-K6IGDI5W.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   Temporal,
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/eachMonthOfInterval.ts
 function eachMonthOfInterval(interval) {
@@ -63,4 +63,4 @@ function eachMonthOfInterval(interval) {
 export {
   eachMonthOfInterval
 };
-//# sourceMappingURL=chunk-7NGP7SAD.js.map
+//# sourceMappingURL=chunk-COQJXPPT.js.map

package/dist/{chunk-7NGP7SAD.js.map → chunk-COQJXPPT.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/eachMonthOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\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 * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array of ZonedDateTime objects for each month within the interval.\n * Each element represents the first moment of the month (day 1 at midnight).\n * The interval is inclusive of both start and end months.\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 * @returns Array of ZonedDateTime at start of each month in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-04-20T14:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC],\n * //   2025-03-01T00:00:00+00:00[UTC],\n * //   2025-04-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-11-15T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-02-15T00:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2024-11-01T00:00:00+00:00[UTC],\n * //   2024-12-01T00:00:00+00:00[UTC],\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n */\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\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.with({ day: 1 });\n    let current = interval.start.with({ day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ months: 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 timezone = startZoned.timeZoneId;\n\n  // Get start of the starting month\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: startZoned.year,\n    month: startZoned.month,\n    calendar: startZoned.calendarId,\n  });\n\n  // Get end month in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: endInTimezone.year,\n    month: endInTimezone.month,\n    calendar: startZoned.calendarId,\n  });\n\n  const months: Temporal.ZonedDateTime[] = [];\n  let current = startYearMonth;\n\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    const firstOfMonth = current.toPlainDate({ day: 1 });\n    months.push(\n      firstOfMonth.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n    current = current.add({ months: 1 });\n  }\n\n  return months;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA2DO,SAAS,oBAAoB,UAGgB;AAClD,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,KAAK,EAAE,KAAK,EAAE,CAAC;AAChC,QAAIA,WAAU,SAAS,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAC5C,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,IACrC;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,WAAW,WAAW;AAG5B,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,WAAW;AAAA,IACjB,OAAO,WAAW;AAAA,IAClB,UAAU,WAAW;AAAA,EACvB,CAAC;AAGD,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,cAAc;AAAA,IACpB,OAAO,cAAc;AAAA,IACrB,UAAU,WAAW;AAAA,EACvB,CAAC;AAED,QAAM,SAAmC,CAAC;AAC1C,MAAI,UAAU;AAEd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,UAAM,eAAe,QAAQ,YAAY,EAAE,KAAK,EAAE,CAAC;AACnD,WAAO;AAAA,MACL,aAAa,gBAAgB;AAAA,QAC3B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AACA,cAAU,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":["current"]}
+{"version":3,"sources":["../src/eachMonthOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\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 * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array of ZonedDateTime objects for each month within the interval.\n * Each element represents the first moment of the month (day 1 at midnight).\n * The interval is inclusive of both start and end months.\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 * @returns Array of ZonedDateTime at start of each month in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-04-20T14:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC],\n * //   2025-03-01T00:00:00+00:00[UTC],\n * //   2025-04-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-11-15T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-02-15T00:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2024-11-01T00:00:00+00:00[UTC],\n * //   2024-12-01T00:00:00+00:00[UTC],\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n */\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\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.with({ day: 1 });\n    let current = interval.start.with({ day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ months: 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 timezone = startZoned.timeZoneId;\n\n  // Get start of the starting month\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: startZoned.year,\n    month: startZoned.month,\n    calendar: startZoned.calendarId\n  });\n\n  // Get end month in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: endInTimezone.year,\n    month: endInTimezone.month,\n    calendar: startZoned.calendarId\n  });\n\n  const months: Temporal.ZonedDateTime[] = [];\n  let current = startYearMonth;\n\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    const firstOfMonth = current.toPlainDate({ day: 1 });\n    months.push(\n      firstOfMonth.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime()\n      })\n    );\n    current = current.add({ months: 1 });\n  }\n\n  return months;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA2DO,SAAS,oBAAoB,UAGgB;AAClD,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,KAAK,EAAE,KAAK,EAAE,CAAC;AAChC,QAAIA,WAAU,SAAS,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAC5C,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,IACrC;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,WAAW,WAAW;AAG5B,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,WAAW;AAAA,IACjB,OAAO,WAAW;AAAA,IAClB,UAAU,WAAW;AAAA,EACvB,CAAC;AAGD,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,cAAc;AAAA,IACpB,OAAO,cAAc;AAAA,IACrB,UAAU,WAAW;AAAA,EACvB,CAAC;AAED,QAAM,SAAmC,CAAC;AAC1C,MAAI,UAAU;AAEd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,UAAM,eAAe,QAAQ,YAAY,EAAE,KAAK,EAAE,CAAC;AACnD,WAAO;AAAA,MACL,aAAa,gBAAgB;AAAA,QAC3B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AACA,cAAU,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":["current"]}

package/dist/{chunk-SLH6TKGN.js → chunk-CX37IV4D.js}

@@ -1,9 +1,9 @@
 import {
   addWeeks
-} from "./chunk-3X2U6I44.js";
+} from "./chunk-TZ4NUY3W.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/subWeeks.ts
 function subWeeks(input, weeks) {
@@ -13,4 +13,4 @@ function subWeeks(input, weeks) {
 export {
   subWeeks
 };
-//# sourceMappingURL=chunk-SLH6TKGN.js.map
+//# sourceMappingURL=chunk-CX37IV4D.js.map

package/dist/{chunk-HYSGJJUR.js → chunk-D2HKS2OM.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/isSameMonth.ts
 function isSameMonth(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMonth(date1, date2) {
 export {
   isSameMonth
 };
-//# sourceMappingURL=chunk-HYSGJJUR.js.map
+//# sourceMappingURL=chunk-D2HKS2OM.js.map

package/dist/{chunk-4GEF7B7W.js → chunk-D73HU7YA.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   Temporal
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/shared/nowZoned.ts
 function nowZoned() {
@@ -13,4 +13,4 @@ function nowZoned() {
 export {
   nowZoned
 };
-//# sourceMappingURL=chunk-4GEF7B7W.js.map
+//# sourceMappingURL=chunk-D73HU7YA.js.map

package/dist/{chunk-OMYVTYHI.js → chunk-DAWWOF5W.js}

@@ -2,7 +2,7 @@ import {
   Temporal,
   isPlainDate,
   isPlainTime
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/shared/compare.ts
 function assertSameDomain(a, b) {
@@ -44,4 +44,4 @@ export {
   compare,
   position
 };
-//# sourceMappingURL=chunk-OMYVTYHI.js.map
+//# sourceMappingURL=chunk-DAWWOF5W.js.map

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

@@ -1,12 +1,12 @@
 import {
   isWeekendDay
-} from "./chunk-K7CLBBBM.js";
+} from "./chunk-QFQHFBN4.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/isWeekend.ts
 function isWeekend(input) {
@@ -17,4 +17,4 @@ function isWeekend(input) {
 export {
   isWeekend
 };
-//# sourceMappingURL=chunk-6QZUAJVF.js.map
+//# sourceMappingURL=chunk-DCQCZCKG.js.map

package/dist/{chunk-5WHGX2J3.js → chunk-DEVXW65H.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/isSameSecond.ts
 function isSameSecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameSecond(date1, date2) {
 export {
   isSameSecond
 };
-//# sourceMappingURL=chunk-5WHGX2J3.js.map
+//# sourceMappingURL=chunk-DEVXW65H.js.map

package/dist/chunk-DFVLLH5O.js

@@ -0,0 +1,17 @@
+import {
+  compare
+} from "./chunk-DAWWOF5W.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-DFVLLH5O.js.map

package/dist/chunk-DFVLLH5O.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-ZM32S3YU.js → chunk-DYDSR35L.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/isPlainDateBefore.ts
 function isPlainDateBefore(date1, date2) {
@@ -13,4 +13,4 @@ function isPlainDateBefore(date1, date2) {
 export {
   isPlainDateBefore
 };
-//# sourceMappingURL=chunk-ZM32S3YU.js.map
+//# sourceMappingURL=chunk-DYDSR35L.js.map

package/dist/{chunk-ZM32S3YU.js.map → chunk-DYDSR35L.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isPlainDateBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is before the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is before date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateBefore(jan20, jan25); // true\n * isPlainDateBefore(jan25, jan20); // false\n * isPlainDateBefore(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateBefore(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  // Only foreign objects need conversion; strings retain their calendar annotations.\n  return Temporal.PlainDate.compare(\n    Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),\n    Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()\n  ) < 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,kBACd,OACA,OACS;AAET,SAAO,SAAS,UAAU;AAAA,IACxB,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,IAC3E,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,EAC7E,IAAI;AACN;","names":[]}
+{"version":3,"sources":["../src/isPlainDateBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is before the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is before date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateBefore(jan20, jan25); // true\n * isPlainDateBefore(jan25, jan20); // false\n * isPlainDateBefore(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateBefore(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean {\n  // Only foreign objects need conversion; strings retain their calendar annotations.\n  return (\n    Temporal.PlainDate.compare(\n      Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),\n      Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()\n    ) < 0\n  );\n}\n"],"mappings":";;;;;AAoBO,SAAS,kBAAkB,OAA2B,OAAoC;AAE/F,SACE,SAAS,UAAU;AAAA,IACjB,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,IAC3E,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,EAC7E,IAAI;AAER;","names":[]}

package/dist/{chunk-QNZJR53W.js → chunk-DZFUKW5U.js}

@@ -1,12 +1,12 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-TCB3IDJM.js";
+} from "./chunk-QCIY5PSJ.js";
 import {
   getEndOfDay
-} from "./chunk-NMMMAMKP.js";
+} from "./chunk-7WGGUDW4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/endOfYear.ts
 function endOfYear(input, timezone) {
@@ -23,4 +23,4 @@ function endOfYear(input, timezone) {
 export {
   endOfYear
 };
-//# sourceMappingURL=chunk-QNZJR53W.js.map
+//# sourceMappingURL=chunk-DZFUKW5U.js.map

package/dist/{chunk-QNZJR53W.js.map → chunk-DZFUKW5U.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/endOfYear.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the last boundary of the year.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the year at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const end = endOfYear(instant);\n * // 2025-12-31T23:59:59.999999999+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-04:00[America/New_York]');\n * const end = endOfYear(zoned);\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date);\n * // 2025-12-31\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfYear(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    const lastMonth = input.with({ month: input.monthsInYear });\n    return lastMonth.with({ day: lastMonth.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });\n  const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AAoDO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,aAAY,MAAM,KAAK,EAAE,OAAO,MAAM,aAAa,CAAC;AAC1D,WAAOA,WAAU,KAAK,EAAE,KAAKA,WAAU,YAAY,CAAC;AAAA,EACtD;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,YAAY,cAAc,KAAK,EAAE,OAAO,cAAc,aAAa,CAAC;AAC1E,QAAM,UAAU,UAAU,KAAK,EAAE,KAAK,UAAU,YAAY,CAAC;AAC7D,SAAO,YAAY,OAAO;AAC5B;","names":["lastMonth"]}
+{"version":3,"sources":["../src/endOfYear.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the last boundary of the year.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the year at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const end = endOfYear(instant);\n * // 2025-12-31T23:59:59.999999999+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-04:00[America/New_York]');\n * const end = endOfYear(zoned);\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date);\n * // 2025-12-31\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfYear(input: Temporal.Instant | Temporal.ZonedDateTime): Temporal.ZonedDateTime;\nexport function endOfYear(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfYear(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    const lastMonth = input.with({ month: input.monthsInYear });\n    return lastMonth.with({ day: lastMonth.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });\n  const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AA+CO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,aAAY,MAAM,KAAK,EAAE,OAAO,MAAM,aAAa,CAAC;AAC1D,WAAOA,WAAU,KAAK,EAAE,KAAKA,WAAU,YAAY,CAAC;AAAA,EACtD;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,YAAY,cAAc,KAAK,EAAE,OAAO,cAAc,aAAa,CAAC;AAC1E,QAAM,UAAU,UAAU,KAAK,EAAE,KAAK,UAAU,YAAY,CAAC;AAC7D,SAAO,YAAY,OAAO;AAC5B;","names":["lastMonth"]}

package/dist/{chunk-F3UZDWOQ.js → chunk-EMJXV6KH.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/isSameDay.ts
 function isSameDay(date1, date2) {
@@ -12,4 +12,4 @@ function isSameDay(date1, date2) {
 export {
   isSameDay
 };
-//# sourceMappingURL=chunk-F3UZDWOQ.js.map
+//# sourceMappingURL=chunk-EMJXV6KH.js.map

package/dist/{chunk-F3UZDWOQ.js.map → chunk-EMJXV6KH.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isSameDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall on the same calendar day.\n * Compares the year, month, and day fields directly.\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 * @returns true if both dates are on the same calendar day, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same day\n * const morning = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');\n * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00+00:00[UTC]');\n *\n * isSameDay(morning, evening); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different days\n * const today = Temporal.ZonedDateTime.from('2025-01-20T23:59:59+00:00[UTC]');\n * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+00:00[UTC]');\n *\n * isSameDay(today, tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar days\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar days from each person's perspective\n * isSameDay(ny, tokyo); // false (Jan 20 in NY, Jan 21 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameDay(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Jan 21 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameDay(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan 20 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T10:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T23:00:00Z');\n *\n * isSameDay(instant1, instant2); // true (both Jan 20 in UTC)\n * ```\n */\nexport function isSameDay(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day\n  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,UACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO;AAE1B;","names":[]}
+{"version":3,"sources":["../src/isSameDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall on the same calendar day.\n * Compares the year, month, and day fields directly.\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 * @returns true if both dates are on the same calendar day, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same day\n * const morning = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');\n * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00+00:00[UTC]');\n *\n * isSameDay(morning, evening); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different days\n * const today = Temporal.ZonedDateTime.from('2025-01-20T23:59:59+00:00[UTC]');\n * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+00:00[UTC]');\n *\n * isSameDay(today, tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar days\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar days from each person's perspective\n * isSameDay(ny, tokyo); // false (Jan 20 in NY, Jan 21 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameDay(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Jan 21 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameDay(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan 20 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T10:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T23:00:00Z');\n *\n * isSameDay(instant1, instant2); // true (both Jan 20 in UTC)\n * ```\n */\nexport function isSameDay(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return zoned1.year === zoned2.year && zoned1.month === zoned2.month && zoned1.day === zoned2.day;\n}\n"],"mappings":";;;;;AA0DO,SAAS,UACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO,QAAQ,OAAO,UAAU,OAAO,SAAS,OAAO,QAAQ,OAAO;AAC/F;","names":[]}