@gobrand/tiempo 3.1.3 → 3.2.0

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/shared/businessDays.d.ts

@@ -21,4 +21,19 @@ export declare function addWeekdays<T extends {
  * Temporal implementation. Instant uses UTC; ZonedDateTime uses its timezone.
  */
 export declare function isoDate(input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate): Temporal.PlainDate;
+/**
+ * @internal
+ * Adds days counting only Monday–Friday that are not holidays. Holidays are
+ * matched by ISO date; those on weekends are already skipped.
+ */
+export declare function addBusinessDaysSkipping<T extends (Temporal.ZonedDateTime | Temporal.PlainDate) & {
+    add(duration: {
+        days: number;
+    }): T;
+}>(start: T, days: number, holidays: readonly Temporal.PlainDate[]): T;
+/**
+ * @internal
+ * Distinct holidays that fall Monday–Friday, as ISO PlainDates.
+ */
+export declare function weekdayHolidays(holidays: readonly Temporal.PlainDate[]): Temporal.PlainDate[];
 //# sourceMappingURL=businessDays.d.ts.map

package/dist/shared/businessDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"businessDays.d.ts","sourceRoot":"","sources":["../../src/shared/businessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,YAAY,CAAC;AAGnD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,CAAC,CAAA;CAAE,EAC7F,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,MAAM,GACX,CAAC,CAcH;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,SAAS,GACpE,QAAQ,CAAC,SAAS,CAGpB"}
+{"version":3,"file":"businessDays.d.ts","sourceRoot":"","sources":["../../src/shared/businessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,YAAY,CAAC;AAGnD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,CAAC,CAAA;CAAE,EAC7F,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,MAAM,GACX,CAAC,CAcH;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,SAAS,GACpE,QAAQ,CAAC,SAAS,CAGpB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,SAAS,CAAC,GAAG;IACxD,GAAG,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,CAAC,CAAC;CACpC,EACD,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,CAmBpE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GAAG,QAAQ,CAAC,SAAS,EAAE,CAO7F"}

package/dist/shared/businessDays.js

@@ -1,13 +1,17 @@
 import {
+  addBusinessDaysSkipping,
   addWeekdays,
   isWeekendDay,
-  isoDate
-} from "../chunk-K7CLBBBM.js";
+  isoDate,
+  weekdayHolidays
+} from "../chunk-4YCEFGZA.js";
 import "../chunk-Q6QLOUXJ.js";
 import "../chunk-BSVOJYJ7.js";
 export {
+  addBusinessDaysSkipping,
   addWeekdays,
   isWeekendDay,
-  isoDate
+  isoDate,
+  weekdayHolidays
 };
 //# sourceMappingURL=businessDays.js.map

package/dist/shared/calendarDates.d.ts

@@ -0,0 +1,9 @@
+import { Temporal } from './temporal.js';
+/**
+ * @internal
+ * The calendar dates behind a differenceInCalendar* pair: PlainDates as given,
+ * Instants by their UTC date, ZonedDateTimes by the date in their own timezone.
+ * Both come back in this implementation and in the earlier date's calendar.
+ */
+export declare function calendarDates(laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate, earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate): [later: Temporal.PlainDate, earlier: Temporal.PlainDate];
+//# sourceMappingURL=calendarDates.d.ts.map

package/dist/shared/calendarDates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendarDates.d.ts","sourceRoot":"","sources":["../../src/shared/calendarDates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,YAAY,CAAC;AAGnD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,SAAS,EACzE,WAAW,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,SAAS,GAC1E,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,CAO1D"}

package/dist/shared/calendarDates.js

@@ -0,0 +1,9 @@
+import {
+  calendarDates
+} from "../chunk-H43LMOCK.js";
+import "../chunk-Q6QLOUXJ.js";
+import "../chunk-BSVOJYJ7.js";
+export {
+  calendarDates
+};
+//# sourceMappingURL=calendarDates.js.map

package/dist/shared/calendarDates.js.map

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

package/dist/shared/formatTokens.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ * Reads the format token that starts at `start`, or null if `char` does not
+ * start one. A run of one letter longer than any token splits into several,
+ * longest first. Shared by format and parse so both read a pattern the same way.
+ */
+export declare function consumeToken(formatStr: string, start: number, char: string): string | null;
+//# sourceMappingURL=formatTokens.d.ts.map

package/dist/shared/formatTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatTokens.d.ts","sourceRoot":"","sources":["../../src/shared/formatTokens.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwF1F"}

package/dist/shared/formatTokens.js

@@ -0,0 +1,7 @@
+import {
+  consumeToken
+} from "../chunk-HH2HTC44.js";
+export {
+  consumeToken
+};
+//# sourceMappingURL=formatTokens.js.map

package/dist/shared/formatTokens.js.map

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

package/dist/shared/week.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Day of the week, numbered as Temporal numbers it: 1 = Monday … 7 = Sunday.
+ */
+export type DayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * Options for functions that need to know where a week begins.
+ */
+export interface WeekOptions {
+    /**
+     * The first day of the week: 1 = Monday … 7 = Sunday.
+     * @default 1 (Monday, as in ISO 8601)
+     */
+    weekStartsOn?: DayOfWeek;
+}
+/**
+ * @internal
+ * Checks a day-of-week argument. date-fns numbers Sunday 0; Temporal numbers it 7,
+ * so 0 is rejected rather than silently meaning something else.
+ */
+export declare function assertDayOfWeek(day: number, name: string): asserts day is DayOfWeek;
+/**
+ * @internal
+ * Days from the start of the week to a given day of the week (0–6).
+ */
+export declare function daysIntoWeek(dayOfWeek: number, options: WeekOptions | undefined): number;
+//# sourceMappingURL=week.d.ts.map

package/dist/shared/week.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"week.d.ts","sourceRoot":"","sources":["../../src/shared/week.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,SAAS,CAInF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAIxF"}

package/dist/shared/week.js

@@ -0,0 +1,9 @@
+import {
+  assertDayOfWeek,
+  daysIntoWeek
+} from "../chunk-M2XB72L5.js";
+export {
+  assertDayOfWeek,
+  daysIntoWeek
+};
+//# sourceMappingURL=week.js.map

package/dist/shared/week.js.map

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

package/dist/startOfQuarter.js

@@ -1,9 +1,9 @@
 import {
   startOfQuarter
-} from "./chunk-NGS5UKDW.js";
-import "./chunk-XS2HUADA.js";
+} from "./chunk-ZNRTNR2Q.js";
 import "./chunk-TCB3IDJM.js";
 import "./chunk-2AID4P2C.js";
+import "./chunk-XS2HUADA.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/startOfWeek.d.ts

@@ -1,12 +1,14 @@
 import { type Temporal } from './shared/temporal.js';
 import type { Timezone } from './types.js';
+import { type WeekOptions } from './shared/week.js';
 /**
- * Returns the first boundary of the week (Monday).
- * Uses ISO 8601 week definition: weeks start on Monday.
+ * Returns the first boundary of the week.
+ * Weeks start on Monday (ISO 8601) unless `weekStartsOn` says otherwise.
  * PlainDate inputs stay in calendar space unless a timezone is provided.
  *
- * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
- * @returns ZonedDateTime at Monday 00:00:00.000000000
+ * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate
+ * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday
+ * @returns The first day of the week at 00:00, or that date for PlainDate input
  *
  * @example
  * ```ts
@@ -39,8 +41,16 @@ import type { Timezone } from './types.js';
  * const start = startOfWeek(date, 'America/New_York');
  * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)
  * ```
+ *
+ * @example
+ * ```ts
+ * // Weeks that start on Sunday
+ * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday
+ * const start = startOfWeek(date, { weekStartsOn: 7 });
+ * // 2025-01-19 (previous Sunday)
+ * ```
  */
-export declare function startOfWeek(input: Temporal.Instant | Temporal.ZonedDateTime): Temporal.ZonedDateTime;
-export declare function startOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;
-export declare function startOfWeek(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;
+export declare function startOfWeek(input: Temporal.Instant | Temporal.ZonedDateTime, options?: WeekOptions): Temporal.ZonedDateTime;
+export declare function startOfWeek(input: Temporal.PlainDate, options?: WeekOptions): Temporal.PlainDate;
+export declare function startOfWeek(input: Temporal.PlainDate, timezone: Timezone, options?: WeekOptions): Temporal.ZonedDateTime;
 //# sourceMappingURL=startOfWeek.d.ts.map

package/dist/startOfWeek.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startOfWeek.d.ts","sourceRoot":"","sources":["../src/startOfWeek.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;AAC3E,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAAC,aAAa,CAAC"}
+{"version":3,"file":"startOfWeek.d.ts","sourceRoot":"","sources":["../src/startOfWeek.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC;AAClG,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,aAAa,CAAC"}

package/dist/startOfWeek.js

@@ -1,7 +1,8 @@
 import {
   startOfWeek
-} from "./chunk-MLHFNZEA.js";
+} from "./chunk-PLPGYCQQ.js";
 import "./chunk-2AID4P2C.js";
+import "./chunk-M2XB72L5.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/subBusinessDays.d.ts

@@ -1,13 +1,15 @@
 import { type Temporal } from './shared/temporal.js';
 /**
- * Subtracts business days (Monday–Friday), skipping weekends. Holidays are
- * not considered. Equivalent to `addBusinessDays(input, -days)`.
+ * Subtracts business days (Monday–Friday), skipping weekends and any holidays
+ * you pass. Equivalent to `addBusinessDays(input, -days, holidays)`.
  *
  * Instant inputs are converted to UTC. ZonedDateTime inputs keep their
  * timezone and time of day. PlainDate inputs stay dates.
  *
  * @param input - An Instant (UTC), ZonedDateTime, or PlainDate
  * @param days - Whole business days to subtract (negative to add)
+ * @param holidays - Dates that are not business days. For Instant and ZonedDateTime
+ *   inputs they are matched against the input's own date (UTC for Instant).
  * @returns PlainDate for a date input; otherwise ZonedDateTime
  * @throws RangeError if days is not an integer
  *
@@ -18,6 +20,6 @@ import { type Temporal } from './shared/temporal.js';
  * subBusinessDays(monday, 1); // 2025-01-24 (Friday)
  * ```
  */
-export declare function subBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;
-export declare function subBusinessDays(input: Temporal.Instant | Temporal.ZonedDateTime, days: number): Temporal.ZonedDateTime;
+export declare function subBusinessDays(input: Temporal.PlainDate, days: number, holidays?: readonly Temporal.PlainDate[]): Temporal.PlainDate;
+export declare function subBusinessDays(input: Temporal.Instant | Temporal.ZonedDateTime, days: number, holidays?: readonly Temporal.PlainDate[]): Temporal.ZonedDateTime;
 //# sourceMappingURL=subBusinessDays.d.ts.map

package/dist/subBusinessDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subBusinessDays.d.ts","sourceRoot":"","sources":["../src/subBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAG/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC;AAC7F,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,IAAI,EAAE,MAAM,GACX,QAAQ,CAAC,aAAa,CAAC"}
+{"version":3,"file":"subBusinessDays.d.ts","sourceRoot":"","sources":["../src/subBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,SAAS,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACvC,QAAQ,CAAC,SAAS,CAAC;AACtB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,SAAS,QAAQ,CAAC,SAAS,EAAE,GACvC,QAAQ,CAAC,aAAa,CAAC"}

package/dist/subBusinessDays.js

@@ -1,8 +1,8 @@
 import {
   subBusinessDays
-} from "./chunk-4PS6BEAC.js";
-import "./chunk-D3N7BT44.js";
-import "./chunk-K7CLBBBM.js";
+} from "./chunk-42IFQS4W.js";
+import "./chunk-2JXI3CAL.js";
+import "./chunk-4YCEFGZA.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobrand/tiempo",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "packageManager": "pnpm@10.33.4",
   "description": "Lightweight timezone-safe date and time utilities built on the Temporal API",
   "private": false,

package/dist/chunk-2TISXHHK.js

@@ -1,29 +0,0 @@
-import {
-  getEndOfDay
-} from "./chunk-NMMMAMKP.js";
-import {
-  plainDateToZonedDateTime
-} from "./chunk-2AID4P2C.js";
-import {
-  normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
-import {
-  isPlainDate
-} from "./chunk-BSVOJYJ7.js";
-
-// src/endOfWeek.ts
-function endOfWeek(input, timezone) {
-  if (isPlainDate(input) && timezone === void 0) {
-    return input.add({ days: 7 - input.dayOfWeek });
-  }
-  const zonedDateTime = isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
-  const dayOfWeek = zonedDateTime.dayOfWeek;
-  const daysToAdd = 7 - dayOfWeek;
-  const sunday = zonedDateTime.add({ days: daysToAdd });
-  return getEndOfDay(sunday);
-}
-
-export {
-  endOfWeek
-};
-//# sourceMappingURL=chunk-2TISXHHK.js.map

package/dist/chunk-2TISXHHK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the last boundary of the week (Sunday).\n * Uses ISO 8601 week definition: weeks end on Sunday.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at Sunday 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const end = endOfWeek(instant);\n * // 2025-01-26T23:59:59.999999999+00:00[UTC] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const end = endOfWeek(zoned);\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date);\n * // 2025-01-26 (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date, 'America/New_York');\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n */\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.add({ days: 7 - input.dayOfWeek });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to add to get to Sunday\n  const daysToAdd = 7 - dayOfWeek;\n\n  // Go to Sunday, then get end of that day\n  const sunday = zonedDateTime.add({ days: daysToAdd });\n\n  return getEndOfDay(sunday);\n}\n"],"mappings":";;;;;;;;;;;;;;AAsDO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,IAAI,EAAE,MAAM,IAAI,MAAM,UAAU,CAAC;AAAA,EAChD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,YAAY,IAAI;AAGtB,QAAM,SAAS,cAAc,IAAI,EAAE,MAAM,UAAU,CAAC;AAEpD,SAAO,YAAY,MAAM;AAC3B;","names":[]}

package/dist/chunk-4PS6BEAC.js

@@ -1,16 +0,0 @@
-import {
-  addBusinessDays
-} from "./chunk-D3N7BT44.js";
-import {
-  isPlainDate
-} from "./chunk-BSVOJYJ7.js";
-
-// src/subBusinessDays.ts
-function subBusinessDays(input, days) {
-  return isPlainDate(input) ? addBusinessDays(input, -days) : addBusinessDays(input, -days);
-}
-
-export {
-  subBusinessDays
-};
-//# sourceMappingURL=chunk-4PS6BEAC.js.map

package/dist/chunk-4PS6BEAC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/subBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addBusinessDays } from './addBusinessDays';\n\n/**\n * Subtracts business days (Monday–Friday), skipping weekends. Holidays are\n * not considered. Equivalent to `addBusinessDays(input, -days)`.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs keep their\n * timezone and time of day. PlainDate inputs stay dates.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @param days - Whole business days to subtract (negative to add)\n * @returns PlainDate for a date input; otherwise ZonedDateTime\n * @throws RangeError if days is not an integer\n *\n * @example\n * ```ts\n * const monday = Temporal.PlainDate.from('2025-01-27');\n *\n * subBusinessDays(monday, 1); // 2025-01-24 (Friday)\n * ```\n */\nexport function subBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addBusinessDays overload.\n  return isPlainDate(input) ? addBusinessDays(input, -days) : addBusinessDays(input, -days);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,gBACd,OACA,MAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,gBAAgB,OAAO,CAAC,IAAI,IAAI,gBAAgB,OAAO,CAAC,IAAI;AAC1F;","names":[]}

package/dist/chunk-57MHNRCU.js

@@ -1,22 +0,0 @@
-import {
-  isAfter
-} from "./chunk-CDKIT7D3.js";
-import {
-  isBefore
-} from "./chunk-BMX7CIRD.js";
-import {
-  normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
-
-// src/isWithinInterval.ts
-function isWithinInterval(date, interval) {
-  const normalizedDate = normalizeTemporalInput(date);
-  const normalizedStart = normalizeTemporalInput(interval.start);
-  const normalizedEnd = normalizeTemporalInput(interval.end);
-  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);
-}
-
-export {
-  isWithinInterval
-};
-//# sourceMappingURL=chunk-57MHNRCU.js.map

package/dist/chunk-57MHNRCU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isWithinInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { isAfter } from './shared/isAfter';\n\n/**\n * Returns true if the given date is within the interval (inclusive of start and end).\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date - The date to check (Instant or ZonedDateTime)\n * @param interval - The interval with start and end dates\n * @returns true if date is within the interval, false otherwise\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date outside the interval\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // false\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval start (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(start, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval end (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(end, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const start = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-07T00:00:00Z');\n * const date = Temporal.Instant.from('2025-01-03T00:00:00Z');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+09:00[Asia/Tokyo]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n */\nexport function isWithinInterval(\n  date: Temporal.Instant | Temporal.ZonedDateTime,\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime;\n    end: Temporal.Instant | Temporal.ZonedDateTime;\n  }\n): boolean {\n  const normalizedDate = normalizeTemporalInput(date);\n  const normalizedStart = normalizeTemporalInput(interval.start);\n  const normalizedEnd = normalizeTemporalInput(interval.end);\n\n  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);\n}\n"],"mappings":";;;;;;;;;;;AAsEO,SAAS,iBACd,MACA,UAIS;AACT,QAAM,iBAAiB,uBAAuB,IAAI;AAClD,QAAM,kBAAkB,uBAAuB,SAAS,KAAK;AAC7D,QAAM,gBAAgB,uBAAuB,SAAS,GAAG;AAEzD,SAAO,CAAC,SAAS,gBAAgB,eAAe,KAAK,CAAC,QAAQ,gBAAgB,aAAa;AAC7F;","names":[]}

package/dist/chunk-AOODDNHA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eachWeekOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * PlainDate endpoints return date-only period starts in the start calendar.\n * Mixed date-only/timeline endpoints are rejected. Reversed endpoints return [].\n *\n * Returns an array of ZonedDateTime objects for each week within the interval.\n * Each element represents the first moment of the week (Monday at midnight).\n * Uses ISO 8601 week definition: weeks start on Monday.\n * The interval is inclusive of both start and end weeks.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each week (Monday) in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00+00:00[UTC]'); // Monday\n * const end = Temporal.ZonedDateTime.from('2025-01-22T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Week 2\n * //   2025-01-13T00:00:00+00:00[UTC],  // Week 3\n * //   2025-01-20T00:00:00+00:00[UTC]   // Week 4\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Mid-week start\n * const start = Temporal.ZonedDateTime.from('2025-01-08T10:00:00+00:00[UTC]'); // Wednesday\n * const end = Temporal.ZonedDateTime.from('2025-01-15T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Monday of week containing Jan 8\n * //   2025-01-13T00:00:00+00:00[UTC]   // Monday of week containing Jan 15\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-12-25T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T00:00:00+00:00[UTC]');\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2024-12-23T00:00:00+00:00[UTC],  // Monday of week containing Dec 25\n * //   2024-12-30T00:00:00+00:00[UTC],  // Monday of week containing Dec 30\n * //   2025-01-06T00:00:00+00:00[UTC]   // Monday of week containing Jan 8\n * // ]\n * ```\n */\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n}): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    const end = interval.end.withCalendar(interval.start.calendarId);\n    const last = end.subtract({ days: end.dayOfWeek - 1 });\n    let current = interval.start.subtract({ days: interval.start.dayOfWeek - 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ weeks: 1 });\n    }\n    dates.push(current);\n    return dates;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const timezone = startZoned.timeZoneId;\n\n  // Get Monday of the starting week\n  // dayOfWeek: 1 = Monday, 7 = Sunday (ISO 8601)\n  const daysToSubtractStart = startZoned.dayOfWeek - 1;\n  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();\n\n  // Get Monday of the ending week\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;\n  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();\n\n  const weeks: Temporal.ZonedDateTime[] = [];\n  let current = startMonday;\n\n  while (current.epochNanoseconds <= endMonday.epochNanoseconds) {\n    weeks.push(current);\n    current = current.add({ weeks: 1 });\n  }\n\n  return weeks;\n}\n"],"mappings":";;;;;;;;;;;;;;AAoEO,SAAS,mBAAmB,UAGiB;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,UAAM,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAC/D,UAAM,OAAO,IAAI,SAAS,EAAE,MAAM,IAAI,YAAY,EAAE,CAAC;AACrD,QAAIA,WAAU,SAAS,MAAM,SAAS,EAAE,MAAM,SAAS,MAAM,YAAY,EAAE,CAAC;AAC5E,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAKA,QAAO;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,WAAW,WAAW;AAI5B,QAAM,sBAAsB,WAAW,YAAY;AACnD,QAAM,cAAc,WAAW,SAAS,EAAE,MAAM,oBAAoB,CAAC,EAAE,WAAW;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,oBAAoB,cAAc,YAAY;AACpD,QAAM,YAAY,cAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC,EAAE,WAAW;AAEjF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,UAAU,kBAAkB;AAC7D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":["current"]}

package/dist/chunk-BYPHFTFD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/format.ts"],"sourcesContent":["import { type Temporal, isInstant, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { Timezone } from './types';\nimport { formatPlainDate, type FormatPlainDateOptions } from './formatPlainDate';\n\nexport interface FormatOptions {\n  locale?: string;\n  timeZone?: Timezone;\n}\n\n/**\n * Format a Temporal.Instant, ZonedDateTime, or PlainDate using date-fns-like format tokens.\n * Uses Intl.DateTimeFormat for localized parts. PlainDate inputs delegate to\n * formatPlainDate and accept locale options only; no time or timezone is invented.\n *\n * @param input - A Temporal.Instant, Temporal.ZonedDateTime, or Temporal.PlainDate to format\n * @param formatStr - Format string using date-fns tokens (e.g., \"yyyy-MM-dd HH:mm:ss\")\n * @param options - Optional configuration for locale and timezone\n * @returns Formatted date string\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n *\n * format(zoned, \"yyyy-MM-dd\"); // \"2025-01-20\"\n * format(zoned, \"MMMM d, yyyy\"); // \"January 20, 2025\"\n * format(zoned, \"h:mm a\"); // \"3:00 PM\"\n * format(zoned, \"EEEE, MMMM do, yyyy 'at' h:mm a\"); // \"Monday, January 20th, 2025 at 3:00 PM\"\n *\n * // With locale\n * format(zoned, \"MMMM d, yyyy\", { locale: \"es-ES\" }); // \"enero 20, 2025\"\n * ```\n */\nexport function format(\n  input: Temporal.PlainDate,\n  formatStr: string,\n  options?: FormatPlainDateOptions & { timeZone?: never }\n): string;\nexport function format(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  formatStr: string,\n  options?: FormatOptions\n): string;\nexport function format(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  formatStr: string,\n  options: FormatOptions = {}\n): string {\n  if (isPlainDate(input)) {\n    if (options.timeZone !== undefined) {\n      throw new TypeError('PlainDate formatting does not accept a timezone');\n    }\n    return formatPlainDate(input, formatStr, options);\n  }\n  const { locale = 'en-US', timeZone } = options;\n\n  // Convert to ZonedDateTime, applying custom timezone if provided\n  let zonedDateTime: Temporal.ZonedDateTime;\n  if (timeZone) {\n    // If custom timezone specified, convert via Instant\n    const instant = isInstant(input) ? input : input.toInstant();\n    zonedDateTime = instant.toZonedDateTimeISO(timeZone);\n  } else {\n    // No custom timezone: normalize to ZonedDateTime (Instant -> UTC, ZonedDateTime -> keep as-is)\n    zonedDateTime = normalizeTemporalInput(input);\n  }\n\n  let result = '';\n  let i = 0;\n  const len = formatStr.length;\n\n  while (i < len) {\n    const char = formatStr[i];\n    if (!char) break;\n\n    // Handle escaped text\n    if (char === \"'\") {\n      // Check for double single quote (not inside a string, just '')\n      if (i + 1 < len && formatStr[i + 1] === \"'\") {\n        result += \"'\";\n        i += 2;\n        continue;\n      }\n      // Find closing quote, handling '' inside the string\n      i++;\n      while (i < len) {\n        if (formatStr[i] === \"'\") {\n          // Check if it's a doubled quote ''\n          if (i + 1 < len && formatStr[i + 1] === \"'\") {\n            result += \"'\";\n            i += 2;\n          } else {\n            // End of quoted string\n            i++;\n            break;\n          }\n        } else {\n          result += formatStr[i];\n          i++;\n        }\n      }\n      continue;\n    }\n\n    // Check for tokens by looking ahead\n    const token = consumeToken(formatStr, i, char);\n    if (token !== null) {\n      result += formatToken(token, zonedDateTime, locale);\n      i += token.length;\n    } else {\n      result += char;\n      i++;\n    }\n  }\n\n  return result;\n}\n\nfunction consumeToken(formatStr: string, start: number, char: string): string | null {\n  // Special case for 'Mo' and 'do' - these end with 'o'\n  if (char === 'M' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'Mo';\n  }\n  if (char === 'd' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'do';\n  }\n\n  // Count how many consecutive identical characters\n  let end = start;\n  while (end < formatStr.length && formatStr[end] === char) {\n    end++;\n  }\n  const count = end - start;\n\n  // Check if this is a valid token pattern\n  const validTokens = [\n    'GGGGG',\n    'GGGG',\n    'GGG',\n    'GG',\n    'G',\n    'yyyy',\n    'yyy',\n    'yy',\n    'y',\n    'QQQQQ',\n    'QQQQ',\n    'QQQ',\n    'QQ',\n    'Q',\n    'MMMMM',\n    'MMMM',\n    'MMM',\n    'MM',\n    'M',\n    'dd',\n    'd',\n    'EEEEEE',\n    'EEEEE',\n    'EEEE',\n    'EEE',\n    'EE',\n    'E',\n    'aaaaa',\n    'aaaa',\n    'aaa',\n    'aa',\n    'a',\n    'HH',\n    'H',\n    'hh',\n    'h',\n    'mm',\n    'm',\n    'ss',\n    's',\n    'SSS',\n    'SS',\n    'S',\n    'XXXXX',\n    'XXXX',\n    'XXX',\n    'XX',\n    'X',\n    'xxxxx',\n    'xxxx',\n    'xxx',\n    'xx',\n    'x',\n    'zzzz',\n    'zzz',\n    'zz',\n    'z',\n    'T',\n    't',\n  ];\n\n  // Try to match from longest to shortest\n  for (let len = Math.min(count, 6); len > 0; len--) {\n    const candidate = char.repeat(len);\n    if (validTokens.includes(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n\nfunction formatToken(token: string, zonedDateTime: Temporal.ZonedDateTime, locale: string): string {\n  switch (token) {\n    // Era\n    case 'GGGGG':\n      return formatPart(zonedDateTime, 'era', 'narrow', locale);\n    case 'GGGG':\n      return formatPart(zonedDateTime, 'era', 'long', locale);\n    case 'GGG':\n    case 'GG':\n    case 'G':\n      return formatPart(zonedDateTime, 'era', 'short', locale);\n\n    // Year\n    case 'yyyy':\n      return zonedDateTime.year.toString().padStart(4, '0');\n    case 'yyy':\n      return zonedDateTime.year.toString().padStart(3, '0');\n    case 'yy':\n      return (zonedDateTime.year % 100).toString().padStart(2, '0');\n    case 'y':\n      return zonedDateTime.year.toString();\n\n    // Quarter\n    case 'QQQQQ':\n      return Math.ceil(zonedDateTime.month / 3).toString();\n    case 'QQQQ': {\n      const quarter = Math.ceil(zonedDateTime.month / 3);\n      return `${quarter}${getOrdinalSuffix(quarter)} quarter`;\n    }\n    case 'QQQ':\n      return `Q${Math.ceil(zonedDateTime.month / 3)}`;\n    case 'QQ':\n      return Math.ceil(zonedDateTime.month / 3)\n        .toString()\n        .padStart(2, '0');\n    case 'Q':\n      return Math.ceil(zonedDateTime.month / 3).toString();\n\n    // Month\n    case 'MMMMM':\n      return formatPart(zonedDateTime, 'month', 'narrow', locale);\n    case 'MMMM':\n      return formatPart(zonedDateTime, 'month', 'long', locale);\n    case 'MMM':\n      return formatPart(zonedDateTime, 'month', 'short', locale);\n    case 'MM':\n      return zonedDateTime.month.toString().padStart(2, '0');\n    case 'Mo':\n      return `${zonedDateTime.month}${getOrdinalSuffix(zonedDateTime.month)}`;\n    case 'M':\n      return zonedDateTime.month.toString();\n\n    // Day of month\n    case 'do':\n      return `${zonedDateTime.day}${getOrdinalSuffix(zonedDateTime.day)}`;\n    case 'dd':\n      return zonedDateTime.day.toString().padStart(2, '0');\n    case 'd':\n      return zonedDateTime.day.toString();\n\n    // Day of week\n    case 'EEEEEE':\n      return formatPart(zonedDateTime, 'weekday', 'short', locale).slice(0, 2);\n    case 'EEEEE':\n      return formatPart(zonedDateTime, 'weekday', 'narrow', locale);\n    case 'EEEE':\n      return formatPart(zonedDateTime, 'weekday', 'long', locale);\n    case 'EEE':\n    case 'EE':\n    case 'E':\n      return formatPart(zonedDateTime, 'weekday', 'short', locale);\n\n    // AM/PM (locale-aware; English widths applied only for ASCII AM/PM)\n    case 'aaaaa': {\n      const period = getDayPeriod(zonedDateTime, locale);\n      if (isAsciiAmPm(period)) return isAm(period) ? 'a' : 'p';\n      return period.charAt(0).toLowerCase();\n    }\n    case 'aaaa': {\n      const period = getDayPeriod(zonedDateTime, locale);\n      if (isAsciiAmPm(period)) return isAm(period) ? 'a.m.' : 'p.m.';\n      return period;\n    }\n    case 'aaa':\n      return getDayPeriod(zonedDateTime, locale).toLowerCase();\n    case 'aa':\n    case 'a':\n      return getDayPeriod(zonedDateTime, locale);\n\n    // Hour [0-23]\n    case 'HH':\n      return zonedDateTime.hour.toString().padStart(2, '0');\n    case 'H':\n      return zonedDateTime.hour.toString();\n\n    // Hour [1-12]\n    case 'hh': {\n      const hour12 = zonedDateTime.hour % 12 || 12;\n      return hour12.toString().padStart(2, '0');\n    }\n    case 'h': {\n      const hour12 = zonedDateTime.hour % 12 || 12;\n      return hour12.toString();\n    }\n\n    // Minute\n    case 'mm':\n      return zonedDateTime.minute.toString().padStart(2, '0');\n    case 'm':\n      return zonedDateTime.minute.toString();\n\n    // Second\n    case 'ss':\n      return zonedDateTime.second.toString().padStart(2, '0');\n    case 's':\n      return zonedDateTime.second.toString();\n\n    // Fractional seconds\n    case 'SSS':\n      return zonedDateTime.millisecond.toString().padStart(3, '0');\n    case 'SS':\n      return Math.floor(zonedDateTime.millisecond / 10)\n        .toString()\n        .padStart(2, '0');\n    case 'S':\n      return Math.floor(zonedDateTime.millisecond / 100).toString();\n\n    // Timezone\n    case 'XXXXX':\n    case 'XXXX':\n    case 'XXX':\n    case 'XX':\n    case 'X':\n    case 'xxxxx':\n    case 'xxxx':\n    case 'xxx':\n    case 'xx':\n    case 'x':\n      return formatTimezoneOffset(zonedDateTime, token);\n    case 'zzzz':\n      return formatPart(zonedDateTime, 'timeZoneName', 'long', locale);\n    case 'zzz':\n    case 'zz':\n    case 'z':\n      return formatPart(zonedDateTime, 'timeZoneName', 'short', locale);\n\n    // Timestamps\n    case 'T':\n      return zonedDateTime.epochMilliseconds.toString();\n    case 't':\n      return Math.floor(zonedDateTime.epochMilliseconds / 1000).toString();\n\n    default:\n      return token;\n  }\n}\n\nfunction formatPart(\n  zonedDateTime: Temporal.ZonedDateTime,\n  part: 'era' | 'year' | 'month' | 'weekday' | 'day' | 'hour' | 'minute' | 'second' | 'timeZoneName',\n  style: 'narrow' | 'short' | 'long' | 'numeric' | '2-digit',\n  locale: string\n): string {\n  const options: Intl.DateTimeFormatOptions = {\n    [part]: style,\n    timeZone: zonedDateTime.timeZoneId,\n    calendar: zonedDateTime.calendarId === 'iso8601' ? undefined : zonedDateTime.calendarId,\n  };\n  return new Intl.DateTimeFormat(locale, options)\n    .formatToParts(zonedDateTime.epochMilliseconds)\n    .find(value => value.type === part)?.value ?? '';\n}\n\nfunction getOrdinalSuffix(num: number): string {\n  const j = num % 10;\n  const k = num % 100;\n  if (j === 1 && k !== 11) return 'st';\n  if (j === 2 && k !== 12) return 'nd';\n  if (j === 3 && k !== 13) return 'rd';\n  return 'th';\n}\n\nfunction formatTimezoneOffset(zonedDateTime: Temporal.ZonedDateTime, token: string): string {\n  if (token[0] === 'X' && zonedDateTime.offsetNanoseconds === 0) return 'Z';\n\n  // Temporal supplies integer HH:mm[:ss] fields. Widths 1–3 omit seconds;\n  // widths 4–5 retain them when present, as specified by Unicode date tokens.\n  const offset = token.length >= 4 ? zonedDateTime.offset : zonedDateTime.offset.slice(0, 6);\n  if (token.length === 1 && offset.endsWith(':00')) return offset.slice(0, 3);\n  return token.length === 3 || token.length === 5 ? offset : offset.replaceAll(':', '');\n}\n\n/**\n * Locale-correct day period (AM/PM equivalent) via Intl.formatToParts.\n * Returns the locale's own value, e.g. \"AM\"/\"PM\" (en), \"p. m.\" (es), \"午後\" (ja).\n */\nfunction getDayPeriod(zonedDateTime: Temporal.ZonedDateTime, locale: string): string {\n  const parts = new Intl.DateTimeFormat(locale, {\n    hour: 'numeric',\n    hour12: true,\n    timeZone: zonedDateTime.timeZoneId,\n  }).formatToParts(zonedDateTime.epochMilliseconds);\n  return parts.find((p) => p.type === 'dayPeriod')?.value ?? '';\n}\n\n/** True when the day-period is recognizably ASCII AM/PM (so English widths apply). */\nfunction isAsciiAmPm(period: string): boolean {\n  const normalized = period.toUpperCase().replace(/[.\\s]/g, '');\n  return normalized === 'AM' || normalized === 'PM';\n}\n\n/** True for the AM half (only meaningful when isAsciiAmPm is true). */\nfunction isAm(period: string): boolean {\n  return period.toUpperCase().replace(/[.\\s]/g, '').startsWith('A');\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-D3N7BT44.js

@@ -1,22 +0,0 @@
-import {
-  addWeekdays
-} from "./chunk-K7CLBBBM.js";
-import {
-  normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
-import {
-  isPlainDate
-} from "./chunk-BSVOJYJ7.js";
-
-// src/addBusinessDays.ts
-function addBusinessDays(input, days) {
-  if (isPlainDate(input)) {
-    return addWeekdays(input, days);
-  }
-  return addWeekdays(normalizeTemporalInput(input), days);
-}
-
-export {
-  addBusinessDays
-};
-//# sourceMappingURL=chunk-D3N7BT44.js.map

package/dist/chunk-D3N7BT44.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { addWeekdays } from './shared/businessDays';\n\n/**\n * Adds business days (Monday–Friday), skipping weekends. Holidays are not\n * considered.\n *\n * Starting on a weekend, the first business day counted is the next Monday\n * (or the previous Friday for negative values). Adding 0 returns the input's\n * date unchanged, even on a weekend.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs keep their\n * timezone and time of day. PlainDate inputs stay dates.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @param days - Whole business days to add (negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime\n * @throws RangeError if days is not an integer\n *\n * @example\n * ```ts\n * const friday = Temporal.PlainDate.from('2025-01-24');\n *\n * addBusinessDays(friday, 1); // 2025-01-27 (Monday)\n * addBusinessDays(friday, 5); // 2025-01-31 (Friday)\n * ```\n */\nexport function addBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return addWeekdays(input, days);\n  }\n  return addWeekdays(normalizeTemporalInput(input), days);\n}\n"],"mappings":";;;;;;;;;;;AAiCO,SAAS,gBACd,OACA,MAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,YAAY,OAAO,IAAI;AAAA,EAChC;AACA,SAAO,YAAY,uBAAuB,KAAK,GAAG,IAAI;AACxD;","names":[]}

package/dist/chunk-GCVX5QIX.js

@@ -1,15 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
-
-// src/isSameWeek.ts
-function isSameWeek(date1, date2) {
-  const zoned1 = normalizeTemporalInput(date1);
-  const zoned2 = normalizeTemporalInput(date2);
-  return zoned1.yearOfWeek === zoned2.yearOfWeek && zoned1.weekOfYear === zoned2.weekOfYear;
-}
-
-export {
-  isSameWeek
-};
-//# sourceMappingURL=chunk-GCVX5QIX.js.map