@gobrand/tiempo 3.0.1 → 3.1.3

package/dist/chunk-K6NQZIAW.js.map

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

package/dist/chunk-K7CLBBBM.js

@@ -0,0 +1,36 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/businessDays.ts
+function isWeekendDay(dayOfWeek) {
+  return dayOfWeek >= 6;
+}
+function addWeekdays(start, days) {
+  if (!Number.isInteger(days)) {
+    throw new RangeError("Business day counts must be integers");
+  }
+  const step = days < 0 ? -1 : 1;
+  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));
+  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });
+  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0; ) {
+    result = result.add({ days: step });
+    if (!isWeekendDay(result.dayOfWeek)) remaining--;
+  }
+  return result;
+}
+function isoDate(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();
+  return Temporal.PlainDate.from(date.toString()).withCalendar("iso8601");
+}
+
+export {
+  isWeekendDay,
+  addWeekdays,
+  isoDate
+};
+//# sourceMappingURL=chunk-K7CLBBBM.js.map

package/dist/chunk-K7CLBBBM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/businessDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\n/**\n * @internal\n * Saturday (6) and Sunday (7) in Temporal's Monday-based dayOfWeek.\n */\nexport function isWeekendDay(dayOfWeek: number): boolean {\n  return dayOfWeek >= 6;\n}\n\n/**\n * @internal\n * Adds days counting only Monday–Friday. The result keeps the input's type,\n * time of day, and timezone.\n */\nexport function addWeekdays<T extends { dayOfWeek: number; add(duration: { days: number }): T }>(\n  start: T,\n  days: number\n): T {\n  if (!Number.isInteger(days)) {\n    throw new RangeError('Business day counts must be integers');\n  }\n  const step = days < 0 ? -1 : 1;\n  // Any 7 consecutive days hold exactly 5 weekdays, so jump whole weeks. Keep\n  // at least one business day to walk so a weekend landing is never returned.\n  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));\n  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });\n  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0;) {\n    result = result.add({ days: step });\n    if (!isWeekendDay(result.dayOfWeek)) remaining--;\n  }\n  return result;\n}\n\n/**\n * @internal\n * The calendar date of a value as an ISO PlainDate from this library's\n * Temporal implementation. Instant uses UTC; ZonedDateTime uses its timezone.\n */\nexport function isoDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): Temporal.PlainDate {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();\n  return Temporal.PlainDate.from(date.toString()).withCalendar('iso8601');\n}\n"],"mappings":";;;;;;;;;AAOO,SAAS,aAAa,WAA4B;AACvD,SAAO,aAAa;AACtB;AAOO,SAAS,YACd,OACA,MACG;AACH,MAAI,CAAC,OAAO,UAAU,IAAI,GAAG;AAC3B,UAAM,IAAI,WAAW,sCAAsC;AAAA,EAC7D;AACA,QAAM,OAAO,OAAO,IAAI,KAAK;AAG7B,QAAM,YAAY,KAAK,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC;AAClE,MAAI,SAAS,cAAc,IAAI,QAAQ,MAAM,IAAI,EAAE,MAAM,OAAO,YAAY,EAAE,CAAC;AAC/E,WAAS,YAAY,KAAK,IAAI,IAAI,IAAI,YAAY,GAAG,YAAY,KAAI;AACnE,aAAS,OAAO,IAAI,EAAE,MAAM,KAAK,CAAC;AAClC,QAAI,CAAC,aAAa,OAAO,SAAS,EAAG;AAAA,EACvC;AACA,SAAO;AACT;AAOO,SAAS,QACd,OACoB;AACpB,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK,EAAE,YAAY;AACpF,SAAO,SAAS,UAAU,KAAK,KAAK,SAAS,CAAC,EAAE,aAAa,SAAS;AACxE;","names":[]}

package/dist/{chunk-NX7MXLFS.js → chunk-KTMCYEU5.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/isPlainTimeBefore.ts
 function isPlainTimeBefore(time1, time2) {
@@ -10,4 +10,4 @@ function isPlainTimeBefore(time1, time2) {
 export {
   isPlainTimeBefore
 };
-//# sourceMappingURL=chunk-NX7MXLFS.js.map
+//# sourceMappingURL=chunk-KTMCYEU5.js.map

package/dist/{chunk-5Y5JH32Z.js → chunk-KYS54PLJ.js}

@@ -1,9 +1,9 @@
 import {
   addQuarters
-} from "./chunk-UQ2F3I2S.js";
+} from "./chunk-QDY2KMYX.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/subQuarters.ts
 function subQuarters(input, quarters) {
@@ -13,4 +13,4 @@ function subQuarters(input, quarters) {
 export {
   subQuarters
 };
-//# sourceMappingURL=chunk-5Y5JH32Z.js.map
+//# sourceMappingURL=chunk-KYS54PLJ.js.map

package/dist/chunk-KYS54PLJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { addQuarters } from \"./addQuarters\";\n\n/**\n * Subtracts the specified number of quarters (3-month blocks) from a datetime or date.\n *\n * This is a convenience wrapper around addQuarters with the count negated.\n * PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param quarters - Number of quarters to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * subQuarters(instant, 2);\n * // 2025-01-20T12:00:00+00:00[UTC] (6 months earlier)\n * ```\n *\n * @example\n * ```ts\n * subQuarters(Temporal.PlainDate.from('2025-07-20'), 1);\n * // 2025-04-20\n * ```\n */\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function subQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Branch so each call resolves to the matching addQuarters overload.\n  return isPlainDate(input) ? addQuarters(input, -quarters) : addQuarters(input, -quarters);\n}\n"],"mappings":";;;;;;;;AA+BO,SAAS,YACd,OACA,UAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,YAAY,OAAO,CAAC,QAAQ,IAAI,YAAY,OAAO,CAAC,QAAQ;AAC1F;","names":[]}

package/dist/chunk-KZCSP3DU.js

@@ -0,0 +1,28 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/differenceInMonths.ts
+function differenceInMonths(laterDate, earlierDate, options) {
+  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {
+    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {
+      throw new TypeError("PlainDate differences require two PlainDate values");
+    }
+    const duration2 = earlierDate.until(laterDate.toString(), { largestUnit: "days" });
+    const precise2 = duration2.total({ unit: "months", relativeTo: earlierDate });
+    return options?.fractional ? precise2 : Math.trunc(precise2);
+  }
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1.toString(), { largestUnit: "hours" });
+  const precise = duration.total({ unit: "months", relativeTo: zoned2 });
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInMonths
+};
+//# sourceMappingURL=chunk-KZCSP3DU.js.map

package/dist/chunk-KZCSP3DU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMonths.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Two PlainDates use calendar arithmetic without a timezone. Their calendars must match.\n * Native and polyfill inputs may be mixed within the same Temporal domain.\n *\n * Returns the number of months between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * months with different numbers of days (28, 29, 30, or 31).\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of months between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInMonths(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-04:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-15T15:00:00-05:00[America/New_York]');\n *\n * differenceInMonths(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-02-05T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInMonths(later, earlier);                     // 0\n * differenceInMonths(later, earlier, { fractional: true }); // ~0.5\n * ```\n */\nexport function differenceInMonths(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions\n): number;\nexport function differenceInMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number;\nexport function differenceInMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: DifferenceOptions\n): number {\n  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {\n    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {\n      throw new TypeError('PlainDate differences require two PlainDate values');\n    }\n    const duration = earlierDate.until(laterDate.toString(), { largestUnit: 'days' });\n    const precise = duration.total({ unit: 'months', relativeTo: earlierDate });\n    return options?.fractional ? precise : Math.trunc(precise);\n  }\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // A canonical string preserves zone, calendar, and precision across implementations.\n  const duration = zoned2.until(zoned1.toString(), { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'months', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AA2DO,SAAS,mBACd,WACA,aACA,SACQ;AACR,MAAI,YAAY,SAAS,KAAK,YAAY,WAAW,GAAG;AACtD,QAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,WAAW,GAAG;AACxD,YAAM,IAAI,UAAU,oDAAoD;AAAA,IAC1E;AACA,UAAMA,YAAW,YAAY,MAAM,UAAU,SAAS,GAAG,EAAE,aAAa,OAAO,CAAC;AAChF,UAAMC,WAAUD,UAAS,MAAM,EAAE,MAAM,UAAU,YAAY,YAAY,CAAC;AAC1E,WAAO,SAAS,aAAaC,WAAU,KAAK,MAAMA,QAAO;AAAA,EAC3D;AACA,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,QAAM,WAAW,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,aAAa,QAAQ,CAAC;AACzE,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,UAAU,YAAY,OAAO,CAAC;AACrE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":["duration","precise"]}

package/dist/chunk-LMOAA73F.js

@@ -0,0 +1,28 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/differenceInYears.ts
+function differenceInYears(laterDate, earlierDate, options) {
+  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {
+    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {
+      throw new TypeError("PlainDate differences require two PlainDate values");
+    }
+    const duration2 = earlierDate.until(laterDate.toString(), { largestUnit: "days" });
+    const precise2 = duration2.total({ unit: "years", relativeTo: earlierDate });
+    return options?.fractional ? precise2 : Math.trunc(precise2);
+  }
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1.toString(), { largestUnit: "hours" });
+  const precise = duration.total({ unit: "years", relativeTo: zoned2 });
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInYears
+};
+//# sourceMappingURL=chunk-LMOAA73F.js.map

package/dist/chunk-LMOAA73F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInYears.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Two PlainDates use calendar arithmetic without a timezone. Their calendars must match.\n * Native and polyfill inputs may be mixed within the same Temporal domain.\n *\n * Returns the number of years between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * leap years (366 days) and regular years (365 days).\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of years between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2028-01-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2030-06-15T15:00:00-04:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-04:00[America/New_York]');\n *\n * differenceInYears(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier);                     // 0\n * differenceInYears(later, earlier, { fractional: true }); // ~0.5\n * ```\n */\nexport function differenceInYears(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions\n): number;\nexport function differenceInYears(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number;\nexport function differenceInYears(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: DifferenceOptions\n): number {\n  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {\n    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {\n      throw new TypeError('PlainDate differences require two PlainDate values');\n    }\n    const duration = earlierDate.until(laterDate.toString(), { largestUnit: 'days' });\n    const precise = duration.total({ unit: 'years', relativeTo: earlierDate });\n    return options?.fractional ? precise : Math.trunc(precise);\n  }\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // A canonical string preserves zone, calendar, and precision across implementations.\n  const duration = zoned2.until(zoned1.toString(), { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'years', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AA2DO,SAAS,kBACd,WACA,aACA,SACQ;AACR,MAAI,YAAY,SAAS,KAAK,YAAY,WAAW,GAAG;AACtD,QAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,WAAW,GAAG;AACxD,YAAM,IAAI,UAAU,oDAAoD;AAAA,IAC1E;AACA,UAAMA,YAAW,YAAY,MAAM,UAAU,SAAS,GAAG,EAAE,aAAa,OAAO,CAAC;AAChF,UAAMC,WAAUD,UAAS,MAAM,EAAE,MAAM,SAAS,YAAY,YAAY,CAAC;AACzE,WAAO,SAAS,aAAaC,WAAU,KAAK,MAAMA,QAAO;AAAA,EAC3D;AACA,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,QAAM,WAAW,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,aAAa,QAAQ,CAAC;AACzE,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":["duration","precise"]}

package/dist/{chunk-2E4KCD3Y.js → chunk-LQ3EQYIX.js}

@@ -1,8 +1,9 @@
 import {
   Temporal,
   isInstant,
+  isPlainDate,
   isZonedDateTime
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toPlainDate.ts
 var PLAIN_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
@@ -37,10 +38,10 @@ function toPlainDate(input, timezone) {
     }
     throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
   }
-  return Temporal.PlainDate.from(input);
+  return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);
 }
 
 export {
   toPlainDate
 };
-//# sourceMappingURL=chunk-2E4KCD3Y.js.map
+//# sourceMappingURL=chunk-LQ3EQYIX.js.map

package/dist/chunk-LQ3EQYIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toPlainDate.ts"],"sourcesContent":["import { Temporal, isInstant, isZonedDateTime, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\n\n// Pattern to detect plain date strings: YYYY-MM-DD\nconst PLAIN_DATE_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * Parse a plain date or extract the calendar date from a datetime.\n *\n * @param input - A PlainDateLike object, plain date string (YYYY-MM-DD), ZonedDateTime, or datetime input requiring timezone\n * @param timezone - IANA timezone identifier. Required for ISO strings, Date, and Instant inputs.\n * @returns A Temporal.PlainDate representing the calendar date\n *\n * @example\n * ```typescript\n * import { toPlainDate, toZonedTime } from '@gobrand/tiempo';\n *\n * // From PlainDateLike object (no timezone needed)\n * const date = toPlainDate({ year: 2025, month: 1, day: 20 }); // 2025-01-20\n *\n * // From plain date string (no timezone needed)\n * const date2 = toPlainDate(\"2025-01-20\"); // 2025-01-20\n *\n * // From ZonedDateTime (no timezone needed)\n * const zdt = toZonedTime(\"2025-01-20T15:30:00Z\", \"America/New_York\");\n * const date3 = toPlainDate(zdt); // 2025-01-20\n *\n * // From UTC string with timezone\n * const date4 = toPlainDate(\"2025-01-20T15:30:00Z\", \"America/New_York\"); // 2025-01-20\n *\n * // From Date with timezone\n * const jsDate = new Date(\"2025-01-20T15:30:00.000Z\");\n * const date5 = toPlainDate(jsDate, \"Europe/London\"); // 2025-01-20\n *\n * // Date boundary crossing: 23:00 UTC on Jan 20 → Jan 21 in Tokyo\n * const date6 = toPlainDate(\"2025-01-20T23:00:00Z\", \"Asia/Tokyo\"); // 2025-01-21\n * ```\n */\nexport function toPlainDate(input: Temporal.ZonedDateTime): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime,\n  timezone: Timezone\n): Temporal.PlainDate;\nexport function toPlainDate(input: Temporal.PlainDateLike | string): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDateLike,\n  timezone?: Timezone\n): Temporal.PlainDate {\n  // ZonedDateTime without timezone override\n  if (isZonedDateTime(input) && timezone === undefined) {\n    return input.toPlainDate();\n  }\n\n  // Date requires timezone\n  if (input instanceof Date) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // Instant requires timezone\n  if (isInstant(input)) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return input.toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // ZonedDateTime with timezone override\n  if (isZonedDateTime(input)) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return input.toInstant().toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // String: ISO datetime (requires timezone) or plain date (no timezone)\n  if (typeof input === 'string') {\n    if (timezone !== undefined) {\n      return Temporal.Instant.from(input).toZonedDateTimeISO(timezone).toPlainDate();\n    }\n    if (PLAIN_DATE_PATTERN.test(input)) {\n      return Temporal.PlainDate.from(input);\n    }\n    throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n  }\n\n  // Foreign PlainDate objects expose calendarId, while property bags use calendar.\n  // A canonical string keeps the ISO date and calendar together across implementations.\n  return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);\n}\n"],"mappings":";;;;;;;;AAIA,IAAM,qBAAqB;AAwCpB,SAAS,YACd,OACA,UACoB;AAEpB,MAAI,gBAAgB,KAAK,KAAK,aAAa,QAAW;AACpD,WAAO,MAAM,YAAY;AAAA,EAC3B;AAGA,MAAI,iBAAiB,MAAM;AACzB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,SAAS,QAAQ,KAAK,MAAM,YAAY,CAAC,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EAC7F;AAGA,MAAI,UAAU,KAAK,GAAG;AACpB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,MAAM,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACxD;AAGA,MAAI,gBAAgB,KAAK,GAAG;AAC1B,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,MAAM,UAAU,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACpE;AAGA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,aAAa,QAAW;AAC1B,aAAO,SAAS,QAAQ,KAAK,KAAK,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,IAC/E;AACA,QAAI,mBAAmB,KAAK,KAAK,GAAG;AAClC,aAAO,SAAS,UAAU,KAAK,KAAK;AAAA,IACtC;AACA,UAAM,IAAI,MAAM,2FAA2F;AAAA,EAC7G;AAIA,SAAO,SAAS,UAAU,KAAK,YAAY,KAAK,IAAI,MAAM,SAAS,IAAI,KAAK;AAC9E;","names":[]}

package/dist/{chunk-ELUSLRWQ.js → chunk-LRIVI5ZC.js}

@@ -1,7 +1,7 @@
 import {
   Temporal,
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toZonedTime.ts
 function toZonedTime(input, timezone) {
@@ -23,4 +23,4 @@ function toZonedTime(input, timezone) {
 export {
   toZonedTime
 };
-//# sourceMappingURL=chunk-ELUSLRWQ.js.map
+//# sourceMappingURL=chunk-LRIVI5ZC.js.map

package/dist/{chunk-M4KDJ4I4.js → chunk-LXOLIOAD.js}

@@ -2,7 +2,7 @@ import {
   Temporal,
   isInstant,
   isZonedDateTime
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toPlainTime.ts
 var PLAIN_TIME_PATTERN = /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/;
@@ -43,4 +43,4 @@ function toPlainTime(input, timezone) {
 export {
   toPlainTime
 };
-//# sourceMappingURL=chunk-M4KDJ4I4.js.map
+//# sourceMappingURL=chunk-LXOLIOAD.js.map

package/dist/{chunk-3TS3D7WD.js → chunk-MLHFNZEA.js}

@@ -1,12 +1,12 @@
 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/startOfWeek.ts
 function startOfWeek(input, timezone) {
@@ -23,4 +23,4 @@ function startOfWeek(input, timezone) {
 export {
   startOfWeek
 };
-//# sourceMappingURL=chunk-3TS3D7WD.js.map
+//# sourceMappingURL=chunk-MLHFNZEA.js.map

package/dist/chunk-MLHFNZEA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the first boundary of the week (Monday).\n * Uses ISO 8601 week definition: weeks start on Monday.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at Monday 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const start = startOfWeek(instant);\n * // 2025-01-20T00:00:00+00:00[UTC] (same day, it's already Monday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const start = startOfWeek(zoned);\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date);\n * // 2025-01-20 (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n */\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.subtract({ days: input.dayOfWeek - 1 });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to subtract to get to Monday\n  const daysToSubtract = dayOfWeek - 1;\n\n  // Go to Monday, then get start of that day\n  const monday = zonedDateTime.subtract({ days: daysToSubtract });\n\n  return monday.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AAqDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,SAAS,EAAE,MAAM,MAAM,YAAY,EAAE,CAAC;AAAA,EACrD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,iBAAiB,YAAY;AAGnC,QAAM,SAAS,cAAc,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9D,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/chunk-MVGBYHG5.js

@@ -0,0 +1,16 @@
+import {
+  addMonths
+} from "./chunk-ZXKU4SKR.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subMonths.ts
+function subMonths(input, months) {
+  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);
+}
+
+export {
+  subMonths
+};
+//# sourceMappingURL=chunk-MVGBYHG5.js.map

package/dist/chunk-MVGBYHG5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates 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 months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00+00:00[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}

package/dist/chunk-MWUVGTKC.js

@@ -0,0 +1,23 @@
+import {
+  today
+} from "./chunk-NL5MQVGD.js";
+import {
+  toPlainDate
+} from "./chunk-LQ3EQYIX.js";
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/relativeDay.ts
+function isDaysFromToday(input, timezone, days) {
+  const date = isPlainDate(input) ? input : toPlainDate(input, timezone);
+  return compare(date, today(timezone).add({ days })) === 0;
+}
+
+export {
+  isDaysFromToday
+};
+//# sourceMappingURL=chunk-MWUVGTKC.js.map

package/dist/chunk-MWUVGTKC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/relativeDay.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './temporal';\nimport type { Timezone } from '../types';\nimport { compare } from './compare';\nimport { toPlainDate } from '../toPlainDate';\nimport { today } from '../today';\n\n/**\n * @internal\n * True when the input's calendar date in `timezone` is `days` away from\n * today's date in that same timezone. PlainDate inputs are already dates.\n */\nexport function isDaysFromToday(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone,\n  days: number\n): boolean {\n  const date = isPlainDate(input) ? input : toPlainDate(input, timezone);\n  return compare(date, today(timezone).add({ days })) === 0;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWO,SAAS,gBACd,OACA,UACA,MACS;AACT,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,YAAY,OAAO,QAAQ;AACrE,SAAO,QAAQ,MAAM,MAAM,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM;AAC1D;","names":[]}

package/dist/{chunk-OSBVYUOQ.js → chunk-MXYAZTDE.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/endOfQuarter.ts
 function endOfQuarter(input, timezone) {
@@ -32,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-OSBVYUOQ.js.map
+//# sourceMappingURL=chunk-MXYAZTDE.js.map

package/dist/chunk-MXYAZTDE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport type { Timezone } from \"./types\";\nimport { getEndOfDay } from \"./shared/endOfDay\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the last moment of the quarter\n * (last day of the quarter's ending month at 23:59:59.999999999).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the quarter at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const end = endOfQuarter(instant);\n * // 2025-06-30T23:59:59.999999999+00:00[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 = endOfQuarter(zoned);\n * // 2025-03-31T23:59:59.999999999-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From a PlainDate in a timezone\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const end = endOfQuarter(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function endOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfQuarter(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → last day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    const endMonth = input.with({\n      month: quarterStartMonth(input.month) + 2,\n      day: 1,\n    });\n    return endMonth.with({ day: endMonth.daysInMonth });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const endMonth = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month) + 2,\n    day: 1,\n  });\n  const lastDay = endMonth.with({ day: endMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;;;;AA4CO,SAAS,aACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,YAAW,MAAM,KAAK;AAAA,MAC1B,OAAO,kBAAkB,MAAM,KAAK,IAAI;AAAA,MACxC,KAAK;AAAA,IACP,CAAC;AACD,WAAOA,UAAS,KAAK,EAAE,KAAKA,UAAS,YAAY,CAAC;AAAA,EACpD;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK,IAAI;AAAA,IAChD,KAAK;AAAA,EACP,CAAC;AACD,QAAM,UAAU,SAAS,KAAK,EAAE,KAAK,SAAS,YAAY,CAAC;AAC3D,SAAO,YAAY,OAAO;AAC5B;","names":["endMonth"]}

package/dist/{chunk-7SCQV77A.js → chunk-NGS5UKDW.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/startOfQuarter.ts
 function startOfQuarter(input, timezone) {
@@ -24,4 +24,4 @@ function startOfQuarter(input, timezone) {
 export {
   startOfQuarter
 };
-//# sourceMappingURL=chunk-7SCQV77A.js.map
+//# sourceMappingURL=chunk-NGS5UKDW.js.map

package/dist/chunk-NGS5UKDW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport type { Timezone } from \"./types\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the first moment of the quarter\n * (first day of the quarter's starting month at midnight).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the 1st day of the quarter at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const start = startOfQuarter(instant);\n * // 2025-04-01T00:00:00+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-08-15T15:30:00-04:00[America/New_York]');\n * const start = startOfQuarter(zoned);\n * // 2025-07-01T00:00:00-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From a PlainDate in a timezone\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const start = startOfQuarter(date, 'America/New_York');\n * // 2025-10-01T00:00:00-04:00[America/New_York]\n * ```\n */\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfQuarter(\n  input: Temporal.PlainDate,\n  timezone: Timezone,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → first day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ month: quarterStartMonth(input.month), day: 1 });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month),\n    day: 1,\n  });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AA8CO,SAAS,eACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,OAAO,kBAAkB,MAAM,KAAK,GAAG,KAAK,EAAE,CAAC;AAAA,EACrE;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK;AAAA,IAC5C,KAAK;AAAA,EACP,CAAC;AACD,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/{chunk-PX2I4GCF.js → chunk-NL5MQVGD.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/today.ts
 function today(timezone) {
@@ -10,4 +10,4 @@ function today(timezone) {
 export {
   today
 };
-//# sourceMappingURL=chunk-PX2I4GCF.js.map
+//# sourceMappingURL=chunk-NL5MQVGD.js.map

package/dist/chunk-NMMMAMKP.js

@@ -0,0 +1,9 @@
+// src/shared/endOfDay.ts
+function getEndOfDay(zonedDateTime) {
+  return zonedDateTime.startOfDay().add({ days: 1 }).startOfDay().subtract({ nanoseconds: 1 });
+}
+
+export {
+  getEndOfDay
+};
+//# sourceMappingURL=chunk-NMMMAMKP.js.map

package/dist/chunk-NMMMAMKP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/endOfDay.ts"],"sourcesContent":["import type { Temporal } from './temporal';\n\n/**\n * Internal helper: Returns the last nanosecond of a given ZonedDateTime's day.\n * Used by endOfDay() and endOfWeek() to ensure consistent DST-safe behavior.\n */\nexport function getEndOfDay(\n  zonedDateTime: Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  return zonedDateTime\n    .startOfDay()\n    .add({ days: 1 })\n    .startOfDay()\n    .subtract({ nanoseconds: 1 });\n}\n"],"mappings":";AAMO,SAAS,YACd,eACwB;AACxB,SAAO,cACJ,WAAW,EACX,IAAI,EAAE,MAAM,EAAE,CAAC,EACf,WAAW,EACX,SAAS,EAAE,aAAa,EAAE,CAAC;AAChC;","names":[]}

package/dist/{chunk-S7L5KBI4.js → chunk-NOWUJERX.js}

@@ -1,9 +1,9 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 
 // src/endOfDay.ts
 function endOfDay(input, timezone) {
@@ -14,4 +14,4 @@ function endOfDay(input, timezone) {
 export {
   endOfDay
 };
-//# sourceMappingURL=chunk-S7L5KBI4.js.map
+//# sourceMappingURL=chunk-NOWUJERX.js.map

package/dist/chunk-NOWUJERX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last nanosecond of the day.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const end = endOfDay(instant);\n * // 2025-01-20T23:59:59.999999999+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const end = endOfDay(zoned);\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-01-20');\n * const end = endOfDay(date, 'America/New_York');\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return getEndOfDay(zonedDateTime);\n}\n"],"mappings":";;;;;;;;AA0CO,SAAS,SACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,YAAY,aAAa;AAClC;","names":[]}

package/dist/{chunk-CCVPCHUO.js → chunk-NVFFQJEW.js}

@@ -1,12 +1,12 @@
 import {
   isAfter
-} from "./chunk-LSKER4FN.js";
+} from "./chunk-CDKIT7D3.js";
 import {
   nowZoned
-} from "./chunk-6RETOV6A.js";
+} from "./chunk-4GEF7B7W.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isFuture.ts
 function isFuture(date) {
@@ -17,4 +17,4 @@ function isFuture(date) {
 export {
   isFuture
 };
-//# sourceMappingURL=chunk-CCVPCHUO.js.map
+//# sourceMappingURL=chunk-NVFFQJEW.js.map

package/dist/chunk-NVFFQJEW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isFuture.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\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-NZLRMN35.js

@@ -0,0 +1,13 @@
+import {
+  isDaysFromToday
+} from "./chunk-MWUVGTKC.js";
+
+// src/isToday.ts
+function isToday(date, timezone) {
+  return isDaysFromToday(date, timezone, 0);
+}
+
+export {
+  isToday
+};
+//# sourceMappingURL=chunk-NZLRMN35.js.map

package/dist/chunk-NZLRMN35.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isToday.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { isDaysFromToday } from './shared/relativeDay';\n\n/**\n * Returns true if the value falls on today's date in the given timezone.\n *\n * \"Today\" depends on where you are, so the timezone is required. Instant and\n * ZonedDateTime inputs are converted to that timezone before taking their\n * date. PlainDate inputs are compared to today's date there directly.\n *\n * @param date - An Instant, ZonedDateTime, or PlainDate\n * @param timezone - The timezone that defines \"today\"\n * @returns true if date is today in timezone, false otherwise\n *\n * @example\n * ```ts\n * isToday(Temporal.Now.instant(), 'America/New_York'); // true\n * isToday(Temporal.Now.instant().add({ hours: 48 }), 'America/New_York'); // false\n * ```\n */\nexport function isToday(\n  date: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone\n): boolean {\n  return isDaysFromToday(date, timezone, 0);\n}\n"],"mappings":";;;;;AAqBO,SAAS,QACd,MACA,UACS;AACT,SAAO,gBAAgB,MAAM,UAAU,CAAC;AAC1C;","names":[]}

package/dist/{chunk-EMZFQEWM.js → chunk-OEPVYNB6.js}

@@ -1,19 +1,16 @@
-import {
-  differenceInMilliseconds
-} from "./chunk-VXOQ7IG5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInMinutes.ts
 function differenceInMinutes(laterDate, earlierDate, options) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  const precise = differenceInMilliseconds(zoned1, zoned2) / 6e4;
-  return options?.fractional ? precise : Math.trunc(precise);
+  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return options?.fractional ? Number(nanoseconds) / 6e10 : Number(nanoseconds / 60000000000n);
 }
 
 export {
   differenceInMinutes
 };
-//# sourceMappingURL=chunk-EMZFQEWM.js.map
+//# sourceMappingURL=chunk-OEPVYNB6.js.map

package/dist/chunk-OEPVYNB6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMinutes.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of minutes between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n * Whole units are truncated toward zero after subtracting epoch nanoseconds.\n * Numeric results use JavaScript number precision; use differenceInNanoseconds\n * when an exact bigint elapsed difference is required.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of minutes between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:45:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');\n *\n * differenceInMinutes(later, earlier); // 15\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMinutes(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n  return options?.fractional\n    ? Number(nanoseconds) / 60_000_000_000\n    : Number(nanoseconds / 60_000_000_000n);\n}\n"],"mappings":";;;;;AA0CO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,cAAc,OAAO,mBAAmB,OAAO;AACrD,SAAO,SAAS,aACZ,OAAO,WAAW,IAAI,OACtB,OAAO,cAAc,YAAe;AAC1C;","names":[]}

package/dist/chunk-OF5YEVUT.js

@@ -0,0 +1,32 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+
+// src/eachHourOfInterval.ts
+function eachHourOfInterval(interval) {
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  let current = startZoned.round({ smallestUnit: "hour", roundingMode: "floor" });
+  const transition = current.getTimeZoneTransition("next");
+  if (transition && transition.epochNanoseconds <= startZoned.epochNanoseconds) {
+    current = transition;
+  }
+  const hours = [];
+  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {
+    hours.push(current);
+    const nextLocalHour = current.toPlainDateTime().round({ smallestUnit: "hour", roundingMode: "floor" }).add({ hours: 1 });
+    let next = nextLocalHour.toZonedDateTime(current.timeZoneId);
+    if (next.epochNanoseconds <= current.epochNanoseconds) {
+      next = nextLocalHour.toZonedDateTime(current.timeZoneId, { disambiguation: "later" });
+    }
+    const nextTransition = current.getTimeZoneTransition("next");
+    current = nextTransition && nextTransition.epochNanoseconds < next.epochNanoseconds ? nextTransition : next;
+  }
+  return hours;
+}
+
+export {
+  eachHourOfInterval
+};
+//# sourceMappingURL=chunk-OF5YEVUT.js.map

package/dist/chunk-OF5YEVUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachHourOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each hour within the interval.\n * Each element represents a local hour boundary (minute/second/etc. set to 0),\n * or the first valid instant after an offset transition within an hour.\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 * Completely missing hours are skipped. Partial hours start at the transition,\n * and repeated hours have separate entries for each offset. Later entries\n * realign to local hour boundaries, so steps need not be 60 elapsed minutes.\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:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T14:15:00+00:00[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:00:00+00:00[UTC],\n * //   2025-01-06T11:00:00+00:00[UTC],\n * //   2025-01-06T12:00:00+00:00[UTC],\n * //   2025-01-06T13:00:00+00:00[UTC],\n * //   2025-01-06T14:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-day boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T22:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T02:00:00+00:00[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T22:00:00+00:00[UTC],\n * //   2025-01-06T23:00:00+00:00[UTC],\n * //   2025-01-07T00:00:00+00:00[UTC],\n * //   2025-01-07T01:00:00+00:00[UTC],\n * //   2025-01-07T02:00:00+00:00[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  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  let current = startZoned.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n  // A repeated partial hour can begin at :30 even though rounding selects the\n  // earlier :00. Include only the occurrence containing the starting instant.\n  const transition = current.getTimeZoneTransition('next');\n  if (transition && transition.epochNanoseconds <= startZoned.epochNanoseconds) {\n    current = transition;\n  }\n\n  const hours: Temporal.ZonedDateTime[] = [];\n  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {\n    hours.push(current);\n    const nextLocalHour = current.toPlainDateTime()\n      .round({ smallestUnit: 'hour', roundingMode: 'floor' })\n      .add({ hours: 1 });\n    let next = nextLocalHour.toZonedDateTime(current.timeZoneId);\n    if (next.epochNanoseconds <= current.epochNanoseconds) {\n      next = nextLocalHour.toZonedDateTime(current.timeZoneId, { disambiguation: 'later' });\n    }\n    // Offset transitions can start a partial or repeated hour before the next\n    // local :00. Afterwards, compute a local boundary again to avoid drift.\n    const nextTransition = current.getTimeZoneTransition('next');\n    current = nextTransition && nextTransition.epochNanoseconds < next.epochNanoseconds\n      ? nextTransition\n      : next;\n  }\n\n  return hours;\n}\n"],"mappings":";;;;;AAkDO,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,MAAI,UAAU,WAAW,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAG9E,QAAM,aAAa,QAAQ,sBAAsB,MAAM;AACvD,MAAI,cAAc,WAAW,oBAAoB,WAAW,kBAAkB;AAC5E,cAAU;AAAA,EACZ;AAEA,QAAM,QAAkC,CAAC;AACzC,SAAO,QAAQ,oBAAoB,SAAS,kBAAkB;AAC5D,UAAM,KAAK,OAAO;AAClB,UAAM,gBAAgB,QAAQ,gBAAgB,EAC3C,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC,EACrD,IAAI,EAAE,OAAO,EAAE,CAAC;AACnB,QAAI,OAAO,cAAc,gBAAgB,QAAQ,UAAU;AAC3D,QAAI,KAAK,oBAAoB,QAAQ,kBAAkB;AACrD,aAAO,cAAc,gBAAgB,QAAQ,YAAY,EAAE,gBAAgB,QAAQ,CAAC;AAAA,IACtF;AAGA,UAAM,iBAAiB,QAAQ,sBAAsB,MAAM;AAC3D,cAAU,kBAAkB,eAAe,mBAAmB,KAAK,mBAC/D,iBACA;AAAA,EACN;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-OMYVTYHI.js

@@ -0,0 +1,47 @@
+import {
+  Temporal,
+  isPlainDate,
+  isPlainTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/compare.ts
+function assertSameDomain(a, b) {
+  if ((isPlainDate(a) || isPlainDate(b)) && !(isPlainDate(a) && isPlainDate(b))) {
+    throw new TypeError("PlainDate comparisons require two PlainDate values");
+  }
+  if ((isPlainTime(a) || isPlainTime(b)) && !(isPlainTime(a) && isPlainTime(b))) {
+    throw new TypeError("PlainTime comparisons require two PlainTime values");
+  }
+}
+function compare(a, b) {
+  assertSameDomain(a, b);
+  if (isPlainDate(a)) {
+    return Temporal.PlainDate.compare(ownDate(a), ownDate(b));
+  }
+  if (isPlainTime(a)) {
+    return Temporal.PlainTime.compare(a, b);
+  }
+  const difference = a.epochNanoseconds - b.epochNanoseconds;
+  return difference < 0n ? -1 : difference > 0n ? 1 : 0;
+}
+function position(value) {
+  if (isPlainDate(value)) {
+    return Temporal.PlainDate.from(ownDate(value)).toZonedDateTime("UTC").epochNanoseconds;
+  }
+  if (isPlainTime(value)) {
+    const seconds = (value.hour * 60 + value.minute) * 60 + value.second;
+    const subsecond = value.millisecond * 1e6 + value.microsecond * 1e3 + value.nanosecond;
+    return BigInt(seconds) * 1000000000n + BigInt(subsecond);
+  }
+  return value.epochNanoseconds;
+}
+function ownDate(date) {
+  return Temporal.PlainDate.prototype.isPrototypeOf(date) ? date : date.toString();
+}
+
+export {
+  assertSameDomain,
+  compare,
+  position
+};
+//# sourceMappingURL=chunk-OMYVTYHI.js.map