@gobrand/tiempo 3.1.2 → 3.2.0

package/dist/isSameMillisecond.js

@@ -1,7 +1,7 @@
 import {
   isSameMillisecond
-} from "./chunk-MCPKXTX7.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-K6NQZIAW.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameMillisecond

package/dist/isSameMinute.d.ts

@@ -14,8 +14,8 @@ import type { Temporal } from './shared/temporal.js';
  * @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 './shared/temporal.js';
  * @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.js

@@ -1,7 +1,7 @@
 import {
   isSameMinute
-} from "./chunk-W5FFJSCD.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-DBOIK3XA.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameMinute

package/dist/isSameMonth.d.ts

@@ -14,8 +14,8 @@ import type { Temporal } from './shared/temporal.js';
  * @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 './shared/temporal.js';
  * @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.js

@@ -1,7 +1,7 @@
 import {
   isSameMonth
-} from "./chunk-FUVG6A7U.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-HYSGJJUR.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameMonth

package/dist/isSameNanosecond.d.ts

@@ -15,8 +15,8 @@ import type { Temporal } from './shared/temporal.js';
  * @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 './shared/temporal.js';
  * @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
  * ```

package/dist/isSameNanosecond.js

@@ -1,7 +1,7 @@
 import {
   isSameNanosecond
-} from "./chunk-DXSRRBJO.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-R5XRTUWH.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameNanosecond

package/dist/isSameQuarter.d.ts

@@ -14,8 +14,8 @@ import { type Temporal } from "./shared/temporal.js";
  *
  * @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.js

@@ -1,8 +1,8 @@
 import {
   isSameQuarter
-} from "./chunk-5WPQUOM4.js";
+} from "./chunk-BPMS34GV.js";
 import "./chunk-XS2HUADA.js";
-import "./chunk-JNAWZ4RN.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameQuarter

package/dist/isSameSecond.d.ts

@@ -15,8 +15,8 @@ import type { Temporal } from './shared/temporal.js';
  * @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 './shared/temporal.js';
  * @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.js

@@ -1,7 +1,7 @@
 import {
   isSameSecond
-} from "./chunk-PYV7MWJJ.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-5WHGX2J3.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameSecond

package/dist/isSameWeek.d.ts

@@ -1,10 +1,8 @@
 import type { Temporal } from './shared/temporal.js';
+import { type WeekOptions } from './shared/week.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
- * of the year is the week containing January 4th.
- *
- * Compares the yearOfWeek and weekOfYear fields directly.
+ * Returns true if both datetimes fall in the same week.
+ * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.
  *
  * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
  * timezone is preserved. Convert to a common timezone before calling if
@@ -12,13 +10,14 @@ import type { Temporal } from './shared/temporal.js';
  *
  * @param date1 - First datetime (Instant or ZonedDateTime)
  * @param date2 - Second datetime (Instant or ZonedDateTime)
- * @returns true if both dates are in the same ISO week, false otherwise
+ * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday
+ * @returns true if both dates are in the same week, false otherwise
  *
  * @example
  * ```ts
  * // Same timezone, same week (both in week 4 of 2025)
- * const monday = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]'); // Monday, Week 4
- * const sunday = Temporal.ZonedDateTime.from('2025-01-26T23:59:59Z[UTC]'); // Sunday, Week 4
+ * const monday = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]'); // Monday, Week 4
+ * const sunday = Temporal.ZonedDateTime.from('2025-01-26T23:59:59+00:00[UTC]'); // Sunday, Week 4
  *
  * isSameWeek(monday, sunday); // true
  * ```
@@ -26,8 +25,8 @@ import type { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Same timezone, different weeks
- * const week3 = Temporal.ZonedDateTime.from('2025-01-19T23:59:59Z[UTC]'); // Sunday, Week 3
- * const week4 = Temporal.ZonedDateTime.from('2025-01-20T00:00:00Z[UTC]'); // Monday, Week 4
+ * const week3 = Temporal.ZonedDateTime.from('2025-01-19T23:59:59+00:00[UTC]'); // Sunday, Week 3
+ * const week4 = Temporal.ZonedDateTime.from('2025-01-20T00:00:00+00:00[UTC]'); // Monday, Week 4
  *
  * isSameWeek(week3, week4); // false
  * ```
@@ -61,12 +60,22 @@ import type { Temporal } from './shared/temporal.js';
  * ```ts
  * // ISO week years can differ from calendar years
  * // December 29, 2024 is in Week 52 of 2024
- * const dec29 = Temporal.ZonedDateTime.from('2024-12-29T12:00:00Z[UTC]');
+ * const dec29 = Temporal.ZonedDateTime.from('2024-12-29T12:00:00+00:00[UTC]');
  * // January 5, 2025 is in Week 1 of 2025
- * const jan5 = Temporal.ZonedDateTime.from('2025-01-05T12:00:00Z[UTC]');
+ * const jan5 = Temporal.ZonedDateTime.from('2025-01-05T12:00:00+00:00[UTC]');
  *
  * isSameWeek(dec29, jan5); // false (different ISO weeks)
  * ```
+ *
+ * @example
+ * ```ts
+ * // Weeks that start on Sunday
+ * const saturday = Temporal.ZonedDateTime.from('2025-01-25T12:00:00+00:00[UTC]');
+ * const sunday = Temporal.ZonedDateTime.from('2025-01-26T12:00:00+00:00[UTC]');
+ *
+ * isSameWeek(saturday, sunday); // true
+ * isSameWeek(saturday, sunday, { weekStartsOn: 7 }); // false
+ * ```
  */
-export declare function isSameWeek(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+export declare function isSameWeek(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime, options?: WeekOptions): boolean;
 //# sourceMappingURL=isSameWeek.d.ts.map

package/dist/isSameWeek.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"isSameWeek.d.ts","sourceRoot":"","sources":["../src/isSameWeek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAOT"}

package/dist/isSameWeek.js

@@ -1,7 +1,8 @@
 import {
   isSameWeek
-} from "./chunk-SATEE2TL.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-6UBFKQIJ.js";
+import "./chunk-M2XB72L5.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameWeek

package/dist/isSameYear.d.ts

@@ -14,8 +14,8 @@ import type { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Same timezone, same year
- * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]');
- * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');
+ * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');
+ * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59+00:00[UTC]');
  *
  * isSameYear(jan, dec); // true
  * ```
@@ -23,8 +23,8 @@ import type { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Same timezone, different years
- * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59Z[UTC]');
- * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
+ * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59+00:00[UTC]');
+ * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');
  *
  * isSameYear(endOf2024, startOf2025); // false
  * ```

package/dist/isSameYear.js

@@ -1,7 +1,7 @@
 import {
   isSameYear
-} from "./chunk-ZO2MTD2E.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-R2DCUSBY.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isSameYear

package/dist/isWeekend.js

@@ -1,8 +1,8 @@
 import {
   isWeekend
-} from "./chunk-QD3ROUIT.js";
-import "./chunk-Z7I7YCKN.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-GOJ45AG7.js";
+import "./chunk-4YCEFGZA.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isWeekend

package/dist/isWithinInterval.d.ts

@@ -1,17 +1,24 @@
-import { Temporal } from './shared/temporal.js';
+import { type Temporal } from './shared/temporal.js';
 /**
- * Returns true if the given date is within the interval (inclusive of start and end).
- * Compares by the underlying instant (epoch time), not by calendar date/time.
+ * Returns true if the given value is within the interval (inclusive of start and end).
  *
- * @param date - The date to check (Instant or ZonedDateTime)
- * @param interval - The interval with start and end dates
- * @returns true if date is within the interval, false otherwise
+ * Instants and ZonedDateTimes compare by the moment they represent, not by
+ * calendar date/time. PlainDates compare by date. PlainTimes compare by
+ * wall-clock time, and an interval whose start is later than its end wraps
+ * past midnight: 22:00 to 02:00 contains 23:30 and 01:00. A reversed timeline
+ * or PlainDate interval contains nothing.
+ *
+ * Mixing PlainDate, PlainTime, and timeline values throws a TypeError.
+ *
+ * @param date - The value to check
+ * @param interval - The interval with start and end values of the same kind
+ * @returns true if the value is within the interval, false otherwise
  *
  * @example
  * ```ts
- * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
- * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00Z[UTC]');
- * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00Z[UTC]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');
+ * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[UTC]');
  *
  * isWithinInterval(date, { start, end }); // true
  * ```
@@ -19,9 +26,9 @@ import { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Date outside the interval
- * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
- * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00Z[UTC]');
- * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00Z[UTC]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');
+ * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[UTC]');
  *
  * isWithinInterval(date, { start, end }); // false
  * ```
@@ -29,8 +36,8 @@ import { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Date equal to interval start (inclusive)
- * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
- * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00Z[UTC]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');
  *
  * isWithinInterval(start, { start, end }); // true
  * ```
@@ -38,8 +45,8 @@ import { Temporal } from './shared/temporal.js';
  * @example
  * ```ts
  * // Date equal to interval end (inclusive)
- * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
- * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00Z[UTC]');
+ * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');
+ * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');
  *
  * isWithinInterval(end, { start, end }); // true
  * ```
@@ -59,11 +66,39 @@ import { Temporal } from './shared/temporal.js';
  * // Different timezones - compares by instant
  * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00-05:00[America/New_York]');
  * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+09:00[Asia/Tokyo]');
- * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00Z[UTC]');
+ * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00+00:00[UTC]');
  *
  * isWithinInterval(date, { start, end }); // true
  * ```
+ *
+ * @example
+ * ```ts
+ * // Dates
+ * const start = Temporal.PlainDate.from('2025-07-01');
+ * const end = Temporal.PlainDate.from('2025-07-15');
+ *
+ * isWithinInterval(Temporal.PlainDate.from('2025-07-15'), { start, end }); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Opening hours that run past midnight
+ * const start = Temporal.PlainTime.from('22:00');
+ * const end = Temporal.PlainTime.from('02:00');
+ *
+ * isWithinInterval(Temporal.PlainTime.from('23:30'), { start, end }); // true
+ * isWithinInterval(Temporal.PlainTime.from('01:00'), { start, end }); // true
+ * isWithinInterval(Temporal.PlainTime.from('12:00'), { start, end }); // false
+ * ```
  */
+export declare function isWithinInterval(date: Temporal.PlainDate, interval: {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}): boolean;
+export declare function isWithinInterval(date: Temporal.PlainTime, interval: {
+    start: Temporal.PlainTime;
+    end: Temporal.PlainTime;
+}): boolean;
 export declare function isWithinInterval(date: Temporal.Instant | Temporal.ZonedDateTime, interval: {
     start: Temporal.Instant | Temporal.ZonedDateTime;
     end: Temporal.Instant | Temporal.ZonedDateTime;

package/dist/isWithinInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isWithinInterval.d.ts","sourceRoot":"","sources":["../src/isWithinInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAC/C,QAAQ,EAAE;IACR,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;IACjD,GAAG,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;CAChD,GACA,OAAO,CAMT"}
+{"version":3,"file":"isWithinInterval.d.ts","sourceRoot":"","sources":["../src/isWithinInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA4B,MAAM,mBAAmB,CAAC;AAM5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,QAAQ,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,GAC/D,OAAO,CAAC;AACX,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,QAAQ,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,GAC/D,OAAO,CAAC;AACX,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAC/C,QAAQ,EAAE;IACR,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;IACjD,GAAG,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;CAChD,GACA,OAAO,CAAC"}

package/dist/isWithinInterval.js

@@ -1,9 +1,10 @@
 import {
   isWithinInterval
-} from "./chunk-ZYRUL5E7.js";
-import "./chunk-CDKIT7D3.js";
+} from "./chunk-IIEHQPKE.js";
 import "./chunk-BMX7CIRD.js";
-import "./chunk-JNAWZ4RN.js";
+import "./chunk-CDKIT7D3.js";
+import "./chunk-OMYVTYHI.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   isWithinInterval

package/dist/nextDay.d.ts

@@ -0,0 +1,33 @@
+import { type Temporal } from './shared/temporal.js';
+import { type DayOfWeek } from './shared/week.js';
+/**
+ * Returns the next date that falls on the given day of the week, always after
+ * the input: next Friday from a Friday is a week later.
+ *
+ * Days are numbered as Temporal numbers them: 1 = Monday … 7 = Sunday.
+ * PlainDate inputs stay dates. Instant inputs are read in UTC and ZonedDateTime
+ * inputs keep their timezone; both keep their wall-clock time.
+ *
+ * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate
+ * @param day - The day of the week to find, 1 = Monday … 7 = Sunday
+ * @returns The next date on that day of the week
+ *
+ * @example
+ * ```ts
+ * const wednesday = Temporal.PlainDate.from('2025-01-22');
+ *
+ * nextDay(wednesday, 5).toString(); // "2025-01-24"
+ * nextDay(wednesday, 3).toString(); // "2025-01-29"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Keeps the wall-clock time across a DST change
+ * const fridayEvening = Temporal.ZonedDateTime.from('2025-03-07T18:00:00-05:00[America/New_York]');
+ *
+ * nextDay(fridayEvening, 1).toString(); // "2025-03-10T18:00:00-04:00[America/New_York]"
+ * ```
+ */
+export declare function nextDay(input: Temporal.PlainDate, day: DayOfWeek): Temporal.PlainDate;
+export declare function nextDay(input: Temporal.Instant | Temporal.ZonedDateTime, day: DayOfWeek): Temporal.ZonedDateTime;
+//# sourceMappingURL=nextDay.d.ts.map

package/dist/nextDay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextDay.d.ts","sourceRoot":"","sources":["../src/nextDay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;AACvF,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,GAAG,EAAE,SAAS,GACb,QAAQ,CAAC,aAAa,CAAC"}

package/dist/nextDay.js

@@ -0,0 +1,10 @@
+import {
+  nextDay
+} from "./chunk-IDB3R3G5.js";
+import "./chunk-M2XB72L5.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  nextDay
+};
+//# sourceMappingURL=nextDay.js.map

package/dist/nextDay.js.map

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

package/dist/parse.d.ts

@@ -0,0 +1,57 @@
+import { Temporal } from './shared/temporal.js';
+import type { Timezone } from './types.js';
+export interface ParseOptions {
+    /** Locale for month, weekday, and AM/PM names. @default 'en-US' */
+    locale?: string;
+    /** Timezone the parsed wall-clock time belongs to. Required when the pattern has time fields. */
+    timeZone?: Timezone;
+}
+/**
+ * Reads a date, or a date and time, written in a known pattern. The pattern uses
+ * the same tokens as `format`, so text that `format` writes with a supported
+ * pattern reads back to the same fields.
+ *
+ * Without a timeZone the result is a PlainDate, and the pattern may only hold
+ * date fields. With a timeZone the result is a ZonedDateTime in that timezone:
+ * an offset in the text (`XXX`) fixes the moment, otherwise the wall-clock time
+ * is read in the timezone, and a time skipped by a DST change moves forward as
+ * in Temporal. A pattern without time fields gives the start of that day.
+ *
+ * Supported tokens: `yyyy` `y` `MMMM` `MMM` `MM` `M` `dd` `d` `EEEE` `EEE` `HH`
+ * `H` `hh` `h` `a` `mm` `m` `ss` `s` `SSS` `SS` `S` `X…XXXXX` `x…xxxxx`. Text in
+ * single quotes and any other character must match exactly. Two-digit years
+ * (`yy`) are rejected because the century is a guess.
+ *
+ * @param text - The text to read
+ * @param pattern - The pattern the text is written in, such as `dd/MM/yyyy`
+ * @param options - `timeZone` for patterns with a time; `locale` for names (default 'en-US')
+ * @returns PlainDate without a timeZone; ZonedDateTime with one
+ * @throws RangeError if the text does not match the pattern or names an impossible date
+ * @throws TypeError if the pattern has time fields but no timeZone is given
+ *
+ * @example
+ * ```ts
+ * parse('20/01/2025', 'dd/MM/yyyy').toString(); // "2025-01-20"
+ * parse('January 20, 2025', 'MMMM d, yyyy').toString(); // "2025-01-20"
+ * ```
+ *
+ * @example
+ * ```ts
+ * parse('01/20/2025 3:45 PM', 'MM/dd/yyyy h:mm a', { timeZone: 'America/New_York' }).toString();
+ * // "2025-01-20T15:45:00-05:00[America/New_York]"
+ * ```
+ *
+ * @example
+ * ```ts
+ * parse('20 enero 2025', 'd MMMM yyyy', { locale: 'es' }).toString(); // "2025-01-20"
+ * ```
+ */
+export declare function parse(text: string, pattern: string, options: {
+    locale?: string;
+    timeZone: Timezone;
+}): Temporal.ZonedDateTime;
+export declare function parse(text: string, pattern: string, options?: {
+    locale?: string;
+    timeZone?: undefined;
+}): Temporal.PlainDate;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GAC/C,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,GAClD,QAAQ,CAAC,SAAS,CAAC"}

package/dist/parse.js

@@ -0,0 +1,9 @@
+import {
+  parse
+} from "./chunk-3OOGJRXH.js";
+import "./chunk-HH2HTC44.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  parse
+};
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

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

package/dist/previousDay.d.ts

@@ -0,0 +1,26 @@
+import { type Temporal } from './shared/temporal.js';
+import { type DayOfWeek } from './shared/week.js';
+/**
+ * Returns the previous date that falls on the given day of the week, always
+ * before the input: previous Monday from a Monday is a week earlier.
+ *
+ * Days are numbered as Temporal numbers them: 1 = Monday … 7 = Sunday.
+ * PlainDate inputs stay dates. Instant inputs are read in UTC and ZonedDateTime
+ * inputs keep their timezone; both keep their wall-clock time.
+ *
+ * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate
+ * @param day - The day of the week to find, 1 = Monday … 7 = Sunday
+ * @returns The previous date on that day of the week
+ *
+ * @example
+ * ```ts
+ * const wednesday = Temporal.PlainDate.from('2025-01-22');
+ *
+ * previousDay(wednesday, 1).toString(); // "2025-01-20"
+ * previousDay(wednesday, 3).toString(); // "2025-01-15"
+ * previousDay(wednesday, 7).toString(); // "2025-01-19"
+ * ```
+ */
+export declare function previousDay(input: Temporal.PlainDate, day: DayOfWeek): Temporal.PlainDate;
+export declare function previousDay(input: Temporal.Instant | Temporal.ZonedDateTime, day: DayOfWeek): Temporal.ZonedDateTime;
+//# sourceMappingURL=previousDay.d.ts.map

package/dist/previousDay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"previousDay.d.ts","sourceRoot":"","sources":["../src/previousDay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;AAC3F,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,GAAG,EAAE,SAAS,GACb,QAAQ,CAAC,aAAa,CAAC"}

package/dist/previousDay.js

@@ -0,0 +1,10 @@
+import {
+  previousDay
+} from "./chunk-XMEPH226.js";
+import "./chunk-M2XB72L5.js";
+import "./chunk-Q6QLOUXJ.js";
+import "./chunk-BSVOJYJ7.js";
+export {
+  previousDay
+};
+//# sourceMappingURL=previousDay.js.map

package/dist/previousDay.js.map

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

package/dist/roundToNearestHour.js

@@ -1,7 +1,7 @@
 import {
   roundToNearestHour
-} from "./chunk-FLVULRGY.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-DGUAV5XN.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   roundToNearestHour

package/dist/roundToNearestMinute.js

@@ -1,7 +1,7 @@
 import {
   roundToNearestMinute
-} from "./chunk-5XJEKPO5.js";
-import "./chunk-JNAWZ4RN.js";
+} from "./chunk-6QOLNYFY.js";
+import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {
   roundToNearestMinute