@gobrand/tiempo 3.1.2 → 3.2.0

package/dist/{chunk-SUONQGAH.js → chunk-525OLFRD.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -17,4 +17,4 @@ function getQuarter(input) {
 export {
   getQuarter
 };
-//# sourceMappingURL=chunk-SUONQGAH.js.map
+//# sourceMappingURL=chunk-525OLFRD.js.map

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

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

package/dist/chunk-5WHGX2J3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameSecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same second.\n * Compares the year, month, day, hour, minute, and second fields directly.\n * Ignores sub-second precision (milliseconds, microseconds, nanoseconds).\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 in the same second, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same second\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999+00:00[UTC]');\n *\n * isSameSecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different seconds\n * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45+00:00[UTC]');\n * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46+00:00[UTC]');\n *\n * isSameSecond(sec45, sec46); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local seconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local seconds from each person's perspective\n * isSameSecond(ny, tokyo); // false (14:30:45 in NY, 04:30:45 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameSecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameSecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.999Z');\n *\n * isSameSecond(instant1, instant2); // true (both 14:30:45 in UTC)\n * ```\n */\nexport function isSameSecond(\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    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,aACd,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,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO;AAE7B;","names":[]}

package/dist/{chunk-NKXMLC6T.js → chunk-67XABEBT.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-ADPVFELS.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal,
   isPlainDate
@@ -53,4 +53,4 @@ function eachYearOfInterval(interval) {
 export {
   eachYearOfInterval
 };
-//# sourceMappingURL=chunk-NKXMLC6T.js.map
+//# sourceMappingURL=chunk-67XABEBT.js.map

package/dist/chunk-67XABEBT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachYearOfInterval.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 year within the interval.\n * Each element represents the first moment of the year (January 1st at midnight).\n * The interval is inclusive of both start and end years.\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 year in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2022-06-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-03-20T14:00:00+00:00[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2022-01-01T00:00:00+00:00[UTC],\n * //   2023-01-01T00:00:00+00:00[UTC],\n * //   2024-01-01T00:00:00+00:00[UTC],\n * //   2025-01-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single year\n * const start = Temporal.ZonedDateTime.from('2025-01-15T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-12-31T23:59:59+00:00[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [2025-01-01T00:00:00+00:00[UTC]]\n * ```\n *\n * @example\n * ```ts\n * // With timezone\n * const start = Temporal.ZonedDateTime.from('2024-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2026-06-15T00:00:00-04:00[America/New_York]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2024-01-01T00:00:00-05:00[America/New_York],\n * //   2025-01-01T00:00:00-05:00[America/New_York],\n * //   2026-01-01T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n */\nexport function eachYearOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachYearOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachYearOfInterval(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({ month: 1, day: 1 });\n    let current = interval.start.with({ month: 1, day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ years: 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  const startYear = startZoned.year;\n\n  // Get end year in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\n  const endYear = endInTimezone.year;\n\n  const years: Temporal.ZonedDateTime[] = [];\n\n  for (let year = startYear; year <= endYear; year++) {\n    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1, calendar: startZoned.calendarId });\n    years.push(\n      firstOfYear.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n  }\n\n  return years;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoEO,SAAS,mBAAmB,UAGiB;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,OAAO,GAAG,KAAK,EAAE,CAAC;AAC1C,QAAI,UAAU,SAAS,MAAM,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACtD,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkB,SAAS,IAAI,GAAG;AACvC,YAAM,KAAK,OAAO;AAClB,gBAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAK,OAAO;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;AAC5B,QAAM,YAAY,WAAW;AAG7B,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,QAAM,UAAU,cAAc;AAE9B,QAAM,QAAkC,CAAC;AAEzC,WAAS,OAAO,WAAW,QAAQ,SAAS,QAAQ;AAClD,UAAM,cAAc,SAAS,UAAU,KAAK,EAAE,MAAM,OAAO,GAAG,KAAK,GAAG,UAAU,WAAW,WAAW,CAAC;AACvG,UAAM;AAAA,MACJ,YAAY,gBAAgB;AAAA,QAC1B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-TUZHOWSN.js → chunk-6QH4NCPA.js}

@@ -1,6 +1,6 @@
 import {
   addMilliseconds
-} from "./chunk-NYM3EW3M.js";
+} from "./chunk-AUOZACFS.js";
 
 // src/subMilliseconds.ts
 function subMilliseconds(input, milliseconds) {
@@ -10,4 +10,4 @@ function subMilliseconds(input, milliseconds) {
 export {
   subMilliseconds
 };
-//# sourceMappingURL=chunk-TUZHOWSN.js.map
+//# sourceMappingURL=chunk-6QH4NCPA.js.map

package/dist/{chunk-TUZHOWSN.js.map → chunk-6QH4NCPA.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subMilliseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMilliseconds } from './addMilliseconds';\n\n/**\n * Subtracts the specified number of milliseconds from a datetime.\n *\n * This is a convenience wrapper around addMilliseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param milliseconds - Number of milliseconds to subtract\n * @returns ZonedDateTime with milliseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');\n * const result = subMilliseconds(instant, 250);\n * // 2025-01-20T12:00:00.250Z[UTC] (250 milliseconds earlier)\n * ```\n */\nexport function subMilliseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  milliseconds: number\n): Temporal.ZonedDateTime {\n  return addMilliseconds(input, -milliseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}
+{"version":3,"sources":["../src/subMilliseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMilliseconds } from './addMilliseconds';\n\n/**\n * Subtracts the specified number of milliseconds from a datetime.\n *\n * This is a convenience wrapper around addMilliseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param milliseconds - Number of milliseconds to subtract\n * @returns ZonedDateTime with milliseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');\n * const result = subMilliseconds(instant, 250);\n * // 2025-01-20T12:00:00.250+00:00[UTC] (250 milliseconds earlier)\n * ```\n */\nexport function subMilliseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  milliseconds: number\n): Temporal.ZonedDateTime {\n  return addMilliseconds(input, -milliseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}

package/dist/{chunk-5XJEKPO5.js → chunk-6QOLNYFY.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/roundToNearestMinute.ts
 var MODE_TO_ROUNDING_MODE = {
@@ -22,4 +22,4 @@ function roundToNearestMinute(input, options) {
 export {
   roundToNearestMinute
 };
-//# sourceMappingURL=chunk-5XJEKPO5.js.map
+//# sourceMappingURL=chunk-6QOLNYFY.js.map

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-WY5I452J.js → chunk-7IKCDOCT.js}

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addSeconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of seconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param seconds - Number of seconds to add (can be negative to subtract)\n * @returns ZonedDateTime with seconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addSeconds(instant, 45);\n * // 2025-01-20T12:00:45+00:00[UTC] (45 seconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addSeconds(zoned, 3600);\n * // 2025-01-20T16:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract seconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addSeconds(instant, -30);\n * // 2025-01-20T11:59:30+00:00[UTC] (30 seconds earlier)\n * ```\n */\nexport function addSeconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  seconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ seconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,WACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,QAAQ,CAAC;AACtC;","names":[]}

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

@@ -6,7 +6,7 @@ import {
 } from "./chunk-ADPVFELS.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal,
   isPlainDate
@@ -63,4 +63,4 @@ function eachMonthOfInterval(interval) {
 export {
   eachMonthOfInterval
 };
-//# sourceMappingURL=chunk-5MB7UZCJ.js.map
+//# sourceMappingURL=chunk-7NGP7SAD.js.map

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

@@ -0,0 +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"]}

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-NYM3EW3M.js → chunk-AUOZACFS.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addMilliseconds.ts
 function addMilliseconds(input, milliseconds) {
@@ -11,4 +11,4 @@ function addMilliseconds(input, milliseconds) {
 export {
   addMilliseconds
 };
-//# sourceMappingURL=chunk-NYM3EW3M.js.map
+//# sourceMappingURL=chunk-AUOZACFS.js.map

package/dist/chunk-AUOZACFS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMilliseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of milliseconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param milliseconds - Number of milliseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with milliseconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMilliseconds(instant, 500);\n * // 2025-01-20T12:00:00.500+00:00[UTC] (500 milliseconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addMilliseconds(zoned, 1500);\n * // 2025-01-20T15:30:01.500-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract milliseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');\n * const result = addMilliseconds(instant, -250);\n * // 2025-01-20T12:00:00.250+00:00[UTC] (250 milliseconds earlier)\n * ```\n */\nexport function addMilliseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  milliseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ milliseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,gBACd,OACA,cACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,aAAa,CAAC;AAC3C;","names":[]}

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

@@ -3,10 +3,10 @@ import {
 } from "./chunk-BMX7CIRD.js";
 import {
   nowZoned
-} from "./chunk-TWRJEIBO.js";
+} from "./chunk-4GEF7B7W.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isPast.ts
 function isPast(date) {
@@ -17,4 +17,4 @@ function isPast(date) {
 export {
   isPast
 };
-//# sourceMappingURL=chunk-XXB6HJ2R.js.map
+//# sourceMappingURL=chunk-BI42E23Z.js.map

package/dist/{chunk-5WPQUOM4.js → chunk-BPMS34GV.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -18,4 +18,4 @@ function isSameQuarter(date1, date2) {
 export {
   isSameQuarter
 };
-//# sourceMappingURL=chunk-5WPQUOM4.js.map
+//# sourceMappingURL=chunk-BPMS34GV.js.map

package/dist/chunk-BPMS34GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterOfMonth } from \"./shared/quarter\";\n\n/**\n * Returns true if both inputs fall in the same calendar quarter and year.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * Instant inputs are converted to UTC; ZonedDateTime inputs keep their own\n * timezone. PlainDate inputs are compared directly — a quarter is intrinsic to\n * the calendar date, so no timezone is needed.\n *\n * @param date1 - First Instant or ZonedDateTime\n * @param date2 - Second Instant or ZonedDateTime\n * @returns true if both are in the same calendar quarter, false otherwise\n *\n * @example\n * ```ts\n * const jan = Temporal.ZonedDateTime.from('2025-01-15T08:00:00+00:00[UTC]');\n * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59+00:00[UTC]');\n * isSameQuarter(jan, mar); // true\n * ```\n *\n * @example\n * ```ts\n * // PlainDate comparison needs no timezone\n * const a = Temporal.PlainDate.from('2025-04-05');\n * const b = Temporal.PlainDate.from('2025-06-28');\n * isSameQuarter(a, b); // true (both Q2)\n * ```\n */\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime,\n): boolean;\nexport function isSameQuarter(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  date2: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n): boolean {\n  const a = isPlainDate(date1) ? date1 : normalizeTemporalInput(date1);\n  const b = isPlainDate(date2) ? date2 : normalizeTemporalInput(date2);\n\n  return a.year === b.year && quarterOfMonth(a.month) === quarterOfMonth(b.month);\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,cACd,OACA,OACS;AACT,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACnE,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AAEnE,SAAO,EAAE,SAAS,EAAE,QAAQ,eAAe,EAAE,KAAK,MAAM,eAAe,EAAE,KAAK;AAChF;","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-W5FFJSCD.js → chunk-DBOIK3XA.js}

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

package/dist/chunk-DBOIK3XA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMinute.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same minute.\n * Compares the year, month, day, hour, and minute 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 in the same minute, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same minute\n * const start = Temporal.ZonedDateTime.from('2025-01-20T14:30:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-20T14:30:59.999+00:00[UTC]');\n *\n * isSameMinute(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different minutes\n * const min30 = Temporal.ZonedDateTime.from('2025-01-20T14:30:59+00:00[UTC]');\n * const min31 = Temporal.ZonedDateTime.from('2025-01-20T14:31:00+00:00[UTC]');\n *\n * isSameMinute(min30, min31); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local minutes\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local minutes from each person's perspective\n * isSameMinute(ny, tokyo); // false (14:30:xx in NY, 04:30:xx in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMinute(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:xx in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMinute(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:xx in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:15Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45Z');\n *\n * isSameMinute(instant1, instant2); // true (both 14:30:xx in UTC)\n * ```\n */\nexport function isSameMinute(\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    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute\n  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,aACd,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,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO;AAE7B;","names":[]}

package/dist/{chunk-FLVULRGY.js → chunk-DGUAV5XN.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/roundToNearestHour.ts
 var MODE_TO_ROUNDING_MODE = {
@@ -22,4 +22,4 @@ function roundToNearestHour(input, options) {
 export {
   roundToNearestHour
 };
-//# sourceMappingURL=chunk-FLVULRGY.js.map
+//# sourceMappingURL=chunk-DGUAV5XN.js.map

package/dist/{chunk-23APOESH.js → chunk-DRBZDI52.js}

@@ -1,6 +1,6 @@
 import {
   addHours
-} from "./chunk-XTS6LZBP.js";
+} from "./chunk-YKXRVQ4S.js";
 
 // src/subHours.ts
 function subHours(input, hours) {
@@ -10,4 +10,4 @@ function subHours(input, hours) {
 export {
   subHours
 };
-//# sourceMappingURL=chunk-23APOESH.js.map
+//# sourceMappingURL=chunk-DRBZDI52.js.map

package/dist/{chunk-23APOESH.js.map → chunk-DRBZDI52.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subHours.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addHours } from './addHours';\n\n/**\n * Subtracts the specified number of hours from a datetime.\n *\n * This is a convenience wrapper around addHours with negated value.\n * Properly handles DST transitions through Temporal API.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param hours - Number of hours to subtract\n * @returns ZonedDateTime with hours subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const result = subHours(instant, 3);\n * // 2025-01-20T12:00:00Z[UTC] (3 hours earlier)\n * ```\n */\nexport function subHours(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  hours: number\n): Temporal.ZonedDateTime {\n  return addHours(input, -hours);\n}\n"],"mappings":";;;;;AAoBO,SAAS,SACd,OACA,OACwB;AACxB,SAAO,SAAS,OAAO,CAAC,KAAK;AAC/B;","names":[]}
+{"version":3,"sources":["../src/subHours.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addHours } from './addHours';\n\n/**\n * Subtracts the specified number of hours from a datetime.\n *\n * This is a convenience wrapper around addHours with negated value.\n * Properly handles DST transitions through Temporal API.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param hours - Number of hours to subtract\n * @returns ZonedDateTime with hours subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const result = subHours(instant, 3);\n * // 2025-01-20T12:00:00+00:00[UTC] (3 hours earlier)\n * ```\n */\nexport function subHours(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  hours: number\n): Temporal.ZonedDateTime {\n  return addHours(input, -hours);\n}\n"],"mappings":";;;;;AAoBO,SAAS,SACd,OACA,OACwB;AACxB,SAAO,SAAS,OAAO,CAAC,KAAK;AAC/B;","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-JWYRXPR4.js → chunk-DYIISNVW.js}

@@ -4,23 +4,28 @@ import {
 import {
   isPlainDateAfter
 } from "./chunk-ADPVFELS.js";
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } 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-JWYRXPR4.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-HSJMG5T7.js → chunk-DZ3647ZK.js}

@@ -1,6 +1,6 @@
 import {
   addDays
-} from "./chunk-V36MCE25.js";
+} from "./chunk-4KAIF44F.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subDays(input, days) {
 export {
   subDays
 };
-//# sourceMappingURL=chunk-HSJMG5T7.js.map
+//# sourceMappingURL=chunk-DZ3647ZK.js.map

package/dist/{chunk-HSJMG5T7.js.map → chunk-DZ3647ZK.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addDays } from './addDays';\n\n/**\n * Subtracts the specified number of days from a datetime or date.\n *\n * This is a convenience wrapper around addDays with negated value.\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param days - Number of days to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with days subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-25T12:00:00Z');\n * const result = subDays(instant, 5);\n * // 2025-01-20T12:00:00Z[UTC] (5 days earlier)\n * ```\n */\nexport function subDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function subDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function subDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addDays overload.\n  return isPlainDate(input) ? addDays(input, -days) : addDays(input, -days);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,QACd,OACA,MAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,QAAQ,OAAO,CAAC,IAAI,IAAI,QAAQ,OAAO,CAAC,IAAI;AAC1E;","names":[]}
+{"version":3,"sources":["../src/subDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addDays } from './addDays';\n\n/**\n * Subtracts the specified number of days from a datetime or date.\n *\n * This is a convenience wrapper around addDays with negated value.\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param days - Number of days to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with days subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-25T12:00:00Z');\n * const result = subDays(instant, 5);\n * // 2025-01-20T12:00:00+00:00[UTC] (5 days earlier)\n * ```\n */\nexport function subDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function subDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function subDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addDays overload.\n  return isPlainDate(input) ? addDays(input, -days) : addDays(input, -days);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,QACd,OACA,MAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,QAAQ,OAAO,CAAC,IAAI,IAAI,QAAQ,OAAO,CAAC,IAAI;AAC1E;","names":[]}

package/dist/{chunk-LKF7U4O4.js → chunk-EAO2SO4N.js}

@@ -1,6 +1,6 @@
 import {
   addMinutes
-} from "./chunk-5ST6IOPN.js";
+} from "./chunk-GXSVYUCG.js";
 
 // src/subMinutes.ts
 function subMinutes(input, minutes) {
@@ -10,4 +10,4 @@ function subMinutes(input, minutes) {
 export {
   subMinutes
 };
-//# sourceMappingURL=chunk-LKF7U4O4.js.map
+//# sourceMappingURL=chunk-EAO2SO4N.js.map

package/dist/{chunk-LKF7U4O4.js.map → chunk-EAO2SO4N.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subMinutes.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMinutes } from './addMinutes';\n\n/**\n * Subtracts the specified number of minutes from a datetime.\n *\n * This is a convenience wrapper around addMinutes with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param minutes - Number of minutes to subtract\n * @returns ZonedDateTime with minutes subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:30:00Z');\n * const result = subMinutes(instant, 15);\n * // 2025-01-20T12:15:00Z[UTC] (15 minutes earlier)\n * ```\n */\nexport function subMinutes(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  minutes: number\n): Temporal.ZonedDateTime {\n  return addMinutes(input, -minutes);\n}\n"],"mappings":";;;;;AAmBO,SAAS,WACd,OACA,SACwB;AACxB,SAAO,WAAW,OAAO,CAAC,OAAO;AACnC;","names":[]}
+{"version":3,"sources":["../src/subMinutes.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMinutes } from './addMinutes';\n\n/**\n * Subtracts the specified number of minutes from a datetime.\n *\n * This is a convenience wrapper around addMinutes with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param minutes - Number of minutes to subtract\n * @returns ZonedDateTime with minutes subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:30:00Z');\n * const result = subMinutes(instant, 15);\n * // 2025-01-20T12:15:00+00:00[UTC] (15 minutes earlier)\n * ```\n */\nexport function subMinutes(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  minutes: number\n): Temporal.ZonedDateTime {\n  return addMinutes(input, -minutes);\n}\n"],"mappings":";;;;;AAmBO,SAAS,WACd,OACA,SACwB;AACxB,SAAO,WAAW,OAAO,CAAC,OAAO;AACnC;","names":[]}

package/dist/{chunk-2OSJHJV5.js → chunk-EBOLL4LY.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInMicroseconds.ts
 function differenceInMicroseconds(laterDate, earlierDate) {
@@ -13,4 +13,4 @@ function differenceInMicroseconds(laterDate, earlierDate) {
 export {
   differenceInMicroseconds
 };
-//# sourceMappingURL=chunk-2OSJHJV5.js.map
+//# sourceMappingURL=chunk-EBOLL4LY.js.map

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

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

package/dist/chunk-F3UZDWOQ.js.map

@@ -0,0 +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":[]}

package/dist/{chunk-QD3ROUIT.js → chunk-GOJ45AG7.js}

@@ -1,9 +1,9 @@
 import {
   isWeekendDay
-} from "./chunk-Z7I7YCKN.js";
+} from "./chunk-4YCEFGZA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -17,4 +17,4 @@ function isWeekend(input) {
 export {
   isWeekend
 };
-//# sourceMappingURL=chunk-QD3ROUIT.js.map
+//# sourceMappingURL=chunk-GOJ45AG7.js.map

package/dist/{chunk-SLBDEPBP.js → chunk-GU3CZAIN.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInHours.ts
 function differenceInHours(laterDate, earlierDate, options) {
@@ -13,4 +13,4 @@ function differenceInHours(laterDate, earlierDate, options) {
 export {
   differenceInHours
 };
-//# sourceMappingURL=chunk-SLBDEPBP.js.map
+//# sourceMappingURL=chunk-GU3CZAIN.js.map