@gobrand/tiempo 2.8.1 → 2.9.1

package/dist/{chunk-HLGMUTFK.js → chunk-RQUVNJBG.js}

@@ -1,9 +1,8 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 
 // src/startOfMonth.ts
-import "@js-temporal/polyfill";
 function startOfMonth(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const firstDay = zonedDateTime.with({ day: 1 });
@@ -13,4 +12,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-HLGMUTFK.js.map
+//# sourceMappingURL=chunk-RQUVNJBG.js.map

package/dist/chunk-RQUVNJBG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfMonth.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the first moment of the month (day 1 at midnight).\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 (requires timezone)\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(\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 {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;AAyCO,SAAS,aACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,KAAK,EAAE,CAAC;AAC9C,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/{chunk-UJW2FPI4.js → chunk-RTNF2H34.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/roundToNearestMinute.ts
 var MODE_TO_ROUNDING_MODE = {
@@ -22,4 +22,4 @@ function roundToNearestMinute(input, options) {
 export {
   roundToNearestMinute
 };
-//# sourceMappingURL=chunk-UJW2FPI4.js.map
+//# sourceMappingURL=chunk-RTNF2H34.js.map

package/dist/{chunk-BPZ7BRJW.js → chunk-RW25XXOH.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/isPlainDateAfter.ts
-import { Temporal } from "@js-temporal/polyfill";
 function isPlainDateAfter(date1, date2) {
   return Temporal.PlainDate.compare(date1, date2) > 0;
 }
@@ -7,4 +10,4 @@ function isPlainDateAfter(date1, date2) {
 export {
   isPlainDateAfter
 };
-//# sourceMappingURL=chunk-BPZ7BRJW.js.map
+//# sourceMappingURL=chunk-RW25XXOH.js.map

package/dist/chunk-RW25XXOH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPlainDateAfter.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is after the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is after date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateAfter(jan25, jan20); // true\n * isPlainDateAfter(jan20, jan25); // false\n * isPlainDateAfter(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateAfter(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  return Temporal.PlainDate.compare(date1, date2) > 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,iBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,IAAI;AACpD;","names":[]}

package/dist/{chunk-QFNGYTTH.js → chunk-RXTMPPOP.js}

@@ -1,9 +1,11 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
 
 // src/shared/nowZoned.ts
-import { Temporal } from "@js-temporal/polyfill";
 function nowZoned() {
   return normalizeTemporalInput(Temporal.Now.instant());
 }
@@ -11,4 +13,4 @@ function nowZoned() {
 export {
   nowZoned
 };
-//# sourceMappingURL=chunk-QFNGYTTH.js.map
+//# sourceMappingURL=chunk-RXTMPPOP.js.map

package/dist/chunk-RXTMPPOP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/nowZoned.ts"],"sourcesContent":["import { Temporal } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\nexport function nowZoned(): Temporal.ZonedDateTime {\n  return normalizeTemporalInput(Temporal.Now.instant());\n}\n"],"mappings":";;;;;;;;AAGO,SAAS,WAAmC;AACjD,SAAO,uBAAuB,SAAS,IAAI,QAAQ,CAAC;AACtD;","names":[]}

package/dist/{chunk-S63QUP4W.js → chunk-SAFMGBXL.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isSameNanosecond.ts
 function isSameNanosecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameNanosecond(date1, date2) {
 export {
   isSameNanosecond
 };
-//# sourceMappingURL=chunk-S63QUP4W.js.map
+//# sourceMappingURL=chunk-SAFMGBXL.js.map

package/dist/chunk-SGHPW77A.js

@@ -0,0 +1,19 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-VXOQ7IG5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-65RGM7EG.js";
+
+// src/differenceInHours.ts
+function differenceInHours(laterDate, earlierDate, options) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const precise = differenceInMilliseconds(zoned1, zoned2) / 36e5;
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInHours
+};
+//# sourceMappingURL=chunk-SGHPW77A.js.map

package/dist/chunk-SGHPW77A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInHours.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of hours between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of hours between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T18:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T15:00:00Z');\n *\n * differenceInHours(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-21T00:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInHours(later, earlier); // 9\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInHours(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInHours(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const precise = differenceInMilliseconds(zoned1, zoned2) / 3600000;\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,kBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,UAAU,yBAAyB,QAAQ,MAAM,IAAI;AAC3D,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/{chunk-AJEIDKVJ.js → chunk-T4J7PXYZ.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/isPlainTimeBefore.ts
-import { Temporal } from "@js-temporal/polyfill";
 function isPlainTimeBefore(time1, time2) {
   return Temporal.PlainTime.compare(time1, time2) < 0;
 }
@@ -7,4 +10,4 @@ function isPlainTimeBefore(time1, time2) {
 export {
   isPlainTimeBefore
 };
-//# sourceMappingURL=chunk-AJEIDKVJ.js.map
+//# sourceMappingURL=chunk-T4J7PXYZ.js.map

package/dist/chunk-T4J7PXYZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPlainTimeBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain time is before the second plain time.\n * Compares wall-clock times without date or timezone considerations.\n *\n * @param time1 - First plain time\n * @param time2 - Second plain time\n * @returns true if time1 is before time2, false otherwise\n *\n * @example\n * ```ts\n * const morning = Temporal.PlainTime.from('09:00');\n * const evening = Temporal.PlainTime.from('17:00');\n *\n * isPlainTimeBefore(morning, evening); // true\n * isPlainTimeBefore(evening, morning); // false\n * isPlainTimeBefore(morning, morning); // false\n * ```\n */\nexport function isPlainTimeBefore(\n  time1: Temporal.PlainTime,\n  time2: Temporal.PlainTime\n): boolean {\n  return Temporal.PlainTime.compare(time1, time2) < 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,kBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,IAAI;AACpD;","names":[]}

package/dist/{chunk-KZB6NERH.js → chunk-TCEDHHNM.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/today.ts
-import { Temporal } from "@js-temporal/polyfill";
 function today(timezone) {
   return Temporal.Now.zonedDateTimeISO(timezone).toPlainDate();
 }
@@ -7,4 +10,4 @@ function today(timezone) {
 export {
   today
 };
-//# sourceMappingURL=chunk-KZB6NERH.js.map
+//# sourceMappingURL=chunk-TCEDHHNM.js.map

package/dist/chunk-TCEDHHNM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/today.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\n\n/**\n * Get today's date in the specified timezone.\n *\n * @param timezone - IANA timezone identifier (e.g., \"America/New_York\", \"Europe/London\") or \"UTC\"\n * @returns A Temporal.PlainDate representing today's date\n *\n * @example\n * ```typescript\n * import { today, browserTimezone } from '@gobrand/tiempo';\n *\n * // Server-side: Get today in UTC\n * const todayUtc = today(\"UTC\");\n *\n * // Server-side: Get today in user's timezone (from DB/preferences)\n * const todayUser = today(user.timezone);\n *\n * // Client-side: Get today in browser's timezone\n * const todayLocal = today(browserTimezone());\n *\n * // Get today in a specific timezone\n * const todayInMadrid = today(\"Europe/Madrid\");\n * ```\n */\nexport function today(timezone: Timezone): Temporal.PlainDate {\n  return Temporal.Now.zonedDateTimeISO(timezone).toPlainDate();\n}\n"],"mappings":";;;;;AA0BO,SAAS,MAAM,UAAwC;AAC5D,SAAO,SAAS,IAAI,iBAAiB,QAAQ,EAAE,YAAY;AAC7D;","names":[]}

package/dist/{chunk-J6G2I2TU.js → chunk-TKV5JYQY.js}

@@ -1,6 +1,6 @@
 import {
   addMinutes
-} from "./chunk-2XHAHSB6.js";
+} from "./chunk-MXE44KVG.js";
 
 // src/subMinutes.ts
 function subMinutes(input, minutes) {
@@ -10,4 +10,4 @@ function subMinutes(input, minutes) {
 export {
   subMinutes
 };
-//# sourceMappingURL=chunk-J6G2I2TU.js.map
+//# sourceMappingURL=chunk-TKV5JYQY.js.map

package/dist/chunk-TUOGC2TY.js

@@ -0,0 +1,19 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-VXOQ7IG5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-65RGM7EG.js";
+
+// src/differenceInSeconds.ts
+function differenceInSeconds(laterDate, earlierDate, options) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const precise = differenceInMilliseconds(zoned1, zoned2) / 1e3;
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInSeconds
+};
+//# sourceMappingURL=chunk-TUOGC2TY.js.map

package/dist/chunk-TUOGC2TY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInSeconds.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of seconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of seconds between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:25Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20Z');\n *\n * differenceInSeconds(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:01:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInSeconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const precise = differenceInMilliseconds(zoned1, zoned2) / 1000;\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,UAAU,yBAAyB,QAAQ,MAAM,IAAI;AAC3D,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-TWZNSMKO.js

@@ -0,0 +1,19 @@
+import {
+  plainDateToZonedDateTime
+} from "./chunk-AHBTUFRW.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-65RGM7EG.js";
+import {
+  isPlainDate
+} from "./chunk-AI5MRREC.js";
+
+// src/shared/normalizeWithPlainDate.ts
+function normalizeWithPlainDate(input, timezone) {
+  return isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
+}
+
+export {
+  normalizeWithPlainDate
+};
+//# sourceMappingURL=chunk-TWZNSMKO.js.map

package/dist/chunk-TWZNSMKO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeWithPlainDate.ts"],"sourcesContent":["import { isPlainDate } from './temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from '../types';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './plainDateToZonedDateTime';\n\n/**\n * @internal\n * Normalizes any temporal input (Instant, ZonedDateTime, or PlainDate) to ZonedDateTime.\n * - Instant → UTC ZonedDateTime\n * - ZonedDateTime → returned as-is\n * - PlainDate → ZonedDateTime at midnight in the specified timezone\n *\n * This is an internal helper - do not use directly.\n */\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  return isPlainDate(input)\n    ? plainDateToZonedDateTime(input, timezone!)\n    : normalizeTemporalInput(input);\n}\n"],"mappings":";;;;;;;;;;;AA0BO,SAAS,uBACd,OACA,UACwB;AACxB,SAAO,YAAY,KAAK,IACpB,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAClC;","names":[]}

package/dist/{chunk-YIT6EMBC.js → chunk-TYYV5UYX.js}

@@ -1,9 +1,8 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 
 // src/startOfDay.ts
-import "@js-temporal/polyfill";
 function startOfDay(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   return zonedDateTime.startOfDay();
@@ -12,4 +11,4 @@ function startOfDay(input, timezone) {
 export {
   startOfDay
 };
-//# sourceMappingURL=chunk-YIT6EMBC.js.map
+//# sourceMappingURL=chunk-TYYV5UYX.js.map

package/dist/chunk-TYYV5UYX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the first moment of the day (midnight).\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 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');\n * const start = startOfDay(instant);\n * // 2025-01-20T00:00:00Z[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 start = startOfDay(zoned);\n * // 2025-01-20T00:00:00-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 start = startOfDay(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return zonedDateTime.startOfDay();\n}\n"],"mappings":";;;;;AAyCO,SAAS,WACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,cAAc,WAAW;AAClC;","names":[]}

package/dist/{chunk-7VLSSOVC.js → chunk-UAYBKORB.js}

@@ -1,12 +1,11 @@
 import {
   isAfter
-} from "./chunk-WY63VEXE.js";
+} from "./chunk-JM42PLWS.js";
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isAfter.ts
-import "@js-temporal/polyfill";
 function isAfter2(date1, date2) {
   const zoned1 = normalizeTemporalInput(date1);
   const zoned2 = normalizeTemporalInput(date2);
@@ -16,4 +15,4 @@ function isAfter2(date1, date2) {
 export {
   isAfter2 as isAfter
 };
-//# sourceMappingURL=chunk-7VLSSOVC.js.map
+//# sourceMappingURL=chunk-UAYBKORB.js.map

package/dist/chunk-UAYBKORB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isAfter.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isAfter as isAfterInternal } from './shared/isAfter';\n\n/**\n * Returns true if the first datetime is after the second datetime.\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if date1 is after date2, false otherwise\n *\n * @example\n * ```ts\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n *\n * isAfter(later, earlier); // true\n * isAfter(earlier, later); // false\n * isAfter(earlier, earlier); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const instant1 = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T16:00:00Z');\n *\n * isAfter(instant2, instant1); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n *\n * isAfter(tokyo, ny); // false\n * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC the previous day (same instant)\n * ```\n */\nexport function isAfter(\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 isAfterInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAyCO,SAASA,SACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,QAAgB,QAAQ,MAAM;AACvC;","names":["isAfter"]}

package/dist/{chunk-OABS374T.js → chunk-VBDGWVJ4.js}

@@ -1,9 +1,8 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/differenceInNanoseconds.ts
-import "@js-temporal/polyfill";
 function differenceInNanoseconds(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
@@ -13,4 +12,4 @@ function differenceInNanoseconds(laterDate, earlierDate) {
 export {
   differenceInNanoseconds
 };
-//# sourceMappingURL=chunk-OABS374T.js.map
+//# sourceMappingURL=chunk-VBDGWVJ4.js.map

package/dist/chunk-VBDGWVJ4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInNanoseconds.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of nanoseconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of nanoseconds between the dates as a BigInt\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:20.000000500Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.000000000Z');\n *\n * differenceInNanoseconds(later, earlier); // 500n\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000001-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000000-05:00[America/New_York]');\n *\n * differenceInNanoseconds(later, earlier); // 1n\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInNanoseconds(tokyo, ny); // 0n (same instant)\n * ```\n */\nexport function differenceInNanoseconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): bigint {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n}\n"],"mappings":";;;;;AAqCO,SAAS,wBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,OAAO,mBAAmB,OAAO;AAC1C;","names":[]}

package/dist/{chunk-BUX26GTD.js → chunk-VDEZJB42.js}

@@ -1,9 +1,11 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
 
 // src/eachYearOfInterval.ts
-import { Temporal } from "@js-temporal/polyfill";
 function eachYearOfInterval(interval) {
   const startZoned = normalizeTemporalInput(interval.start);
   const endZoned = normalizeTemporalInput(interval.end);
@@ -27,4 +29,4 @@ function eachYearOfInterval(interval) {
 export {
   eachYearOfInterval
 };
-//# sourceMappingURL=chunk-BUX26GTD.js.map
+//# sourceMappingURL=chunk-VDEZJB42.js.map

package/dist/chunk-VDEZJB42.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachYearOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each year within the interval.\n * Each element represents the first moment of the year (January 1st at midnight).\n * The interval is inclusive of both start and end years.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each year in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2022-06-15T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-03-20T14:00:00Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2022-01-01T00:00:00Z[UTC],\n * //   2023-01-01T00:00:00Z[UTC],\n * //   2024-01-01T00:00:00Z[UTC],\n * //   2025-01-01T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single year\n * const start = Temporal.ZonedDateTime.from('2025-01-15T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [2025-01-01T00:00:00Z[UTC]]\n * ```\n *\n * @example\n * ```ts\n * // With timezone\n * const start = Temporal.ZonedDateTime.from('2024-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2026-06-15T00:00:00-04:00[America/New_York]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2024-01-01T00:00:00-05:00[America/New_York],\n * //   2025-01-01T00:00:00-05:00[America/New_York],\n * //   2026-01-01T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n */\nexport function eachYearOfInterval(interval: {\n  start: Temporal.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\n  const timezone = startZoned.timeZoneId;\n  const startYear = startZoned.year;\n\n  // Get end year in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endYear = endInTimezone.year;\n\n  const years: Temporal.ZonedDateTime[] = [];\n\n  for (let year = startYear; year <= endYear; year++) {\n    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1 });\n    years.push(\n      firstOfYear.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n  }\n\n  return years;\n}\n"],"mappings":";;;;;;;;AAoDO,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAC5B,QAAM,YAAY,WAAW;AAG7B,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,UAAU,cAAc;AAE9B,QAAM,QAAkC,CAAC;AAEzC,WAAS,OAAO,WAAW,QAAQ,SAAS,QAAQ;AAClD,UAAM,cAAc,SAAS,UAAU,KAAK,EAAE,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC;AACtE,UAAM;AAAA,MACJ,YAAY,gBAAgB;AAAA,QAC1B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-O6RIN7K3.js → chunk-VJGNLAF2.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/isPlainDateEqual.ts
-import { Temporal } from "@js-temporal/polyfill";
 function isPlainDateEqual(date1, date2) {
   return Temporal.PlainDate.compare(date1, date2) === 0;
 }
@@ -7,4 +10,4 @@ function isPlainDateEqual(date1, date2) {
 export {
   isPlainDateEqual
 };
-//# sourceMappingURL=chunk-O6RIN7K3.js.map
+//# sourceMappingURL=chunk-VJGNLAF2.js.map

package/dist/chunk-VJGNLAF2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPlainDateEqual.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the two plain dates are equal.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 equals date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20a = Temporal.PlainDate.from('2025-01-20');\n * const jan20b = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateEqual(jan20a, jan20b); // true\n * isPlainDateEqual(jan20a, jan25); // false\n * ```\n */\nexport function isPlainDateEqual(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  return Temporal.PlainDate.compare(date1, date2) === 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,iBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,MAAM;AACtD;","names":[]}

package/dist/{chunk-ZDA7GSWU.js → chunk-VTP4QJY6.js}

@@ -1,12 +1,11 @@
 import {
   isBefore
-} from "./chunk-WUAIUEH7.js";
+} from "./chunk-EZJDWFFE.js";
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isBefore.ts
-import "@js-temporal/polyfill";
 function isBefore2(date1, date2) {
   const zoned1 = normalizeTemporalInput(date1);
   const zoned2 = normalizeTemporalInput(date2);
@@ -16,4 +15,4 @@ function isBefore2(date1, date2) {
 export {
   isBefore2 as isBefore
 };
-//# sourceMappingURL=chunk-ZDA7GSWU.js.map
+//# sourceMappingURL=chunk-VTP4QJY6.js.map

package/dist/chunk-VTP4QJY6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore as isBeforeInternal } from './shared/isBefore';\n\n/**\n * Returns true if the first datetime is before the second datetime.\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if date1 is before date2, false otherwise\n *\n * @example\n * ```ts\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n *\n * isBefore(earlier, later); // true\n * isBefore(later, earlier); // false\n * isBefore(earlier, earlier); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const instant1 = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T16:00:00Z');\n *\n * isBefore(instant1, instant2); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n *\n * isBefore(ny, tokyo); // true\n * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC the previous day\n * ```\n */\nexport function isBefore(\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 isBeforeInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAyCO,SAASA,UACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,SAAiB,QAAQ,MAAM;AACxC;","names":["isBefore"]}

package/dist/{chunk-DFLGGK4F.js → chunk-VTXBG2JV.js}

@@ -1,9 +1,12 @@
+import {
+  isInstant
+} from "./chunk-AI5MRREC.js";
+
 // src/toIso9075.ts
-import { Temporal } from "@js-temporal/polyfill";
 function toIso9075(input, options = {}) {
   const { mode = "utc", representation = "complete" } = options;
   let zdt;
-  if (input instanceof Temporal.Instant) {
+  if (isInstant(input)) {
     zdt = input.toZonedDateTimeISO("UTC");
   } else {
     zdt = mode === "utc" ? input.toInstant().toZonedDateTimeISO("UTC") : input;
@@ -27,4 +30,4 @@ function pad(n) {
 export {
   toIso9075
 };
-//# sourceMappingURL=chunk-DFLGGK4F.js.map
+//# sourceMappingURL=chunk-VTXBG2JV.js.map

package/dist/chunk-VTXBG2JV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toIso9075.ts"],"sourcesContent":["import { isInstant } from './shared/temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\n\nexport type Iso9075Mode = 'utc' | 'local';\nexport type Iso9075Representation = 'complete' | 'date' | 'time';\n\nexport interface ToIso9075Options {\n  /**\n   * Which time to output.\n   * - 'utc' (default): convert to UTC before formatting\n   * - 'local': use the local time of the ZonedDateTime\n   */\n  mode?: Iso9075Mode;\n  /**\n   * What to include in the output.\n   * - 'complete' (default): date and time (2019-09-18 19:00:52)\n   * - 'date': date only (2019-09-18)\n   * - 'time': time only (19:00:52)\n   */\n  representation?: Iso9075Representation;\n}\n\n/**\n * Convert a Temporal.Instant to an ISO 9075 (SQL) formatted string in UTC.\n */\nexport function toIso9075(\n  input: Temporal.Instant,\n  options?: Omit<ToIso9075Options, 'mode'>\n): string;\n\n/**\n * Convert a Temporal.ZonedDateTime to an ISO 9075 (SQL) formatted string.\n *\n * @param input - A Temporal.ZonedDateTime\n * @param options - Format options\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n *\n * toIso9075(zoned);                       // \"2025-01-20 20:00:00\" (UTC, default)\n * toIso9075(zoned, { mode: 'utc' });      // \"2025-01-20 20:00:00\"\n * toIso9075(zoned, { mode: 'local' });    // \"2025-01-20 15:00:00\"\n * toIso9075(zoned, { representation: 'date' }); // \"2025-01-20\"\n * toIso9075(zoned, { representation: 'time' }); // \"20:00:00\"\n * ```\n */\nexport function toIso9075(\n  input: Temporal.ZonedDateTime,\n  options?: ToIso9075Options\n): string;\n\nexport function toIso9075(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options: ToIso9075Options = {}\n): string {\n  const { mode = 'utc', representation = 'complete' } = options;\n\n  let zdt: Temporal.ZonedDateTime;\n\n  if (isInstant(input)) {\n    zdt = input.toZonedDateTimeISO('UTC');\n  } else {\n    // ZonedDateTime: apply mode\n    zdt = mode === 'utc' ? input.toInstant().toZonedDateTimeISO('UTC') : input;\n  }\n\n  const year = zdt.year;\n  const month = zdt.month;\n  const day = zdt.day;\n  const hour = zdt.hour;\n  const minute = zdt.minute;\n  const second = zdt.second;\n\n  const datePart = `${year}-${pad(month)}-${pad(day)}`;\n  const timePart = `${pad(hour)}:${pad(minute)}:${pad(second)}`;\n\n  if (representation === 'date') return datePart;\n  if (representation === 'time') return timePart;\n  return `${datePart} ${timePart}`;\n}\n\nfunction pad(n: number): string {\n  return n.toString().padStart(2, '0');\n}\n"],"mappings":";;;;;AAoDO,SAAS,UACd,OACA,UAA4B,CAAC,GACrB;AACR,QAAM,EAAE,OAAO,OAAO,iBAAiB,WAAW,IAAI;AAEtD,MAAI;AAEJ,MAAI,UAAU,KAAK,GAAG;AACpB,UAAM,MAAM,mBAAmB,KAAK;AAAA,EACtC,OAAO;AAEL,UAAM,SAAS,QAAQ,MAAM,UAAU,EAAE,mBAAmB,KAAK,IAAI;AAAA,EACvE;AAEA,QAAM,OAAO,IAAI;AACjB,QAAM,QAAQ,IAAI;AAClB,QAAM,MAAM,IAAI;AAChB,QAAM,OAAO,IAAI;AACjB,QAAM,SAAS,IAAI;AACnB,QAAM,SAAS,IAAI;AAEnB,QAAM,WAAW,GAAG,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC;AAClD,QAAM,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC;AAE3D,MAAI,mBAAmB,OAAQ,QAAO;AACtC,MAAI,mBAAmB,OAAQ,QAAO;AACtC,SAAO,GAAG,QAAQ,IAAI,QAAQ;AAChC;AAEA,SAAS,IAAI,GAAmB;AAC9B,SAAO,EAAE,SAAS,EAAE,SAAS,GAAG,GAAG;AACrC;","names":[]}

package/dist/{chunk-BH2YB4MV.js → chunk-VXG2IG2N.js}

@@ -1,6 +1,6 @@
 import {
   addSeconds
-} from "./chunk-NRD5HRZV.js";
+} from "./chunk-IOLV6PTH.js";
 
 // src/subSeconds.ts
 function subSeconds(input, seconds) {
@@ -10,4 +10,4 @@ function subSeconds(input, seconds) {
 export {
   subSeconds
 };
-//# sourceMappingURL=chunk-BH2YB4MV.js.map
+//# sourceMappingURL=chunk-VXG2IG2N.js.map

package/dist/{chunk-AJ4JBKJK.js → chunk-VXOQ7IG5.js}

@@ -1,5 +1,4 @@
 // src/shared/differenceInMilliseconds.ts
-import "@js-temporal/polyfill";
 function differenceInMilliseconds(laterDate, earlierDate) {
   return laterDate.epochMilliseconds - earlierDate.epochMilliseconds;
 }
@@ -7,4 +6,4 @@ function differenceInMilliseconds(laterDate, earlierDate) {
 export {
   differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-AJ4JBKJK.js.map
+//# sourceMappingURL=chunk-VXOQ7IG5.js.map

package/dist/chunk-VXOQ7IG5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/differenceInMilliseconds.ts"],"sourcesContent":["import { Temporal } from './temporal';\n\nexport function differenceInMilliseconds(\n  laterDate: Temporal.ZonedDateTime,\n  earlierDate: Temporal.ZonedDateTime\n): number {\n  return laterDate.epochMilliseconds - earlierDate.epochMilliseconds;\n}\n"],"mappings":";AAEO,SAAS,yBACd,WACA,aACQ;AACR,SAAO,UAAU,oBAAoB,YAAY;AACnD;","names":[]}

package/dist/{chunk-V27NUBXQ.js → chunk-WWLDINLH.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/addMicroseconds.ts
 function addMicroseconds(input, microseconds) {
@@ -11,4 +11,4 @@ function addMicroseconds(input, microseconds) {
 export {
   addMicroseconds
 };
-//# sourceMappingURL=chunk-V27NUBXQ.js.map
+//# sourceMappingURL=chunk-WWLDINLH.js.map

package/dist/{chunk-CHW2EN2O.js → chunk-X3T7QMBA.js}

@@ -1,17 +1,17 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/differenceInYears.ts
-import "@js-temporal/polyfill";
-function differenceInYears(laterDate, earlierDate) {
+function differenceInYears(laterDate, earlierDate, options) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
   const duration = zoned2.until(zoned1, { largestUnit: "hours" });
-  return duration.total({ unit: "years", relativeTo: zoned2 });
+  const precise = duration.total({ unit: "years", relativeTo: zoned2 });
+  return options?.fractional ? precise : Math.trunc(precise);
 }
 
 export {
   differenceInYears
 };
-//# sourceMappingURL=chunk-CHW2EN2O.js.map
+//# sourceMappingURL=chunk-X3T7QMBA.js.map

package/dist/chunk-X3T7QMBA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInYears.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of years between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * leap years (366 days) and regular years (365 days).\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of years between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2028-01-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2030-06-15T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-05:00[America/New_York]');\n *\n * differenceInYears(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier);                     // 0\n * differenceInYears(later, earlier, { fractional: true }); // ~0.5\n * ```\n */\nexport function differenceInYears(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'years', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;AA8CO,SAAS,kBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-XVAVCEKT.js

@@ -0,0 +1,19 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-VXOQ7IG5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-65RGM7EG.js";
+
+// src/differenceInMinutes.ts
+function differenceInMinutes(laterDate, earlierDate, options) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const precise = differenceInMilliseconds(zoned1, zoned2) / 6e4;
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInMinutes
+};
+//# sourceMappingURL=chunk-XVAVCEKT.js.map

package/dist/chunk-XVAVCEKT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMinutes.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of minutes between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of minutes between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:45:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');\n *\n * differenceInMinutes(later, earlier); // 15\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMinutes(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const precise = differenceInMilliseconds(zoned1, zoned2) / 60000;\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,UAAU,yBAAyB,QAAQ,MAAM,IAAI;AAC3D,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/{chunk-Q2F3HEXB.js → chunk-YMS7JXBN.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/addYears.ts
 function addYears(input, years) {
@@ -11,4 +11,4 @@ function addYears(input, years) {
 export {
   addYears
 };
-//# sourceMappingURL=chunk-Q2F3HEXB.js.map
+//# sourceMappingURL=chunk-YMS7JXBN.js.map

package/dist/{chunk-52NEOY34.js → chunk-YNV6WGXV.js}

@@ -1,6 +1,6 @@
 import {
   addMonths
-} from "./chunk-7ATM7AXL.js";
+} from "./chunk-3RSGMPWR.js";
 
 // src/subMonths.ts
 function subMonths(input, months) {
@@ -10,4 +10,4 @@ function subMonths(input, months) {
 export {
   subMonths
 };
-//# sourceMappingURL=chunk-52NEOY34.js.map
+//# sourceMappingURL=chunk-YNV6WGXV.js.map

package/dist/{chunk-BSV32PSO.js → chunk-YO2VXHA5.js}

@@ -1,8 +1,11 @@
+import {
+  isInstant
+} from "./chunk-AI5MRREC.js";
+
 // src/toIso.ts
-import { Temporal } from "@js-temporal/polyfill";
 function toIso(input, options = {}) {
   const { mode = "utc" } = options;
-  if (input instanceof Temporal.Instant) {
+  if (isInstant(input)) {
     return input.toString();
   }
   if (mode === "offset") {
@@ -14,4 +17,4 @@ function toIso(input, options = {}) {
 export {
   toIso
 };
-//# sourceMappingURL=chunk-BSV32PSO.js.map
+//# sourceMappingURL=chunk-YO2VXHA5.js.map

package/dist/chunk-YO2VXHA5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toIso.ts"],"sourcesContent":["import { isInstant } from './shared/temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\n\nexport type IsoMode = 'utc' | 'offset';\n\nexport interface ToIsoOptions {\n  /**\n   * Output mode for time zone designator.\n   * - 'utc' (default): UTC time with Z suffix\n   * - 'offset': local time with offset suffix\n   */\n  mode?: IsoMode;\n}\n\n/**\n * Convert a Temporal.Instant to a UTC ISO 8601 string.\n */\nexport function toIso(input: Temporal.Instant): string;\n\n/**\n * Convert a Temporal.ZonedDateTime to an ISO 8601 string.\n *\n * @param input - A Temporal.ZonedDateTime\n * @param options - Output options\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n *\n * toIso(zoned);                    // \"2025-01-20T20:00:00Z\"\n * toIso(zoned, { mode: 'utc' });   // \"2025-01-20T20:00:00Z\"\n * toIso(zoned, { mode: 'offset' }); // \"2025-01-20T15:00:00-05:00\"\n * ```\n */\nexport function toIso(\n  input: Temporal.ZonedDateTime,\n  options?: ToIsoOptions\n): string;\n\nexport function toIso(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options: ToIsoOptions = {}\n): string {\n  const { mode = 'utc' } = options;\n\n  if (isInstant(input)) {\n    return input.toString();\n  }\n\n  if (mode === 'offset') {\n    return input.toString({ timeZoneName: 'never' });\n  }\n\n  return input.toInstant().toString();\n}\n"],"mappings":";;;;;AAuCO,SAAS,MACd,OACA,UAAwB,CAAC,GACjB;AACR,QAAM,EAAE,OAAO,MAAM,IAAI;AAEzB,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO,MAAM,SAAS;AAAA,EACxB;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,MAAM,SAAS,EAAE,cAAc,QAAQ,CAAC;AAAA,EACjD;AAEA,SAAO,MAAM,UAAU,EAAE,SAAS;AACpC;","names":[]}

package/dist/{chunk-ISHZRFVN.js → chunk-ZITFEEZS.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isSameMillisecond.ts
 function isSameMillisecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMillisecond(date1, date2) {
 export {
   isSameMillisecond
 };
-//# sourceMappingURL=chunk-ISHZRFVN.js.map
+//# sourceMappingURL=chunk-ZITFEEZS.js.map