@gobrand/tiempo 3.0.1 → 3.1.3

package/dist/chunk-U7VOIXLY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/compareAsc.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable } from './shared/compare';\n\n/**\n * Compares two values for ascending order: -1 if the first is earlier,\n * 1 if it is later, 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.Instant.from('2025-03-01T00:00:00Z'),\n *   Temporal.Instant.from('2025-01-01T00:00:00Z'),\n *   Temporal.Instant.from('2025-02-01T00:00:00Z'),\n * ];\n *\n * dates.sort(compareAsc);\n * // [2025-01-01, 2025-02-01, 2025-03-01]\n * ```\n */\nexport function compareAsc(date1: Temporal.PlainDate, date2: Temporal.PlainDate): -1 | 0 | 1;\nexport function compareAsc(date1: Temporal.PlainTime, date2: Temporal.PlainTime): -1 | 0 | 1;\nexport function compareAsc(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): -1 | 0 | 1;\nexport function compareAsc(date1: Comparable, date2: Comparable): -1 | 0 | 1 {\n  return compare(date1, date2);\n}\n"],"mappings":";;;;;AAgCO,SAAS,WAAW,OAAmB,OAA+B;AAC3E,SAAO,QAAQ,OAAO,KAAK;AAC7B;","names":[]}

package/dist/chunk-V2NSN6ET.js

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

package/dist/chunk-V2NSN6ET.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isEqual.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable } from './shared/compare';\n\n/**\n * Returns true if both values are the same point in their domain.\n * Timeline values are equal when they are the same exact instant, even in\n * different timezones. PlainDate pairs compare dates; PlainTime pairs compare\n * wall-clock times.\n *\n * Use `isSameNanosecond` to compare wall-clock fields instead, or\n * `ZonedDateTime#equals` to also require the same timezone and calendar.\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 true if date1 and date2 are equal, false otherwise\n *\n * @example\n * ```ts\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const utc = Temporal.Instant.from('2025-01-20T15:00:00Z');\n *\n * isEqual(ny, utc); // true (same instant)\n * isEqual(Temporal.PlainDate.from('2025-01-20'), Temporal.PlainDate.from('2025-01-21')); // false\n * ```\n */\nexport function isEqual(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;\nexport function isEqual(date1: Temporal.PlainTime, date2: Temporal.PlainTime): boolean;\nexport function isEqual(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean;\nexport function isEqual(date1: Comparable, date2: Comparable): boolean {\n  return compare(date1, date2) === 0;\n}\n"],"mappings":";;;;;AA+BO,SAAS,QAAQ,OAAmB,OAA4B;AACrE,SAAO,QAAQ,OAAO,KAAK,MAAM;AACnC;","names":[]}

package/dist/chunk-VDV24TWQ.js

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

package/dist/chunk-VDV24TWQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isYesterday.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 yesterday's date in the given timezone.\n *\n * Instant and ZonedDateTime inputs are converted to the timezone before taking\n * their date. PlainDate inputs are compared to yesterday'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 yesterday in timezone, false otherwise\n *\n * @example\n * ```ts\n * const lastLogin = Temporal.Now.instant().subtract({ hours: 24 });\n * isYesterday(lastLogin, 'UTC'); // true\n * ```\n */\nexport function isYesterday(\n  date: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone\n): boolean {\n  return isDaysFromToday(date, timezone, -1);\n}\n"],"mappings":";;;;;AAoBO,SAAS,YACd,MACA,UACS;AACT,SAAO,gBAAgB,MAAM,UAAU,EAAE;AAC3C;","names":[]}

package/dist/{chunk-YOSCEJ36.js → chunk-VM2YJ5PN.js}

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

package/dist/{chunk-XWBOD6MD.js → chunk-WTLMIOKZ.js}

@@ -2,7 +2,7 @@ import {
   Temporal,
   isInstant,
   isZonedDateTime
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/simpleFormat.ts
 function simpleFormat(input, options) {
@@ -59,4 +59,4 @@ function formatCompactTime(zdt) {
 export {
   simpleFormat
 };
-//# sourceMappingURL=chunk-XWBOD6MD.js.map
+//# sourceMappingURL=chunk-WTLMIOKZ.js.map

package/dist/{chunk-VC7RTDJP.js → chunk-X27XGVCT.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInNanoseconds.ts
 function differenceInNanoseconds(laterDate, earlierDate) {
@@ -12,4 +12,4 @@ function differenceInNanoseconds(laterDate, earlierDate) {
 export {
   differenceInNanoseconds
 };
-//# sourceMappingURL=chunk-VC7RTDJP.js.map
+//# sourceMappingURL=chunk-X27XGVCT.js.map

package/dist/{chunk-EBVLBLR3.js → chunk-XSHFR2SX.js}

@@ -1,19 +1,16 @@
-import {
-  differenceInMilliseconds
-} from "./chunk-VXOQ7IG5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/differenceInSeconds.ts
 function differenceInSeconds(laterDate, earlierDate, options) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  const precise = differenceInMilliseconds(zoned1, zoned2) / 1e3;
-  return options?.fractional ? precise : Math.trunc(precise);
+  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return options?.fractional ? Number(nanoseconds) / 1e9 : Number(nanoseconds / 1000000000n);
 }
 
 export {
   differenceInSeconds
 };
-//# sourceMappingURL=chunk-EBVLBLR3.js.map
+//# sourceMappingURL=chunk-XSHFR2SX.js.map

package/dist/chunk-XSHFR2SX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInSeconds.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 seconds 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 seconds 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:30:25Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20Z');\n *\n * differenceInSeconds(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:01:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInSeconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  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) / 1_000_000_000\n    : Number(nanoseconds / 1_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,MACtB,OAAO,cAAc,WAAc;AACzC;","names":[]}

package/dist/{chunk-OVSCDXYN.js → chunk-Y24VUXMX.js}

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

package/dist/chunk-Y24VUXMX.js.map

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

package/dist/{chunk-DHFBKOFZ.js → chunk-YKXRVQ4S.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addHours.ts
 function addHours(input, hours) {
@@ -11,4 +11,4 @@ function addHours(input, hours) {
 export {
   addHours
 };
-//# sourceMappingURL=chunk-DHFBKOFZ.js.map
+//# sourceMappingURL=chunk-YKXRVQ4S.js.map

package/dist/chunk-YKXRVQ4S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addHours.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of hours to a datetime.\n *\n * Properly handles DST transitions through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param hours - Number of hours to add (can be negative to subtract)\n * @returns ZonedDateTime with hours added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addHours(instant, 3);\n * // 2025-01-20T15:00:00+00:00[UTC] (3 hours later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addHours(zoned, 24);\n * // 2025-01-21T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract hours\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addHours(instant, -5);\n * // 2025-01-20T07:00:00+00:00[UTC] (5 hours earlier)\n * ```\n */\nexport function addHours(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  hours: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ hours });\n}\n"],"mappings":";;;;;AAqCO,SAAS,SACd,OACA,OACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,MAAM,CAAC;AACpC;","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-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-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-DMFV2AL7.js → chunk-ZW32E6EJ.js}

@@ -1,27 +1,27 @@
-import {
-  differenceInMinutes
-} from "./chunk-EMZFQEWM.js";
-import {
-  differenceInMonths
-} from "./chunk-CIA46DWB.js";
 import {
   differenceInSeconds
-} from "./chunk-EBVLBLR3.js";
+} from "./chunk-XSHFR2SX.js";
 import {
   differenceInWeeks
-} from "./chunk-LODULPI3.js";
+} from "./chunk-TU3LNQKW.js";
 import {
   differenceInYears
-} from "./chunk-DCCHY45G.js";
+} from "./chunk-LMOAA73F.js";
 import {
   differenceInDays
-} from "./chunk-EU3SYJHM.js";
+} from "./chunk-JGPTGV5X.js";
 import {
   differenceInHours
-} from "./chunk-X3ARINEH.js";
+} from "./chunk-GU3CZAIN.js";
+import {
+  differenceInMinutes
+} from "./chunk-OEPVYNB6.js";
+import {
+  differenceInMonths
+} from "./chunk-KZCSP3DU.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/intlFormatDistance.ts
 function intlFormatDistance(laterDate, earlierDate, options) {
@@ -92,4 +92,4 @@ function intlFormatDistance(laterDate, earlierDate, options) {
 export {
   intlFormatDistance
 };
-//# sourceMappingURL=chunk-DMFV2AL7.js.map
+//# sourceMappingURL=chunk-ZW32E6EJ.js.map

package/dist/chunk-ZW32E6EJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/intlFormatDistance.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { differenceInDays } from './differenceInDays.js';\nimport { differenceInHours } from './differenceInHours.js';\nimport { differenceInMinutes } from './differenceInMinutes.js';\nimport { differenceInMonths } from './differenceInMonths.js';\nimport { differenceInSeconds } from './differenceInSeconds.js';\nimport { differenceInWeeks } from './differenceInWeeks.js';\nimport { differenceInYears } from './differenceInYears.js';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput.js';\n\nexport interface IntlFormatDistanceOptions {\n  /**\n   * The unit to force formatting in. If not specified, the unit will be automatically selected.\n   */\n  unit?: Intl.RelativeTimeFormatUnit;\n  /**\n   * The locale to use for formatting. Defaults to the system locale.\n   */\n  locale?: string | string[];\n  /**\n   * The locale matching algorithm to use.\n   */\n  localeMatcher?: 'best fit' | 'lookup';\n  /**\n   * Whether to use numeric values always, or use special strings like \"yesterday\", \"tomorrow\", etc.\n   * Defaults to 'auto'.\n   */\n  numeric?: 'always' | 'auto';\n  /**\n   * The formatting style to use.\n   */\n  style?: 'long' | 'short' | 'narrow';\n}\n\n/**\n * Formats the distance between two dates as a human-readable, internationalized string.\n *\n * The function automatically picks the most appropriate unit based on the distance between dates.\n * For example, if the distance is a few hours, it returns \"in X hours\". If the distance is a few\n * months, it returns \"in X months\".\n *\n * You can force a specific unit using the `options.unit` parameter.\n *\n * @param laterDate - The later date to compare\n * @param earlierDate - The earlier date to compare with\n * @param options - Formatting options\n * @returns The formatted distance string\n *\n * @example\n * ```typescript\n * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');\n *\n * intlFormatDistance(later, earlier);\n * // => 'in 1 hour'\n *\n * intlFormatDistance(earlier, later);\n * // => '1 hour ago'\n * ```\n *\n * @example\n * ```typescript\n * // Force a specific unit\n * const later = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');\n *\n * intlFormatDistance(later, earlier, { unit: 'quarter' });\n * // => 'in 4 quarters'\n * ```\n *\n * @example\n * ```typescript\n * // Use a different locale\n * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');\n *\n * intlFormatDistance(later, earlier, { locale: 'es' });\n * // => 'dentro de 1 hora'\n * ```\n *\n * @example\n * ```typescript\n * // Use numeric: 'always' to avoid special strings\n * const later = Temporal.Instant.from('2024-01-02T00:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');\n *\n * intlFormatDistance(later, earlier, { numeric: 'auto' });\n * // => 'tomorrow'\n *\n * intlFormatDistance(later, earlier, { numeric: 'always' });\n * // => 'in 1 day'\n * ```\n */\nexport function intlFormatDistance(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: IntlFormatDistanceOptions\n): string {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // Determine unit if not specified\n  let unit = options?.unit;\n  if (!unit) {\n    const absSeconds = Math.abs(differenceInSeconds(zoned1, zoned2));\n    const absMinutes = Math.abs(differenceInMinutes(zoned1, zoned2));\n    const absHours = Math.abs(differenceInHours(zoned1, zoned2));\n    // calendar units were fractional pre-2.x; sub-day units stay truncated so Math.round below is a no-op\n    const absDays = Math.abs(differenceInDays(zoned1, zoned2, { fractional: true }));\n    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2, { fractional: true }));\n    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2, { fractional: true }));\n\n    if (absSeconds < 60) {\n      unit = 'second';\n    } else if (absMinutes < 60) {\n      unit = 'minute';\n    } else if (absHours < 24) {\n      unit = 'hour';\n    } else if (absDays < 7) {\n      unit = 'day';\n    } else if (absWeeks < 4) {\n      unit = 'week';\n    } else if (absMonths < 12) {\n      unit = 'month';\n    } else {\n      unit = 'year';\n    }\n  }\n\n  // Calculate value for the selected unit\n  let value: number;\n  switch (unit) {\n    case 'second':\n      value = Math.round(differenceInSeconds(zoned1, zoned2));\n      break;\n    case 'minute':\n      value = Math.round(differenceInMinutes(zoned1, zoned2));\n      break;\n    case 'hour':\n      value = Math.round(differenceInHours(zoned1, zoned2));\n      break;\n    // calendar units were fractional pre-2.x; sub-day units stay truncated so Math.round is a no-op\n    case 'day':\n      value = Math.round(differenceInDays(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'week':\n      value = Math.round(differenceInWeeks(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'month':\n      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'quarter':\n      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }) / 3);\n      break;\n    case 'year':\n      value = Math.round(differenceInYears(zoned1, zoned2, { fractional: true }));\n      break;\n    default:\n      // For any other unit type, try to use it directly\n      value = Math.round(differenceInSeconds(zoned1, zoned2));\n  }\n\n  // Format using Intl.RelativeTimeFormat\n  const formatter = new Intl.RelativeTimeFormat(options?.locale, {\n    localeMatcher: options?.localeMatcher,\n    numeric: options?.numeric ?? 'auto',\n    style: options?.style,\n  });\n\n  return formatter.format(value, unit);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6FO,SAAS,mBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,MAAI,OAAO,SAAS;AACpB,MAAI,CAAC,MAAM;AACT,UAAM,aAAa,KAAK,IAAI,oBAAoB,QAAQ,MAAM,CAAC;AAC/D,UAAM,aAAa,KAAK,IAAI,oBAAoB,QAAQ,MAAM,CAAC;AAC/D,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,MAAM,CAAC;AAE3D,UAAM,UAAU,KAAK,IAAI,iBAAiB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC/E,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AACjF,UAAM,YAAY,KAAK,IAAI,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAEnF,QAAI,aAAa,IAAI;AACnB,aAAO;AAAA,IACT,WAAW,aAAa,IAAI;AAC1B,aAAO;AAAA,IACT,WAAW,WAAW,IAAI;AACxB,aAAO;AAAA,IACT,WAAW,UAAU,GAAG;AACtB,aAAO;AAAA,IACT,WAAW,WAAW,GAAG;AACvB,aAAO;AAAA,IACT,WAAW,YAAY,IAAI;AACzB,aAAO;AAAA,IACT,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI;AACJ,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AACtD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AACtD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,MAAM,CAAC;AACpD;AAAA;AAAA,IAEF,KAAK;AACH,cAAQ,KAAK,MAAM,iBAAiB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AACzE;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC1E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC3E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,IAAI,CAAC;AAC/E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC1E;AAAA,IACF;AAEE,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AAAA,EAC1D;AAGA,QAAM,YAAY,IAAI,KAAK,mBAAmB,SAAS,QAAQ;AAAA,IAC7D,eAAe,SAAS;AAAA,IACxB,SAAS,SAAS,WAAW;AAAA,IAC7B,OAAO,SAAS;AAAA,EAClB,CAAC;AAED,SAAO,UAAU,OAAO,OAAO,IAAI;AACrC;","names":[]}

package/dist/chunk-ZXKU4SKR.js

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

package/dist/chunk-ZXKU4SKR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of months 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. For ZonedDateTime inputs, their timezone is preserved.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param months - Number of months to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMonths(instant, 3);\n * // 2025-04-20T12:00:00+00:00[UTC] (3 months later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addMonths(zoned, 6);\n * // 2025-07-20T15:30:00-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Month-end handling\n * const instant = Temporal.Instant.from('2025-01-31T12:00:00Z');\n * const result = addMonths(instant, 1);\n * // 2025-02-28T12:00:00+00:00[UTC] (Jan 31 → Feb 28)\n * ```\n */\nexport function addMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function addMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function addMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ months });\n  }\n  return normalizeTemporalInput(input).add({ months });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,UACd,OACA,QAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,OAAO,CAAC;AAAA,EAC7B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC;AACrD;","names":[]}

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-OVBZ2NBB.js";
+import "./chunk-K7CLBBBM.js";
+import "./chunk-Q6QLOUXJ.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"}