@gobrand/tiempo 2.2.1 → 2.2.3

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

package/dist/differenceInDays.js.map

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

package/dist/differenceInDays.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInDays.test.d.ts.map

package/dist/differenceInDays.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInDays.test.d.ts","sourceRoot":"","sources":["../src/differenceInDays.test.ts"],"names":[],"mappings":""}

package/dist/differenceInHours.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of hours between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of hours between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-01-20T18:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T15:00:00Z');
+ *
+ * differenceInHours(later, earlier); // 3
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-21T00:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInHours(later, earlier); // 9
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInHours(tokyo, ny); // 0 (same instant)
+ * ```
+ */
+export declare function differenceInHours(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInHours.d.ts.map

package/dist/differenceInHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInHours.d.ts","sourceRoot":"","sources":["../src/differenceInHours.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GACrD,MAAM,CAKR"}

package/dist/differenceInHours.js

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

package/dist/differenceInHours.js.map

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

package/dist/differenceInHours.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInHours.test.d.ts.map

package/dist/differenceInHours.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInHours.test.d.ts","sourceRoot":"","sources":["../src/differenceInHours.test.ts"],"names":[],"mappings":""}

package/dist/differenceInMicroseconds.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of microseconds between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of microseconds between the dates
+ *
+ * @example
+ * ```ts
+ * 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
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000500-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000-05:00[America/New_York]');
+ *
+ * differenceInMicroseconds(later, earlier); // 500
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInMicroseconds(tokyo, ny); // 0 (same instant)
+ * ```
+ */
+export declare function differenceInMicroseconds(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInMicroseconds.d.ts.map

package/dist/differenceInMicroseconds.d.ts.map

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

package/dist/differenceInMicroseconds.js

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

package/dist/differenceInMicroseconds.js.map

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

package/dist/differenceInMicroseconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInMicroseconds.test.d.ts.map

package/dist/differenceInMicroseconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInMicroseconds.test.d.ts","sourceRoot":"","sources":["../src/differenceInMicroseconds.test.ts"],"names":[],"mappings":""}

package/dist/differenceInMilliseconds.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of milliseconds between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of milliseconds between the dates
+ *
+ * @example
+ * ```ts
+ * 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
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T14:00:00-05:00[America/New_York]');
+ *
+ * differenceInMilliseconds(later, earlier); // 3600000
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInMilliseconds(tokyo, ny); // 0 (same instant)
+ * ```
+ */
+export declare function differenceInMilliseconds(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInMilliseconds.d.ts.map

package/dist/differenceInMilliseconds.d.ts.map

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

package/dist/differenceInMilliseconds.js

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

package/dist/differenceInMilliseconds.js.map

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

package/dist/differenceInMilliseconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInMilliseconds.test.d.ts.map

package/dist/differenceInMilliseconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInMilliseconds.test.d.ts","sourceRoot":"","sources":["../src/differenceInMilliseconds.test.ts"],"names":[],"mappings":""}

package/dist/differenceInMinutes.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of minutes between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of minutes between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-01-20T12:45:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');
+ *
+ * differenceInMinutes(later, earlier); // 15
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInMinutes(later, earlier); // 60
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInMinutes(tokyo, ny); // 0 (same instant)
+ * ```
+ */
+export declare function differenceInMinutes(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInMinutes.d.ts.map

package/dist/differenceInMinutes.d.ts.map

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

package/dist/differenceInMinutes.js

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

package/dist/differenceInMinutes.js.map

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

package/dist/differenceInMinutes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInMinutes.test.d.ts.map

package/dist/differenceInMinutes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInMinutes.test.d.ts","sourceRoot":"","sources":["../src/differenceInMinutes.test.ts"],"names":[],"mappings":""}

package/dist/differenceInMonths.d.ts

@@ -0,0 +1,43 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of months 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
+ * months with different numbers of days (28, 29, 30, or 31).
+ *
+ * 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 months between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-04-20T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ *
+ * differenceInMonths(later, earlier); // 3
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-15T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInMonths(later, earlier); // 5
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Returns fractional months for partial month differences
+ * const later = Temporal.Instant.from('2025-02-05T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ *
+ * differenceInMonths(later, earlier); // ~0.5 (approximately half a month)
+ * ```
+ */
+export declare function differenceInMonths(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInMonths.d.ts.map

package/dist/differenceInMonths.d.ts.map

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

package/dist/differenceInMonths.js

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

package/dist/differenceInMonths.js.map

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

package/dist/differenceInMonths.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInMonths.test.d.ts.map

package/dist/differenceInMonths.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInMonths.test.d.ts","sourceRoot":"","sources":["../src/differenceInMonths.test.ts"],"names":[],"mappings":""}

package/dist/differenceInNanoseconds.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of nanoseconds between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of nanoseconds between the dates as a BigInt
+ *
+ * @example
+ * ```ts
+ * 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
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000001-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00.000000000-05:00[America/New_York]');
+ *
+ * differenceInNanoseconds(later, earlier); // 1n
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInNanoseconds(tokyo, ny); // 0n (same instant)
+ * ```
+ */
+export declare function differenceInNanoseconds(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): bigint;
+//# sourceMappingURL=differenceInNanoseconds.d.ts.map

package/dist/differenceInNanoseconds.d.ts.map

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

package/dist/differenceInNanoseconds.js

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

package/dist/differenceInNanoseconds.js.map

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

package/dist/differenceInNanoseconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInNanoseconds.test.d.ts.map

package/dist/differenceInNanoseconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInNanoseconds.test.d.ts","sourceRoot":"","sources":["../src/differenceInNanoseconds.test.ts"],"names":[],"mappings":""}

package/dist/differenceInSeconds.d.ts

@@ -0,0 +1,37 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of seconds between two datetimes.
+ * The result is positive if laterDate is after earlierDate, negative if before.
+ *
+ * @param laterDate - The later datetime (Instant or ZonedDateTime)
+ * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)
+ * @returns The number of seconds between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-01-20T12:30:25Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:30:20Z');
+ *
+ * differenceInSeconds(later, earlier); // 5
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-01-20T15:01:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInSeconds(later, earlier); // 60
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handles different timezones - compares by instant
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ *
+ * differenceInSeconds(tokyo, ny); // 0 (same instant)
+ * ```
+ */
+export declare function differenceInSeconds(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInSeconds.d.ts.map

package/dist/differenceInSeconds.d.ts.map

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

package/dist/differenceInSeconds.js

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

package/dist/differenceInSeconds.js.map

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

package/dist/differenceInSeconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInSeconds.test.d.ts.map

package/dist/differenceInSeconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInSeconds.test.d.ts","sourceRoot":"","sources":["../src/differenceInSeconds.test.ts"],"names":[],"mappings":""}

package/dist/differenceInWeeks.d.ts

@@ -0,0 +1,43 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns the number of weeks 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 and calendar weeks.
+ *
+ * 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 weeks between the dates
+ *
+ * @example
+ * ```ts
+ * const later = Temporal.Instant.from('2025-02-10T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ *
+ * differenceInWeeks(later, earlier); // 3
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Works with ZonedDateTime
+ * const later = Temporal.ZonedDateTime.from('2025-02-10T15:00:00-05:00[America/New_York]');
+ * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');
+ *
+ * differenceInWeeks(later, earlier); // 3
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Returns fractional weeks for partial week differences
+ * const later = Temporal.Instant.from('2025-01-27T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ *
+ * differenceInWeeks(later, earlier); // 1
+ * ```
+ */
+export declare function differenceInWeeks(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime): number;
+//# sourceMappingURL=differenceInWeeks.d.ts.map

package/dist/differenceInWeeks.d.ts.map

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

package/dist/differenceInWeeks.js

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

package/dist/differenceInWeeks.js.map

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

package/dist/differenceInWeeks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=differenceInWeeks.test.d.ts.map

package/dist/differenceInWeeks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceInWeeks.test.d.ts","sourceRoot":"","sources":["../src/differenceInWeeks.test.ts"],"names":[],"mappings":""}