@gobrand/tiempo 3.0.0 → 3.1.2

package/dist/intlFormatDistance.js

@@ -1,16 +1,15 @@
 import {
   intlFormatDistance
-} from "./chunk-DMFV2AL7.js";
-import "./chunk-EMZFQEWM.js";
-import "./chunk-CIA46DWB.js";
-import "./chunk-EBVLBLR3.js";
-import "./chunk-LODULPI3.js";
-import "./chunk-DCCHY45G.js";
-import "./chunk-EU3SYJHM.js";
-import "./chunk-X3ARINEH.js";
-import "./chunk-VXOQ7IG5.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-3IYGWL34.js";
+import "./chunk-D3BJEYTR.js";
+import "./chunk-MXUGDXSG.js";
+import "./chunk-35IJG3T2.js";
+import "./chunk-E5HJJFUI.js";
+import "./chunk-SLBDEPBP.js";
+import "./chunk-OYTQWJ2O.js";
+import "./chunk-2LN57UVR.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   intlFormatDistance
 };

package/dist/isAfter.d.ts

@@ -1,10 +1,11 @@
-import { Temporal } from './shared/temporal.js';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if the first datetime is after the second datetime.
- * Compares by the underlying instant (epoch time), not by calendar date/time.
+ * Timeline values compare by their instant. PlainDate pairs compare dates;
+ * PlainTime pairs compare wall-clock times without wrapping at midnight.
  *
- * @param date1 - First datetime (Instant or ZonedDateTime)
- * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @param date1 - First value in a matching date, time, or timeline pair
+ * @param date2 - Second value in the same comparison domain
  * @returns true if date1 is after date2, false otherwise
  *
  * @example
@@ -33,8 +34,10 @@ import { Temporal } from './shared/temporal.js';
  * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
  *
  * isAfter(tokyo, ny); // false
- * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC the previous day (same instant)
+ * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC on January 20 (same instant)
  * ```
  */
+export declare function isAfter(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;
+export declare function isAfter(date1: Temporal.PlainTime, date2: Temporal.PlainTime): boolean;
 export declare function isAfter(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
 //# sourceMappingURL=isAfter.d.ts.map

package/dist/isAfter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isAfter.d.ts","sourceRoot":"","sources":["../src/isAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAKT"}
+{"version":3,"file":"isAfter.d.ts","sourceRoot":"","sources":["../src/isAfter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACvF,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACvF,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAAC"}

package/dist/isAfter.js

@@ -1,9 +1,8 @@
 import {
   isAfter
-} from "./chunk-7K5BJ6F7.js";
-import "./chunk-LSKER4FN.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-CN3OICYB.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isAfter
 };

package/dist/isBefore.d.ts

@@ -1,10 +1,11 @@
-import { Temporal } from './shared/temporal.js';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if the first datetime is before the second datetime.
- * Compares by the underlying instant (epoch time), not by calendar date/time.
+ * Timeline values compare by their instant. PlainDate pairs compare dates;
+ * PlainTime pairs compare wall-clock times without wrapping at midnight.
  *
- * @param date1 - First datetime (Instant or ZonedDateTime)
- * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @param date1 - First value in a matching date, time, or timeline pair
+ * @param date2 - Second value in the same comparison domain
  * @returns true if date1 is before date2, false otherwise
  *
  * @example
@@ -32,9 +33,11 @@ import { Temporal } from './shared/temporal.js';
  * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
  * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');
  *
- * isBefore(ny, tokyo); // true
- * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC the previous day
+ * isBefore(ny, tokyo); // false
+ * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC on January 20
  * ```
  */
+export declare function isBefore(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;
+export declare function isBefore(date1: Temporal.PlainTime, date2: Temporal.PlainTime): boolean;
 export declare function isBefore(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
 //# sourceMappingURL=isBefore.d.ts.map

package/dist/isBefore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isBefore.d.ts","sourceRoot":"","sources":["../src/isBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAKT"}
+{"version":3,"file":"isBefore.d.ts","sourceRoot":"","sources":["../src/isBefore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACxF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACxF,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAAC"}

package/dist/isBefore.js

@@ -1,9 +1,8 @@
 import {
   isBefore
-} from "./chunk-KGO3G2QB.js";
-import "./chunk-EVEMK2K2.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-OOOVMKOG.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isBefore
 };

package/dist/isEqual.d.ts

@@ -0,0 +1,27 @@
+import type { Temporal } from './shared/temporal.js';
+/**
+ * Returns true if both values are the same point in their domain.
+ * Timeline values are equal when they are the same exact instant, even in
+ * different timezones. PlainDate pairs compare dates; PlainTime pairs compare
+ * wall-clock times.
+ *
+ * Use `isSameNanosecond` to compare wall-clock fields instead, or
+ * `ZonedDateTime#equals` to also require the same timezone and calendar.
+ *
+ * @param date1 - First value in a matching date, time, or timeline pair
+ * @param date2 - Second value in the same comparison domain
+ * @returns true if date1 and date2 are equal, false otherwise
+ *
+ * @example
+ * ```ts
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');
+ * const utc = Temporal.Instant.from('2025-01-20T15:00:00Z');
+ *
+ * isEqual(ny, utc); // true (same instant)
+ * isEqual(Temporal.PlainDate.from('2025-01-20'), Temporal.PlainDate.from('2025-01-21')); // false
+ * ```
+ */
+export declare function isEqual(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;
+export declare function isEqual(date1: Temporal.PlainTime, date2: Temporal.PlainTime): boolean;
+export declare function isEqual(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isEqual.d.ts.map

package/dist/isEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.d.ts","sourceRoot":"","sources":["../src/isEqual.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACvF,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;AACvF,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAAC"}

package/dist/isEqual.js

@@ -0,0 +1,9 @@
+import {
+  isEqual
+} from "./chunk-V2NSN6ET.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  isEqual
+};
+//# sourceMappingURL=isEqual.js.map

package/dist/isEqual.js.map

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

package/dist/isFuture.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if the given datetime is in the future.
  * Compares by the underlying instant (epoch time) against the current time.

package/dist/isFuture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isFuture.d.ts","sourceRoot":"","sources":["../src/isFuture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC9C,OAAO,CAIT"}
+{"version":3,"file":"isFuture.d.ts","sourceRoot":"","sources":["../src/isFuture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC9C,OAAO,CAIT"}

package/dist/isFuture.js

@@ -1,10 +1,10 @@
 import {
   isFuture
-} from "./chunk-CCVPCHUO.js";
-import "./chunk-LSKER4FN.js";
-import "./chunk-6RETOV6A.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-O4YU4N6Q.js";
+import "./chunk-CDKIT7D3.js";
+import "./chunk-TWRJEIBO.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isFuture
 };

package/dist/isPast.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if the given datetime is in the past.
  * Compares by the underlying instant (epoch time) against the current time.

package/dist/isPast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPast.d.ts","sourceRoot":"","sources":["../src/isPast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC9C,OAAO,CAIT"}
+{"version":3,"file":"isPast.d.ts","sourceRoot":"","sources":["../src/isPast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC9C,OAAO,CAIT"}

package/dist/isPast.js

@@ -1,10 +1,10 @@
 import {
   isPast
-} from "./chunk-A42NID5P.js";
-import "./chunk-EVEMK2K2.js";
-import "./chunk-6RETOV6A.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-XXB6HJ2R.js";
+import "./chunk-BMX7CIRD.js";
+import "./chunk-TWRJEIBO.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPast
 };

package/dist/isPlainDateAfter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPlainDateAfter.d.ts","sourceRoot":"","sources":["../src/isPlainDateAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAET"}
+{"version":3,"file":"isPlainDateAfter.d.ts","sourceRoot":"","sources":["../src/isPlainDateAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAMT"}

package/dist/isPlainDateAfter.js

@@ -1,7 +1,7 @@
 import {
   isPlainDateAfter
-} from "./chunk-NEHYVVTH.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-ADPVFELS.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainDateAfter
 };

package/dist/isPlainDateBefore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPlainDateBefore.d.ts","sourceRoot":"","sources":["../src/isPlainDateBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAET"}
+{"version":3,"file":"isPlainDateBefore.d.ts","sourceRoot":"","sources":["../src/isPlainDateBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAMT"}

package/dist/isPlainDateBefore.js

@@ -1,7 +1,7 @@
 import {
   isPlainDateBefore
-} from "./chunk-UXMNCRG7.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-ZM32S3YU.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainDateBefore
 };

package/dist/isPlainDateEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPlainDateEqual.d.ts","sourceRoot":"","sources":["../src/isPlainDateEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAET"}
+{"version":3,"file":"isPlainDateEqual.d.ts","sourceRoot":"","sources":["../src/isPlainDateEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,GACxB,OAAO,CAMT"}

package/dist/isPlainDateEqual.js

@@ -1,7 +1,7 @@
 import {
   isPlainDateEqual
-} from "./chunk-OKXCGA4Y.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-EH4GVGXD.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainDateEqual
 };

package/dist/isPlainTimeAfter.js

@@ -1,7 +1,7 @@
 import {
   isPlainTimeAfter
-} from "./chunk-TQUKIG26.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-QJYU5TLL.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainTimeAfter
 };

package/dist/isPlainTimeBefore.js

@@ -1,7 +1,7 @@
 import {
   isPlainTimeBefore
-} from "./chunk-NX7MXLFS.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-KTMCYEU5.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainTimeBefore
 };

package/dist/isPlainTimeEqual.js

@@ -1,7 +1,7 @@
 import {
   isPlainTimeEqual
-} from "./chunk-PURKYS5T.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-6XEHR3MG.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isPlainTimeEqual
 };

package/dist/isSameDay.js

@@ -1,8 +1,8 @@
 import {
   isSameDay
-} from "./chunk-RLVCSGRU.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-AVPV4BA5.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameDay
 };

package/dist/isSameHour.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same hour.
  * Compares the year, month, day, and hour fields directly.

package/dist/isSameHour.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"isSameHour.d.ts","sourceRoot":"","sources":["../src/isSameHour.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,8 +1,8 @@
 import {
   isSameHour
-} from "./chunk-MENMDB6M.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-44EIUFJB.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameHour
 };

package/dist/isSameMicrosecond.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same microsecond.
  * Compares the year, month, day, hour, minute, second, millisecond, and microsecond fields directly.
@@ -34,10 +34,10 @@ import type { Temporal } from '@js-temporal/polyfill';
  * ```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]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456+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)
+ * isSameMicrosecond(ny, tokyo); // false (14:30:45.123456 in NY, 04:30:45.123456 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)

package/dist/isSameMicrosecond.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"isSameMicrosecond.d.ts","sourceRoot":"","sources":["../src/isSameMicrosecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,8 +1,8 @@
 import {
   isSameMicrosecond
-} from "./chunk-SDW4W3XE.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-EBQ25TEY.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameMicrosecond
 };

package/dist/isSameMillisecond.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same millisecond.
  * Compares the year, month, day, hour, minute, second, and millisecond fields directly.
@@ -34,10 +34,10 @@ import type { Temporal } from '@js-temporal/polyfill';
  * ```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]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123+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)
+ * isSameMillisecond(ny, tokyo); // false (14:30:45.123 in NY, 04:30:45.123 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)

package/dist/isSameMillisecond.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"isSameMillisecond.d.ts","sourceRoot":"","sources":["../src/isSameMillisecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,8 +1,8 @@
 import {
   isSameMillisecond
-} from "./chunk-T5WSO6US.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-MCPKXTX7.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameMillisecond
 };

package/dist/isSameMinute.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same minute.
  * Compares the year, month, day, hour, and minute fields directly.

package/dist/isSameMinute.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"isSameMinute.d.ts","sourceRoot":"","sources":["../src/isSameMinute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,8 +1,8 @@
 import {
   isSameMinute
-} from "./chunk-OLLX6YCN.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-W5FFJSCD.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameMinute
 };

package/dist/isSameMonth.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same calendar month and year.
  * Compares the year and month fields directly.

package/dist/isSameMonth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameMonth.d.ts","sourceRoot":"","sources":["../src/isSameMonth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAKT"}
+{"version":3,"file":"isSameMonth.d.ts","sourceRoot":"","sources":["../src/isSameMonth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAKT"}

package/dist/isSameMonth.js

@@ -1,8 +1,8 @@
 import {
   isSameMonth
-} from "./chunk-SCD2JNY3.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-FUVG6A7U.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameMonth
 };

package/dist/isSameNanosecond.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes represent the exact same nanosecond.
  * Compares all time fields: year, month, day, hour, minute, second, millisecond, microsecond, and nanosecond.
@@ -34,10 +34,10 @@ import type { Temporal } from '@js-temporal/polyfill';
  * ```ts
  * // Different timezones - compares their local nanoseconds
  * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789-05:00[America/New_York]');
- * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987654321+09:00[Asia/Tokyo]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456789+09:00[Asia/Tokyo]');
  *
  * // Same instant, different local nanoseconds from each person's perspective
- * isSameNanosecond(ny, tokyo); // false (14:30:45.123456789 in NY, 04:30:45.987654321 in Tokyo)
+ * isSameNanosecond(ny, tokyo); // false (14:30:45.123456789 in NY, 04:30:45.123456789 in Tokyo)
  *
  * // Convert to UTC to compare in UTC timezone
  * isSameNanosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456789 in UTC)

package/dist/isSameNanosecond.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameNanosecond.d.ts","sourceRoot":"","sources":["../src/isSameNanosecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAeT"}
+{"version":3,"file":"isSameNanosecond.d.ts","sourceRoot":"","sources":["../src/isSameNanosecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAeT"}

package/dist/isSameNanosecond.js

@@ -1,8 +1,8 @@
 import {
   isSameNanosecond
-} from "./chunk-3LTTYG6N.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-DXSRRBJO.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameNanosecond
 };

package/dist/isSameQuarter.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import { type Temporal } from "./shared/temporal.js";
 /**
  * Returns true if both inputs fall in the same calendar quarter and year.
  *

package/dist/isSameQuarter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameQuarter.d.ts","sourceRoot":"","sources":["../src/isSameQuarter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAAC;AACX,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC"}
+{"version":3,"file":"isSameQuarter.d.ts","sourceRoot":"","sources":["../src/isSameQuarter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAAC;AACX,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC"}

package/dist/isSameQuarter.js

@@ -1,9 +1,9 @@
 import {
   isSameQuarter
-} from "./chunk-25CVKMFC.js";
+} from "./chunk-5WPQUOM4.js";
 import "./chunk-XS2HUADA.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameQuarter
 };

package/dist/isSameSecond.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same second.
  * Compares the year, month, day, hour, minute, and second fields directly.

package/dist/isSameSecond.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameSecond.d.ts","sourceRoot":"","sources":["../src/isSameSecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;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,CAYT"}
+{"version":3,"file":"isSameSecond.d.ts","sourceRoot":"","sources":["../src/isSameSecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;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,CAYT"}

package/dist/isSameSecond.js

@@ -1,8 +1,8 @@
 import {
   isSameSecond
-} from "./chunk-CSOSM46M.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-PYV7MWJJ.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameSecond
 };

package/dist/isSameWeek.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same ISO 8601 week.
  * Uses ISO week numbering where weeks start on Monday and the first week

package/dist/isSameWeek.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameWeek.d.ts","sourceRoot":"","sources":["../src/isSameWeek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;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,CAQT"}
+{"version":3,"file":"isSameWeek.d.ts","sourceRoot":"","sources":["../src/isSameWeek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;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,CAQT"}

package/dist/isSameWeek.js

@@ -1,8 +1,8 @@
 import {
   isSameWeek
-} from "./chunk-MNV2H4N6.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-SATEE2TL.js";
+import "./chunk-JNAWZ4RN.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameWeek
 };

package/dist/isSameYear.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from '@js-temporal/polyfill';
+import type { Temporal } from './shared/temporal.js';
 /**
  * Returns true if both datetimes fall in the same calendar year.
  * Compares the year field directly.