@gobrand/tiempo 3.0.1 → 3.1.3

package/dist/{chunk-L5AMAEWX.js → chunk-2AID4P2C.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/shared/plainDateToZonedDateTime.ts
 function plainDateToZonedDateTime(date, timezone) {
@@ -13,4 +13,4 @@ function plainDateToZonedDateTime(date, timezone) {
 export {
   plainDateToZonedDateTime
 };
-//# sourceMappingURL=chunk-L5AMAEWX.js.map
+//# sourceMappingURL=chunk-2AID4P2C.js.map

package/dist/{chunk-MTDZG4HK.js → chunk-2TISXHHK.js}

@@ -1,15 +1,15 @@
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 import {
   plainDateToZonedDateTime
-} from "./chunk-L5AMAEWX.js";
+} from "./chunk-2AID4P2C.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/endOfWeek.ts
 function endOfWeek(input, timezone) {
@@ -26,4 +26,4 @@ function endOfWeek(input, timezone) {
 export {
   endOfWeek
 };
-//# sourceMappingURL=chunk-MTDZG4HK.js.map
+//# sourceMappingURL=chunk-2TISXHHK.js.map

package/dist/chunk-2TISXHHK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the last boundary of the week (Sunday).\n * Uses ISO 8601 week definition: weeks end on Sunday.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at Sunday 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'); // Monday\n * const end = endOfWeek(instant);\n * // 2025-01-26T23:59:59.999999999+00:00[UTC] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const end = endOfWeek(zoned);\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date);\n * // 2025-01-26 (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date, 'America/New_York');\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n */\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.add({ days: 7 - input.dayOfWeek });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to add to get to Sunday\n  const daysToAdd = 7 - dayOfWeek;\n\n  // Go to Sunday, then get end of that day\n  const sunday = zonedDateTime.add({ days: daysToAdd });\n\n  return getEndOfDay(sunday);\n}\n"],"mappings":";;;;;;;;;;;;;;AAsDO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,IAAI,EAAE,MAAM,IAAI,MAAM,UAAU,CAAC;AAAA,EAChD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,YAAY,IAAI;AAGtB,QAAM,SAAS,cAAc,IAAI,EAAE,MAAM,UAAU,CAAC;AAEpD,SAAO,YAAY,MAAM;AAC3B;","names":[]}

package/dist/{chunk-WGLZHBJG.js → chunk-32AWWYBF.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addNanoseconds.ts
 function addNanoseconds(input, nanoseconds) {
@@ -11,4 +11,4 @@ function addNanoseconds(input, nanoseconds) {
 export {
   addNanoseconds
 };
-//# sourceMappingURL=chunk-WGLZHBJG.js.map
+//# sourceMappingURL=chunk-32AWWYBF.js.map

package/dist/chunk-32AWWYBF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addNanoseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of nanoseconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param nanoseconds - Number of nanoseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with nanoseconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addNanoseconds(zoned, 1000);\n * // 2025-01-20T15:30:00.000001-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract nanoseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = addNanoseconds(instant, -500);\n * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function addNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ nanoseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,eACd,OACA,aACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,YAAY,CAAC;AAC1C;","names":[]}

package/dist/{chunk-BV32K227.js → chunk-3D4YR2SR.js}

@@ -1,9 +1,9 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/startOfMonth.ts
 function startOfMonth(input, timezone) {
@@ -18,4 +18,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-BV32K227.js.map
+//# sourceMappingURL=chunk-3D4YR2SR.js.map

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

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

package/dist/chunk-3HD7HEN4.js

@@ -0,0 +1,42 @@
+import {
+  differenceInDays
+} from "./chunk-JGPTGV5X.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachDayOfInterval.ts
+function eachDayOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    const dayCount = differenceInDays(
+      interval.end.withCalendar(interval.start.calendarId),
+      interval.start
+    );
+    const days2 = [];
+    for (let offset = 0; offset <= dayCount; offset++) {
+      days2.push(interval.start.add({ days: offset }));
+    }
+    return days2;
+  }
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const days = [];
+  let current = startZoned.startOfDay();
+  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {
+    days.push(current);
+    current = current.add({ days: 1 }).startOfDay();
+  }
+  return days;
+}
+
+export {
+  eachDayOfInterval
+};
+//# sourceMappingURL=chunk-3HD7HEN4.js.map

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

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

package/dist/chunk-3HF4F36S.js

@@ -0,0 +1,16 @@
+import {
+  addYears
+} from "./chunk-HRCTWTP3.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subYears.ts
+function subYears(input, years) {
+  return isPlainDate(input) ? addYears(input, -years) : addYears(input, -years);
+}
+
+export {
+  subYears
+};
+//# sourceMappingURL=chunk-3HF4F36S.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subYears.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addYears } from './addYears';\n\n/**\n * Subtracts the specified number of years from a datetime or date.\n *\n * This is a convenience wrapper around addYears with negated value.\n * Properly handles leap years and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param years - Number of years to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with years subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = subYears(instant, 2);\n * // 2023-01-20T12:00:00+00:00[UTC] (2 years earlier)\n * ```\n */\nexport function subYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  years: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addYears overload.\n  return isPlainDate(input) ? addYears(input, -years) : addYears(input, -years);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}

package/dist/{chunk-VXOQ7IG5.js → chunk-3KE6GK4R.js}

@@ -1,9 +1,9 @@
 // src/shared/differenceInMilliseconds.ts
 function differenceInMilliseconds(laterDate, earlierDate) {
-  return laterDate.epochMilliseconds - earlierDate.epochMilliseconds;
+  return Number((laterDate.epochNanoseconds - earlierDate.epochNanoseconds) / 1000000n);
 }
 
 export {
   differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-VXOQ7IG5.js.map
+//# sourceMappingURL=chunk-3KE6GK4R.js.map

package/dist/{chunk-VXOQ7IG5.js.map → chunk-3KE6GK4R.js.map}

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

package/dist/chunk-3S6TSXZ3.js

@@ -0,0 +1,18 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/clamp.ts
+function clamp(value, interval) {
+  if (compare(interval.start, interval.end) > 0) {
+    throw new RangeError("clamp requires interval.start to be before or equal to interval.end");
+  }
+  if (compare(value, interval.start) < 0) return interval.start;
+  if (compare(value, interval.end) > 0) return interval.end;
+  return value;
+}
+
+export {
+  clamp
+};
+//# sourceMappingURL=chunk-3S6TSXZ3.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/clamp.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable, type Timeline } from './shared/compare';\n\n/**\n * Restricts a value to an inclusive interval. Returns the value itself when it\n * is inside, otherwise the nearer endpoint, unchanged.\n *\n * Timeline values compare by exact instant, PlainDates by date, and\n * PlainTimes by wall-clock time. Mixed domains throw a TypeError.\n *\n * @param value - The value to restrict\n * @param interval - Inclusive bounds from the same domain as value\n * @returns value, interval.start, or interval.end\n * @throws RangeError if interval.start is after interval.end\n *\n * @example\n * ```ts\n * const start = Temporal.PlainDate.from('2025-01-01');\n * const end = Temporal.PlainDate.from('2025-01-31');\n *\n * clamp(Temporal.PlainDate.from('2025-02-14'), { start, end }); // 2025-01-31\n * clamp(Temporal.PlainDate.from('2025-01-10'), { start, end }); // 2025-01-10\n * ```\n */\nexport function clamp<T extends Timeline, S extends Timeline, E extends Timeline>(\n  value: T,\n  interval: { start: S; end: E }\n): T | S | E;\nexport function clamp(\n  value: Temporal.PlainDate,\n  interval: { start: Temporal.PlainDate; end: Temporal.PlainDate }\n): Temporal.PlainDate;\nexport function clamp(\n  value: Temporal.PlainTime,\n  interval: { start: Temporal.PlainTime; end: Temporal.PlainTime }\n): Temporal.PlainTime;\nexport function clamp(\n  value: Comparable,\n  interval: { start: Comparable; end: Comparable }\n): Comparable {\n  if (compare(interval.start, interval.end) > 0) {\n    throw new RangeError('clamp requires interval.start to be before or equal to interval.end');\n  }\n  if (compare(value, interval.start) < 0) return interval.start;\n  if (compare(value, interval.end) > 0) return interval.end;\n  return value;\n}\n"],"mappings":";;;;;AAoCO,SAAS,MACd,OACA,UACY;AACZ,MAAI,QAAQ,SAAS,OAAO,SAAS,GAAG,IAAI,GAAG;AAC7C,UAAM,IAAI,WAAW,qEAAqE;AAAA,EAC5F;AACA,MAAI,QAAQ,OAAO,SAAS,KAAK,IAAI,EAAG,QAAO,SAAS;AACxD,MAAI,QAAQ,OAAO,SAAS,GAAG,IAAI,EAAG,QAAO,SAAS;AACtD,SAAO;AACT;","names":[]}

package/dist/chunk-3X2U6I44.js

@@ -0,0 +1,19 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/addWeeks.ts
+function addWeeks(input, weeks) {
+  if (isPlainDate(input)) {
+    return input.add({ weeks });
+  }
+  return normalizeTemporalInput(input).add({ weeks });
+}
+
+export {
+  addWeeks
+};
+//# sourceMappingURL=chunk-3X2U6I44.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of weeks to a datetime or date.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param weeks - Number of weeks to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, 2);\n * // 2025-02-03T12:00:00+00:00[UTC] (2 weeks later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addWeeks(zoned, 2);\n * // 2025-02-03T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract weeks\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, -1);\n * // 2025-01-13T12:00:00+00:00[UTC] (1 week earlier)\n * ```\n */\nexport function addWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ weeks });\n  }\n  return normalizeTemporalInput(input).add({ weeks });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,SACd,OACA,OAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,MAAM,CAAC;AAAA,EAC5B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC;AACpD;","names":[]}

package/dist/{chunk-SDW4W3XE.js → chunk-3XGUCQ2A.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isSameMicrosecond.ts
 function isSameMicrosecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMicrosecond(date1, date2) {
 export {
   isSameMicrosecond
 };
-//# sourceMappingURL=chunk-SDW4W3XE.js.map
+//# sourceMappingURL=chunk-3XGUCQ2A.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMicrosecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same microsecond.\n * Compares the year, month, day, hour, minute, second, millisecond, and microsecond fields directly.\n * Ignores sub-microsecond precision (nanoseconds).\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same microsecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same microsecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456999+00:00[UTC]');\n *\n * isSameMicrosecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different microseconds\n * const us456 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');\n * const us457 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123457+00:00[UTC]');\n *\n * isSameMicrosecond(us456, us457); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local microseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local microseconds from each person's perspective\n * isSameMicrosecond(ny, tokyo); // false (14:30:45.123456 in NY, 04:30:45.123456 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMicrosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMicrosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456999Z');\n *\n * isSameMicrosecond(instant1, instant2); // true (both 14:30:45.123456 in UTC)\n * ```\n */\nexport function isSameMicrosecond(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second &&\n    zoned1.millisecond === zoned2.millisecond &&\n    zoned1.microsecond === zoned2.microsecond\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,kBACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO,UACzB,OAAO,gBAAgB,OAAO,eAC9B,OAAO,gBAAgB,OAAO;AAElC;","names":[]}

package/dist/{chunk-6RETOV6A.js → chunk-4GEF7B7W.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/shared/nowZoned.ts
 function nowZoned() {
@@ -13,4 +13,4 @@ function nowZoned() {
 export {
   nowZoned
 };
-//# sourceMappingURL=chunk-6RETOV6A.js.map
+//# sourceMappingURL=chunk-4GEF7B7W.js.map

package/dist/chunk-4KAIF44F.js

@@ -0,0 +1,19 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/addDays.ts
+function addDays(input, days) {
+  if (isPlainDate(input)) {
+    return input.add({ days });
+  }
+  return normalizeTemporalInput(input).add({ days });
+}
+
+export {
+  addDays
+};
+//# sourceMappingURL=chunk-4KAIF44F.js.map

package/dist/chunk-4KAIF44F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of days to a datetime or date.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param days - Number of days to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with days added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addDays(instant, 5);\n * // 2025-01-25T12:00:00+00:00[UTC] (5 days later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addDays(zoned, 10);\n * // 2025-01-30T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract days\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addDays(instant, -7);\n * // 2025-01-13T12:00:00+00:00[UTC] (7 days earlier)\n * ```\n */\nexport function addDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function addDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function addDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ days });\n  }\n  return normalizeTemporalInput(input).add({ days });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,QACd,OACA,MAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,KAAK,CAAC;AAAA,EAC3B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;AACnD;","names":[]}

package/dist/chunk-4PS6BEAC.js

@@ -0,0 +1,16 @@
+import {
+  addBusinessDays
+} from "./chunk-D3N7BT44.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subBusinessDays.ts
+function subBusinessDays(input, days) {
+  return isPlainDate(input) ? addBusinessDays(input, -days) : addBusinessDays(input, -days);
+}
+
+export {
+  subBusinessDays
+};
+//# sourceMappingURL=chunk-4PS6BEAC.js.map

package/dist/chunk-4PS6BEAC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addBusinessDays } from './addBusinessDays';\n\n/**\n * Subtracts business days (Monday–Friday), skipping weekends. Holidays are\n * not considered. Equivalent to `addBusinessDays(input, -days)`.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs keep their\n * timezone and time of day. PlainDate inputs stay dates.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @param days - Whole business days to subtract (negative to add)\n * @returns PlainDate for a date input; otherwise ZonedDateTime\n * @throws RangeError if days is not an integer\n *\n * @example\n * ```ts\n * const monday = Temporal.PlainDate.from('2025-01-27');\n *\n * subBusinessDays(monday, 1); // 2025-01-24 (Friday)\n * ```\n */\nexport function subBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addBusinessDays overload.\n  return isPlainDate(input) ? addBusinessDays(input, -days) : addBusinessDays(input, -days);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,gBACd,OACA,MAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,gBAAgB,OAAO,CAAC,IAAI,IAAI,gBAAgB,OAAO,CAAC,IAAI;AAC1F;","names":[]}

package/dist/chunk-4VWUTQKP.js

@@ -0,0 +1,65 @@
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  quarterStartMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachQuarterOfInterval.ts
+function eachQuarterOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    if (isPlainDateAfter(interval.start, interval.end)) return [];
+    return eachQuarterStart(interval.start, interval.end.withCalendar(interval.start.calendarId), (ym) => ym.toPlainDate({ day: 1 }));
+  }
+  const startZoned = normalizeTemporalInput(
+    interval.start
+  );
+  const endZoned = normalizeTemporalInput(
+    interval.end
+  );
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const timezone = startZoned.timeZoneId;
+  return eachQuarterStart(
+    startZoned,
+    endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId),
+    (ym) => ym.toPlainDate({ day: 1 }).toZonedDateTime({
+      timeZone: timezone,
+      plainTime: new Temporal.PlainTime()
+    })
+  );
+}
+function eachQuarterStart(start, end, make) {
+  const startYearMonth = Temporal.PlainYearMonth.from({
+    year: start.year,
+    month: quarterStartMonth(start.month),
+    calendar: start.calendarId
+  });
+  const endYearMonth = Temporal.PlainYearMonth.from({
+    year: end.year,
+    month: quarterStartMonth(end.month),
+    calendar: start.calendarId
+  });
+  const out = [];
+  let current = startYearMonth;
+  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {
+    out.push(make(current));
+    const next = current.add({ months: 3 });
+    current = next.with({ month: quarterStartMonth(next.month) });
+  }
+  return out;
+}
+
+export {
+  eachQuarterOfInterval
+};
+//# sourceMappingURL=chunk-4VWUTQKP.js.map

package/dist/chunk-4VWUTQKP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachQuarterOfInterval.ts"],"sourcesContent":["import { isPlainDateAfter } from './isPlainDateAfter';\nimport { Temporal } from \"./shared/temporal\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array with the start of each quarter within the interval, inclusive\n * of both the start and end quarters.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec. Each element\n * is the first moment of the quarter (1st day of the quarter's starting month at\n * midnight) for Instant/ZonedDateTime inputs, or the first day as a PlainDate for\n * PlainDate inputs.\n *\n * For Instant inputs, UTC is used. For ZonedDateTime inputs, the timezone of the\n * start date is preserved. PlainDate inputs need no timezone and return PlainDate[].\n *\n * @param interval - The interval with start and end\n * @returns Array of ZonedDateTime (or PlainDate) at the start of each quarter\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-02-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-11-20T14:00:00+00:00[UTC]');\n * eachQuarterOfInterval({ start, end });\n * // [2025-01-01…, 2025-04-01…, 2025-07-01…, 2025-10-01…]\n * ```\n *\n * @example\n * ```ts\n * // PlainDate interval returns PlainDate quarter starts (no timezone)\n * eachQuarterOfInterval({\n *   start: Temporal.PlainDate.from('2025-02-15'),\n *   end: Temporal.PlainDate.from('2025-08-20'),\n * });\n * // [2025-01-01, 2025-04-01, 2025-07-01]\n * ```\n */\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n}): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    return eachQuarterStart(interval.start, interval.end.withCalendar(interval.start.calendarId), (ym) => ym.toPlainDate({ day: 1 }));\n  }\n\n  const startZoned = normalizeTemporalInput(\n    interval.start as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  const endZoned = normalizeTemporalInput(\n    interval.end as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n  const timezone = startZoned.timeZoneId;\n\n  return eachQuarterStart(startZoned, endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId), (ym) =>\n    ym.toPlainDate({ day: 1 }).toZonedDateTime({\n      timeZone: timezone,\n      plainTime: new Temporal.PlainTime(),\n    }),\n  );\n}\n\n/**\n * Walks quarter-aligned year-months from start to end (inclusive) and maps each\n * to a result. Both bounds are snapped to their quarter's starting month.\n */\nfunction eachQuarterStart<T>(\n  start: { year: number; month: number; calendarId: string },\n  end: { year: number; month: number; calendarId: string },\n  make: (ym: Temporal.PlainYearMonth) => T,\n): T[] {\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: start.year,\n    month: quarterStartMonth(start.month),\n    calendar: start.calendarId,\n  });\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: end.year,\n    month: quarterStartMonth(end.month),\n    calendar: start.calendarId,\n  });\n\n  const out: T[] = [];\n  let current = startYearMonth;\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    out.push(make(current));\n    // A calendar can have thirteen months; realign after crossing its year end.\n    const next = current.add({ months: 3 });\n    current = next.with({ month: quarterStartMonth(next.month) });\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkDO,SAAS,sBAAsB,UAGc;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,WAAO,iBAAiB,SAAS,OAAO,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;AAAA,EAClI;AAEA,QAAM,aAAa;AAAA,IACjB,SAAS;AAAA,EACX;AACA,QAAM,WAAW;AAAA,IACf,SAAS;AAAA,EACX;AACA,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AACrE,QAAM,WAAW,WAAW;AAE5B,SAAO;AAAA,IAAiB;AAAA,IAAY,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AAAA,IAAG,CAAC,OACxG,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,EAAE,gBAAgB;AAAA,MACzC,UAAU;AAAA,MACV,WAAW,IAAI,SAAS,UAAU;AAAA,IACpC,CAAC;AAAA,EACH;AACF;AAMA,SAAS,iBACP,OACA,KACA,MACK;AACL,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,MAAM;AAAA,IACZ,OAAO,kBAAkB,MAAM,KAAK;AAAA,IACpC,UAAU,MAAM;AAAA,EAClB,CAAC;AACD,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,IAAI;AAAA,IACV,OAAO,kBAAkB,IAAI,KAAK;AAAA,IAClC,UAAU,MAAM;AAAA,EAClB,CAAC;AAED,QAAM,MAAW,CAAC;AAClB,MAAI,UAAU;AACd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,QAAI,KAAK,KAAK,OAAO,CAAC;AAEtB,UAAM,OAAO,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AACtC,cAAU,KAAK,KAAK,EAAE,OAAO,kBAAkB,KAAK,KAAK,EAAE,CAAC;AAAA,EAC9D;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-GR7322AQ.js → chunk-525OLFRD.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/getQuarter.ts
 function getQuarter(input) {
@@ -17,4 +17,4 @@ function getQuarter(input) {
 export {
   getQuarter
 };
-//# sourceMappingURL=chunk-GR7322AQ.js.map
+//# sourceMappingURL=chunk-525OLFRD.js.map

package/dist/chunk-525OLFRD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterOfMonth } from \"./shared/quarter\";\n\n/**\n * Returns the quarter (1-4) that a datetime or date falls in.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * A quarter is intrinsic to the calendar date, so no timezone is ever needed.\n * `Instant` inputs are interpreted in UTC; `ZonedDateTime` inputs use their own\n * timezone; `PlainDate` inputs use their calendar month directly.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @returns The quarter number: 1, 2, 3, or 4\n *\n * @example\n * ```ts\n * getQuarter(Temporal.Instant.from('2025-05-15T12:00:00Z'));   // 2\n * getQuarter(Temporal.PlainDate.from('2025-11-15'));           // 4\n * ```\n */\nexport function getQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n): 1 | 2 | 3 | 4 {\n  const month = isPlainDate(input) ? input.month : normalizeTemporalInput(input).month;\n  return quarterOfMonth(month);\n}\n"],"mappings":";;;;;;;;;;;AAsBO,SAAS,WACd,OACe;AACf,QAAM,QAAQ,YAAY,KAAK,IAAI,MAAM,QAAQ,uBAAuB,KAAK,EAAE;AAC/E,SAAO,eAAe,KAAK;AAC7B;","names":[]}

package/dist/{chunk-PYALKKWZ.js → chunk-57MHNRCU.js}

@@ -1,12 +1,12 @@
 import {
   isAfter
-} from "./chunk-LSKER4FN.js";
+} from "./chunk-CDKIT7D3.js";
 import {
   isBefore
-} from "./chunk-EVEMK2K2.js";
+} from "./chunk-BMX7CIRD.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isWithinInterval.ts
 function isWithinInterval(date, interval) {
@@ -19,4 +19,4 @@ function isWithinInterval(date, interval) {
 export {
   isWithinInterval
 };
-//# sourceMappingURL=chunk-PYALKKWZ.js.map
+//# sourceMappingURL=chunk-57MHNRCU.js.map

package/dist/chunk-57MHNRCU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isWithinInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[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:00+00:00[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":";;;;;;;;;;;AAsEO,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-CSOSM46M.js → chunk-5WHGX2J3.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isSameSecond.ts
 function isSameSecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameSecond(date1, date2) {
 export {
   isSameSecond
 };
-//# sourceMappingURL=chunk-CSOSM46M.js.map
+//# sourceMappingURL=chunk-5WHGX2J3.js.map

package/dist/chunk-5WHGX2J3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameSecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same second.\n * Compares the year, month, day, hour, minute, and second fields directly.\n * Ignores sub-second precision (milliseconds, microseconds, nanoseconds).\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same second, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same second\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999+00:00[UTC]');\n *\n * isSameSecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different seconds\n * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45+00:00[UTC]');\n * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46+00:00[UTC]');\n *\n * isSameSecond(sec45, sec46); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local seconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local seconds from each person's perspective\n * isSameSecond(ny, tokyo); // false (14:30:45 in NY, 04:30:45 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameSecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameSecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.999Z');\n *\n * isSameSecond(instant1, instant2); // true (both 14:30:45 in UTC)\n * ```\n */\nexport function isSameSecond(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,aACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO;AAE7B;","names":[]}

package/dist/chunk-67XABEBT.js

@@ -0,0 +1,56 @@
+import {
+  isPlainDateBefore
+} from "./chunk-ZM32S3YU.js";
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachYearOfInterval.ts
+function eachYearOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    if (isPlainDateAfter(interval.start, interval.end)) return [];
+    const end = interval.end.withCalendar(interval.start.calendarId);
+    const last = end.with({ month: 1, day: 1 });
+    let current = interval.start.with({ month: 1, day: 1 });
+    const dates = [];
+    while (isPlainDateBefore(current, last)) {
+      dates.push(current);
+      current = current.add({ years: 1 });
+    }
+    dates.push(current);
+    return dates;
+  }
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const timezone = startZoned.timeZoneId;
+  const startYear = startZoned.year;
+  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);
+  const endYear = endInTimezone.year;
+  const years = [];
+  for (let year = startYear; year <= endYear; year++) {
+    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1, calendar: startZoned.calendarId });
+    years.push(
+      firstOfYear.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: new Temporal.PlainTime()
+      })
+    );
+  }
+  return years;
+}
+
+export {
+  eachYearOfInterval
+};
+//# sourceMappingURL=chunk-67XABEBT.js.map

package/dist/chunk-67XABEBT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachYearOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * PlainDate endpoints return date-only period starts in the start calendar.\n * Mixed date-only/timeline endpoints are rejected. Reversed endpoints return [].\n *\n * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array of ZonedDateTime objects for each 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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-03-20T14:00:00+00:00[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2022-01-01T00:00:00+00:00[UTC],\n * //   2023-01-01T00:00:00+00:00[UTC],\n * //   2024-01-01T00:00:00+00:00[UTC],\n * //   2025-01-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single year\n * const start = Temporal.ZonedDateTime.from('2025-01-15T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-12-31T23:59:59+00:00[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [2025-01-01T00:00:00+00:00[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.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachYearOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachYearOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n}): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    const end = interval.end.withCalendar(interval.start.calendarId);\n    const last = end.with({ month: 1, day: 1 });\n    let current = interval.start.with({ month: 1, day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ years: 1 });\n    }\n    dates.push(current);\n    return dates;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const timezone = startZoned.timeZoneId;\n  const startYear = startZoned.year;\n\n  // Get end year in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\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, calendar: startZoned.calendarId });\n    years.push(\n      firstOfYear.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n  }\n\n  return years;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoEO,SAAS,mBAAmB,UAGiB;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,UAAM,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAC/D,UAAM,OAAO,IAAI,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AAC1C,QAAI,UAAU,SAAS,MAAM,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACtD,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkB,SAAS,IAAI,GAAG;AACvC,YAAM,KAAK,OAAO;AAClB,gBAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAK,OAAO;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,WAAW,WAAW;AAC5B,QAAM,YAAY,WAAW;AAG7B,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,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,GAAG,UAAU,WAAW,WAAW,CAAC;AACvG,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-VS2VCQLP.js → chunk-6QH4NCPA.js}

@@ -1,6 +1,6 @@
 import {
   addMilliseconds
-} from "./chunk-FCJO72WG.js";
+} from "./chunk-AUOZACFS.js";
 
 // src/subMilliseconds.ts
 function subMilliseconds(input, milliseconds) {
@@ -10,4 +10,4 @@ function subMilliseconds(input, milliseconds) {
 export {
   subMilliseconds
 };
-//# sourceMappingURL=chunk-VS2VCQLP.js.map
+//# sourceMappingURL=chunk-6QH4NCPA.js.map

package/dist/chunk-6QH4NCPA.js.map

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

package/dist/{chunk-IONQ6TOR.js → chunk-6QOLNYFY.js}

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