@gobrand/tiempo 3.1.2 → 3.1.3

package/dist/startOfQuarter.d.ts

@@ -14,7 +14,7 @@ import type { Timezone } from "./types.js";
  * // From Instant (always UTC)
  * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');
  * const start = startOfQuarter(instant);
- * // 2025-04-01T00:00:00Z[UTC]
+ * // 2025-04-01T00:00:00+00:00[UTC]
  * ```
  *
  * @example
@@ -27,7 +27,7 @@ import type { Timezone } from "./types.js";
  *
  * @example
  * ```ts
- * // From PlainDate (requires timezone)
+ * // From a PlainDate in a timezone
  * const date = Temporal.PlainDate.from('2025-11-15');
  * const start = startOfQuarter(date, 'America/New_York');
  * // 2025-10-01T00:00:00-04:00[America/New_York]

package/dist/startOfQuarter.js

@@ -1,10 +1,10 @@
 import {
   startOfQuarter
-} from "./chunk-5KVFPVBT.js";
+} from "./chunk-NGS5UKDW.js";
 import "./chunk-XS2HUADA.js";
-import "./chunk-2MFBXSTL.js";
+import "./chunk-TCB3IDJM.js";
 import "./chunk-2AID4P2C.js";
-import "./chunk-JNAWZ4RN.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   startOfQuarter

package/dist/startOfWeek.d.ts

@@ -13,7 +13,7 @@ import type { Timezone } from './types.js';
  * // From Instant (always UTC)
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday
  * const start = startOfWeek(instant);
- * // 2025-01-20T00:00:00Z[UTC] (same day, it's already Monday)
+ * // 2025-01-20T00:00:00+00:00[UTC] (same day, it's already Monday)
  * ```
  *
  * @example

package/dist/startOfWeek.js

@@ -1,8 +1,8 @@
 import {
   startOfWeek
-} from "./chunk-ITQ6OJAL.js";
+} from "./chunk-MLHFNZEA.js";
 import "./chunk-2AID4P2C.js";
-import "./chunk-JNAWZ4RN.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   startOfWeek

package/dist/startOfYear.d.ts

@@ -12,7 +12,7 @@ import type { Timezone } from './types.js';
  * // From Instant (always UTC)
  * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');
  * const start = startOfYear(instant);
- * // 2025-01-01T00:00:00Z[UTC]
+ * // 2025-01-01T00:00:00+00:00[UTC]
  * ```
  *
  * @example

package/dist/startOfYear.js

@@ -1,9 +1,9 @@
 import {
   startOfYear
-} from "./chunk-DCZDGS5G.js";
-import "./chunk-2MFBXSTL.js";
+} from "./chunk-Y24VUXMX.js";
+import "./chunk-TCB3IDJM.js";
 import "./chunk-2AID4P2C.js";
-import "./chunk-JNAWZ4RN.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   startOfYear

package/dist/subBusinessDays.js

@@ -1,9 +1,9 @@
 import {
   subBusinessDays
-} from "./chunk-H544BC2X.js";
-import "./chunk-SMMVTXL4.js";
-import "./chunk-Z7I7YCKN.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-4PS6BEAC.js";
+import "./chunk-D3N7BT44.js";
+import "./chunk-K7CLBBBM.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subBusinessDays

package/dist/subDays.d.ts

@@ -15,7 +15,7 @@ import { type Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-25T12:00:00Z');
  * const result = subDays(instant, 5);
- * // 2025-01-20T12:00:00Z[UTC] (5 days earlier)
+ * // 2025-01-20T12:00:00+00:00[UTC] (5 days earlier)
  * ```
  */
 export declare function subDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;

package/dist/subDays.js

@@ -1,8 +1,8 @@
 import {
   subDays
-} from "./chunk-HSJMG5T7.js";
-import "./chunk-V36MCE25.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-DZ3647ZK.js";
+import "./chunk-4KAIF44F.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subDays

package/dist/subHours.d.ts

@@ -13,7 +13,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T15:00:00Z');
  * const result = subHours(instant, 3);
- * // 2025-01-20T12:00:00Z[UTC] (3 hours earlier)
+ * // 2025-01-20T12:00:00+00:00[UTC] (3 hours earlier)
  * ```
  */
 export declare function subHours(input: Temporal.Instant | Temporal.ZonedDateTime, hours: number): Temporal.ZonedDateTime;

package/dist/subHours.js

@@ -1,8 +1,8 @@
 import {
   subHours
-} from "./chunk-23APOESH.js";
-import "./chunk-XTS6LZBP.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-DRBZDI52.js";
+import "./chunk-YKXRVQ4S.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subHours

package/dist/subMicroseconds.d.ts

@@ -12,7 +12,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00.001Z');
  * const result = subMicroseconds(instant, 500);
- * // 2025-01-20T12:00:00.000500Z[UTC] (500 microseconds earlier)
+ * // 2025-01-20T12:00:00.000500+00:00[UTC] (500 microseconds earlier)
  * ```
  */
 export declare function subMicroseconds(input: Temporal.Instant | Temporal.ZonedDateTime, microseconds: number): Temporal.ZonedDateTime;

package/dist/subMicroseconds.js

@@ -1,8 +1,8 @@
 import {
   subMicroseconds
-} from "./chunk-XIVWFVVX.js";
-import "./chunk-PU6PU2JM.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-IXNGK5OF.js";
+import "./chunk-TI6WBLCB.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subMicroseconds

package/dist/subMilliseconds.d.ts

@@ -12,7 +12,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');
  * const result = subMilliseconds(instant, 250);
- * // 2025-01-20T12:00:00.250Z[UTC] (250 milliseconds earlier)
+ * // 2025-01-20T12:00:00.250+00:00[UTC] (250 milliseconds earlier)
  * ```
  */
 export declare function subMilliseconds(input: Temporal.Instant | Temporal.ZonedDateTime, milliseconds: number): Temporal.ZonedDateTime;

package/dist/subMilliseconds.js

@@ -1,8 +1,8 @@
 import {
   subMilliseconds
-} from "./chunk-TUZHOWSN.js";
-import "./chunk-NYM3EW3M.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-6QH4NCPA.js";
+import "./chunk-AUOZACFS.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subMilliseconds

package/dist/subMinutes.d.ts

@@ -12,7 +12,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:30:00Z');
  * const result = subMinutes(instant, 15);
- * // 2025-01-20T12:15:00Z[UTC] (15 minutes earlier)
+ * // 2025-01-20T12:15:00+00:00[UTC] (15 minutes earlier)
  * ```
  */
 export declare function subMinutes(input: Temporal.Instant | Temporal.ZonedDateTime, minutes: number): Temporal.ZonedDateTime;

package/dist/subMinutes.js

@@ -1,8 +1,8 @@
 import {
   subMinutes
-} from "./chunk-LKF7U4O4.js";
-import "./chunk-5ST6IOPN.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-EAO2SO4N.js";
+import "./chunk-GXSVYUCG.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subMinutes

package/dist/subMonths.d.ts

@@ -15,7 +15,7 @@ import { type Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');
  * const result = subMonths(instant, 3);
- * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)
+ * // 2025-01-20T12:00:00+00:00[UTC] (3 months earlier)
  * ```
  */
 export declare function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;

package/dist/subMonths.js

@@ -1,8 +1,8 @@
 import {
   subMonths
-} from "./chunk-NNUATTN7.js";
-import "./chunk-WJZHUNF5.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-MVGBYHG5.js";
+import "./chunk-ZXKU4SKR.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subMonths

package/dist/subNanoseconds.d.ts

@@ -12,7 +12,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');
  * const result = subNanoseconds(instant, 500);
- * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds earlier)
+ * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds earlier)
  * ```
  */
 export declare function subNanoseconds(input: Temporal.Instant | Temporal.ZonedDateTime, nanoseconds: number): Temporal.ZonedDateTime;

package/dist/subNanoseconds.js

@@ -1,8 +1,8 @@
 import {
   subNanoseconds
-} from "./chunk-C5OJIIJP.js";
-import "./chunk-ETO77GIW.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-IWVSM77B.js";
+import "./chunk-32AWWYBF.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subNanoseconds

package/dist/subQuarters.d.ts

@@ -13,7 +13,7 @@ import { type Temporal } from "./shared/temporal.js";
  * ```ts
  * const instant = Temporal.Instant.from('2025-07-20T12:00:00Z');
  * subQuarters(instant, 2);
- * // 2025-01-20T12:00:00Z[UTC] (6 months earlier)
+ * // 2025-01-20T12:00:00+00:00[UTC] (6 months earlier)
  * ```
  *
  * @example

package/dist/subQuarters.js

@@ -1,8 +1,8 @@
 import {
   subQuarters
-} from "./chunk-XZS6J4LM.js";
-import "./chunk-YR26F7OA.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-KYS54PLJ.js";
+import "./chunk-QDY2KMYX.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subQuarters

package/dist/subSeconds.d.ts

@@ -12,7 +12,7 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:00:45Z');
  * const result = subSeconds(instant, 30);
- * // 2025-01-20T12:00:15Z[UTC] (30 seconds earlier)
+ * // 2025-01-20T12:00:15+00:00[UTC] (30 seconds earlier)
  * ```
  */
 export declare function subSeconds(input: Temporal.Instant | Temporal.ZonedDateTime, seconds: number): Temporal.ZonedDateTime;

package/dist/subSeconds.js

@@ -1,8 +1,8 @@
 import {
   subSeconds
-} from "./chunk-4E5OJUMN.js";
-import "./chunk-WY5I452J.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-K3L6MJJB.js";
+import "./chunk-7IKCDOCT.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subSeconds

package/dist/subWeeks.d.ts

@@ -15,7 +15,7 @@ import { type Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-02-03T12:00:00Z');
  * const result = subWeeks(instant, 2);
- * // 2025-01-20T12:00:00Z[UTC] (2 weeks earlier)
+ * // 2025-01-20T12:00:00+00:00[UTC] (2 weeks earlier)
  * ```
  */
 export declare function subWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;

package/dist/subWeeks.js

@@ -1,8 +1,8 @@
 import {
   subWeeks
-} from "./chunk-33MHEBQR.js";
-import "./chunk-426MJGNT.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-SLH6TKGN.js";
+import "./chunk-3X2U6I44.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subWeeks

package/dist/subYears.d.ts

@@ -15,7 +15,7 @@ import { type Temporal } from './shared/temporal.js';
  * ```ts
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
  * const result = subYears(instant, 2);
- * // 2023-01-20T12:00:00Z[UTC] (2 years earlier)
+ * // 2023-01-20T12:00:00+00:00[UTC] (2 years earlier)
  * ```
  */
 export declare function subYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;

package/dist/subYears.js

@@ -1,8 +1,8 @@
 import {
   subYears
-} from "./chunk-TEL44S5A.js";
-import "./chunk-FL33IWLY.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-3HF4F36S.js";
+import "./chunk-HRCTWTP3.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   subYears

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobrand/tiempo",
-  "version": "3.1.2",
+  "version": "3.1.3",
   "packageManager": "pnpm@10.33.4",
   "description": "Lightweight timezone-safe date and time utilities built on the Temporal API",
   "private": false,

package/dist/chunk-426MJGNT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of weeks to a datetime or date.\n *\n * Properly handles DST transitions 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 weeks - Number of weeks to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks 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 = addWeeks(instant, 2);\n * // 2025-02-03T12:00:00Z[UTC] (2 weeks 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 = addWeeks(zoned, 2);\n * // 2025-02-03T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract weeks\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, -1);\n * // 2025-01-13T12:00:00Z[UTC] (1 week earlier)\n * ```\n */\nexport function addWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ weeks });\n  }\n  return normalizeTemporalInput(input).add({ weeks });\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-44EIUFJB.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999Z[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:59Z[UTC]');\n * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00Z[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-5KVFPVBT.js.map

@@ -1 +0,0 @@
-{"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:00Z[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 PlainDate (requires 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-5MB7UZCJ.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-04-20T14:00:00Z[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2025-01-01T00:00:00Z[UTC],\n * //   2025-02-01T00:00:00Z[UTC],\n * //   2025-03-01T00:00:00Z[UTC],\n * //   2025-04-01T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-11-15T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-02-15T00:00:00Z[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2024-11-01T00:00:00Z[UTC],\n * //   2024-12-01T00:00:00Z[UTC],\n * //   2025-01-01T00:00:00Z[UTC],\n * //   2025-02-01T00:00:00Z[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-5ST6IOPN.js.map

@@ -1 +0,0 @@
-{"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:00Z[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:00Z[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-5WPQUOM4.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59Z[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-AA56LFMF.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T10:33:45Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:30:00Z[UTC],\n * //   2025-01-06T10:31:00Z[UTC],\n * //   2025-01-06T10:32:00Z[UTC],\n * //   2025-01-06T10:33:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-hour boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:58:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T11:02:00Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:58:00Z[UTC],\n * //   2025-01-06T10:59:00Z[UTC],\n * //   2025-01-06T11:00:00Z[UTC],\n * //   2025-01-06T11:01:00Z[UTC],\n * //   2025-01-06T11:02:00Z[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-ASIYAAQV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eachDayOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { differenceInDays } from './differenceInDays';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns each calendar day within the interval, including both endpoints.\n * PlainDate endpoints return PlainDates in the start calendar, without a timezone.\n * Instant/ZonedDateTime endpoints return ZonedDateTimes.\n * Each element represents the first valid moment of the day in the timezone of the interval start.\n * Nonexistent calendar dates are skipped only for timezone-aware intervals.\n * The interval is inclusive of both start and end days.\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 - Two PlainDates, or two Instant/ZonedDateTime timeline endpoints\n * @returns PlainDates for date-only endpoints; otherwise ZonedDateTimes at each day start. Reversed endpoints return [].\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-10T14:00:00Z[UTC]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-08T00:00:00Z[UTC],\n * //   2025-01-09T00:00:00Z[UTC],\n * //   2025-01-10T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With timezone - preserves the timezone from start\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T14:00:00-05:00[America/New_York]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00-05:00[America/New_York],\n * //   2025-01-07T00:00:00-05:00[America/New_York],\n * //   2025-01-08T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With Instant (uses UTC)\n * const start = Temporal.Instant.from('2025-01-06T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-08T00:00:00Z');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-08T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single day interval\n * const date = Temporal.ZonedDateTime.from('2025-01-15T12:00:00Z[UTC]');\n *\n * eachDayOfInterval({ start: date, end: date });\n * // [2025-01-15T00:00:00Z[UTC]]\n * ```\n */\nexport function eachDayOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachDayOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachDayOfInterval(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    const dayCount = differenceInDays(\n      interval.end.withCalendar(interval.start.calendarId),\n      interval.start\n    );\n    const days: Temporal.PlainDate[] = [];\n    for (let offset = 0; offset <= dayCount; offset++) {\n      days.push(interval.start.add({ days: offset }));\n    }\n    return days;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const days: Temporal.ZonedDateTime[] = [];\n  let current = startZoned.startOfDay();\n\n  // Advancing the resolved date skips nonexistent dates instead of resolving\n  // two consecutive PlainDates to the same instant.\n  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {\n    days.push(current);\n    current = current.add({ days: 1 }).startOfDay();\n  }\n\n  return days;\n}\n"],"mappings":";;;;;;;;;;;AA8EO,SAAS,kBAAkB,UAGkB;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,UAAM,WAAW;AAAA,MACf,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAAA,MACnD,SAAS;AAAA,IACX;AACA,UAAMA,QAA6B,CAAC;AACpC,aAAS,SAAS,GAAG,UAAU,UAAU,UAAU;AACjD,MAAAA,MAAK,KAAK,SAAS,MAAM,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC;AAAA,IAChD;AACA,WAAOA;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,OAAiC,CAAC;AACxC,MAAI,UAAU,WAAW,WAAW;AAIpC,SAAO,QAAQ,oBAAoB,SAAS,kBAAkB;AAC5D,SAAK,KAAK,OAAO;AACjB,cAAU,QAAQ,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW;AAAA,EAChD;AAEA,SAAO;AACT;","names":["days"]}

package/dist/chunk-AVPV4BA5.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00Z[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:59Z[UTC]');\n * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00Z[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-B6VZ2AKN.js.map

@@ -1 +0,0 @@
-{"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.999999999Z[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-DCZDGS5G.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/startOfYear.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the first 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 January 1st at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const start = startOfYear(instant);\n * // 2025-01-01T00:00:00Z[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 start = startOfYear(zoned);\n * // 2025-01-01T00:00:00-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 start = startOfYear(date);\n * // 2025-01-01\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 start = startOfYear(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfYear(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfYear(\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({ month: 1, day: 1 });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ month: 1, day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;AAmDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AAAA,EACxC;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACxD,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/chunk-DXSRRBJO.js.map

@@ -1 +0,0 @@
-{"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.123456789Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[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.123456789Z[UTC]');\n * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790Z[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-EBQ25TEY.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isSameMicrosecond.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 microsecond.\n * Compares the year, month, day, hour, minute, second, millisecond, and microsecond fields directly.\n * Ignores sub-microsecond precision (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 microsecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same microsecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456999Z[UTC]');\n *\n * isSameMicrosecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different microseconds\n * const us456 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456Z[UTC]');\n * const us457 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123457Z[UTC]');\n *\n * isSameMicrosecond(us456, us457); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local microseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local microseconds from each person's perspective\n * isSameMicrosecond(ny, tokyo); // false (14:30:45.123456 in NY, 04:30:45.123456 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMicrosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMicrosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456 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.123456999Z');\n *\n * isSameMicrosecond(instant1, instant2); // true (both 14:30:45.123456 in UTC)\n * ```\n */\nexport function isSameMicrosecond(\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  );\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,eAC9B,OAAO,gBAAgB,OAAO;AAElC;","names":[]}

package/dist/chunk-ETO77GIW.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addNanoseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of nanoseconds 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 nanoseconds - Number of nanoseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with nanoseconds 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 = addNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds 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 = addNanoseconds(zoned, 1000);\n * // 2025-01-20T15:30:00.000001-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract nanoseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = addNanoseconds(instant, -500);\n * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function addNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ nanoseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,eACd,OACA,aACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,YAAY,CAAC;AAC1C;","names":[]}

package/dist/chunk-FAVYJIRM.js.map

@@ -1 +0,0 @@
-{"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.999999999Z[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-FL33IWLY.js.map

@@ -1 +0,0 @@
-{"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:00Z[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:00Z[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.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[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:59Z[UTC]');\n * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00Z[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-HQ3YMKQ5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/startOfMonth.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the first 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 1st day of the month at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const start = startOfMonth(instant);\n * // 2025-01-01T00:00:00Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-15T15:30:00-05:00[America/New_York]');\n * const start = startOfMonth(zoned);\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-15');\n * const start = startOfMonth(date);\n * // 2025-01-01\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-15');\n * const start = startOfMonth(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfMonth(\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: 1 });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;AAmDO,SAAS,aACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAAA,EAC9B;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,KAAK,EAAE,CAAC;AAC9C,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/chunk-ITQ6OJAL.js.map

@@ -1 +0,0 @@
-{"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:00Z[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-JNAWZ4RN.js

@@ -1,13 +0,0 @@
-import {
-  isInstant
-} from "./chunk-BSVOJYJ7.js";
-
-// src/shared/normalizeTemporalInput.ts
-function normalizeTemporalInput(input) {
-  return isInstant(input) ? input.toZonedDateTimeISO("UTC") : input;
-}
-
-export {
-  normalizeTemporalInput
-};
-//# sourceMappingURL=chunk-JNAWZ4RN.js.map

package/dist/chunk-JNAWZ4RN.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/shared/normalizeTemporalInput.ts"],"sourcesContent":["import { type Temporal, isInstant } from './temporal';\n\n/**\n * @internal\n * Normalizes input to ZonedDateTime. Converts Instant to UTC, or returns existing ZonedDateTime.\n * This is an internal helper - do not use directly.\n */\nexport function normalizeTemporalInput(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  return isInstant(input)\n    ? input.toZonedDateTimeISO('UTC')\n    : input;\n}\n"],"mappings":";;;;;AAOO,SAAS,uBACd,OACwB;AACxB,SAAO,UAAU,KAAK,IAClB,MAAM,mBAAmB,KAAK,IAC9B;AACN;","names":[]}

package/dist/chunk-JWYRXPR4.js.map

@@ -1 +0,0 @@
-{"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:00Z[UTC]'); // Monday\n * const end = Temporal.ZonedDateTime.from('2025-01-22T14:00:00Z[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],  // Week 2\n * //   2025-01-13T00:00:00Z[UTC],  // Week 3\n * //   2025-01-20T00:00:00Z[UTC]   // Week 4\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Mid-week start\n * const start = Temporal.ZonedDateTime.from('2025-01-08T10:00:00Z[UTC]'); // Wednesday\n * const end = Temporal.ZonedDateTime.from('2025-01-15T14:00:00Z[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],  // Monday of week containing Jan 8\n * //   2025-01-13T00:00:00Z[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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T00:00:00Z[UTC]');\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2024-12-23T00:00:00Z[UTC],  // Monday of week containing Dec 25\n * //   2024-12-30T00:00:00Z[UTC],  // Monday of week containing Dec 30\n * //   2025-01-06T00:00:00Z[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-MCPKXTX7.js.map

@@ -1 +0,0 @@
-{"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.123Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999Z[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.123Z[UTC]');\n * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124Z[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":[]}