@gobrand/tiempo 2.6.1 → 2.6.3

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-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-BUX26GTD.js

@@ -0,0 +1,30 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachYearOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachYearOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const startYear = startZoned.year;
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const endYear = endInTimezone.year;
+  const years = [];
+  for (let year = startYear; year <= endYear; year++) {
+    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1 });
+    years.push(
+      firstOfYear.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: new Temporal.PlainTime()
+      })
+    );
+  }
+  return years;
+}
+
+export {
+  eachYearOfInterval
+};
+//# sourceMappingURL=chunk-BUX26GTD.js.map

package/dist/chunk-BUX26GTD.js.map

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

@@ -0,0 +1,25 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachDayOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachDayOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const startDate = startZoned.toPlainDate();
+  const endDate = endZoned.withTimeZone(timezone).toPlainDate();
+  const days = [];
+  let current = startDate;
+  while (Temporal.PlainDate.compare(current, endDate) <= 0) {
+    days.push(current.toZonedDateTime({ timeZone: timezone, plainTime: new Temporal.PlainTime() }));
+    current = current.add({ days: 1 });
+  }
+  return days;
+}
+
+export {
+  eachDayOfInterval
+};
+//# sourceMappingURL=chunk-DKYVFYWM.js.map

package/dist/chunk-DKYVFYWM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachDayOfInterval.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each calendar day within the interval.\n * Each element represents the start of day (midnight) in the timezone of the interval start.\n * The interval is inclusive of both start and end days.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each day in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-10T14:00:00Z[UTC]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-08T00:00:00Z[UTC],\n * //   2025-01-09T00:00:00Z[UTC],\n * //   2025-01-10T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With timezone - preserves the timezone from start\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T14:00:00-05:00[America/New_York]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00-05:00[America/New_York],\n * //   2025-01-07T00:00:00-05:00[America/New_York],\n * //   2025-01-08T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With Instant (uses UTC)\n * const start = Temporal.Instant.from('2025-01-06T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-08T00:00:00Z');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-08T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single day interval\n * const date = Temporal.ZonedDateTime.from('2025-01-15T12:00:00Z[UTC]');\n *\n * eachDayOfInterval({ start: date, end: date });\n * // [2025-01-15T00:00:00Z[UTC]]\n * ```\n */\nexport function eachDayOfInterval(interval: {\n  start: Temporal.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 startDate = startZoned.toPlainDate();\n  const endDate = endZoned.withTimeZone(timezone).toPlainDate();\n\n  const days: Temporal.ZonedDateTime[] = [];\n  let current = startDate;\n\n  while (Temporal.PlainDate.compare(current, endDate) <= 0) {\n    days.push(current.toZonedDateTime({ timeZone: timezone, plainTime: new Temporal.PlainTime() }));\n    current = current.add({ days: 1 });\n  }\n\n  return days;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAkElB,SAAS,kBAAkB,UAGL;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAC5B,QAAM,YAAY,WAAW,YAAY;AACzC,QAAM,UAAU,SAAS,aAAa,QAAQ,EAAE,YAAY;AAE5D,QAAM,OAAiC,CAAC;AACxC,MAAI,UAAU;AAEd,SAAO,SAAS,UAAU,QAAQ,SAAS,OAAO,KAAK,GAAG;AACxD,SAAK,KAAK,QAAQ,gBAAgB,EAAE,UAAU,UAAU,WAAW,IAAI,SAAS,UAAU,EAAE,CAAC,CAAC;AAC9F,cAAU,QAAQ,IAAI,EAAE,MAAM,EAAE,CAAC;AAAA,EACnC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-G2JUEBC5.js

@@ -0,0 +1,26 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachMinuteOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachMinuteOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const startMinute = startZoned.round({ smallestUnit: "minute", roundingMode: "floor" });
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const endMinute = endInTimezone.round({ smallestUnit: "minute", roundingMode: "floor" });
+  const minutes = [];
+  let current = startMinute;
+  while (Temporal.ZonedDateTime.compare(current, endMinute) <= 0) {
+    minutes.push(current);
+    current = current.add({ minutes: 1 });
+  }
+  return minutes;
+}
+
+export {
+  eachMinuteOfInterval
+};
+//# sourceMappingURL=chunk-G2JUEBC5.js.map

package/dist/chunk-G2JUEBC5.js.map

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

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-JA7SVLAF.js

@@ -0,0 +1,20 @@
+import {
+  isAfter
+} from "./chunk-WY63VEXE.js";
+import {
+  nowZoned
+} from "./chunk-QFNGYTTH.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-JA7SVLAF.js.map

package/dist/chunk-JA7SVLAF.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-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-OLEOU3XE.js

@@ -0,0 +1,28 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachWeekOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachWeekOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const daysToSubtractStart = startZoned.dayOfWeek - 1;
+  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;
+  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();
+  const weeks = [];
+  let current = startMonday;
+  while (Temporal.ZonedDateTime.compare(current, endMonday) <= 0) {
+    weeks.push(current);
+    current = current.add({ weeks: 1 });
+  }
+  return weeks;
+}
+
+export {
+  eachWeekOfInterval
+};
+//# sourceMappingURL=chunk-OLEOU3XE.js.map

package/dist/chunk-OLEOU3XE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachWeekOfInterval.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each week within the interval.\n * Each element represents the first moment of the week (Monday at midnight).\n * Uses ISO 8601 week definition: weeks start on Monday.\n * The interval is inclusive of both start and end weeks.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each week (Monday) in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00Z[UTC]'); // Monday\n * const end = Temporal.ZonedDateTime.from('2025-01-22T14:00:00Z[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],  // Week 2\n * //   2025-01-13T00:00:00Z[UTC],  // Week 3\n * //   2025-01-20T00:00:00Z[UTC]   // Week 4\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Mid-week start\n * const start = Temporal.ZonedDateTime.from('2025-01-08T10:00:00Z[UTC]'); // Wednesday\n * const end = Temporal.ZonedDateTime.from('2025-01-15T14:00:00Z[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00Z[UTC],  // Monday of week containing Jan 8\n * //   2025-01-13T00:00:00Z[UTC]   // Monday of week containing Jan 15\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-12-25T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T00:00:00Z[UTC]');\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2024-12-23T00:00:00Z[UTC],  // Monday of week containing Dec 25\n * //   2024-12-30T00:00:00Z[UTC],  // Monday of week containing Dec 30\n * //   2025-01-06T00:00:00Z[UTC]   // Monday of week containing Jan 8\n * // ]\n * ```\n */\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.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\n  // Get Monday of the starting week\n  // dayOfWeek: 1 = Monday, 7 = Sunday (ISO 8601)\n  const daysToSubtractStart = startZoned.dayOfWeek - 1;\n  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();\n\n  // Get Monday of the ending week\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;\n  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();\n\n  const weeks: Temporal.ZonedDateTime[] = [];\n  let current = startMonday;\n\n  while (Temporal.ZonedDateTime.compare(current, endMonday) <= 0) {\n    weeks.push(current);\n    current = current.add({ weeks: 1 });\n  }\n\n  return weeks;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAuDlB,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAI5B,QAAM,sBAAsB,WAAW,YAAY;AACnD,QAAM,cAAc,WAAW,SAAS,EAAE,MAAM,oBAAoB,CAAC,EAAE,WAAW;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,oBAAoB,cAAc,YAAY;AACpD,QAAM,YAAY,cAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC,EAAE,WAAW;AAEjF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,SAAS,cAAc,QAAQ,SAAS,SAAS,KAAK,GAAG;AAC9D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","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-TNCLJK4Y.js

@@ -0,0 +1,38 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachMonthOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachMonthOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const startYearMonth = Temporal.PlainYearMonth.from({
+    year: startZoned.year,
+    month: startZoned.month
+  });
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const endYearMonth = Temporal.PlainYearMonth.from({
+    year: endInTimezone.year,
+    month: endInTimezone.month
+  });
+  const months = [];
+  let current = startYearMonth;
+  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {
+    const firstOfMonth = current.toPlainDate({ day: 1 });
+    months.push(
+      firstOfMonth.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: new Temporal.PlainTime()
+      })
+    );
+    current = current.add({ months: 1 });
+  }
+  return months;
+}
+
+export {
+  eachMonthOfInterval
+};
+//# sourceMappingURL=chunk-TNCLJK4Y.js.map

package/dist/chunk-TNCLJK4Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachMonthOfInterval.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each month within the interval.\n * Each element represents the first moment of the month (day 1 at midnight).\n * The interval is inclusive of both start and end months.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each month in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-15T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-04-20T14:00:00Z[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2025-01-01T00:00:00Z[UTC],\n * //   2025-02-01T00:00:00Z[UTC],\n * //   2025-03-01T00:00:00Z[UTC],\n * //   2025-04-01T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-11-15T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-02-15T00:00:00Z[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2024-11-01T00:00:00Z[UTC],\n * //   2024-12-01T00:00:00Z[UTC],\n * //   2025-01-01T00:00:00Z[UTC],\n * //   2025-02-01T00:00:00Z[UTC]\n * // ]\n * ```\n */\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.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\n  // Get start of the starting month\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: startZoned.year,\n    month: startZoned.month,\n  });\n\n  // Get end month in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: endInTimezone.year,\n    month: endInTimezone.month,\n  });\n\n  const months: Temporal.ZonedDateTime[] = [];\n  let current = startYearMonth;\n\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    const firstOfMonth = current.toPlainDate({ day: 1 });\n    months.push(\n      firstOfMonth.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n    current = current.add({ months: 1 });\n  }\n\n  return months;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AA2ClB,SAAS,oBAAoB,UAGP;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAG5B,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,WAAW;AAAA,IACjB,OAAO,WAAW;AAAA,EACpB,CAAC;AAGD,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,cAAc;AAAA,IACpB,OAAO,cAAc;AAAA,EACvB,CAAC;AAED,QAAM,SAAmC,CAAC;AAC1C,MAAI,UAAU;AAEd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,UAAM,eAAe,QAAQ,YAAY,EAAE,KAAK,EAAE,CAAC;AACnD,WAAO;AAAA,MACL,aAAa,gBAAgB;AAAA,QAC3B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AACA,cAAU,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

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-Y7CIJQ67.js

@@ -0,0 +1,26 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/eachHourOfInterval.ts
+import { Temporal } from "@js-temporal/polyfill";
+function eachHourOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  const timezone = startZoned.timeZoneId;
+  const startHour = startZoned.round({ smallestUnit: "hour", roundingMode: "floor" });
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const endHour = endInTimezone.round({ smallestUnit: "hour", roundingMode: "floor" });
+  const hours = [];
+  let current = startHour;
+  while (Temporal.ZonedDateTime.compare(current, endHour) <= 0) {
+    hours.push(current);
+    current = current.add({ hours: 1 });
+  }
+  return hours;
+}
+
+export {
+  eachHourOfInterval
+};
+//# sourceMappingURL=chunk-Y7CIJQ67.js.map

package/dist/chunk-Y7CIJQ67.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachHourOfInterval.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each hour within the interval.\n * Each element represents the start of the hour (minute/second/etc. set to 0).\n * The interval is inclusive of both start and end hours.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * Note: During DST transitions, some hours may be skipped (spring forward) or\n * the array may contain fewer/more hours than expected based on wall-clock time.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each hour in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:30:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T14:15:00Z[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:00:00Z[UTC],\n * //   2025-01-06T11:00:00Z[UTC],\n * //   2025-01-06T12:00:00Z[UTC],\n * //   2025-01-06T13:00:00Z[UTC],\n * //   2025-01-06T14:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-day boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T22:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T02:00:00Z[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T22:00:00Z[UTC],\n * //   2025-01-06T23:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-07T01:00:00Z[UTC],\n * //   2025-01-07T02:00:00Z[UTC]\n * // ]\n * ```\n */\nexport function eachHourOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[] {\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n\n  const timezone = startZoned.timeZoneId;\n\n  // Get start of the starting hour\n  const startHour = startZoned.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n\n  // Get start of the ending hour in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endHour = endInTimezone.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n\n  const hours: Temporal.ZonedDateTime[] = [];\n  let current = startHour;\n\n  while (Temporal.ZonedDateTime.compare(current, endHour) <= 0) {\n    hours.push(current);\n    current = current.add({ hours: 1 });\n  }\n\n  return hours;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAgDlB,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAG5B,QAAM,YAAY,WAAW,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,UAAU,cAAc,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAEnF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,SAAS,cAAc,QAAQ,SAAS,OAAO,KAAK,GAAG;AAC5D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","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