@gobrand/tiempo 3.0.0 → 3.1.2

package/dist/chunk-YHQSI4WC.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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-11-20T14:00:00Z[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-YMJHVVM4.js

@@ -0,0 +1,13 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/compareDesc.ts
+function compareDesc(date1, date2) {
+  return compare(date2, date1);
+}
+
+export {
+  compareDesc
+};
+//# sourceMappingURL=chunk-YMJHVVM4.js.map

package/dist/chunk-YMJHVVM4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/compareDesc.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable } from './shared/compare';\n\n/**\n * Compares two values for descending order: -1 if the first is later,\n * 1 if it is earlier, 0 if they are equal. Pass it to `Array#sort`.\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 date1 - First value in a matching date, time, or timeline pair\n * @param date2 - Second value in the same comparison domain\n * @returns -1, 0, or 1\n *\n * @example\n * ```ts\n * const dates = [\n *   Temporal.PlainDate.from('2025-01-01'),\n *   Temporal.PlainDate.from('2025-03-01'),\n *   Temporal.PlainDate.from('2025-02-01'),\n * ];\n *\n * dates.sort(compareDesc);\n * // [2025-03-01, 2025-02-01, 2025-01-01]\n * ```\n */\nexport function compareDesc(date1: Temporal.PlainDate, date2: Temporal.PlainDate): -1 | 0 | 1;\nexport function compareDesc(date1: Temporal.PlainTime, date2: Temporal.PlainTime): -1 | 0 | 1;\nexport function compareDesc(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): -1 | 0 | 1;\nexport function compareDesc(date1: Comparable, date2: Comparable): -1 | 0 | 1 {\n  return compare(date2, date1);\n}\n"],"mappings":";;;;;AAgCO,SAAS,YAAY,OAAmB,OAA+B;AAC5E,SAAO,QAAQ,OAAO,KAAK;AAC7B;","names":[]}

package/dist/{chunk-UQ2F3I2S.js → chunk-YR26F7OA.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/addQuarters.ts
 function addQuarters(input, quarters) {
@@ -16,4 +16,4 @@ function addQuarters(input, quarters) {
 export {
   addQuarters
 };
-//# sourceMappingURL=chunk-UQ2F3I2S.js.map
+//# sourceMappingURL=chunk-YR26F7OA.js.map

package/dist/chunk-YR26F7OA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\n\n/**\n * Adds the specified number of quarters (3-month blocks) to a datetime or date.\n *\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC; ZonedDateTime inputs preserve their\n * timezone. 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 add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters added\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * addQuarters(instant, 2);\n * // 2025-07-20T12:00:00Z[UTC] (6 months later)\n * ```\n *\n * @example\n * ```ts\n * // Calendar arithmetic on a date stays a date\n * addQuarters(Temporal.PlainDate.from('2025-01-31'), 1);\n * // 2025-04-30 (Jan 31 → Apr 30)\n * ```\n */\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function addQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ months: quarters * 3 });\n  }\n  return normalizeTemporalInput(input).add({ months: quarters * 3 });\n}\n"],"mappings":";;;;;;;;AAiCO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AAAA,EAC3C;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AACnE;","names":[]}

package/dist/chunk-YSDLXJHE.js

@@ -0,0 +1,16 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/min.ts
+function min(values) {
+  if (values.length === 0) {
+    throw new RangeError("min requires at least one value");
+  }
+  return values.reduce((earliest, value) => compare(value, earliest) < 0 ? value : earliest);
+}
+
+export {
+  min
+};
+//# sourceMappingURL=chunk-YSDLXJHE.js.map

package/dist/chunk-YSDLXJHE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/min.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable, type Timeline } from './shared/compare';\n\n/**\n * Returns the earliest value in a non-empty array. The value is returned as\n * given, with its type, timezone, and calendar intact. Ties return the first.\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 values - Values from one domain; at least one is required\n * @returns The earliest value\n * @throws RangeError if values is empty\n *\n * @example\n * ```ts\n * const deadlines = [\n *   Temporal.PlainDate.from('2025-03-01'),\n *   Temporal.PlainDate.from('2025-01-15')\n * ];\n *\n * min(deadlines); // 2025-01-15\n * ```\n */\nexport function min<T extends Timeline>(values: readonly T[]): T;\nexport function min(values: readonly Temporal.PlainDate[]): Temporal.PlainDate;\nexport function min(values: readonly Temporal.PlainTime[]): Temporal.PlainTime;\nexport function min(values: readonly Comparable[]): Comparable {\n  if (values.length === 0) {\n    throw new RangeError('min requires at least one value');\n  }\n  return values.reduce((earliest, value) => (compare(value, earliest) < 0 ? value : earliest));\n}\n"],"mappings":";;;;;AA2BO,SAAS,IAAI,QAA2C;AAC7D,MAAI,OAAO,WAAW,GAAG;AACvB,UAAM,IAAI,WAAW,iCAAiC;AAAA,EACxD;AACA,SAAO,OAAO,OAAO,CAAC,UAAU,UAAW,QAAQ,OAAO,QAAQ,IAAI,IAAI,QAAQ,QAAS;AAC7F;","names":[]}

package/dist/chunk-Z7I7YCKN.js

@@ -0,0 +1,36 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.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-Z7I7YCKN.js.map

package/dist/chunk-Z7I7YCKN.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-ZM32S3YU.js

@@ -0,0 +1,16 @@
+import {
+  Temporal
+} from "./chunk-BSVOJYJ7.js";
+
+// src/isPlainDateBefore.ts
+function isPlainDateBefore(date1, date2) {
+  return Temporal.PlainDate.compare(
+    Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),
+    Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()
+  ) < 0;
+}
+
+export {
+  isPlainDateBefore
+};
+//# sourceMappingURL=chunk-ZM32S3YU.js.map

package/dist/{chunk-UXMNCRG7.js.map → chunk-ZM32S3YU.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isPlainDateBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is before the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is before date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateBefore(jan20, jan25); // true\n * isPlainDateBefore(jan25, jan20); // false\n * isPlainDateBefore(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateBefore(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  return Temporal.PlainDate.compare(date1, date2) < 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,kBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,IAAI;AACpD;","names":[]}
+{"version":3,"sources":["../src/isPlainDateBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is before the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is before date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateBefore(jan20, jan25); // true\n * isPlainDateBefore(jan25, jan20); // false\n * isPlainDateBefore(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateBefore(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  // Only foreign objects need conversion; strings retain their calendar annotations.\n  return Temporal.PlainDate.compare(\n    Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),\n    Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()\n  ) < 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,kBACd,OACA,OACS;AAET,SAAO,SAAS,UAAU;AAAA,IACxB,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,IAC3E,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,EAC7E,IAAI;AACN;","names":[]}

package/dist/{chunk-PWIEPZVO.js → chunk-ZO2MTD2E.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/isSameYear.ts
 function isSameYear(date1, date2) {
@@ -12,4 +12,4 @@ function isSameYear(date1, date2) {
 export {
   isSameYear
 };
-//# sourceMappingURL=chunk-PWIEPZVO.js.map
+//# sourceMappingURL=chunk-ZO2MTD2E.js.map

package/dist/chunk-ZO2MTD2E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameYear.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 calendar year.\n * Compares the year field directly.\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 calendar year, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same year\n * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]');\n * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');\n *\n * isSameYear(jan, dec); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different years\n * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59Z[UTC]');\n * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');\n *\n * isSameYear(endOf2024, startOf2025); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar years\n * const ny = Temporal.ZonedDateTime.from('2024-12-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar years from each person's perspective\n * isSameYear(ny, tokyo); // false (2024 in NY, 2025 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameYear(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 2025 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameYear(ny, tokyo.withTimeZone('America/New_York')); // true (both 2024 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-12-31T23:59:59Z');\n *\n * isSameYear(instant1, instant2); // true (both 2025 in UTC)\n * ```\n */\nexport function isSameYear(\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 zoned1.year === zoned2.year;\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO;AAChC;","names":[]}

package/dist/{chunk-PYALKKWZ.js → chunk-ZYRUL5E7.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-JNAWZ4RN.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-ZYRUL5E7.js.map

package/dist/clamp.d.ts

@@ -0,0 +1,36 @@
+import type { Temporal } from './shared/temporal.js';
+import { type Timeline } from './shared/compare.js';
+/**
+ * Restricts a value to an inclusive interval. Returns the value itself when it
+ * is inside, otherwise the nearer endpoint, unchanged.
+ *
+ * Timeline values compare by exact instant, PlainDates by date, and
+ * PlainTimes by wall-clock time. Mixed domains throw a TypeError.
+ *
+ * @param value - The value to restrict
+ * @param interval - Inclusive bounds from the same domain as value
+ * @returns value, interval.start, or interval.end
+ * @throws RangeError if interval.start is after interval.end
+ *
+ * @example
+ * ```ts
+ * const start = Temporal.PlainDate.from('2025-01-01');
+ * const end = Temporal.PlainDate.from('2025-01-31');
+ *
+ * clamp(Temporal.PlainDate.from('2025-02-14'), { start, end }); // 2025-01-31
+ * clamp(Temporal.PlainDate.from('2025-01-10'), { start, end }); // 2025-01-10
+ * ```
+ */
+export declare function clamp<T extends Timeline, S extends Timeline, E extends Timeline>(value: T, interval: {
+    start: S;
+    end: E;
+}): T | S | E;
+export declare function clamp(value: Temporal.PlainDate, interval: {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}): Temporal.PlainDate;
+export declare function clamp(value: Temporal.PlainTime, interval: {
+    start: Temporal.PlainTime;
+    end: Temporal.PlainTime;
+}): Temporal.PlainTime;
+//# sourceMappingURL=clamp.d.ts.map

package/dist/clamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../src/clamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAA4B,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC9E,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,CAAA;CAAE,GAC7B,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACb,wBAAgB,KAAK,CACnB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,GAC/D,QAAQ,CAAC,SAAS,CAAC;AACtB,wBAAgB,KAAK,CACnB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,GAC/D,QAAQ,CAAC,SAAS,CAAC"}

package/dist/clamp.js

@@ -0,0 +1,9 @@
+import {
+  clamp
+} from "./chunk-3S6TSXZ3.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  clamp
+};
+//# sourceMappingURL=clamp.js.map

package/dist/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/closestTo.d.ts

@@ -0,0 +1,30 @@
+import type { Temporal } from './shared/temporal.js';
+import { type Timeline } from './shared/compare.js';
+/**
+ * Returns the candidate nearest to the target, or undefined when there are no
+ * candidates. Ties return the first. The candidate is returned as given.
+ *
+ * Timeline values measure exact elapsed time, PlainDates whole days, and
+ * PlainTimes time within one day (no wrapping at midnight). Mixed domains throw
+ * a TypeError.
+ *
+ * @param target - The value to measure from
+ * @param candidates - Values from the same domain as target
+ * @returns The nearest candidate, or undefined if candidates is empty
+ *
+ * @example
+ * ```ts
+ * const now = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const slots = [
+ *   Temporal.Instant.from('2025-01-20T09:00:00Z'),
+ *   Temporal.Instant.from('2025-01-20T13:30:00Z'),
+ * ];
+ *
+ * closestTo(now, slots); // 2025-01-20T13:30:00Z
+ * closestTo(now, []); // undefined
+ * ```
+ */
+export declare function closestTo<T extends Timeline>(target: Timeline, candidates: readonly T[]): T | undefined;
+export declare function closestTo(target: Temporal.PlainDate, candidates: readonly Temporal.PlainDate[]): Temporal.PlainDate | undefined;
+export declare function closestTo(target: Temporal.PlainTime, candidates: readonly Temporal.PlainTime[]): Temporal.PlainTime | undefined;
+//# sourceMappingURL=closestTo.d.ts.map

package/dist/closestTo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closestTo.d.ts","sourceRoot":"","sources":["../src/closestTo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAA+C,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAC1C,MAAM,EAAE,QAAQ,EAChB,UAAU,EAAE,SAAS,CAAC,EAAE,GACvB,CAAC,GAAG,SAAS,CAAC;AACjB,wBAAgB,SAAS,CACvB,MAAM,EAAE,QAAQ,CAAC,SAAS,EAC1B,UAAU,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACxC,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC;AAClC,wBAAgB,SAAS,CACvB,MAAM,EAAE,QAAQ,CAAC,SAAS,EAC1B,UAAU,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACxC,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC"}

package/dist/closestTo.js

@@ -0,0 +1,9 @@
+import {
+  closestTo
+} from "./chunk-GQXJICRA.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  closestTo
+};
+//# sourceMappingURL=closestTo.js.map

package/dist/closestTo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/compareAsc.d.ts

@@ -0,0 +1,28 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Compares two values for ascending order: -1 if the first is earlier,
+ * 1 if it is later, 0 if they are equal. Pass it to `Array#sort`.
+ *
+ * Timeline values compare by exact instant, PlainDates by date, and
+ * PlainTimes by wall-clock time. Mixed domains throw a TypeError.
+ *
+ * @param date1 - First value in a matching date, time, or timeline pair
+ * @param date2 - Second value in the same comparison domain
+ * @returns -1, 0, or 1
+ *
+ * @example
+ * ```ts
+ * const dates = [
+ *   Temporal.Instant.from('2025-03-01T00:00:00Z'),
+ *   Temporal.Instant.from('2025-01-01T00:00:00Z'),
+ *   Temporal.Instant.from('2025-02-01T00:00:00Z'),
+ * ];
+ *
+ * dates.sort(compareAsc);
+ * // [2025-01-01, 2025-02-01, 2025-03-01]
+ * ```
+ */
+export declare function compareAsc(date1: Temporal.PlainDate, date2: Temporal.PlainDate): -1 | 0 | 1;
+export declare function compareAsc(date1: Temporal.PlainTime, date2: Temporal.PlainTime): -1 | 0 | 1;
+export declare function compareAsc(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): -1 | 0 | 1;
+//# sourceMappingURL=compareAsc.d.ts.map

package/dist/compareAsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareAsc.d.ts","sourceRoot":"","sources":["../src/compareAsc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7F,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7F,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC"}

package/dist/compareAsc.js

@@ -0,0 +1,9 @@
+import {
+  compareAsc
+} from "./chunk-U7VOIXLY.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  compareAsc
+};
+//# sourceMappingURL=compareAsc.js.map

package/dist/compareAsc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/compareDesc.d.ts

@@ -0,0 +1,28 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Compares two values for descending order: -1 if the first is later,
+ * 1 if it is earlier, 0 if they are equal. Pass it to `Array#sort`.
+ *
+ * Timeline values compare by exact instant, PlainDates by date, and
+ * PlainTimes by wall-clock time. Mixed domains throw a TypeError.
+ *
+ * @param date1 - First value in a matching date, time, or timeline pair
+ * @param date2 - Second value in the same comparison domain
+ * @returns -1, 0, or 1
+ *
+ * @example
+ * ```ts
+ * const dates = [
+ *   Temporal.PlainDate.from('2025-01-01'),
+ *   Temporal.PlainDate.from('2025-03-01'),
+ *   Temporal.PlainDate.from('2025-02-01'),
+ * ];
+ *
+ * dates.sort(compareDesc);
+ * // [2025-03-01, 2025-02-01, 2025-01-01]
+ * ```
+ */
+export declare function compareDesc(date1: Temporal.PlainDate, date2: Temporal.PlainDate): -1 | 0 | 1;
+export declare function compareDesc(date1: Temporal.PlainTime, date2: Temporal.PlainTime): -1 | 0 | 1;
+export declare function compareDesc(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): -1 | 0 | 1;
+//# sourceMappingURL=compareDesc.d.ts.map

package/dist/compareDesc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareDesc.d.ts","sourceRoot":"","sources":["../src/compareDesc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9F,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9F,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC"}

package/dist/compareDesc.js

@@ -0,0 +1,9 @@
+import {
+  compareDesc
+} from "./chunk-YMJHVVM4.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  compareDesc
+};
+//# sourceMappingURL=compareDesc.js.map

package/dist/compareDesc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInBusinessDays.d.ts

@@ -0,0 +1,26 @@
+import { type Temporal } from './shared/temporal.js';
+/**
+ * Returns the number of business days (Monday–Friday) from earlierDate up to
+ * laterDate: the earlier date counts, the later date does not. Holidays are
+ * not considered. Swapping the arguments negates the result.
+ *
+ * Only calendar dates matter; times of day are ignored. Instant inputs use
+ * their UTC date and ZonedDateTime inputs use their own timezone's date.
+ * Convert both to one timezone first to count from a single perspective.
+ *
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @returns Business days between the dates (negative if laterDate is earlier)
+ *
+ * @example
+ * ```ts
+ * const friday = Temporal.PlainDate.from('2025-01-24');
+ * const nextFriday = Temporal.PlainDate.from('2025-01-31');
+ *
+ * differenceInBusinessDays(nextFriday, friday); // 5
+ * differenceInBusinessDays(friday, nextFriday); // -5
+ * ```
+ */
+export declare function differenceInBusinessDays(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate): number;
+export declare function differenceInBusinessDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInBusinessDays.d.ts.map

package/dist/differenceInBusinessDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInBusinessDays.d.ts","sourceRoot":"","sources":["../src/differenceInBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,GAC9B,MAAM,CAAC;AACV,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAAC"}

package/dist/differenceInBusinessDays.js

@@ -0,0 +1,10 @@
+import {
+  differenceInBusinessDays
+} from "./chunk-RQ5CX67T.js";
+import "./chunk-Z7I7YCKN.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  differenceInBusinessDays
+};
+//# sourceMappingURL=differenceInBusinessDays.js.map

package/dist/differenceInBusinessDays.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/differenceInDays.d.ts

@@ -1,17 +1,20 @@
 import { Temporal } from './shared/temporal.js';
 import type { DifferenceOptions } from './shared/differenceOptions.js';
 /**
- * Returns the number of days between two datetimes.
+ * Returns the number of days between two dates or datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.
  *
  * This function uses calendar-aware calculation, which means it properly handles
  * DST transitions where days can be 23, 24, or 25 hours long.
  *
+ * Two PlainDate inputs return signed whole calendar days without a timezone.
+ * Their calendars must match; fractional options do not change date-only results.
+ *
  * Instant inputs are converted to UTC for calendar calculations.
  * For ZonedDateTime inputs, their timezone is preserved.
  *
- * @param laterDate - The later datetime (Instant or ZonedDateTime)
- * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @param laterDate - The later PlainDate, Instant or ZonedDateTime
+ * @param earlierDate - The earlier value in the same Temporal domain
  * @param options - Optional { fractional } to return the precise value
  * @returns The number of days between the dates, truncated toward zero (pass { fractional: true } for the precise value)
  *
@@ -41,5 +44,6 @@ import type { DifferenceOptions } from './shared/differenceOptions.js';
  * differenceInDays(afterDst, beforeDst); // 2 (calendar days, not 48 hours)
  * ```
  */
+export declare function differenceInDays(laterDate: Temporal.PlainDate, earlierDate: Temporal.PlainDate, options?: DifferenceOptions): number;
 export declare function differenceInDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime, options?: DifferenceOptions): number;
 //# sourceMappingURL=differenceInDays.d.ts.map

package/dist/differenceInDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInDays.d.ts","sourceRoot":"","sources":["../src/differenceInDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAOR"}
+{"version":3,"file":"differenceInDays.d.ts","sourceRoot":"","sources":["../src/differenceInDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,QAAQ,CAAC,SAAS,EAC7B,WAAW,EAAE,QAAQ,CAAC,SAAS,EAC/B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAAC;AACV,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAAC"}

package/dist/differenceInDays.js

@@ -1,8 +1,8 @@
 import {
   differenceInDays
-} from "./chunk-EU3SYJHM.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-E5HJJFUI.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   differenceInDays
 };

package/dist/differenceInHours.d.ts

@@ -3,6 +3,9 @@ import type { DifferenceOptions } from './shared/differenceOptions.js';
 /**
  * Returns the number of hours between two datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.
+ * Whole units are truncated toward zero after subtracting epoch nanoseconds.
+ * Numeric results use JavaScript number precision; use differenceInNanoseconds
+ * when an exact bigint elapsed difference is required.
  *
  * @param laterDate - The later datetime (Instant or ZonedDateTime)
  * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)

package/dist/differenceInHours.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInHours.d.ts","sourceRoot":"","sources":["../src/differenceInHours.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAG7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAMR"}
+{"version":3,"file":"differenceInHours.d.ts","sourceRoot":"","sources":["../src/differenceInHours.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAQR"}

package/dist/differenceInHours.js

@@ -1,9 +1,8 @@
 import {
   differenceInHours
-} from "./chunk-X3ARINEH.js";
-import "./chunk-VXOQ7IG5.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-SLBDEPBP.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   differenceInHours
 };

package/dist/differenceInMicroseconds.js

@@ -1,8 +1,8 @@
 import {
   differenceInMicroseconds
-} from "./chunk-DBVGH55Z.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-2OSJHJV5.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   differenceInMicroseconds
 };

package/dist/differenceInMilliseconds.d.ts

@@ -2,6 +2,9 @@ import { Temporal } from './shared/temporal.js';
 /**
  * Returns the number of milliseconds between two datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.
+ * Whole units are truncated toward zero after subtracting epoch nanoseconds.
+ * Numeric results use JavaScript number precision; use differenceInNanoseconds
+ * when an exact bigint elapsed difference is required.
  *
  * @param laterDate - The later datetime (Instant or ZonedDateTime)
  * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)

package/dist/differenceInMilliseconds.d.ts.map

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

package/dist/differenceInMilliseconds.js

@@ -1,9 +1,9 @@
 import {
   differenceInMilliseconds
-} from "./chunk-WTLAKRCT.js";
-import "./chunk-VXOQ7IG5.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-DHVGDIIO.js";
+import "./chunk-3KE6GK4R.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   differenceInMilliseconds
 };

package/dist/differenceInMinutes.d.ts

@@ -3,6 +3,9 @@ import type { DifferenceOptions } from './shared/differenceOptions.js';
 /**
  * Returns the number of minutes between two datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.
+ * Whole units are truncated toward zero after subtracting epoch nanoseconds.
+ * Numeric results use JavaScript number precision; use differenceInNanoseconds
+ * when an exact bigint elapsed difference is required.
  *
  * @param laterDate - The later datetime (Instant or ZonedDateTime)
  * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)

package/dist/differenceInMinutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differenceInMinutes.d.ts","sourceRoot":"","sources":["../src/differenceInMinutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAG7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAMR"}
+{"version":3,"file":"differenceInMinutes.d.ts","sourceRoot":"","sources":["../src/differenceInMinutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAQR"}

package/dist/differenceInMinutes.js

@@ -1,9 +1,8 @@
 import {
   differenceInMinutes
-} from "./chunk-EMZFQEWM.js";
-import "./chunk-VXOQ7IG5.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-OYTQWJ2O.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   differenceInMinutes
 };