@gobrand/tiempo 3.0.1 → 3.1.3

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-NVFFQJEW.js";
+import "./chunk-CDKIT7D3.js";
+import "./chunk-4GEF7B7W.js";
+import "./chunk-Q6QLOUXJ.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-BI42E23Z.js";
+import "./chunk-BMX7CIRD.js";
+import "./chunk-4GEF7B7W.js";
+import "./chunk-Q6QLOUXJ.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.d.ts

@@ -14,8 +14,8 @@ import { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Same timezone, same day
- * const morning = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]');
- * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00Z[UTC]');
+ * const morning = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');
+ * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00+00:00[UTC]');
  *
  * isSameDay(morning, evening); // true
  * ```
@@ -23,8 +23,8 @@ import { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Same timezone, different days
- * const today = Temporal.ZonedDateTime.from('2025-01-20T23:59:59Z[UTC]');
- * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00Z[UTC]');
+ * const today = Temporal.ZonedDateTime.from('2025-01-20T23:59:59+00:00[UTC]');
+ * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+00:00[UTC]');
  *
  * isSameDay(today, tomorrow); // false
  * ```

package/dist/isSameDay.js

@@ -1,8 +1,8 @@
 import {
   isSameDay
-} from "./chunk-RLVCSGRU.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+} from "./chunk-F3UZDWOQ.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -14,8 +14,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-20T14:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999+00:00[UTC]');
  *
  * isSameHour(start, end); // true
  * ```
@@ -23,8 +23,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const hour14 = Temporal.ZonedDateTime.from('2025-01-20T14:59:59+00:00[UTC]');
+ * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00+00:00[UTC]');
  *
  * isSameHour(hour14, hour15); // false
  * ```

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-QZ6WXAUO.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -15,8 +15,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456999+00:00[UTC]');
  *
  * isSameMicrosecond(time1, time2); // true
  * ```
@@ -24,8 +24,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const us456 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');
+ * const us457 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123457+00:00[UTC]');
  *
  * isSameMicrosecond(us456, us457); // false
  * ```
@@ -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-3XGUCQ2A.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -15,8 +15,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999+00:00[UTC]');
  *
  * isSameMillisecond(time1, time2); // true
  * ```
@@ -24,8 +24,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const ms123 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');
+ * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124+00:00[UTC]');
  *
  * isSameMillisecond(ms123, ms124); // false
  * ```
@@ -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-K6NQZIAW.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -14,8 +14,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-20T14:30:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-20T14:30:59.999+00:00[UTC]');
  *
  * isSameMinute(start, end); // true
  * ```
@@ -23,8 +23,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @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]');
+ * const min30 = Temporal.ZonedDateTime.from('2025-01-20T14:30:59+00:00[UTC]');
+ * const min31 = Temporal.ZonedDateTime.from('2025-01-20T14:31:00+00:00[UTC]');
  *
  * isSameMinute(min30, min31); // false
  * ```

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-DBOIK3XA.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -14,8 +14,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, same month
- * const start = Temporal.ZonedDateTime.from('2025-01-01T08:00:00Z[UTC]');
- * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[UTC]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-01T08:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');
  *
  * isSameMonth(start, end); // true
  * ```
@@ -23,8 +23,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, different months
- * const jan = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[UTC]');
- * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00Z[UTC]');
+ * const jan = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');
+ * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00+00:00[UTC]');
  *
  * isSameMonth(jan, feb); // false
  * ```

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-HYSGJJUR.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -15,8 +15,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, exact same nanosecond
- * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
- * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');
  *
  * isSameNanosecond(time1, time2); // true
  * ```
@@ -24,8 +24,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, different nanoseconds
- * const ns789 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
- * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790Z[UTC]');
+ * const ns789 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789+00:00[UTC]');
+ * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790+00:00[UTC]');
  *
  * isSameNanosecond(ns789, ns790); // false
  * ```
@@ -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-R5XRTUWH.js";
+import "./chunk-Q6QLOUXJ.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.
  *
@@ -14,8 +14,8 @@ import type { Temporal } from "@js-temporal/polyfill";
  *
  * @example
  * ```ts
- * const jan = Temporal.ZonedDateTime.from('2025-01-15T08:00:00Z[UTC]');
- * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59Z[UTC]');
+ * const jan = Temporal.ZonedDateTime.from('2025-01-15T08:00:00+00:00[UTC]');
+ * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59+00:00[UTC]');
  * isSameQuarter(jan, mar); // true
  * ```
  *

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-BPMS34GV.js";
 import "./chunk-XS2HUADA.js";
-import "./chunk-NTMT5XGC.js";
-import "./chunk-R7ZCA6AQ.js";
+import "./chunk-Q6QLOUXJ.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.
@@ -15,8 +15,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, same second
- * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000Z[UTC]');
- * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999Z[UTC]');
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000+00:00[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999+00:00[UTC]');
  *
  * isSameSecond(time1, time2); // true
  * ```
@@ -24,8 +24,8 @@ import type { Temporal } from '@js-temporal/polyfill';
  * @example
  * ```ts
  * // Same timezone, different seconds
- * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45Z[UTC]');
- * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46Z[UTC]');
+ * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45+00:00[UTC]');
+ * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46+00:00[UTC]');
  *
  * isSameSecond(sec45, sec46); // false
  * ```

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-5WHGX2J3.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
 export {
   isSameSecond
 };