@gobrand/tiempo 3.1.2 → 3.1.3

package/dist/{chunk-XIVWFVVX.js → chunk-IXNGK5OF.js}

@@ -1,6 +1,6 @@
 import {
   addMicroseconds
-} from "./chunk-PU6PU2JM.js";
+} from "./chunk-TI6WBLCB.js";
 
 // src/subMicroseconds.ts
 function subMicroseconds(input, microseconds) {
@@ -10,4 +10,4 @@ function subMicroseconds(input, microseconds) {
 export {
   subMicroseconds
 };
-//# sourceMappingURL=chunk-XIVWFVVX.js.map
+//# sourceMappingURL=chunk-IXNGK5OF.js.map

package/dist/{chunk-XIVWFVVX.js.map → chunk-IXNGK5OF.js.map}

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

package/dist/{chunk-XR7Q6IP6.js → chunk-JA5ER27P.js}

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

package/dist/{chunk-E5HJJFUI.js → chunk-JGPTGV5X.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -23,4 +23,4 @@ function differenceInDays(laterDate, earlierDate, options) {
 export {
   differenceInDays
 };
-//# sourceMappingURL=chunk-E5HJJFUI.js.map
+//# sourceMappingURL=chunk-JGPTGV5X.js.map

package/dist/{chunk-4E5OJUMN.js → chunk-K3L6MJJB.js}

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

package/dist/{chunk-4E5OJUMN.js.map → chunk-K3L6MJJB.js.map}

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

package/dist/{chunk-MCPKXTX7.js → chunk-K6NQZIAW.js}

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

package/dist/chunk-K6NQZIAW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMillisecond.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 millisecond.\n * Compares the year, month, day, hour, minute, second, and millisecond fields directly.\n * Ignores sub-millisecond precision (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 millisecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same millisecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999+00:00[UTC]');\n *\n * isSameMillisecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different milliseconds\n * const ms123 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');\n * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124+00:00[UTC]');\n *\n * isSameMillisecond(ms123, ms124); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local milliseconds\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.123+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local milliseconds from each person's perspective\n * isSameMillisecond(ny, tokyo); // false (14:30:45.123 in NY, 04:30:45.123 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMillisecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMillisecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123 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.123456Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123999Z');\n *\n * isSameMillisecond(instant1, instant2); // true (both 14:30:45.123 in UTC)\n * ```\n */\nexport function isSameMillisecond(\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    zoned1.millisecond === zoned2.millisecond\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,kBACd,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,UACzB,OAAO,gBAAgB,OAAO;AAElC;","names":[]}

package/dist/{chunk-Z7I7YCKN.js → chunk-K7CLBBBM.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal,
   isPlainDate
@@ -33,4 +33,4 @@ export {
   addWeekdays,
   isoDate
 };
-//# sourceMappingURL=chunk-Z7I7YCKN.js.map
+//# sourceMappingURL=chunk-K7CLBBBM.js.map

package/dist/{chunk-XZS6J4LM.js → chunk-KYS54PLJ.js}

@@ -1,6 +1,6 @@
 import {
   addQuarters
-} from "./chunk-YR26F7OA.js";
+} from "./chunk-QDY2KMYX.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subQuarters(input, quarters) {
 export {
   subQuarters
 };
-//# sourceMappingURL=chunk-XZS6J4LM.js.map
+//# sourceMappingURL=chunk-KYS54PLJ.js.map

package/dist/chunk-KYS54PLJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { addQuarters } from \"./addQuarters\";\n\n/**\n * Subtracts the specified number of quarters (3-month blocks) from a datetime or date.\n *\n * This is a convenience wrapper around addQuarters with the count negated.\n * PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param quarters - Number of quarters to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * subQuarters(instant, 2);\n * // 2025-01-20T12:00:00+00:00[UTC] (6 months earlier)\n * ```\n *\n * @example\n * ```ts\n * subQuarters(Temporal.PlainDate.from('2025-07-20'), 1);\n * // 2025-04-20\n * ```\n */\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function subQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Branch so each call resolves to the matching addQuarters overload.\n  return isPlainDate(input) ? addQuarters(input, -quarters) : addQuarters(input, -quarters);\n}\n"],"mappings":";;;;;;;;AA+BO,SAAS,YACd,OACA,UAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,YAAY,OAAO,CAAC,QAAQ,IAAI,YAAY,OAAO,CAAC,QAAQ;AAC1F;","names":[]}

package/dist/{chunk-2LN57UVR.js → chunk-KZCSP3DU.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -25,4 +25,4 @@ function differenceInMonths(laterDate, earlierDate, options) {
 export {
   differenceInMonths
 };
-//# sourceMappingURL=chunk-2LN57UVR.js.map
+//# sourceMappingURL=chunk-KZCSP3DU.js.map

package/dist/{chunk-35IJG3T2.js → chunk-LMOAA73F.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -25,4 +25,4 @@ function differenceInYears(laterDate, earlierDate, options) {
 export {
   differenceInYears
 };
-//# sourceMappingURL=chunk-35IJG3T2.js.map
+//# sourceMappingURL=chunk-LMOAA73F.js.map

package/dist/{chunk-ITQ6OJAL.js → chunk-MLHFNZEA.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2AID4P2C.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -23,4 +23,4 @@ function startOfWeek(input, timezone) {
 export {
   startOfWeek
 };
-//# sourceMappingURL=chunk-ITQ6OJAL.js.map
+//# sourceMappingURL=chunk-MLHFNZEA.js.map

package/dist/chunk-MLHFNZEA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the first boundary of the week (Monday).\n * Uses ISO 8601 week definition: weeks start on Monday.\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 Monday 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const start = startOfWeek(instant);\n * // 2025-01-20T00:00:00+00:00[UTC] (same day, it's already Monday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const start = startOfWeek(zoned);\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date);\n * // 2025-01-20 (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n */\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfWeek(\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.subtract({ days: input.dayOfWeek - 1 });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to subtract to get to Monday\n  const daysToSubtract = dayOfWeek - 1;\n\n  // Go to Monday, then get start of that day\n  const monday = zonedDateTime.subtract({ days: daysToSubtract });\n\n  return monday.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AAqDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,SAAS,EAAE,MAAM,MAAM,YAAY,EAAE,CAAC;AAAA,EACrD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,iBAAiB,YAAY;AAGnC,QAAM,SAAS,cAAc,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9D,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/{chunk-NNUATTN7.js → chunk-MVGBYHG5.js}

@@ -1,6 +1,6 @@
 import {
   addMonths
-} from "./chunk-WJZHUNF5.js";
+} from "./chunk-ZXKU4SKR.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subMonths(input, months) {
 export {
   subMonths
 };
-//# sourceMappingURL=chunk-NNUATTN7.js.map
+//# sourceMappingURL=chunk-MVGBYHG5.js.map

package/dist/{chunk-NNUATTN7.js.map → chunk-MVGBYHG5.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates 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 months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}
+{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates 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 months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00+00:00[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}

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

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
 } from "./chunk-NMMMAMKP.js";
@@ -32,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-R3PZ56AD.js.map
+//# sourceMappingURL=chunk-MXYAZTDE.js.map

package/dist/chunk-MXYAZTDE.js.map

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

package/dist/{chunk-5KVFPVBT.js → chunk-NGS5UKDW.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -24,4 +24,4 @@ function startOfQuarter(input, timezone) {
 export {
   startOfQuarter
 };
-//# sourceMappingURL=chunk-5KVFPVBT.js.map
+//# sourceMappingURL=chunk-NGS5UKDW.js.map

package/dist/chunk-NGS5UKDW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport type { Timezone } from \"./types\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the first moment of the quarter\n * (first day of the quarter's starting month at midnight).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the 1st day of the quarter at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const start = startOfQuarter(instant);\n * // 2025-04-01T00:00:00+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-08-15T15:30:00-04:00[America/New_York]');\n * const start = startOfQuarter(zoned);\n * // 2025-07-01T00:00:00-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From a PlainDate in a timezone\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const start = startOfQuarter(date, 'America/New_York');\n * // 2025-10-01T00:00:00-04:00[America/New_York]\n * ```\n */\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfQuarter(\n  input: Temporal.PlainDate,\n  timezone: Timezone,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → first day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ month: quarterStartMonth(input.month), day: 1 });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month),\n    day: 1,\n  });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AA8CO,SAAS,eACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,OAAO,kBAAkB,MAAM,KAAK,GAAG,KAAK,EAAE,CAAC;AAAA,EACrE;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK;AAAA,IAC5C,KAAK;AAAA,EACP,CAAC;AACD,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/{chunk-FAVYJIRM.js → chunk-NOWUJERX.js}

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

package/dist/chunk-NOWUJERX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last nanosecond of the day.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const end = endOfDay(instant);\n * // 2025-01-20T23: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-01-20T15:30:00-05:00[America/New_York]');\n * const end = endOfDay(zoned);\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-01-20');\n * const end = endOfDay(date, 'America/New_York');\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return getEndOfDay(zonedDateTime);\n}\n"],"mappings":";;;;;;;;AA0CO,SAAS,SACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,YAAY,aAAa;AAClC;","names":[]}

package/dist/{chunk-O4YU4N6Q.js → chunk-NVFFQJEW.js}

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

package/dist/{chunk-OYTQWJ2O.js → chunk-OEPVYNB6.js}

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

package/dist/{chunk-T775UWIV.js → chunk-OF5YEVUT.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/eachHourOfInterval.ts
 function eachHourOfInterval(interval) {
@@ -29,4 +29,4 @@ function eachHourOfInterval(interval) {
 export {
   eachHourOfInterval
 };
-//# sourceMappingURL=chunk-T775UWIV.js.map
+//# sourceMappingURL=chunk-OF5YEVUT.js.map

package/dist/chunk-OF5YEVUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachHourOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each hour within the interval.\n * Each element represents a local hour boundary (minute/second/etc. set to 0),\n * or the first valid instant after an offset transition within an hour.\n * The interval is inclusive of both start and end hours.\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 * Completely missing hours are skipped. Partial hours start at the transition,\n * and repeated hours have separate entries for each offset. Later entries\n * realign to local hour boundaries, so steps need not be 60 elapsed minutes.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each hour in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:30:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T14:15:00+00:00[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:00:00+00:00[UTC],\n * //   2025-01-06T11:00:00+00:00[UTC],\n * //   2025-01-06T12:00:00+00:00[UTC],\n * //   2025-01-06T13:00:00+00:00[UTC],\n * //   2025-01-06T14:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-day boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T22:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T02:00:00+00:00[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T22:00:00+00:00[UTC],\n * //   2025-01-06T23:00:00+00:00[UTC],\n * //   2025-01-07T00:00:00+00:00[UTC],\n * //   2025-01-07T01:00:00+00:00[UTC],\n * //   2025-01-07T02:00:00+00:00[UTC]\n * // ]\n * ```\n */\nexport function eachHourOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[] {\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  let current = startZoned.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n  // A repeated partial hour can begin at :30 even though rounding selects the\n  // earlier :00. Include only the occurrence containing the starting instant.\n  const transition = current.getTimeZoneTransition('next');\n  if (transition && transition.epochNanoseconds <= startZoned.epochNanoseconds) {\n    current = transition;\n  }\n\n  const hours: Temporal.ZonedDateTime[] = [];\n  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {\n    hours.push(current);\n    const nextLocalHour = current.toPlainDateTime()\n      .round({ smallestUnit: 'hour', roundingMode: 'floor' })\n      .add({ hours: 1 });\n    let next = nextLocalHour.toZonedDateTime(current.timeZoneId);\n    if (next.epochNanoseconds <= current.epochNanoseconds) {\n      next = nextLocalHour.toZonedDateTime(current.timeZoneId, { disambiguation: 'later' });\n    }\n    // Offset transitions can start a partial or repeated hour before the next\n    // local :00. Afterwards, compute a local boundary again to avoid drift.\n    const nextTransition = current.getTimeZoneTransition('next');\n    current = nextTransition && nextTransition.epochNanoseconds < next.epochNanoseconds\n      ? nextTransition\n      : next;\n  }\n\n  return hours;\n}\n"],"mappings":";;;;;AAkDO,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,MAAI,UAAU,WAAW,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAG9E,QAAM,aAAa,QAAQ,sBAAsB,MAAM;AACvD,MAAI,cAAc,WAAW,oBAAoB,WAAW,kBAAkB;AAC5E,cAAU;AAAA,EACZ;AAEA,QAAM,QAAkC,CAAC;AACzC,SAAO,QAAQ,oBAAoB,SAAS,kBAAkB;AAC5D,UAAM,KAAK,OAAO;AAClB,UAAM,gBAAgB,QAAQ,gBAAgB,EAC3C,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC,EACrD,IAAI,EAAE,OAAO,EAAE,CAAC;AACnB,QAAI,OAAO,cAAc,gBAAgB,QAAQ,UAAU;AAC3D,QAAI,KAAK,oBAAoB,QAAQ,kBAAkB;AACrD,aAAO,cAAc,gBAAgB,QAAQ,YAAY,EAAE,gBAAgB,QAAQ,CAAC;AAAA,IACtF;AAGA,UAAM,iBAAiB,QAAQ,sBAAsB,MAAM;AAC3D,cAAU,kBAAkB,eAAe,mBAAmB,KAAK,mBAC/D,iBACA;AAAA,EACN;AAEA,SAAO;AACT;","names":[]}

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

@@ -1,7 +1,7 @@
 import {
   isWeekendDay,
   isoDate
-} from "./chunk-Z7I7YCKN.js";
+} from "./chunk-K7CLBBBM.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -27,4 +27,4 @@ function differenceInBusinessDays(laterDate, earlierDate) {
 export {
   differenceInBusinessDays
 };
-//# sourceMappingURL=chunk-RQ5CX67T.js.map
+//# sourceMappingURL=chunk-OVBZ2NBB.js.map

package/dist/{chunk-5FCHKIGV.js → chunk-PAM6VJQM.js}

@@ -1,6 +1,6 @@
 import {
   differenceInMonths
-} from "./chunk-2LN57UVR.js";
+} from "./chunk-KZCSP3DU.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -22,4 +22,4 @@ function differenceInQuarters(laterDate, earlierDate, options) {
 export {
   differenceInQuarters
 };
-//# sourceMappingURL=chunk-5FCHKIGV.js.map
+//# sourceMappingURL=chunk-PAM6VJQM.js.map

package/dist/chunk-Q6QLOUXJ.js

@@ -0,0 +1,18 @@
+import {
+  isInstant,
+  isZonedDateTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/normalizeTemporalInput.ts
+function normalizeTemporalInput(input) {
+  if (isInstant(input)) return input.toZonedDateTimeISO("UTC");
+  if (isZonedDateTime(input)) return input;
+  throw new TypeError(
+    `Expected a Temporal.Instant or Temporal.ZonedDateTime, got ${Object.prototype.toString.call(input).slice(8, -1)}`
+  );
+}
+
+export {
+  normalizeTemporalInput
+};
+//# sourceMappingURL=chunk-Q6QLOUXJ.js.map

package/dist/chunk-Q6QLOUXJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeTemporalInput.ts"],"sourcesContent":["import { type Temporal, isInstant, isZonedDateTime } from './temporal';\n\n/**\n * @internal\n * Normalizes input to ZonedDateTime. Converts Instant to UTC, or returns existing ZonedDateTime.\n * Anything else (a PlainDate, a string, a Date) throws, so a wrong-domain value can never\n * flow through as if it were a moment.\n * This is an internal helper - do not use directly.\n */\nexport function normalizeTemporalInput(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  if (isInstant(input)) return input.toZonedDateTimeISO('UTC');\n  if (isZonedDateTime(input)) return input;\n  throw new TypeError(\n    `Expected a Temporal.Instant or Temporal.ZonedDateTime, got ${Object.prototype.toString.call(input).slice(8, -1)}`\n  );\n}\n"],"mappings":";;;;;;AASO,SAAS,uBACd,OACwB;AACxB,MAAI,UAAU,KAAK,EAAG,QAAO,MAAM,mBAAmB,KAAK;AAC3D,MAAI,gBAAgB,KAAK,EAAG,QAAO;AACnC,QAAM,IAAI;AAAA,IACR,8DAA8D,OAAO,UAAU,SAAS,KAAK,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC;AAAA,EAClH;AACF;","names":[]}

package/dist/{chunk-YR26F7OA.js → chunk-QDY2KMYX.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 addQuarters(input, quarters) {
 export {
   addQuarters
 };
-//# sourceMappingURL=chunk-YR26F7OA.js.map
+//# sourceMappingURL=chunk-QDY2KMYX.js.map

package/dist/chunk-QDY2KMYX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\n\n/**\n * Adds the specified number of quarters (3-month blocks) to a datetime or date.\n *\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC; ZonedDateTime inputs preserve their\n * timezone. PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param quarters - Number of quarters to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters added\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * addQuarters(instant, 2);\n * // 2025-07-20T12:00:00+00:00[UTC] (6 months later)\n * ```\n *\n * @example\n * ```ts\n * // Calendar arithmetic on a date stays a date\n * addQuarters(Temporal.PlainDate.from('2025-01-31'), 1);\n * // 2025-04-30 (Jan 31 → Apr 30)\n * ```\n */\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function addQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ months: quarters * 3 });\n  }\n  return normalizeTemporalInput(input).add({ months: quarters * 3 });\n}\n"],"mappings":";;;;;;;;AAiCO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AAAA,EAC3C;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AACnE;","names":[]}

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

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

package/dist/chunk-QNZJR53W.js.map

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

package/dist/{chunk-44EIUFJB.js → chunk-QZ6WXAUO.js}

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

package/dist/chunk-QZ6WXAUO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameHour.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 hour.\n * Compares the year, month, day, and hour 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 hour, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same hour\n * const start = Temporal.ZonedDateTime.from('2025-01-20T14:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999+00:00[UTC]');\n *\n * isSameHour(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different hours\n * const hour14 = Temporal.ZonedDateTime.from('2025-01-20T14:59:59+00:00[UTC]');\n * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00+00:00[UTC]');\n *\n * isSameHour(hour14, hour15); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local hours\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local hours from each person's perspective\n * isSameHour(ny, tokyo); // false (14:xx in NY, 04:xx in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameHour(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:xx in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameHour(ny, tokyo.withTimeZone('America/New_York')); // true (both 14: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:15:30Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:45:50Z');\n *\n * isSameHour(instant1, instant2); // true (both 14:xx in UTC)\n * ```\n */\nexport function isSameHour(\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  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,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;AAE3B;","names":[]}

package/dist/{chunk-ZO2MTD2E.js → chunk-R2DCUSBY.js}

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

package/dist/chunk-R2DCUSBY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameYear.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 year.\n * Compares the year field 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 year, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same year\n * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');\n * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59+00:00[UTC]');\n *\n * isSameYear(jan, dec); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different years\n * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59+00:00[UTC]');\n * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n *\n * isSameYear(endOf2024, startOf2025); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar years\n * const ny = Temporal.ZonedDateTime.from('2024-12-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar years from each person's perspective\n * isSameYear(ny, tokyo); // false (2024 in NY, 2025 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameYear(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 2025 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameYear(ny, tokyo.withTimeZone('America/New_York')); // true (both 2024 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-12-31T23:59:59Z');\n *\n * isSameYear(instant1, instant2); // true (both 2025 in UTC)\n * ```\n */\nexport function isSameYear(\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;\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO;AAChC;","names":[]}

package/dist/{chunk-DXSRRBJO.js → chunk-R5XRTUWH.js}

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

package/dist/chunk-R5XRTUWH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameNanosecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes represent the exact same nanosecond.\n * Compares all time fields: year, month, day, hour, minute, second, millisecond, microsecond, and nanosecond.\n * This is the most precise comparison possible, representing exact instant equality in their respective timezones.\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 exact same nanosecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, exact same nanosecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');\n *\n * isSameNanosecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different nanoseconds\n * const ns789 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');\n * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790+00:00[UTC]');\n *\n * isSameNanosecond(ns789, ns790); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local nanoseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456789+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local nanoseconds from each person's perspective\n * isSameNanosecond(ny, tokyo); // false (14:30:45.123456789 in NY, 04:30:45.123456789 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameNanosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456789 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameNanosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456789 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.123456789Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');\n *\n * isSameNanosecond(instant1, instant2); // true\n * ```\n */\nexport function isSameNanosecond(\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    zoned1.millisecond === zoned2.millisecond &&\n    zoned1.microsecond === zoned2.microsecond &&\n    zoned1.nanosecond === zoned2.nanosecond\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,iBACd,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,UACzB,OAAO,gBAAgB,OAAO,eAC9B,OAAO,gBAAgB,OAAO,eAC9B,OAAO,eAAe,OAAO;AAEjC;","names":[]}

package/dist/{chunk-AA56LFMF.js → chunk-SHKSAHJO.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/eachMinuteOfInterval.ts
 function eachMinuteOfInterval(interval) {
@@ -23,4 +23,4 @@ function eachMinuteOfInterval(interval) {
 export {
   eachMinuteOfInterval
 };
-//# sourceMappingURL=chunk-AA56LFMF.js.map
+//# sourceMappingURL=chunk-SHKSAHJO.js.map

package/dist/chunk-SHKSAHJO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachMinuteOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each minute within the interval.\n * Each element represents the start of the minute (seconds/etc. set to 0).\n * The interval is inclusive of both start and end minutes.\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 * Warning: Large intervals can produce very large arrays. For example, a 24-hour\n * interval produces 1,441 elements. Consider whether this is appropriate for your use case.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each minute in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:30:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T10:33:45+00:00[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:30:00+00:00[UTC],\n * //   2025-01-06T10:31:00+00:00[UTC],\n * //   2025-01-06T10:32:00+00:00[UTC],\n * //   2025-01-06T10:33:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-hour boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:58:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T11:02:00+00:00[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:58:00+00:00[UTC],\n * //   2025-01-06T10:59:00+00:00[UTC],\n * //   2025-01-06T11:00:00+00:00[UTC],\n * //   2025-01-06T11:01:00+00:00[UTC],\n * //   2025-01-06T11:02:00+00:00[UTC]\n * // ]\n * ```\n */\nexport function eachMinuteOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[] {\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 minute\n  const startMinute = startZoned.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  // Get start of the ending minute in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endMinute = endInTimezone.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  const minutes: Temporal.ZonedDateTime[] = [];\n  let current = startMinute;\n\n  while (current.epochNanoseconds <= endMinute.epochNanoseconds) {\n    minutes.push(current);\n    current = current.add({ minutes: 1 });\n  }\n\n  return minutes;\n}\n"],"mappings":";;;;;AA+CO,SAAS,qBAAqB,UAGR;AAC3B,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,cAAc,WAAW,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAGtF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,YAAY,cAAc,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAEvF,QAAM,UAAoC,CAAC;AAC3C,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,UAAU,kBAAkB;AAC7D,YAAQ,KAAK,OAAO;AACpB,cAAU,QAAQ,IAAI,EAAE,SAAS,EAAE,CAAC;AAAA,EACtC;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-33MHEBQR.js → chunk-SLH6TKGN.js}

@@ -1,6 +1,6 @@
 import {
   addWeeks
-} from "./chunk-426MJGNT.js";
+} from "./chunk-3X2U6I44.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subWeeks(input, weeks) {
 export {
   subWeeks
 };
-//# sourceMappingURL=chunk-33MHEBQR.js.map
+//# sourceMappingURL=chunk-SLH6TKGN.js.map

package/dist/{chunk-33MHEBQR.js.map → chunk-SLH6TKGN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addWeeks } from './addWeeks';\n\n/**\n * Subtracts the specified number of weeks from a datetime or date.\n *\n * This is a convenience wrapper around addWeeks 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 weeks - Number of weeks to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-02-03T12:00:00Z');\n * const result = subWeeks(instant, 2);\n * // 2025-01-20T12:00:00Z[UTC] (2 weeks earlier)\n * ```\n */\nexport function subWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addWeeks overload.\n  return isPlainDate(input) ? addWeeks(input, -weeks) : addWeeks(input, -weeks);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}
+{"version":3,"sources":["../src/subWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addWeeks } from './addWeeks';\n\n/**\n * Subtracts the specified number of weeks from a datetime or date.\n *\n * This is a convenience wrapper around addWeeks 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 weeks - Number of weeks to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-02-03T12:00:00Z');\n * const result = subWeeks(instant, 2);\n * // 2025-01-20T12:00:00+00:00[UTC] (2 weeks earlier)\n * ```\n */\nexport function subWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addWeeks overload.\n  return isPlainDate(input) ? addWeeks(input, -weeks) : addWeeks(input, -weeks);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}

package/dist/{chunk-2MFBXSTL.js → chunk-TCB3IDJM.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2AID4P2C.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -16,4 +16,4 @@ function normalizeWithPlainDate(input, timezone) {
 export {
   normalizeWithPlainDate
 };
-//# sourceMappingURL=chunk-2MFBXSTL.js.map
+//# sourceMappingURL=chunk-TCB3IDJM.js.map

package/dist/{chunk-DHVGDIIO.js → chunk-TD6MVGV2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-3KE6GK4R.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInMilliseconds.ts
 function differenceInMilliseconds2(laterDate, earlierDate) {
@@ -15,4 +15,4 @@ function differenceInMilliseconds2(laterDate, earlierDate) {
 export {
   differenceInMilliseconds2 as differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-DHVGDIIO.js.map
+//# sourceMappingURL=chunk-TD6MVGV2.js.map