@gobrand/tiempo 3.1.2 → 3.1.3

package/dist/chunk-57MHNRCU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isWithinInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { isAfter } from './shared/isAfter';\n\n/**\n * Returns true if the given date is within the interval (inclusive of start and end).\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date - The date to check (Instant or ZonedDateTime)\n * @param interval - The interval with start and end dates\n * @returns true if date is within the interval, false otherwise\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date outside the interval\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // false\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval start (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(start, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval end (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(end, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const start = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-07T00:00:00Z');\n * const date = Temporal.Instant.from('2025-01-03T00:00:00Z');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+09:00[Asia/Tokyo]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n */\nexport function isWithinInterval(\n  date: Temporal.Instant | Temporal.ZonedDateTime,\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime;\n    end: Temporal.Instant | Temporal.ZonedDateTime;\n  }\n): boolean {\n  const normalizedDate = normalizeTemporalInput(date);\n  const normalizedStart = normalizeTemporalInput(interval.start);\n  const normalizedEnd = normalizeTemporalInput(interval.end);\n\n  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);\n}\n"],"mappings":";;;;;;;;;;;AAsEO,SAAS,iBACd,MACA,UAIS;AACT,QAAM,iBAAiB,uBAAuB,IAAI;AAClD,QAAM,kBAAkB,uBAAuB,SAAS,KAAK;AAC7D,QAAM,gBAAgB,uBAAuB,SAAS,GAAG;AAEzD,SAAO,CAAC,SAAS,gBAAgB,eAAe,KAAK,CAAC,QAAQ,gBAAgB,aAAa;AAC7F;","names":[]}

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-QD3ROUIT.js → chunk-6QZUAJVF.js}

@@ -1,9 +1,9 @@
 import {
   isWeekendDay
-} from "./chunk-Z7I7YCKN.js";
+} from "./chunk-K7CLBBBM.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-6QZUAJVF.js.map

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-JWYRXPR4.js → chunk-AOODDNHA.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-ADPVFELS.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -50,4 +50,4 @@ function eachWeekOfInterval(interval) {
 export {
   eachWeekOfInterval
 };
-//# sourceMappingURL=chunk-JWYRXPR4.js.map
+//# sourceMappingURL=chunk-AOODDNHA.js.map

package/dist/chunk-AOODDNHA.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';\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 (Monday at midnight).\n * Uses ISO 8601 week definition: weeks start on Monday.\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 * @returns Array of ZonedDateTime at start of each week (Monday) 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(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachWeekOfInterval(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.subtract({ days: end.dayOfWeek - 1 });\n    let current = interval.start.subtract({ days: interval.start.dayOfWeek - 1 });\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 timezone = startZoned.timeZoneId;\n\n  // Get Monday of the starting week\n  // dayOfWeek: 1 = Monday, 7 = Sunday (ISO 8601)\n  const daysToSubtractStart = startZoned.dayOfWeek - 1;\n  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();\n\n  // Get Monday of the ending week\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;\n  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();\n\n  const weeks: Temporal.ZonedDateTime[] = [];\n  let current = startMonday;\n\n  while (current.epochNanoseconds <= endMonday.epochNanoseconds) {\n    weeks.push(current);\n    current = current.add({ weeks: 1 });\n  }\n\n  return weeks;\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,SAAS,EAAE,MAAM,IAAI,YAAY,EAAE,CAAC;AACrD,QAAIA,WAAU,SAAS,MAAM,SAAS,EAAE,MAAM,SAAS,MAAM,YAAY,EAAE,CAAC;AAC5E,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,WAAW,WAAW;AAI5B,QAAM,sBAAsB,WAAW,YAAY;AACnD,QAAM,cAAc,WAAW,SAAS,EAAE,MAAM,oBAAoB,CAAC,EAAE,WAAW;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,oBAAoB,cAAc,YAAY;AACpD,QAAM,YAAY,cAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC,EAAE,WAAW;AAEjF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,UAAU,kBAAkB;AAC7D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":["current"]}

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-22IDWEHQ.js → chunk-BYPHFTFD.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TWXUGWYX.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isInstant,
   isPlainDate
@@ -325,4 +325,4 @@ function isAm(period) {
 export {
   format
 };
-//# sourceMappingURL=chunk-22IDWEHQ.js.map
+//# sourceMappingURL=chunk-BYPHFTFD.js.map

package/dist/{chunk-SMMVTXL4.js → chunk-D3N7BT44.js}

@@ -1,9 +1,9 @@
 import {
   addWeekdays
-} from "./chunk-Z7I7YCKN.js";
+} from "./chunk-K7CLBBBM.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -19,4 +19,4 @@ function addBusinessDays(input, days) {
 export {
   addBusinessDays
 };
-//# sourceMappingURL=chunk-SMMVTXL4.js.map
+//# sourceMappingURL=chunk-D3N7BT44.js.map

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-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-SATEE2TL.js → chunk-GCVX5QIX.js}

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

package/dist/chunk-GCVX5QIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameWeek.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 ISO 8601 week.\n * Uses ISO week numbering where weeks start on Monday and the first week\n * of the year is the week containing January 4th.\n *\n * Compares the yearOfWeek and weekOfYear 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 ISO 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 */\nexport function isSameWeek(\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.yearOfWeek === zoned2.yearOfWeek &&\n    zoned1.weekOfYear === zoned2.weekOfYear\n  );\n}\n"],"mappings":";;;;;AAwEO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,eAAe,OAAO,cAC7B,OAAO,eAAe,OAAO;AAEjC;","names":[]}

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

package/dist/{chunk-5ST6IOPN.js → chunk-GXSVYUCG.js}

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

package/dist/chunk-GXSVYUCG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMinutes.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of minutes 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 minutes - Number of minutes to add (can be negative to subtract)\n * @returns ZonedDateTime with minutes 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 = addMinutes(instant, 30);\n * // 2025-01-20T12:30:00+00:00[UTC] (30 minutes 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 = addMinutes(zoned, 90);\n * // 2025-01-20T17:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract minutes\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMinutes(instant, -15);\n * // 2025-01-20T11:45:00+00:00[UTC] (15 minutes earlier)\n * ```\n */\nexport function addMinutes(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  minutes: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ minutes });\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-B6VZ2AKN.js → chunk-HCORON7B.js}

@@ -1,6 +1,6 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
 } from "./chunk-NMMMAMKP.js";
@@ -21,4 +21,4 @@ function endOfMonth(input, timezone) {
 export {
   endOfMonth
 };
-//# sourceMappingURL=chunk-B6VZ2AKN.js.map
+//# sourceMappingURL=chunk-HCORON7B.js.map

package/dist/chunk-HCORON7B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfMonth.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 month.\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 month at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const end = endOfMonth(instant);\n * // 2025-01-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-02-15T15:30:00-05:00[America/New_York]');\n * const end = endOfMonth(zoned);\n * // 2025-02-28T23: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-02-15');\n * const end = endOfMonth(date);\n * // 2025-02-28\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date, 'America/New_York');\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ day: input.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AAoDO,SAAS,WACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,MAAM,YAAY,CAAC;AAAA,EAC9C;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,UAAU,cAAc,KAAK,EAAE,KAAK,cAAc,YAAY,CAAC;AACrE,SAAO,YAAY,OAAO;AAC5B;","names":[]}

package/dist/{chunk-FL33IWLY.js → chunk-HRCTWTP3.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -16,4 +16,4 @@ function addYears(input, years) {
 export {
   addYears
 };
-//# sourceMappingURL=chunk-FL33IWLY.js.map
+//# sourceMappingURL=chunk-HRCTWTP3.js.map

package/dist/chunk-HRCTWTP3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addYears.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of years to a datetime or date.\n *\n * Properly handles leap years and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\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 years - Number of years to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with years added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addYears(instant, 2);\n * // 2027-01-20T12:00:00+00:00[UTC] (2 years 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 = addYears(zoned, 1);\n * // 2026-01-20T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Leap year handling\n * const instant = Temporal.Instant.from('2024-02-29T12:00:00Z');\n * const result = addYears(instant, 1);\n * // 2025-02-28T12:00:00+00:00[UTC] (Feb 29 → Feb 28)\n * ```\n */\nexport function addYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;\nexport function addYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime;\nexport function addYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  years: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ years });\n  }\n  return normalizeTemporalInput(input).add({ years });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,SACd,OACA,OAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,MAAM,CAAC;AAAA,EAC5B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC;AACpD;","names":[]}

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

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

package/dist/chunk-HYSGJJUR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMonth.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 calendar month and year.\n * Compares the year and month 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 calendar month, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same month\n * const start = Temporal.ZonedDateTime.from('2025-01-01T08:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');\n *\n * isSameMonth(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different months\n * const jan = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');\n * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00+00:00[UTC]');\n *\n * isSameMonth(jan, feb); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar months\n * const ny = Temporal.ZonedDateTime.from('2025-01-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-02-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar months from each person's perspective\n * isSameMonth(ny, tokyo); // false (Jan in NY, Feb in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMonth(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Feb in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMonth(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-31T23:59:59Z');\n *\n * isSameMonth(instant1, instant2); // true (both Jan 2025 in UTC)\n * ```\n */\nexport function isSameMonth(\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;\n}\n"],"mappings":";;;;;AA0DO,SAAS,YACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO,QAAQ,OAAO,UAAU,OAAO;AAChE;","names":[]}

package/dist/{chunk-C5OJIIJP.js → chunk-IWVSM77B.js}

@@ -1,6 +1,6 @@
 import {
   addNanoseconds
-} from "./chunk-ETO77GIW.js";
+} from "./chunk-32AWWYBF.js";
 
 // src/subNanoseconds.ts
 function subNanoseconds(input, nanoseconds) {
@@ -10,4 +10,4 @@ function subNanoseconds(input, nanoseconds) {
 export {
   subNanoseconds
 };
-//# sourceMappingURL=chunk-C5OJIIJP.js.map
+//# sourceMappingURL=chunk-IWVSM77B.js.map

package/dist/{chunk-C5OJIIJP.js.map → chunk-IWVSM77B.js.map}

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