@gobrand/tiempo 2.2.2 → 2.3.0

package/dist/index.js

@@ -1,9 +1,3 @@
-import {
-  startOfWeek
-} from "./chunk-2WMXB7QL.js";
-import {
-  startOfYear
-} from "./chunk-YR2UCUIT.js";
 import {
   toUtc
 } from "./chunk-GPAFAHKJ.js";
@@ -16,6 +10,84 @@ import {
 import {
   today
 } from "./chunk-67QHALIG.js";
+import {
+  subMicroseconds
+} from "./chunk-BQBLSXK2.js";
+import {
+  subMilliseconds
+} from "./chunk-HDBH7RTY.js";
+import {
+  subMinutes
+} from "./chunk-J6G2I2TU.js";
+import {
+  subMonths
+} from "./chunk-52NEOY34.js";
+import {
+  subNanoseconds
+} from "./chunk-WVHAYLBW.js";
+import {
+  subSeconds
+} from "./chunk-BH2YB4MV.js";
+import {
+  subWeeks
+} from "./chunk-U4RNUZXO.js";
+import {
+  subYears
+} from "./chunk-AHMKY474.js";
+import {
+  isSameYear
+} from "./chunk-VLZ3HQQA.js";
+import {
+  now
+} from "./chunk-3YGPHHB6.js";
+import {
+  startOfDay
+} from "./chunk-TW5EV3DH.js";
+import {
+  startOfMonth
+} from "./chunk-TU2UNOOW.js";
+import {
+  startOfWeek
+} from "./chunk-2WMXB7QL.js";
+import {
+  startOfYear
+} from "./chunk-YR2UCUIT.js";
+import {
+  subDays
+} from "./chunk-YKBP3G7L.js";
+import {
+  subHours
+} from "./chunk-XW5MLXX5.js";
+import {
+  isSameHour
+} from "./chunk-EEQ3REET.js";
+import {
+  isSameMicrosecond
+} from "./chunk-PPB62JYV.js";
+import {
+  isSameMillisecond
+} from "./chunk-ISHZRFVN.js";
+import {
+  isSameMinute
+} from "./chunk-LDO6PRNJ.js";
+import {
+  isSameMonth
+} from "./chunk-ADQTZVMH.js";
+import {
+  isSameNanosecond
+} from "./chunk-S63QUP4W.js";
+import {
+  isSameSecond
+} from "./chunk-CY746ZUQ.js";
+import {
+  isSameWeek
+} from "./chunk-JOD4ATPE.js";
+import {
+  format
+} from "./chunk-2G5RJGPR.js";
+import {
+  intlFormatDistance
+} from "./chunk-XEDXPI5G.js";
 import {
   isAfter
 } from "./chunk-BBNNR2QH.js";
@@ -32,14 +104,11 @@ import {
   isSameDay
 } from "./chunk-RW3C2677.js";
 import {
-  now
-} from "./chunk-3YGPHHB6.js";
-import {
-  startOfDay
-} from "./chunk-TW5EV3DH.js";
+  differenceInNanoseconds
+} from "./chunk-OABS374T.js";
 import {
-  startOfMonth
-} from "./chunk-TU2UNOOW.js";
+  differenceInSeconds
+} from "./chunk-ZHRMURYP.js";
 import {
   differenceInWeeks
 } from "./chunk-PVAOUYXF.js";
@@ -60,8 +129,11 @@ import {
 } from "./chunk-XDVUGTUV.js";
 import "./chunk-AVGNRINZ.js";
 import {
-  format
-} from "./chunk-2G5RJGPR.js";
+  addWeeks
+} from "./chunk-DT2EWLHU.js";
+import {
+  addYears
+} from "./chunk-Q2F3HEXB.js";
 import {
   differenceInDays
 } from "./chunk-6IP245MS.js";
@@ -81,13 +153,41 @@ import {
   differenceInMonths
 } from "./chunk-BIAPE4MR.js";
 import {
-  differenceInNanoseconds
-} from "./chunk-OABS374T.js";
+  addDays
+} from "./chunk-L4SVABDH.js";
 import {
-  differenceInSeconds
-} from "./chunk-ZHRMURYP.js";
+  addHours
+} from "./chunk-4NJMCCUM.js";
+import {
+  addMicroseconds
+} from "./chunk-V27NUBXQ.js";
+import {
+  addMilliseconds
+} from "./chunk-A5VVBYNT.js";
+import {
+  addMinutes
+} from "./chunk-2XHAHSB6.js";
+import {
+  addMonths
+} from "./chunk-7ATM7AXL.js";
+import {
+  addNanoseconds
+} from "./chunk-EYO2ZJLH.js";
+import {
+  addSeconds
+} from "./chunk-NRD5HRZV.js";
 import "./chunk-MJSZNWCV.js";
 export {
+  addDays,
+  addHours,
+  addMicroseconds,
+  addMilliseconds,
+  addMinutes,
+  addMonths,
+  addNanoseconds,
+  addSeconds,
+  addWeeks,
+  addYears,
   differenceInDays,
   differenceInHours,
   differenceInMicroseconds,
@@ -103,16 +203,36 @@ export {
   endOfWeek,
   endOfYear,
   format,
+  intlFormatDistance,
   isAfter,
   isBefore,
   isFuture,
   isPast,
   isSameDay,
+  isSameHour,
+  isSameMicrosecond,
+  isSameMillisecond,
+  isSameMinute,
+  isSameMonth,
+  isSameNanosecond,
+  isSameSecond,
+  isSameWeek,
+  isSameYear,
   now,
   startOfDay,
   startOfMonth,
   startOfWeek,
   startOfYear,
+  subDays,
+  subHours,
+  subMicroseconds,
+  subMilliseconds,
+  subMinutes,
+  subMonths,
+  subNanoseconds,
+  subSeconds,
+  subWeeks,
+  subYears,
   toUtc,
   toUtcString,
   toZonedTime,

package/dist/intlFormatDistance.d.ts

@@ -0,0 +1,85 @@
+import type { Temporal } from '@js-temporal/polyfill';
+export interface IntlFormatDistanceOptions {
+    /**
+     * The unit to force formatting in. If not specified, the unit will be automatically selected.
+     */
+    unit?: Intl.RelativeTimeFormatUnit;
+    /**
+     * The locale to use for formatting. Defaults to the system locale.
+     */
+    locale?: string | string[];
+    /**
+     * The locale matching algorithm to use.
+     */
+    localeMatcher?: 'best fit' | 'lookup';
+    /**
+     * Whether to use numeric values always, or use special strings like "yesterday", "tomorrow", etc.
+     * Defaults to 'auto'.
+     */
+    numeric?: 'always' | 'auto';
+    /**
+     * The formatting style to use.
+     */
+    style?: 'long' | 'short' | 'narrow';
+}
+/**
+ * Formats the distance between two dates as a human-readable, internationalized string.
+ *
+ * The function automatically picks the most appropriate unit based on the distance between dates.
+ * For example, if the distance is a few hours, it returns "in X hours". If the distance is a few
+ * months, it returns "in X months".
+ *
+ * You can force a specific unit using the `options.unit` parameter.
+ *
+ * @param laterDate - The later date to compare
+ * @param earlierDate - The earlier date to compare with
+ * @param options - Formatting options
+ * @returns The formatted distance string
+ *
+ * @example
+ * ```typescript
+ * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');
+ *
+ * intlFormatDistance(later, earlier);
+ * // => 'in 1 hour'
+ *
+ * intlFormatDistance(earlier, later);
+ * // => '1 hour ago'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Force a specific unit
+ * const later = Temporal.Instant.from('2025-01-01T00:00:00Z');
+ * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');
+ *
+ * intlFormatDistance(later, earlier, { unit: 'quarter' });
+ * // => 'in 4 quarters'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use a different locale
+ * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');
+ * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');
+ *
+ * intlFormatDistance(later, earlier, { locale: 'es' });
+ * // => 'dentro de 1 hora'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use numeric: 'always' to avoid special strings
+ * const later = Temporal.Instant.from('2024-01-02T00:00:00Z');
+ * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');
+ *
+ * intlFormatDistance(later, earlier, { numeric: 'auto' });
+ * // => 'tomorrow'
+ *
+ * intlFormatDistance(later, earlier, { numeric: 'always' });
+ * // => 'in 1 day'
+ * ```
+ */
+export declare function intlFormatDistance(laterDate: Temporal.Instant | Temporal.ZonedDateTime, earlierDate: Temporal.Instant | Temporal.ZonedDateTime, options?: IntlFormatDistanceOptions): string;
+//# sourceMappingURL=intlFormatDistance.d.ts.map

package/dist/intlFormatDistance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intlFormatDistance.d.ts","sourceRoot":"","sources":["../src/intlFormatDistance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAUtD,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC,sBAAsB,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B;;OAEG;IACH,aAAa,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC5B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACpD,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EACtD,OAAO,CAAC,EAAE,yBAAyB,GAClC,MAAM,CAuER"}

package/dist/intlFormatDistance.js

@@ -0,0 +1,15 @@
+import {
+  intlFormatDistance
+} from "./chunk-XEDXPI5G.js";
+import "./chunk-ZHRMURYP.js";
+import "./chunk-PVAOUYXF.js";
+import "./chunk-CHW2EN2O.js";
+import "./chunk-6IP245MS.js";
+import "./chunk-PIDXROVB.js";
+import "./chunk-RJY62CDU.js";
+import "./chunk-BIAPE4MR.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  intlFormatDistance
+};
+//# sourceMappingURL=intlFormatDistance.js.map

package/dist/intlFormatDistance.js.map

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

package/dist/intlFormatDistance.test.d.ts

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

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

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

package/dist/isSameHour.d.ts

@@ -0,0 +1,58 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same hour.
+ * Compares the year, month, day, and hour fields directly.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same hour, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same hour
+ * const start = Temporal.ZonedDateTime.from('2025-01-20T14:00:00Z[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999Z[UTC]');
+ *
+ * isSameHour(start, end); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different hours
+ * const hour14 = Temporal.ZonedDateTime.from('2025-01-20T14:59:59Z[UTC]');
+ * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00Z[UTC]');
+ *
+ * isSameHour(hour14, hour15); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local hours
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:00-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:00+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local hours from each person's perspective
+ * isSameHour(ny, tokyo); // false (14:xx in NY, 04:xx in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameHour(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:xx in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameHour(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:xx in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:15:30Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:45:50Z');
+ *
+ * isSameHour(instant1, instant2); // true (both 14:xx in UTC)
+ * ```
+ */
+export declare function isSameHour(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameHour.d.ts.map

package/dist/isSameHour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameHour.d.ts","sourceRoot":"","sources":["../src/isSameHour.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAUT"}

package/dist/isSameHour.js

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

package/dist/isSameHour.js.map

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

package/dist/isSameHour.test.d.ts

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

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

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

package/dist/isSameMicrosecond.d.ts

@@ -0,0 +1,59 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same microsecond.
+ * Compares the year, month, day, hour, minute, second, millisecond, and microsecond fields directly.
+ * Ignores sub-microsecond precision (nanoseconds).
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same microsecond, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same microsecond
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456Z[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456999Z[UTC]');
+ *
+ * isSameMicrosecond(time1, time2); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different microseconds
+ * const us456 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456Z[UTC]');
+ * const us457 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123457Z[UTC]');
+ *
+ * isSameMicrosecond(us456, us457); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local microseconds
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987654+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local microseconds from each person's perspective
+ * isSameMicrosecond(ny, tokyo); // false (14:30:45.123456 in NY, 04:30:45.987654 in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameMicrosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameMicrosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456999Z');
+ *
+ * isSameMicrosecond(instant1, instant2); // true (both 14:30:45.123456 in UTC)
+ * ```
+ */
+export declare function isSameMicrosecond(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameMicrosecond.d.ts.map

package/dist/isSameMicrosecond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameMicrosecond.d.ts","sourceRoot":"","sources":["../src/isSameMicrosecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAcT"}

package/dist/isSameMicrosecond.js

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

package/dist/isSameMicrosecond.js.map

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

package/dist/isSameMicrosecond.test.d.ts

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

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

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

package/dist/isSameMillisecond.d.ts

@@ -0,0 +1,59 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same millisecond.
+ * Compares the year, month, day, hour, minute, second, and millisecond fields directly.
+ * Ignores sub-millisecond precision (microseconds, nanoseconds).
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same millisecond, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same millisecond
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123Z[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999Z[UTC]');
+ *
+ * isSameMillisecond(time1, time2); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different milliseconds
+ * const ms123 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123Z[UTC]');
+ * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124Z[UTC]');
+ *
+ * isSameMillisecond(ms123, ms124); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local milliseconds
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local milliseconds from each person's perspective
+ * isSameMillisecond(ny, tokyo); // false (14:30:45.123 in NY, 04:30:45.987 in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameMillisecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameMillisecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123999Z');
+ *
+ * isSameMillisecond(instant1, instant2); // true (both 14:30:45.123 in UTC)
+ * ```
+ */
+export declare function isSameMillisecond(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameMillisecond.d.ts.map

package/dist/isSameMillisecond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameMillisecond.d.ts","sourceRoot":"","sources":["../src/isSameMillisecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAaT"}

package/dist/isSameMillisecond.js

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

package/dist/isSameMillisecond.js.map

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

package/dist/isSameMillisecond.test.d.ts

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

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

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

package/dist/isSameMinute.d.ts

@@ -0,0 +1,58 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same minute.
+ * Compares the year, month, day, hour, and minute fields directly.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same minute, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same minute
+ * const start = Temporal.ZonedDateTime.from('2025-01-20T14:30:00Z[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-20T14:30:59.999Z[UTC]');
+ *
+ * isSameMinute(start, end); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different minutes
+ * const min30 = Temporal.ZonedDateTime.from('2025-01-20T14:30:59Z[UTC]');
+ * const min31 = Temporal.ZonedDateTime.from('2025-01-20T14:31:00Z[UTC]');
+ *
+ * isSameMinute(min30, min31); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local minutes
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local minutes from each person's perspective
+ * isSameMinute(ny, tokyo); // false (14:30:xx in NY, 04:30:xx in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameMinute(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:xx in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameMinute(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:xx in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:30:15Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45Z');
+ *
+ * isSameMinute(instant1, instant2); // true (both 14:30:xx in UTC)
+ * ```
+ */
+export declare function isSameMinute(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameMinute.d.ts.map

package/dist/isSameMinute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameMinute.d.ts","sourceRoot":"","sources":["../src/isSameMinute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAWT"}

package/dist/isSameMinute.js

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

package/dist/isSameMinute.js.map

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

package/dist/isSameMinute.test.d.ts

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

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

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