@gobrand/tiempo 2.6.0 → 2.6.2

package/dist/chunk-3TSFIPUR.js

@@ -0,0 +1,16 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-KGVUENQO.js";
+
+// src/startOfYear.ts
+import "@js-temporal/polyfill";
+function startOfYear(input, timezone) {
+  const zonedDateTime = normalizeWithPlainDate(input, timezone);
+  const firstDay = zonedDateTime.with({ month: 1, day: 1 });
+  return firstDay.startOfDay();
+}
+
+export {
+  startOfYear
+};
+//# sourceMappingURL=chunk-3TSFIPUR.js.map

package/dist/chunk-3TSFIPUR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfYear.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the first moment of the year (January 1 at midnight).\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-05: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 (requires timezone)\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(\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 {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ month: 1, day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAyClB,SAAS,YACd,OACA,UACwB;AACxB,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-776JOVV6.js

@@ -0,0 +1,20 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-KGVUENQO.js";
+import {
+  getEndOfDay
+} from "./chunk-AVGNRINZ.js";
+
+// src/endOfYear.ts
+import "@js-temporal/polyfill";
+function endOfYear(input, timezone) {
+  const zonedDateTime = normalizeWithPlainDate(input, timezone);
+  const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });
+  const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });
+  return getEndOfDay(lastDay);
+}
+
+export {
+  endOfYear
+};
+//# sourceMappingURL=chunk-776JOVV6.js.map

package/dist/chunk-776JOVV6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfYear.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last moment of the year (last day at 23:59:59.999999999).\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the year at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const end = endOfYear(instant);\n * // 2025-12-31T23:59:59.999999999Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-05:00[America/New_York]');\n * const end = endOfYear(zoned);\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });\n  const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AA0ClB,SAAS,UACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,YAAY,cAAc,KAAK,EAAE,OAAO,cAAc,aAAa,CAAC;AAC1E,QAAM,UAAU,UAAU,KAAK,EAAE,KAAK,UAAU,YAAY,CAAC;AAC7D,SAAO,YAAY,OAAO;AAC5B;","names":[]}

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

@@ -1,16 +1,19 @@
+import {
+  isAfter
+} from "./chunk-WY63VEXE.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
 
 // src/isAfter.ts
-import { Temporal } from "@js-temporal/polyfill";
-function isAfter(date1, date2) {
+import "@js-temporal/polyfill";
+function isAfter2(date1, date2) {
   const zoned1 = normalizeTemporalInput(date1);
   const zoned2 = normalizeTemporalInput(date2);
-  return Temporal.ZonedDateTime.compare(zoned1, zoned2) > 0;
+  return isAfter(zoned1, zoned2);
 }
 
 export {
-  isAfter
+  isAfter2 as isAfter
 };
-//# sourceMappingURL=chunk-BBNNR2QH.js.map
+//# sourceMappingURL=chunk-7VLSSOVC.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../src/isAfter.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\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 Temporal.ZonedDateTime.compare(zoned1, zoned2) > 0;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAwClB,SAAS,QACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,SAAS,cAAc,QAAQ,QAAQ,MAAM,IAAI;AAC1D;","names":[]}
+{"version":3,"sources":["../src/isAfter.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\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":";;;;;;;;AAAA,OAAyB;AAyClB,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-AJ4JBKJK.js

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

package/dist/chunk-AJ4JBKJK.js.map

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

package/dist/{chunk-RJY62CDU.js → chunk-B2R2G5YK.js}

@@ -1,3 +1,6 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-AJ4JBKJK.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
@@ -7,10 +10,10 @@ import "@js-temporal/polyfill";
 function differenceInMinutes(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 6e4);
+  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 6e4);
 }
 
 export {
   differenceInMinutes
 };
-//# sourceMappingURL=chunk-RJY62CDU.js.map
+//# sourceMappingURL=chunk-B2R2G5YK.js.map

package/dist/chunk-B2R2G5YK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMinutes.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\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 * @returns The number of minutes between the dates\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): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 60000);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AAsClB,SAAS,oBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,KAAK,MAAM,yBAAyB,QAAQ,MAAM,IAAI,GAAK;AACpE;","names":[]}

package/dist/{chunk-D7DPB2JR.js → chunk-BV6CLVSI.js}

@@ -1,16 +1,19 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-AJ4JBKJK.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
 
 // src/differenceInMilliseconds.ts
 import "@js-temporal/polyfill";
-function differenceInMilliseconds(laterDate, earlierDate) {
+function differenceInMilliseconds2(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  return zoned1.epochMilliseconds - zoned2.epochMilliseconds;
+  return differenceInMilliseconds(zoned1, zoned2);
 }
 
 export {
-  differenceInMilliseconds
+  differenceInMilliseconds2 as differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-D7DPB2JR.js.map
+//# sourceMappingURL=chunk-BV6CLVSI.js.map

package/dist/chunk-BV6CLVSI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMilliseconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds as differenceInMillisecondsInternal } from './shared/differenceInMilliseconds';\n\n/**\n * Returns the number of milliseconds 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 milliseconds between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:21.700Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.600Z');\n *\n * differenceInMilliseconds(later, earlier); // 1100\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T14:00:00-05:00[America/New_York]');\n *\n * differenceInMilliseconds(later, earlier); // 3600000\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 * differenceInMilliseconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMilliseconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return differenceInMillisecondsInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AAsClB,SAASA,0BACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,yBAAiC,QAAQ,MAAM;AACxD;","names":["differenceInMilliseconds"]}

package/dist/chunk-HLGMUTFK.js

@@ -0,0 +1,16 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-KGVUENQO.js";
+
+// src/startOfMonth.ts
+import "@js-temporal/polyfill";
+function startOfMonth(input, timezone) {
+  const zonedDateTime = normalizeWithPlainDate(input, timezone);
+  const firstDay = zonedDateTime.with({ day: 1 });
+  return firstDay.startOfDay();
+}
+
+export {
+  startOfMonth
+};
+//# sourceMappingURL=chunk-HLGMUTFK.js.map

package/dist/chunk-HLGMUTFK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfMonth.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\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":";;;;;AAAA,OAAyB;AAyClB,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-HOCNCQTC.js

@@ -0,0 +1,18 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-KGVUENQO.js";
+import {
+  getEndOfDay
+} from "./chunk-AVGNRINZ.js";
+
+// src/endOfDay.ts
+import "@js-temporal/polyfill";
+function endOfDay(input, timezone) {
+  const zonedDateTime = normalizeWithPlainDate(input, timezone);
+  return getEndOfDay(zonedDateTime);
+}
+
+export {
+  endOfDay
+};
+//# sourceMappingURL=chunk-HOCNCQTC.js.map

package/dist/chunk-HOCNCQTC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfDay.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\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":";;;;;;;;AAAA,OAAyB;AA0ClB,SAAS,SACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,YAAY,aAAa;AAClC;","names":[]}

package/dist/chunk-IBO2U23N.js

@@ -0,0 +1,23 @@
+import {
+  isBefore
+} from "./chunk-WUAIUEH7.js";
+import {
+  isAfter
+} from "./chunk-WY63VEXE.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isWithinInterval.ts
+import "@js-temporal/polyfill";
+function isWithinInterval(date, interval) {
+  const normalizedDate = normalizeTemporalInput(date);
+  const normalizedStart = normalizeTemporalInput(interval.start);
+  const normalizedEnd = normalizeTemporalInput(interval.end);
+  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);
+}
+
+export {
+  isWithinInterval
+};
+//# sourceMappingURL=chunk-IBO2U23N.js.map

package/dist/chunk-IBO2U23N.js.map

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

package/dist/chunk-KGVUENQO.js

@@ -0,0 +1,17 @@
+import {
+  plainDateToZonedDateTime
+} from "./chunk-JNA3AFOC.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/shared/normalizeWithPlainDate.ts
+import { Temporal } from "@js-temporal/polyfill";
+function normalizeWithPlainDate(input, timezone) {
+  return input instanceof Temporal.PlainDate ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
+}
+
+export {
+  normalizeWithPlainDate
+};
+//# sourceMappingURL=chunk-KGVUENQO.js.map

package/dist/chunk-KGVUENQO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeWithPlainDate.ts"],"sourcesContent":["import { 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 input instanceof Temporal.PlainDate\n    ? plainDateToZonedDateTime(input, timezone!)\n    : normalizeTemporalInput(input);\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,gBAAgB;AAyBlB,SAAS,uBACd,OACA,UACwB;AACxB,SAAO,iBAAiB,SAAS,YAC7B,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAClC;","names":[]}

package/dist/chunk-MGMLT4L6.js

@@ -0,0 +1,20 @@
+import {
+  nowZoned
+} from "./chunk-QFNGYTTH.js";
+import {
+  isAfter
+} from "./chunk-WY63VEXE.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isFuture.ts
+function isFuture(date) {
+  const zoned = normalizeTemporalInput(date);
+  return isAfter(zoned, nowZoned());
+}
+
+export {
+  isFuture
+};
+//# sourceMappingURL=chunk-MGMLT4L6.js.map

package/dist/chunk-MGMLT4L6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isFuture.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isAfter } from './shared/isAfter';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the future.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is after the current instant, false otherwise\n *\n * @example\n * ```ts\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n *\n * isFuture(tomorrow); // true\n * isFuture(yesterday); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const futureInstant = Temporal.Now.instant().add({ hours: 1 });\n *\n * isFuture(futureInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const futureInTokyo = Temporal.ZonedDateTime.from('2100-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isFuture(futureInTokyo); // true\n * ```\n */\nexport function isFuture(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isAfter(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,SACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,QAAQ,OAAO,SAAS,CAAC;AAClC;","names":[]}

package/dist/chunk-OQ4CWKJT.js

@@ -0,0 +1,19 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-KGVUENQO.js";
+import {
+  getEndOfDay
+} from "./chunk-AVGNRINZ.js";
+
+// src/endOfMonth.ts
+import "@js-temporal/polyfill";
+function endOfMonth(input, timezone) {
+  const zonedDateTime = normalizeWithPlainDate(input, timezone);
+  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });
+  return getEndOfDay(lastDay);
+}
+
+export {
+  endOfMonth
+};
+//# sourceMappingURL=chunk-OQ4CWKJT.js.map

package/dist/chunk-OQ4CWKJT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfMonth.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last moment of the month (last day at 23:59:59.999999999).\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 (requires timezone)\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(\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 {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AA0ClB,SAAS,WACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,UAAU,cAAc,KAAK,EAAE,KAAK,cAAc,YAAY,CAAC;AACrE,SAAO,YAAY,OAAO;AAC5B;","names":[]}

package/dist/{chunk-PIDXROVB.js → chunk-PMJD5N5J.js}

@@ -1,3 +1,6 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-AJ4JBKJK.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
@@ -7,10 +10,10 @@ import "@js-temporal/polyfill";
 function differenceInHours(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 36e5);
+  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 36e5);
 }
 
 export {
   differenceInHours
 };
-//# sourceMappingURL=chunk-PIDXROVB.js.map
+//# sourceMappingURL=chunk-PMJD5N5J.js.map

package/dist/chunk-PMJD5N5J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInHours.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\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 * @returns The number of hours between the dates\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): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 3600000);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AAsClB,SAAS,kBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,KAAK,MAAM,yBAAyB,QAAQ,MAAM,IAAI,IAAO;AACtE;","names":[]}

package/dist/chunk-QFNGYTTH.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/shared/nowZoned.ts
+import { Temporal } from "@js-temporal/polyfill";
+function nowZoned() {
+  return normalizeTemporalInput(Temporal.Now.instant());
+}
+
+export {
+  nowZoned
+};
+//# sourceMappingURL=chunk-QFNGYTTH.js.map

package/dist/chunk-QFNGYTTH.js.map

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

package/dist/{chunk-ZHRMURYP.js → chunk-QVOEXF46.js}

@@ -1,3 +1,6 @@
+import {
+  differenceInMilliseconds
+} from "./chunk-AJ4JBKJK.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
@@ -7,10 +10,10 @@ import "@js-temporal/polyfill";
 function differenceInSeconds(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 1e3);
+  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 1e3);
 }
 
 export {
   differenceInSeconds
 };
-//# sourceMappingURL=chunk-ZHRMURYP.js.map
+//# sourceMappingURL=chunk-QVOEXF46.js.map

package/dist/chunk-QVOEXF46.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInSeconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\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 * @returns The number of seconds between the dates\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): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc(differenceInMilliseconds(zoned1, zoned2) / 1000);\n}\n"],"mappings":";;;;;;;;AAAA,OAAyB;AAsClB,SAAS,oBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,KAAK,MAAM,yBAAyB,QAAQ,MAAM,IAAI,GAAI;AACnE;","names":[]}

package/dist/chunk-UBY22QWM.js

@@ -0,0 +1,20 @@
+import {
+  isBefore
+} from "./chunk-WUAIUEH7.js";
+import {
+  nowZoned
+} from "./chunk-QFNGYTTH.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isPast.ts
+function isPast(date) {
+  const zoned = normalizeTemporalInput(date);
+  return isBefore(zoned, nowZoned());
+}
+
+export {
+  isPast
+};
+//# sourceMappingURL=chunk-UBY22QWM.js.map

package/dist/chunk-UBY22QWM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the past.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is before the current instant, false otherwise\n *\n * @example\n * ```ts\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n *\n * isPast(yesterday); // true\n * isPast(tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const pastInstant = Temporal.Now.instant().subtract({ hours: 1 });\n *\n * isPast(pastInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const pastInTokyo = Temporal.ZonedDateTime.from('1970-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isPast(pastInTokyo); // true\n * ```\n */\nexport function isPast(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isBefore(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,OACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,SAAS,OAAO,SAAS,CAAC;AACnC;","names":[]}

package/dist/chunk-WUAIUEH7.js

@@ -0,0 +1,10 @@
+// src/shared/isBefore.ts
+import { Temporal } from "@js-temporal/polyfill";
+function isBefore(date1, date2) {
+  return Temporal.ZonedDateTime.compare(date1, date2) < 0;
+}
+
+export {
+  isBefore
+};
+//# sourceMappingURL=chunk-WUAIUEH7.js.map

package/dist/chunk-WUAIUEH7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/isBefore.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nexport function isBefore(\n  date1: Temporal.ZonedDateTime,\n  date2: Temporal.ZonedDateTime\n): boolean {\n  return Temporal.ZonedDateTime.compare(date1, date2) < 0;\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAElB,SAAS,SACd,OACA,OACS;AACT,SAAO,SAAS,cAAc,QAAQ,OAAO,KAAK,IAAI;AACxD;","names":[]}

package/dist/chunk-WY63VEXE.js

@@ -0,0 +1,10 @@
+// src/shared/isAfter.ts
+import { Temporal } from "@js-temporal/polyfill";
+function isAfter(date1, date2) {
+  return Temporal.ZonedDateTime.compare(date1, date2) > 0;
+}
+
+export {
+  isAfter
+};
+//# sourceMappingURL=chunk-WY63VEXE.js.map

package/dist/chunk-WY63VEXE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/isAfter.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nexport function isAfter(\n  date1: Temporal.ZonedDateTime,\n  date2: Temporal.ZonedDateTime\n): boolean {\n  return Temporal.ZonedDateTime.compare(date1, date2) > 0;\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAElB,SAAS,QACd,OACA,OACS;AACT,SAAO,SAAS,cAAc,QAAQ,OAAO,KAAK,IAAI;AACxD;","names":[]}

package/dist/chunk-YIT6EMBC.js

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

package/dist/chunk-YIT6EMBC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfDay.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\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":";;;;;AAAA,OAAyB;AAyClB,SAAS,WACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,cAAc,WAAW;AAClC;","names":[]}

package/dist/chunk-ZDA7GSWU.js

@@ -0,0 +1,19 @@
+import {
+  isBefore
+} from "./chunk-WUAIUEH7.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isBefore.ts
+import "@js-temporal/polyfill";
+function isBefore2(date1, date2) {
+  const zoned1 = normalizeTemporalInput(date1);
+  const zoned2 = normalizeTemporalInput(date2);
+  return isBefore(zoned1, zoned2);
+}
+
+export {
+  isBefore2 as isBefore
+};
+//# sourceMappingURL=chunk-ZDA7GSWU.js.map

package/dist/chunk-ZDA7GSWU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isBefore.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\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":";;;;;;;;AAAA,OAAyB;AAyClB,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-TDQXOSO3.js → chunk-ZJQS7ZY7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BIAPE4MR.js";
 import {
   differenceInSeconds
-} from "./chunk-ZHRMURYP.js";
+} from "./chunk-QVOEXF46.js";
 import {
   differenceInWeeks
 } from "./chunk-PVAOUYXF.js";
@@ -15,10 +15,10 @@ import {
 } from "./chunk-6IP245MS.js";
 import {
   differenceInHours
-} from "./chunk-PIDXROVB.js";
+} from "./chunk-PMJD5N5J.js";
 import {
   differenceInMinutes
-} from "./chunk-RJY62CDU.js";
+} from "./chunk-B2R2G5YK.js";
 import {
   normalizeTemporalInput
 } from "./chunk-MJSZNWCV.js";
@@ -91,4 +91,4 @@ function intlFormatDistance(laterDate, earlierDate, options) {
 export {
   intlFormatDistance
 };
-//# sourceMappingURL=chunk-TDQXOSO3.js.map
+//# sourceMappingURL=chunk-ZJQS7ZY7.js.map

package/dist/differenceInHours.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInHours.d.ts","sourceRoot":"","sources":["../src/differenceInHours.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}
+{"version":3,"file":"differenceInHours.d.ts","sourceRoot":"","sources":["../src/differenceInHours.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}

package/dist/differenceInHours.js

@@ -1,6 +1,7 @@
 import {
   differenceInHours
-} from "./chunk-PIDXROVB.js";
+} from "./chunk-PMJD5N5J.js";
+import "./chunk-AJ4JBKJK.js";
 import "./chunk-MJSZNWCV.js";
 export {
   differenceInHours

package/dist/differenceInMilliseconds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInMilliseconds.d.ts","sourceRoot":"","sources":["../src/differenceInMilliseconds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}
+{"version":3,"file":"differenceInMilliseconds.d.ts","sourceRoot":"","sources":["../src/differenceInMilliseconds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}

package/dist/differenceInMilliseconds.js

@@ -1,6 +1,7 @@
 import {
   differenceInMilliseconds
-} from "./chunk-D7DPB2JR.js";
+} from "./chunk-BV6CLVSI.js";
+import "./chunk-AJ4JBKJK.js";
 import "./chunk-MJSZNWCV.js";
 export {
   differenceInMilliseconds

package/dist/differenceInMinutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInMinutes.d.ts","sourceRoot":"","sources":["../src/differenceInMinutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}
+{"version":3,"file":"differenceInMinutes.d.ts","sourceRoot":"","sources":["../src/differenceInMinutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}

package/dist/differenceInMinutes.js

@@ -1,6 +1,7 @@
 import {
   differenceInMinutes
-} from "./chunk-RJY62CDU.js";
+} from "./chunk-B2R2G5YK.js";
+import "./chunk-AJ4JBKJK.js";
 import "./chunk-MJSZNWCV.js";
 export {
   differenceInMinutes

package/dist/differenceInSeconds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInSeconds.d.ts","sourceRoot":"","sources":["../src/differenceInSeconds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}
+{"version":3,"file":"differenceInSeconds.d.ts","sourceRoot":"","sources":["../src/differenceInSeconds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}

package/dist/differenceInSeconds.js

@@ -1,6 +1,7 @@
 import {
   differenceInSeconds
-} from "./chunk-ZHRMURYP.js";
+} from "./chunk-QVOEXF46.js";
+import "./chunk-AJ4JBKJK.js";
 import "./chunk-MJSZNWCV.js";
 export {
   differenceInSeconds

package/dist/endOfDay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endOfDay.d.ts","sourceRoot":"","sources":["../src/endOfDay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAAC,aAAa,CAAC"}
+{"version":3,"file":"endOfDay.d.ts","sourceRoot":"","sources":["../src/endOfDay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAAC,aAAa,CAAC"}