@gobrand/tiempo 2.2.1 → 2.2.3

package/README.md

@@ -120,6 +120,84 @@ console.log(iso2); // "2025-01-20T20:00:00Z"
 
 ### Formatting
 
+#### `intlFormatDistance(laterDate, earlierDate, options?)`
+
+Format the distance between two dates as a human-readable, internationalized string using `Intl.RelativeTimeFormat`. Automatically selects the most appropriate unit (seconds, minutes, hours, days, weeks, months, years) based on the distance.
+
+**Parameters:**
+- `laterDate` (Temporal.Instant | Temporal.ZonedDateTime): The later date to compare
+- `earlierDate` (Temporal.Instant | Temporal.ZonedDateTime): The earlier date to compare with
+- `options` (IntlFormatDistanceOptions, optional): Formatting options
+  - `unit` (Intl.RelativeTimeFormatUnit): Force a specific unit instead of automatic selection
+  - `locale` (string | string[]): Locale for formatting (default: system locale)
+  - `numeric` ('always' | 'auto'): Use numeric values always or allow natural language like "tomorrow" (default: 'auto')
+  - `style` ('long' | 'short' | 'narrow'): Formatting style (default: 'long')
+  - `localeMatcher` ('best fit' | 'lookup'): Locale matching algorithm
+
+**Returns:** `string` - Formatted relative time string
+
+**Automatic unit selection:**
+- < 60 seconds → "in X seconds" / "X seconds ago"
+- < 60 minutes → "in X minutes" / "X minutes ago"
+- < 24 hours → "in X hours" / "X hours ago"
+- < 7 days → "tomorrow" / "yesterday" / "in X days" / "X days ago"
+- < 4 weeks → "next week" / "last week" / "in X weeks" / "X weeks ago"
+- < 12 months → "next month" / "last month" / "in X months" / "X months ago"
+- ≥ 12 months → "next year" / "last year" / "in X years" / "X years ago"
+
+**Example:**
+```typescript
+import { intlFormatDistance } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T12:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T11:00:00Z');
+
+// Basic usage
+intlFormatDistance(later, earlier);
+// => "in 1 hour"
+
+intlFormatDistance(earlier, later);
+// => "1 hour ago"
+
+// With different locales
+intlFormatDistance(later, earlier, { locale: 'es' });
+// => "dentro de 1 hora"
+
+intlFormatDistance(later, earlier, { locale: 'ja' });
+// => "1 時間後"
+
+// Force numeric format
+const tomorrow = Temporal.Instant.from('2025-01-21T00:00:00Z');
+const today = Temporal.Instant.from('2025-01-20T00:00:00Z');
+
+intlFormatDistance(tomorrow, today, { numeric: 'auto' });
+// => "tomorrow"
+
+intlFormatDistance(tomorrow, today, { numeric: 'always' });
+// => "in 1 day"
+
+// Different styles
+const future = Temporal.Instant.from('2027-01-20T00:00:00Z');
+const now = Temporal.Instant.from('2025-01-20T00:00:00Z');
+
+intlFormatDistance(future, now, { style: 'long' });
+// => "in 2 years"
+
+intlFormatDistance(future, now, { style: 'short' });
+// => "in 2 yr."
+
+intlFormatDistance(future, now, { style: 'narrow' });
+// => "in 2y"
+
+// Force specific units
+intlFormatDistance(future, now, { unit: 'quarter' });
+// => "in 8 quarters"
+
+const dayLater = Temporal.Instant.from('2025-01-21T00:00:00Z');
+intlFormatDistance(dayLater, today, { unit: 'hour' });
+// => "in 24 hours"
+```
+
 #### `format(input, formatStr, options?)`
 
 Format a Temporal.Instant or ZonedDateTime using date-fns-like format tokens.
@@ -270,32 +348,178 @@ endOfYear(zoned);   // 2025-12-31T23:59:59.999999999-05:00[America/New_York]
 
 ### Comparison Utilities
 
-#### `isBefore(date1, date2)`
+#### `isBefore(date1, date2)` / `isAfter(date1, date2)`
 
-Check if the first datetime is before the second. Compares the underlying instant in time.
+Check if the first datetime is before or after the second. Compares the underlying instant in time.
 
 ```typescript
-import { isBefore } from '@gobrand/tiempo';
+import { isBefore, isAfter } from '@gobrand/tiempo';
 
 const earlier = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
 const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
 
 isBefore(earlier, later); // true
 isBefore(later, earlier); // false
+
+isAfter(later, earlier); // true
+isAfter(earlier, later); // false
 ```
 
-#### `isAfter(date1, date2)`
+### Difference Utilities
 
-Check if the first datetime is after the second. Compares the underlying instant in time.
+All difference functions compare the underlying instant in time and return a positive value if laterDate is after earlierDate, negative if before.
+
+#### Time-based precision (instant comparison)
+
+##### `differenceInNanoseconds(laterDate, earlierDate)`
+
+Returns the difference in nanoseconds as a BigInt. Provides the highest precision available in Temporal.
 
 ```typescript
-import { isAfter } from '@gobrand/tiempo';
+import { differenceInNanoseconds } from '@gobrand/tiempo';
 
-const earlier = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
-const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+const later = Temporal.Instant.from('2025-01-20T12:30:20.000000500Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:30:20.000000000Z');
+differenceInNanoseconds(later, earlier); // 500n
+```
 
-isAfter(later, earlier); // true
-isAfter(earlier, later); // false
+##### `differenceInMicroseconds(laterDate, earlierDate)`
+
+Returns the difference in microseconds (1/1,000,000 second).
+
+```typescript
+import { differenceInMicroseconds } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T12:30:20.001000Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:30:20.000000Z');
+differenceInMicroseconds(later, earlier); // 1000
+```
+
+##### `differenceInMilliseconds(laterDate, earlierDate)`
+
+Returns the difference in milliseconds (1/1,000 second).
+
+```typescript
+import { differenceInMilliseconds } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T12:30:21.700Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:30:20.600Z');
+differenceInMilliseconds(later, earlier); // 1100
+```
+
+##### `differenceInSeconds(laterDate, earlierDate)`
+
+Returns the difference in seconds (truncates sub-second precision).
+
+```typescript
+import { differenceInSeconds } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T12:30:25Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:30:20Z');
+differenceInSeconds(later, earlier); // 5
+```
+
+##### `differenceInMinutes(laterDate, earlierDate)`
+
+Returns the difference in minutes (truncates sub-minute precision).
+
+```typescript
+import { differenceInMinutes } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T12:45:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');
+differenceInMinutes(later, earlier); // 15
+```
+
+##### `differenceInHours(laterDate, earlierDate)`
+
+Returns the difference in hours (truncates sub-hour precision).
+
+```typescript
+import { differenceInHours } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-20T18:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T15:00:00Z');
+differenceInHours(later, earlier); // 3
+```
+
+#### Calendar-aware precision
+
+These functions use Temporal's `until()` method to account for variable-length calendar units.
+
+##### `differenceInDays(laterDate, earlierDate)`
+
+Returns the difference in days. Calendar-aware, so it properly handles DST transitions where days can be 23, 24, or 25 hours.
+
+```typescript
+import { differenceInDays } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-01-25T12:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+differenceInDays(later, earlier); // 5
+
+// Handles DST transitions correctly
+const afterDst = Temporal.ZonedDateTime.from('2025-03-10T12:00:00-04:00[America/New_York]');
+const beforeDst = Temporal.ZonedDateTime.from('2025-03-08T12:00:00-05:00[America/New_York]');
+differenceInDays(afterDst, beforeDst); // 2 (calendar days, not 48 hours)
+```
+
+##### `differenceInWeeks(laterDate, earlierDate)`
+
+Returns the difference in weeks (7-day periods).
+
+```typescript
+import { differenceInWeeks } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-02-10T12:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+differenceInWeeks(later, earlier); // 3
+```
+
+##### `differenceInMonths(laterDate, earlierDate)`
+
+Returns the difference in months. Calendar-aware, properly handling months with different numbers of days (28-31).
+
+```typescript
+import { differenceInMonths } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2025-04-20T12:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+differenceInMonths(later, earlier); // 3
+```
+
+##### `differenceInYears(laterDate, earlierDate)`
+
+Returns the difference in years. Calendar-aware, properly handling leap years (366 days) and regular years (365 days).
+
+```typescript
+import { differenceInYears } from '@gobrand/tiempo';
+
+const later = Temporal.Instant.from('2028-01-20T12:00:00Z');
+const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+differenceInYears(later, earlier); // 3
+
+// Calculate age
+const today = Temporal.ZonedDateTime.from('2025-01-20T12:00:00Z[UTC]');
+const birthdate = Temporal.ZonedDateTime.from('1990-01-20T12:00:00Z[UTC]');
+differenceInYears(today, birthdate); // 35
+```
+
+#### `isFuture(date)` / `isPast(date)`
+
+Check if a datetime is in the future or past relative to the current moment. Compares against `Temporal.Now.instant()`.
+
+```typescript
+import { isFuture, isPast } from '@gobrand/tiempo';
+
+const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });
+const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });
+
+isFuture(tomorrow); // true
+isFuture(yesterday); // false
+
+isPast(yesterday); // true
+isPast(tomorrow); // false
 ```
 
 #### `isSameDay(date1, date2)`

package/dist/chunk-2H4KLXGL.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isPast.ts
+import { Temporal } from "@js-temporal/polyfill";
+function isPast(date) {
+  const zoned = normalizeTemporalInput(date);
+  const nowInstant = Temporal.Now.instant();
+  return Temporal.Instant.compare(zoned.toInstant(), nowInstant) < 0;
+}
+
+export {
+  isPast
+};
+//# sourceMappingURL=chunk-2H4KLXGL.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if the given datetime is in the past.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is before the current instant, false otherwise\n *\n * @example\n * ```ts\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n *\n * isPast(yesterday); // true\n * isPast(tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const pastInstant = Temporal.Now.instant().subtract({ hours: 1 });\n *\n * isPast(pastInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const pastInTokyo = Temporal.ZonedDateTime.from('1970-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isPast(pastInTokyo); // true\n * ```\n */\nexport function isPast(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n  const nowInstant = Temporal.Now.instant();\n\n  return Temporal.Instant.compare(zoned.toInstant(), nowInstant) < 0;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAmClB,SAAS,OACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AACzC,QAAM,aAAa,SAAS,IAAI,QAAQ;AAExC,SAAO,SAAS,QAAQ,QAAQ,MAAM,UAAU,GAAG,UAAU,IAAI;AACnE;","names":[]}

package/dist/chunk-6IP245MS.js

@@ -0,0 +1,17 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInDays.ts
+import "@js-temporal/polyfill";
+function differenceInDays(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
+  return duration.total({ unit: "days", relativeTo: zoned2 });
+}
+
+export {
+  differenceInDays
+};
+//# sourceMappingURL=chunk-6IP245MS.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInDays.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of days 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 * DST transitions where days can be 23, 24, or 25 hours long.\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 * @returns The number of days between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-25T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInDays(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-25T15: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 * differenceInDays(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Handles DST transitions correctly\n * const afterDst = Temporal.ZonedDateTime.from('2025-03-10T12:00:00-04:00[America/New_York]');\n * const beforeDst = Temporal.ZonedDateTime.from('2025-03-08T12:00:00-05:00[America/New_York]');\n *\n * differenceInDays(afterDst, beforeDst); // 2 (calendar days, not 48 hours)\n * ```\n */\nexport function differenceInDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  return duration.total({ unit: 'days', relativeTo: zoned2 });\n}\n"],"mappings":";;;;;AAAA,OAAyB;AA2ClB,SAAS,iBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,SAAO,SAAS,MAAM,EAAE,MAAM,QAAQ,YAAY,OAAO,CAAC;AAC5D;","names":[]}

package/dist/chunk-BIAPE4MR.js

@@ -0,0 +1,17 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInMonths.ts
+import "@js-temporal/polyfill";
+function differenceInMonths(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
+  return duration.total({ unit: "months", relativeTo: zoned2 });
+}
+
+export {
+  differenceInMonths
+};
+//# sourceMappingURL=chunk-BIAPE4MR.js.map

package/dist/chunk-BIAPE4MR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMonths.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\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 * @returns The number of months between the dates\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-05: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 * // Returns fractional months for partial month differences\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.5 (approximately half a month)\n * ```\n */\nexport function differenceInMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  return duration.total({ unit: 'months', relativeTo: zoned2 });\n}\n"],"mappings":";;;;;AAAA,OAAyB;AA2ClB,SAAS,mBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,SAAO,SAAS,MAAM,EAAE,MAAM,UAAU,YAAY,OAAO,CAAC;AAC9D;","names":[]}

package/dist/chunk-CHW2EN2O.js

@@ -0,0 +1,17 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInYears.ts
+import "@js-temporal/polyfill";
+function differenceInYears(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
+  return duration.total({ unit: "years", relativeTo: zoned2 });
+}
+
+export {
+  differenceInYears
+};
+//# sourceMappingURL=chunk-CHW2EN2O.js.map

package/dist/chunk-CHW2EN2O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInYears.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\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 * @returns The number of years between the dates\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-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-05:00[America/New_York]');\n *\n * differenceInYears(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Returns fractional years for partial year differences\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.5 (approximately half a year)\n * ```\n */\nexport function differenceInYears(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  return duration.total({ unit: 'years', relativeTo: zoned2 });\n}\n"],"mappings":";;;;;AAAA,OAAyB;AA2ClB,SAAS,kBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,SAAO,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AAC7D;","names":[]}

package/dist/chunk-D7DPB2JR.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInMilliseconds.ts
+import "@js-temporal/polyfill";
+function differenceInMilliseconds(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  return zoned1.epochMilliseconds - zoned2.epochMilliseconds;
+}
+
+export {
+  differenceInMilliseconds
+};
+//# sourceMappingURL=chunk-D7DPB2JR.js.map

package/dist/chunk-D7DPB2JR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMilliseconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of milliseconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of milliseconds between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:21.700Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.600Z');\n *\n * differenceInMilliseconds(later, earlier); // 1100\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T14:00:00-05:00[America/New_York]');\n *\n * differenceInMilliseconds(later, earlier); // 3600000\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInMilliseconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMilliseconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return zoned1.epochMilliseconds - zoned2.epochMilliseconds;\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAqClB,SAAS,yBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,OAAO,oBAAoB,OAAO;AAC3C;","names":[]}

package/dist/chunk-NL5LWPJI.js

@@ -0,0 +1,94 @@
+import {
+  differenceInWeeks
+} from "./chunk-PVAOUYXF.js";
+import {
+  differenceInYears
+} from "./chunk-CHW2EN2O.js";
+import {
+  differenceInDays
+} from "./chunk-6IP245MS.js";
+import {
+  differenceInHours
+} from "./chunk-PIDXROVB.js";
+import {
+  differenceInMinutes
+} from "./chunk-RJY62CDU.js";
+import {
+  differenceInMonths
+} from "./chunk-BIAPE4MR.js";
+import {
+  differenceInSeconds
+} from "./chunk-ZHRMURYP.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/intlFormatDistance.ts
+function intlFormatDistance(laterDate, earlierDate, options) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  let unit = options?.unit;
+  if (!unit) {
+    const absSeconds = Math.abs(differenceInSeconds(zoned1, zoned2));
+    const absMinutes = Math.abs(differenceInMinutes(zoned1, zoned2));
+    const absHours = Math.abs(differenceInHours(zoned1, zoned2));
+    const absDays = Math.abs(differenceInDays(zoned1, zoned2));
+    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2));
+    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2));
+    if (absSeconds < 60) {
+      unit = "second";
+    } else if (absMinutes < 60) {
+      unit = "minute";
+    } else if (absHours < 24) {
+      unit = "hour";
+    } else if (absDays < 7) {
+      unit = "day";
+    } else if (absWeeks < 4) {
+      unit = "week";
+    } else if (absMonths < 12) {
+      unit = "month";
+    } else {
+      unit = "year";
+    }
+  }
+  let value;
+  switch (unit) {
+    case "second":
+      value = differenceInSeconds(zoned1, zoned2);
+      break;
+    case "minute":
+      value = differenceInMinutes(zoned1, zoned2);
+      break;
+    case "hour":
+      value = differenceInHours(zoned1, zoned2);
+      break;
+    case "day":
+      value = differenceInDays(zoned1, zoned2);
+      break;
+    case "week":
+      value = differenceInWeeks(zoned1, zoned2);
+      break;
+    case "month":
+      value = differenceInMonths(zoned1, zoned2);
+      break;
+    case "quarter":
+      value = Math.round(differenceInMonths(zoned1, zoned2) / 3);
+      break;
+    case "year":
+      value = differenceInYears(zoned1, zoned2);
+      break;
+    default:
+      value = differenceInSeconds(zoned1, zoned2);
+  }
+  const formatter = new Intl.RelativeTimeFormat(options?.locale, {
+    localeMatcher: options?.localeMatcher,
+    numeric: options?.numeric ?? "auto",
+    style: options?.style
+  });
+  return formatter.format(value, unit);
+}
+
+export {
+  intlFormatDistance
+};
+//# sourceMappingURL=chunk-NL5LWPJI.js.map

package/dist/chunk-NL5LWPJI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/intlFormatDistance.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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    const absDays = Math.abs(differenceInDays(zoned1, zoned2));\n    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2));\n    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2));\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 = differenceInSeconds(zoned1, zoned2);\n      break;\n    case 'minute':\n      value = differenceInMinutes(zoned1, zoned2);\n      break;\n    case 'hour':\n      value = differenceInHours(zoned1, zoned2);\n      break;\n    case 'day':\n      value = differenceInDays(zoned1, zoned2);\n      break;\n    case 'week':\n      value = differenceInWeeks(zoned1, zoned2);\n      break;\n    case 'month':\n      value = differenceInMonths(zoned1, zoned2);\n      break;\n    case 'quarter':\n      value = Math.round(differenceInMonths(zoned1, zoned2) / 3);\n      break;\n    case 'year':\n      value = differenceInYears(zoned1, zoned2);\n      break;\n    default:\n      // For any other unit type, try to use it directly\n      value = 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;AAC3D,UAAM,UAAU,KAAK,IAAI,iBAAiB,QAAQ,MAAM,CAAC;AACzD,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,MAAM,CAAC;AAC3D,UAAM,YAAY,KAAK,IAAI,mBAAmB,QAAQ,MAAM,CAAC;AAE7D,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,oBAAoB,QAAQ,MAAM;AAC1C;AAAA,IACF,KAAK;AACH,cAAQ,oBAAoB,QAAQ,MAAM;AAC1C;AAAA,IACF,KAAK;AACH,cAAQ,kBAAkB,QAAQ,MAAM;AACxC;AAAA,IACF,KAAK;AACH,cAAQ,iBAAiB,QAAQ,MAAM;AACvC;AAAA,IACF,KAAK;AACH,cAAQ,kBAAkB,QAAQ,MAAM;AACxC;AAAA,IACF,KAAK;AACH,cAAQ,mBAAmB,QAAQ,MAAM;AACzC;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,MAAM,IAAI,CAAC;AACzD;AAAA,IACF,KAAK;AACH,cAAQ,kBAAkB,QAAQ,MAAM;AACxC;AAAA,IACF;AAEE,cAAQ,oBAAoB,QAAQ,MAAM;AAAA,EAC9C;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-OABS374T.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInNanoseconds.ts
+import "@js-temporal/polyfill";
+function differenceInNanoseconds(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  return zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+}
+
+export {
+  differenceInNanoseconds
+};
+//# sourceMappingURL=chunk-OABS374T.js.map

package/dist/chunk-OABS374T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInNanoseconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of nanoseconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of nanoseconds between the dates as a BigInt\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:20.000000500Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.000000000Z');\n *\n * differenceInNanoseconds(later, earlier); // 500n\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000001-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000000-05:00[America/New_York]');\n *\n * differenceInNanoseconds(later, earlier); // 1n\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 * differenceInNanoseconds(tokyo, ny); // 0n (same instant)\n * ```\n */\nexport function differenceInNanoseconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): bigint {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAqClB,SAAS,wBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,OAAO,mBAAmB,OAAO;AAC1C;","names":[]}

package/dist/chunk-PIDXROVB.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInHours.ts
+import "@js-temporal/polyfill";
+function differenceInHours(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 36e5);
+}
+
+export {
+  differenceInHours
+};
+//# sourceMappingURL=chunk-PIDXROVB.js.map

package/dist/chunk-PIDXROVB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInHours.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of hours between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of hours between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T18:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T15:00:00Z');\n *\n * differenceInHours(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-21T00:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInHours(later, earlier); // 9\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInHours(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInHours(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 3600000);\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAqClB,SAAS,kBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,KAAK,OAAO,OAAO,oBAAoB,OAAO,qBAAqB,IAAO;AACnF;","names":[]}

package/dist/chunk-PVAOUYXF.js

@@ -0,0 +1,17 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInWeeks.ts
+import "@js-temporal/polyfill";
+function differenceInWeeks(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
+  return duration.total({ unit: "weeks", relativeTo: zoned2 });
+}
+
+export {
+  differenceInWeeks
+};
+//# sourceMappingURL=chunk-PVAOUYXF.js.map

package/dist/chunk-PVAOUYXF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInWeeks.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of weeks 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 * DST transitions and calendar weeks.\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 * @returns The number of weeks between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-02-10T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-02-10T15: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 * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Returns fractional weeks for partial week differences\n * const later = Temporal.Instant.from('2025-01-27T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 1\n * ```\n */\nexport function differenceInWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  return duration.total({ unit: 'weeks', relativeTo: zoned2 });\n}\n"],"mappings":";;;;;AAAA,OAAyB;AA2ClB,SAAS,kBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,SAAO,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AAC7D;","names":[]}

package/dist/chunk-R5XN76EV.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isFuture.ts
+import { Temporal } from "@js-temporal/polyfill";
+function isFuture(date) {
+  const zoned = normalizeTemporalInput(date);
+  const nowInstant = Temporal.Now.instant();
+  return Temporal.Instant.compare(zoned.toInstant(), nowInstant) > 0;
+}
+
+export {
+  isFuture
+};
+//# sourceMappingURL=chunk-R5XN76EV.js.map

package/dist/chunk-R5XN76EV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isFuture.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\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  const nowInstant = Temporal.Now.instant();\n\n  return Temporal.Instant.compare(zoned.toInstant(), nowInstant) > 0;\n}\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAmClB,SAAS,SACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AACzC,QAAM,aAAa,SAAS,IAAI,QAAQ;AAExC,SAAO,SAAS,QAAQ,QAAQ,MAAM,UAAU,GAAG,UAAU,IAAI;AACnE;","names":[]}

package/dist/chunk-RJY62CDU.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInMinutes.ts
+import "@js-temporal/polyfill";
+function differenceInMinutes(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 6e4);
+}
+
+export {
+  differenceInMinutes
+};
+//# sourceMappingURL=chunk-RJY62CDU.js.map

package/dist/chunk-RJY62CDU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMinutes.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of minutes between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of minutes between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:45:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');\n *\n * differenceInMinutes(later, earlier); // 15\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInMinutes(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMinutes(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 60000);\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAqClB,SAAS,oBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,KAAK,OAAO,OAAO,oBAAoB,OAAO,qBAAqB,GAAK;AACjF;","names":[]}