@gobrand/tiempo 2.2.0 → 2.2.2

package/README.md

@@ -173,6 +173,49 @@ format(instant, "yyyy-MM-dd HH:mm", { timeZone: "Asia/Tokyo" }); // "2025-01-21
 
 ### Start/End Utilities
 
+#### `today(timezone?)`
+
+Get today's date in the system's local timezone or a specified timezone.
+
+**Parameters:**
+- `timezone` (string, optional): An IANA timezone identifier (e.g., `"America/New_York"`, `"Europe/Madrid"`) or `"UTC"`. If not provided, uses the system's local timezone.
+
+**Returns:** `Temporal.PlainDate` - A Temporal.PlainDate representing today's date
+
+**Example:**
+```typescript
+import { today } from '@gobrand/tiempo';
+
+const date = today(); // 2025-01-20
+date.year;      // 2025
+date.month;     // 1
+date.day;       // 20
+
+// Get today in a specific timezone
+const dateInTokyo = today("Asia/Tokyo"); // 2025-01-21 (next day due to timezone)
+```
+
+#### `now(timezone?)`
+
+Get the current date and time in the system's local timezone or a specified timezone.
+
+**Parameters:**
+- `timezone` (string, optional): An IANA timezone identifier (e.g., `"America/New_York"`, `"Europe/Madrid"`) or `"UTC"`. If not provided, uses the system's local timezone.
+
+**Returns:** `Temporal.ZonedDateTime` - A Temporal.ZonedDateTime representing the current date and time
+
+**Example:**
+```typescript
+import { now } from '@gobrand/tiempo';
+
+const current = now(); // 2025-01-20T15:30:45.123-05:00[America/New_York]
+current.hour;   // 15
+current.minute; // 30
+
+// Get current time in a specific timezone
+const currentInTokyo = now("Asia/Tokyo"); // 2025-01-21T05:30:45.123+09:00[Asia/Tokyo]
+```
+
 #### `startOfDay(input)` / `endOfDay(input)`
 
 Get the start or end of the day for a given datetime.
@@ -227,32 +270,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-3YGPHHB6.js

@@ -0,0 +1,13 @@
+// src/now.ts
+import { Temporal } from "@js-temporal/polyfill";
+function now(timezone) {
+  if (timezone) {
+    return Temporal.Now.zonedDateTimeISO(timezone);
+  }
+  return Temporal.Now.zonedDateTimeISO();
+}
+
+export {
+  now
+};
+//# sourceMappingURL=chunk-3YGPHHB6.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/now.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\n/**\n * Get the current date and time in the system's local timezone or a specified timezone.\n *\n * @param timezone - Optional IANA timezone identifier (e.g., \"America/Asuncion\", \"Europe/Madrid\") or \"UTC\"\n * @returns A Temporal.ZonedDateTime representing the current date and time\n *\n * @example\n * ```typescript\n * // Get now in local timezone\n * const current = now();\n *\n * // Get now in Madrid\n * const nowInMadrid = now(\"Europe/Madrid\");\n *\n * // Get now in UTC\n * const nowUtc = now(\"UTC\");\n * ```\n */\nexport function now(timezone?: 'UTC' | string): Temporal.ZonedDateTime {\n  if (timezone) {\n    return Temporal.Now.zonedDateTimeISO(timezone);\n  }\n  return Temporal.Now.zonedDateTimeISO();\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAoBlB,SAAS,IAAI,UAAmD;AACrE,MAAI,UAAU;AACZ,WAAO,SAAS,IAAI,iBAAiB,QAAQ;AAAA,EAC/C;AACA,SAAO,SAAS,IAAI,iBAAiB;AACvC;","names":[]}

package/dist/{chunk-ANLD6IWG.js → chunk-67QHALIG.js}

@@ -1,6 +1,6 @@
-// src/getToday.ts
+// src/today.ts
 import { Temporal } from "@js-temporal/polyfill";
-function getToday(timezone) {
+function today(timezone) {
   if (timezone) {
     return Temporal.Now.zonedDateTimeISO(timezone).toPlainDate();
   }
@@ -8,6 +8,6 @@ function getToday(timezone) {
 }
 
 export {
-  getToday
+  today
 };
-//# sourceMappingURL=chunk-ANLD6IWG.js.map
+//# sourceMappingURL=chunk-67QHALIG.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/today.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\n/**\n * Get today's date in the system's local timezone or a specified timezone.\n *\n * @param timezone - Optional IANA timezone identifier (e.g., \"America/Asuncion\", \"Europe/Madrid\") or \"UTC\"\n * @returns A Temporal.PlainDate representing today's date\n *\n * @example\n * ```typescript\n * // Get today in local timezone\n * const date = today();\n *\n * // Get today in Madrid\n * const todayInMadrid = today(\"Europe/Madrid\");\n *\n * // Get today in UTC\n * const todayUtc = today(\"UTC\");\n * ```\n */\nexport function today(timezone?: \"UTC\" | string): Temporal.PlainDate {\n  if (timezone) {\n    return Temporal.Now.zonedDateTimeISO(timezone).toPlainDate();\n  }\n  return Temporal.Now.plainDateISO();\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAoBlB,SAAS,MAAM,UAA+C;AACnE,MAAI,UAAU;AACZ,WAAO,SAAS,IAAI,iBAAiB,QAAQ,EAAE,YAAY;AAAA,EAC7D;AACA,SAAO,SAAS,IAAI,aAAa;AACnC;","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-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":[]}

package/dist/chunk-ZGR4NZTS.js

@@ -0,0 +1,17 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/differenceInMicroseconds.ts
+import "@js-temporal/polyfill";
+function differenceInMicroseconds(laterDate, earlierDate) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const diffNanos = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return Number(diffNanos / 1000n);
+}
+
+export {
+  differenceInMicroseconds
+};
+//# sourceMappingURL=chunk-ZGR4NZTS.js.map

package/dist/chunk-ZGR4NZTS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMicroseconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns the number of microseconds 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 microseconds between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:20.001000Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.000000Z');\n *\n * differenceInMicroseconds(later, earlier); // 1000\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000500-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000-05:00[America/New_York]');\n *\n * differenceInMicroseconds(later, earlier); // 500\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 * differenceInMicroseconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMicroseconds(\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 diffNanos = zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n  return Number(diffNanos / 1000n);\n}\n"],"mappings":";;;;;AAAA,OAAyB;AAqClB,SAAS,yBACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,YAAY,OAAO,mBAAmB,OAAO;AACnD,SAAO,OAAO,YAAY,KAAK;AACjC;","names":[]}

package/dist/chunk-ZHRMURYP.js

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

package/dist/chunk-ZHRMURYP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInSeconds.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\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 *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of seconds between the dates\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): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return Math.trunc((zoned1.epochMilliseconds - zoned2.epochMilliseconds) / 1000);\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,GAAI;AAChF;","names":[]}

package/dist/differenceInDays.d.ts

@@ -0,0 +1,43 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of days between two 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.
+ *
+ * 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)
+ * @returns The number of days between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-01-25T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ *
+ * differenceInDays(later, earlier); // 5
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-25T15:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInDays(later, earlier); // 5
+ * ```
+ *
+ * @example
+ * ```ts
+ * // 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)
+ * ```
+ */
+export declare function differenceInDays(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInDays.d.ts.map

package/dist/differenceInDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInDays.d.ts","sourceRoot":"","sources":["../src/differenceInDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAMR"}

package/dist/differenceInDays.js

@@ -0,0 +1,8 @@
+import {
+  differenceInDays
+} from "./chunk-6IP245MS.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  differenceInDays
+};
+//# sourceMappingURL=differenceInDays.js.map