@gobrand/tiempo 3.1.2 → 3.2.0

package/dist/{chunk-ETO77GIW.js → chunk-32AWWYBF.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addNanoseconds.ts
 function addNanoseconds(input, nanoseconds) {
@@ -11,4 +11,4 @@ function addNanoseconds(input, nanoseconds) {
 export {
   addNanoseconds
 };
-//# sourceMappingURL=chunk-ETO77GIW.js.map
+//# sourceMappingURL=chunk-32AWWYBF.js.map

package/dist/chunk-32AWWYBF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addNanoseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of nanoseconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param nanoseconds - Number of nanoseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with nanoseconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addNanoseconds(zoned, 1000);\n * // 2025-01-20T15:30:00.000001-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract nanoseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = addNanoseconds(instant, -500);\n * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function addNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ nanoseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,eACd,OACA,aACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,YAAY,CAAC;AAC1C;","names":[]}

package/dist/{chunk-HQ3YMKQ5.js → chunk-3D4YR2SR.js}

@@ -1,6 +1,6 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -18,4 +18,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-HQ3YMKQ5.js.map
+//# sourceMappingURL=chunk-3D4YR2SR.js.map

package/dist/chunk-3D4YR2SR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfMonth.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the first boundary of the month.\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 the 1st day of the month at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const start = startOfMonth(instant);\n * // 2025-01-01T00:00:00+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-15T15:30:00-05:00[America/New_York]');\n * const start = startOfMonth(zoned);\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-15');\n * const start = startOfMonth(date);\n * // 2025-01-01\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-15');\n * const start = startOfMonth(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfMonth(\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.with({ day: 1 });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;AAmDO,SAAS,aACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAAA,EAC9B;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,KAAK,EAAE,CAAC;AAC9C,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/{chunk-ASIYAAQV.js → chunk-3HD7HEN4.js}

@@ -1,9 +1,9 @@
 import {
   differenceInDays
-} from "./chunk-E5HJJFUI.js";
+} from "./chunk-JGPTGV5X.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -39,4 +39,4 @@ function eachDayOfInterval(interval) {
 export {
   eachDayOfInterval
 };
-//# sourceMappingURL=chunk-ASIYAAQV.js.map
+//# sourceMappingURL=chunk-3HD7HEN4.js.map

package/dist/chunk-3HD7HEN4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachDayOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { differenceInDays } from './differenceInDays';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns each calendar day within the interval, including both endpoints.\n * PlainDate endpoints return PlainDates in the start calendar, without a timezone.\n * Instant/ZonedDateTime endpoints return ZonedDateTimes.\n * Each element represents the first valid moment of the day in the timezone of the interval start.\n * Nonexistent calendar dates are skipped only for timezone-aware intervals.\n * The interval is inclusive of both start and end days.\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 - Two PlainDates, or two Instant/ZonedDateTime timeline endpoints\n * @returns PlainDates for date-only endpoints; otherwise ZonedDateTimes at each day start. Reversed endpoints return [].\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-10T14:00:00+00:00[UTC]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],\n * //   2025-01-07T00:00:00+00:00[UTC],\n * //   2025-01-08T00:00:00+00:00[UTC],\n * //   2025-01-09T00:00:00+00:00[UTC],\n * //   2025-01-10T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With timezone - preserves the timezone from start\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T14:00:00-05:00[America/New_York]');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00-05:00[America/New_York],\n * //   2025-01-07T00:00:00-05:00[America/New_York],\n * //   2025-01-08T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // With Instant (uses UTC)\n * const start = Temporal.Instant.from('2025-01-06T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-08T00:00:00Z');\n *\n * const days = eachDayOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],\n * //   2025-01-07T00:00:00+00:00[UTC],\n * //   2025-01-08T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single day interval\n * const date = Temporal.ZonedDateTime.from('2025-01-15T12:00:00+00:00[UTC]');\n *\n * eachDayOfInterval({ start: date, end: date });\n * // [2025-01-15T00:00:00+00:00[UTC]]\n * ```\n */\nexport function eachDayOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachDayOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachDayOfInterval(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    const dayCount = differenceInDays(\n      interval.end.withCalendar(interval.start.calendarId),\n      interval.start\n    );\n    const days: Temporal.PlainDate[] = [];\n    for (let offset = 0; offset <= dayCount; offset++) {\n      days.push(interval.start.add({ days: offset }));\n    }\n    return days;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const days: Temporal.ZonedDateTime[] = [];\n  let current = startZoned.startOfDay();\n\n  // Advancing the resolved date skips nonexistent dates instead of resolving\n  // two consecutive PlainDates to the same instant.\n  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {\n    days.push(current);\n    current = current.add({ days: 1 }).startOfDay();\n  }\n\n  return days;\n}\n"],"mappings":";;;;;;;;;;;AA8EO,SAAS,kBAAkB,UAGkB;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,UAAM,WAAW;AAAA,MACf,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAAA,MACnD,SAAS;AAAA,IACX;AACA,UAAMA,QAA6B,CAAC;AACpC,aAAS,SAAS,GAAG,UAAU,UAAU,UAAU;AACjD,MAAAA,MAAK,KAAK,SAAS,MAAM,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC;AAAA,IAChD;AACA,WAAOA;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,OAAiC,CAAC;AACxC,MAAI,UAAU,WAAW,WAAW;AAIpC,SAAO,QAAQ,oBAAoB,SAAS,kBAAkB;AAC5D,SAAK,KAAK,OAAO;AACjB,cAAU,QAAQ,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW;AAAA,EAChD;AAEA,SAAO;AACT;","names":["days"]}

package/dist/{chunk-TEL44S5A.js → chunk-3HF4F36S.js}

@@ -1,6 +1,6 @@
 import {
   addYears
-} from "./chunk-FL33IWLY.js";
+} from "./chunk-HRCTWTP3.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subYears(input, years) {
 export {
   subYears
 };
-//# sourceMappingURL=chunk-TEL44S5A.js.map
+//# sourceMappingURL=chunk-3HF4F36S.js.map

package/dist/{chunk-TEL44S5A.js.map → chunk-3HF4F36S.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subYears.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addYears } from './addYears';\n\n/**\n * Subtracts the specified number of years from a datetime or date.\n *\n * This is a convenience wrapper around addYears with negated value.\n * Properly handles leap years and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param years - Number of years to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with years subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = subYears(instant, 2);\n * // 2023-01-20T12:00:00Z[UTC] (2 years earlier)\n * ```\n */\nexport function subYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  years: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addYears overload.\n  return isPlainDate(input) ? addYears(input, -years) : addYears(input, -years);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}
+{"version":3,"sources":["../src/subYears.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addYears } from './addYears';\n\n/**\n * Subtracts the specified number of years from a datetime or date.\n *\n * This is a convenience wrapper around addYears with negated value.\n * Properly handles leap years and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param years - Number of years to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with years subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = subYears(instant, 2);\n * // 2023-01-20T12:00:00+00:00[UTC] (2 years earlier)\n * ```\n */\nexport function subYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime;\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  years: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addYears overload.\n  return isPlainDate(input) ? addYears(input, -years) : addYears(input, -years);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}

package/dist/chunk-3OOGJRXH.js

@@ -0,0 +1,247 @@
+import {
+  consumeToken
+} from "./chunk-HH2HTC44.js";
+import {
+  Temporal
+} from "./chunk-BSVOJYJ7.js";
+
+// src/parse.ts
+function parse(text, pattern, options = {}) {
+  const { locale = "en-US", timeZone } = options;
+  const fields = readFields(text, pattern, locale);
+  const fail = (reason) => new RangeError(`Cannot parse "${text}" with pattern "${pattern}": ${reason}`);
+  if (fields.year === void 0 || fields.month === void 0 || fields.day === void 0) {
+    throw fail("the pattern needs a year, month, and day");
+  }
+  const date = Temporal.PlainDate.from(
+    { year: fields.year, month: fields.month, day: fields.day },
+    { overflow: "reject" }
+  );
+  if (fields.dayOfWeek !== void 0 && fields.dayOfWeek !== date.dayOfWeek) {
+    throw fail(`${date} is not that day of the week`);
+  }
+  const hasTime = fields.hour !== void 0 || fields.hour12 !== void 0 || fields.minute !== void 0 || fields.second !== void 0 || fields.millisecond !== void 0;
+  if (timeZone === void 0) {
+    if (hasTime || fields.offset !== void 0) {
+      throw new TypeError("Patterns with time or offset fields need a timeZone");
+    }
+    return date;
+  }
+  if (!hasTime && fields.offset === void 0) {
+    return date.toZonedDateTime(timeZone);
+  }
+  if (fields.hour12 !== void 0) {
+    if (fields.pm === void 0) throw fail("12-hour times (h) need AM/PM (a)");
+    if (fields.hour12 < 1 || fields.hour12 > 12)
+      throw fail(`${fields.hour12} is not a 12-hour hour`);
+  }
+  const hour = fields.hour ?? (fields.hour12 === void 0 ? 0 : fields.hour12 % 12 + (fields.pm ? 12 : 0));
+  const dateTime = Temporal.PlainDateTime.from(
+    {
+      year: date.year,
+      month: date.month,
+      day: date.day,
+      hour,
+      minute: fields.minute ?? 0,
+      second: fields.second ?? 0,
+      millisecond: fields.millisecond ?? 0
+    },
+    { overflow: "reject" }
+  );
+  if (fields.offset !== void 0) {
+    return Temporal.Instant.from(`${dateTime}${fields.offset}`).toZonedDateTimeISO(timeZone);
+  }
+  return dateTime.toZonedDateTime(timeZone);
+}
+function readFields(text, pattern, locale) {
+  const fields = {};
+  let position = 0;
+  const fail = (reason) => new RangeError(`Cannot parse "${text}" with pattern "${pattern}": ${reason}`);
+  const literal = (expected) => {
+    if (!text.startsWith(expected, position)) {
+      throw fail(`expected "${expected}" at position ${position}`);
+    }
+    position += expected.length;
+  };
+  const digits = (min, max) => {
+    const match = text.slice(position).match(new RegExp(`^\\d{${min},${max}}`));
+    if (!match)
+      throw fail(`expected ${min === max ? min : `${min}\u2013${max}`} digits at position ${position}`);
+    position += match[0].length;
+    return match[0];
+  };
+  const name = (candidates) => {
+    const rest = text.slice(position).toLocaleLowerCase(locale);
+    let best = -1;
+    let length = 0;
+    candidates.forEach((candidate, index) => {
+      const lower = candidate.toLocaleLowerCase(locale);
+      if (lower.length > length && rest.startsWith(lower)) {
+        best = index;
+        length = lower.length;
+      }
+    });
+    if (best === -1) throw fail(`expected one of ${candidates.join(", ")} at position ${position}`);
+    position += length;
+    return best;
+  };
+  for (let i = 0; i < pattern.length; ) {
+    const char = pattern[i];
+    if (char === "'") {
+      if (pattern[i + 1] === "'") {
+        literal("'");
+        i += 2;
+        continue;
+      }
+      let quoted = "";
+      for (i++; i < pattern.length; i++) {
+        if (pattern[i] !== "'") quoted += pattern[i];
+        else if (pattern[i + 1] === "'") quoted += "'", i++;
+        else break;
+      }
+      literal(quoted);
+      i++;
+      continue;
+    }
+    const token = consumeToken(pattern, i, char);
+    if (token === null) {
+      literal(char);
+      i++;
+      continue;
+    }
+    i += token.length;
+    switch (token) {
+      case "yyyy":
+        fields.year = Number(digits(4, 4));
+        break;
+      case "y":
+        fields.year = Number(digits(1, 6));
+        break;
+      case "MMMM":
+      case "MMM":
+        fields.month = name(monthNames(locale, token === "MMMM" ? "long" : "short")) + 1;
+        break;
+      case "MM":
+        fields.month = Number(digits(2, 2));
+        break;
+      case "M":
+        fields.month = Number(digits(1, 2));
+        break;
+      case "dd":
+        fields.day = Number(digits(2, 2));
+        break;
+      case "d":
+        fields.day = Number(digits(1, 2));
+        break;
+      case "EEEE":
+      case "EEE":
+      case "EE":
+      case "E":
+        fields.dayOfWeek = name(weekdayNames(locale, token === "EEEE" ? "long" : "short")) + 1;
+        break;
+      case "HH":
+        fields.hour = Number(digits(2, 2));
+        break;
+      case "H":
+        fields.hour = Number(digits(1, 2));
+        break;
+      case "hh":
+        fields.hour12 = Number(digits(2, 2));
+        break;
+      case "h":
+        fields.hour12 = Number(digits(1, 2));
+        break;
+      case "aaaa":
+      case "aaa":
+      case "aa":
+      case "a": {
+        const [am, pm] = dayPeriods(locale);
+        const candidates = [am, pm];
+        if (isAsciiAmPm(am) && isAsciiAmPm(pm)) candidates.push("a.m.", "p.m.");
+        fields.pm = name(candidates) % 2 === 1;
+        break;
+      }
+      case "mm":
+        fields.minute = Number(digits(2, 2));
+        break;
+      case "m":
+        fields.minute = Number(digits(1, 2));
+        break;
+      case "ss":
+        fields.second = Number(digits(2, 2));
+        break;
+      case "s":
+        fields.second = Number(digits(1, 2));
+        break;
+      case "SSS":
+      case "SS":
+      case "S":
+        fields.millisecond = Number(digits(token.length, token.length).padEnd(3, "0"));
+        break;
+      default:
+        if (/^[Xx]+$/.test(token)) {
+          const match = text.slice(position).match(token[0] === "X" ? /^(Z|[+-]\d{2}(:?\d{2}){0,2})/ : /^[+-]\d{2}(:?\d{2}){0,2}/);
+          if (!match) throw fail(`expected a UTC offset at position ${position}`);
+          position += match[0].length;
+          fields.offset = match[0] === "Z" ? "+00:00" : normalizeOffset(match[0]);
+          break;
+        }
+        throw new RangeError(
+          token === "yy" ? "parse does not read two-digit years (yy); the century would be a guess" : token === "T" || token === "t" ? "parse does not read timestamps (T, t); use toInstant" : `parse does not support the "${token}" token`
+        );
+    }
+  }
+  if (position !== text.length) {
+    throw fail(`unexpected "${text.slice(position)}" at position ${position}`);
+  }
+  return fields;
+}
+function normalizeOffset(offset) {
+  const numbers = offset.slice(1).replaceAll(":", "");
+  const parts = numbers.match(/\d{2}/g);
+  return `${offset[0]}${parts.length === 1 ? `${parts[0]}:00` : parts.join(":")}`;
+}
+function intlPart(locale, options, type, date) {
+  const epochMilliseconds = date.toZonedDateTime("UTC").epochMilliseconds;
+  return new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }).formatToParts(epochMilliseconds).find((part) => part.type === type)?.value ?? "";
+}
+function monthNames(locale, style) {
+  return Array.from(
+    { length: 12 },
+    (_, index) => intlPart(
+      locale,
+      { month: style },
+      "month",
+      Temporal.PlainDateTime.from({ year: 2e3, month: index + 1, day: 15 })
+    )
+  );
+}
+function weekdayNames(locale, style) {
+  return Array.from(
+    { length: 7 },
+    (_, index) => intlPart(
+      locale,
+      { weekday: style },
+      "weekday",
+      Temporal.PlainDateTime.from({ year: 2e3, month: 1, day: 3 + index })
+    )
+  );
+}
+function dayPeriods(locale) {
+  const at = (hour) => intlPart(
+    locale,
+    { hour: "numeric", hour12: true },
+    "dayPeriod",
+    Temporal.PlainDateTime.from({ year: 2e3, month: 1, day: 3, hour })
+  );
+  return [at(9), at(15)];
+}
+function isAsciiAmPm(period) {
+  const normalized = period.toUpperCase().replace(/[.\s]/g, "");
+  return normalized === "AM" || normalized === "PM";
+}
+
+export {
+  parse
+};
+//# sourceMappingURL=chunk-3OOGJRXH.js.map

package/dist/chunk-3OOGJRXH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parse.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { consumeToken } from './shared/formatTokens';\nimport type { Timezone } from './types';\n\nexport interface ParseOptions {\n  /** Locale for month, weekday, and AM/PM names. @default 'en-US' */\n  locale?: string;\n  /** Timezone the parsed wall-clock time belongs to. Required when the pattern has time fields. */\n  timeZone?: Timezone;\n}\n\ninterface Fields {\n  year?: number;\n  month?: number;\n  day?: number;\n  dayOfWeek?: number;\n  hour?: number;\n  hour12?: number;\n  pm?: boolean;\n  minute?: number;\n  second?: number;\n  millisecond?: number;\n  offset?: string;\n}\n\n/**\n * Reads a date, or a date and time, written in a known pattern. The pattern uses\n * the same tokens as `format`, so text that `format` writes with a supported\n * pattern reads back to the same fields.\n *\n * Without a timeZone the result is a PlainDate, and the pattern may only hold\n * date fields. With a timeZone the result is a ZonedDateTime in that timezone:\n * an offset in the text (`XXX`) fixes the moment, otherwise the wall-clock time\n * is read in the timezone, and a time skipped by a DST change moves forward as\n * in Temporal. A pattern without time fields gives the start of that day.\n *\n * Supported tokens: `yyyy` `y` `MMMM` `MMM` `MM` `M` `dd` `d` `EEEE` `EEE` `HH`\n * `H` `hh` `h` `a` `mm` `m` `ss` `s` `SSS` `SS` `S` `X…XXXXX` `x…xxxxx`. Text in\n * single quotes and any other character must match exactly. Two-digit years\n * (`yy`) are rejected because the century is a guess.\n *\n * @param text - The text to read\n * @param pattern - The pattern the text is written in, such as `dd/MM/yyyy`\n * @param options - `timeZone` for patterns with a time; `locale` for names (default 'en-US')\n * @returns PlainDate without a timeZone; ZonedDateTime with one\n * @throws RangeError if the text does not match the pattern or names an impossible date\n * @throws TypeError if the pattern has time fields but no timeZone is given\n *\n * @example\n * ```ts\n * parse('20/01/2025', 'dd/MM/yyyy').toString(); // \"2025-01-20\"\n * parse('January 20, 2025', 'MMMM d, yyyy').toString(); // \"2025-01-20\"\n * ```\n *\n * @example\n * ```ts\n * parse('01/20/2025 3:45 PM', 'MM/dd/yyyy h:mm a', { timeZone: 'America/New_York' }).toString();\n * // \"2025-01-20T15:45:00-05:00[America/New_York]\"\n * ```\n *\n * @example\n * ```ts\n * parse('20 enero 2025', 'd MMMM yyyy', { locale: 'es' }).toString(); // \"2025-01-20\"\n * ```\n */\nexport function parse(\n  text: string,\n  pattern: string,\n  options: { locale?: string; timeZone: Timezone }\n): Temporal.ZonedDateTime;\nexport function parse(\n  text: string,\n  pattern: string,\n  options?: { locale?: string; timeZone?: undefined }\n): Temporal.PlainDate;\nexport function parse(\n  text: string,\n  pattern: string,\n  options: ParseOptions = {}\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  const { locale = 'en-US', timeZone } = options;\n  const fields = readFields(text, pattern, locale);\n  const fail = (reason: string) =>\n    new RangeError(`Cannot parse \"${text}\" with pattern \"${pattern}\": ${reason}`);\n\n  if (fields.year === undefined || fields.month === undefined || fields.day === undefined) {\n    throw fail('the pattern needs a year, month, and day');\n  }\n  const date = Temporal.PlainDate.from(\n    { year: fields.year, month: fields.month, day: fields.day },\n    { overflow: 'reject' }\n  );\n  if (fields.dayOfWeek !== undefined && fields.dayOfWeek !== date.dayOfWeek) {\n    throw fail(`${date} is not that day of the week`);\n  }\n\n  const hasTime =\n    fields.hour !== undefined ||\n    fields.hour12 !== undefined ||\n    fields.minute !== undefined ||\n    fields.second !== undefined ||\n    fields.millisecond !== undefined;\n  if (timeZone === undefined) {\n    if (hasTime || fields.offset !== undefined) {\n      throw new TypeError('Patterns with time or offset fields need a timeZone');\n    }\n    return date;\n  }\n  if (!hasTime && fields.offset === undefined) {\n    return date.toZonedDateTime(timeZone);\n  }\n\n  if (fields.hour12 !== undefined) {\n    if (fields.pm === undefined) throw fail('12-hour times (h) need AM/PM (a)');\n    if (fields.hour12 < 1 || fields.hour12 > 12)\n      throw fail(`${fields.hour12} is not a 12-hour hour`);\n  }\n  const hour =\n    fields.hour ?? (fields.hour12 === undefined ? 0 : (fields.hour12 % 12) + (fields.pm ? 12 : 0));\n  const dateTime = Temporal.PlainDateTime.from(\n    {\n      year: date.year,\n      month: date.month,\n      day: date.day,\n      hour,\n      minute: fields.minute ?? 0,\n      second: fields.second ?? 0,\n      millisecond: fields.millisecond ?? 0\n    },\n    { overflow: 'reject' }\n  );\n  if (fields.offset !== undefined) {\n    return Temporal.Instant.from(`${dateTime}${fields.offset}`).toZonedDateTimeISO(timeZone);\n  }\n  return dateTime.toZonedDateTime(timeZone);\n}\n\nfunction readFields(text: string, pattern: string, locale: string): Fields {\n  const fields: Fields = {};\n  let position = 0;\n  const fail = (reason: string) =>\n    new RangeError(`Cannot parse \"${text}\" with pattern \"${pattern}\": ${reason}`);\n\n  const literal = (expected: string) => {\n    if (!text.startsWith(expected, position)) {\n      throw fail(`expected \"${expected}\" at position ${position}`);\n    }\n    position += expected.length;\n  };\n\n  const digits = (min: number, max: number) => {\n    const match = text.slice(position).match(new RegExp(`^\\\\d{${min},${max}}`));\n    if (!match)\n      throw fail(`expected ${min === max ? min : `${min}–${max}`} digits at position ${position}`);\n    position += match[0].length;\n    return match[0];\n  };\n\n  const name = (candidates: readonly string[]) => {\n    const rest = text.slice(position).toLocaleLowerCase(locale);\n    let best = -1;\n    let length = 0;\n    candidates.forEach((candidate, index) => {\n      const lower = candidate.toLocaleLowerCase(locale);\n      if (lower.length > length && rest.startsWith(lower)) {\n        best = index;\n        length = lower.length;\n      }\n    });\n    if (best === -1) throw fail(`expected one of ${candidates.join(', ')} at position ${position}`);\n    position += length;\n    return best;\n  };\n\n  for (let i = 0; i < pattern.length;) {\n    const char = pattern[i]!;\n\n    if (char === \"'\") {\n      // '' is a literal quote; 'text' is literal text with '' for a quote inside.\n      if (pattern[i + 1] === \"'\") {\n        literal(\"'\");\n        i += 2;\n        continue;\n      }\n      let quoted = '';\n      for (i++; i < pattern.length; i++) {\n        if (pattern[i] !== \"'\") quoted += pattern[i];\n        else if (pattern[i + 1] === \"'\") ((quoted += \"'\"), i++);\n        else break;\n      }\n      literal(quoted);\n      i++;\n      continue;\n    }\n\n    const token = consumeToken(pattern, i, char);\n    if (token === null) {\n      literal(char);\n      i++;\n      continue;\n    }\n    i += token.length;\n\n    switch (token) {\n      case 'yyyy':\n        fields.year = Number(digits(4, 4));\n        break;\n      case 'y':\n        fields.year = Number(digits(1, 6));\n        break;\n      case 'MMMM':\n      case 'MMM':\n        fields.month = name(monthNames(locale, token === 'MMMM' ? 'long' : 'short')) + 1;\n        break;\n      case 'MM':\n        fields.month = Number(digits(2, 2));\n        break;\n      case 'M':\n        fields.month = Number(digits(1, 2));\n        break;\n      case 'dd':\n        fields.day = Number(digits(2, 2));\n        break;\n      case 'd':\n        fields.day = Number(digits(1, 2));\n        break;\n      case 'EEEE':\n      case 'EEE':\n      case 'EE':\n      case 'E':\n        fields.dayOfWeek = name(weekdayNames(locale, token === 'EEEE' ? 'long' : 'short')) + 1;\n        break;\n      case 'HH':\n        fields.hour = Number(digits(2, 2));\n        break;\n      case 'H':\n        fields.hour = Number(digits(1, 2));\n        break;\n      case 'hh':\n        fields.hour12 = Number(digits(2, 2));\n        break;\n      case 'h':\n        fields.hour12 = Number(digits(1, 2));\n        break;\n      case 'aaaa':\n      case 'aaa':\n      case 'aa':\n      case 'a': {\n        const [am, pm] = dayPeriods(locale);\n        const candidates = [am, pm];\n        if (isAsciiAmPm(am) && isAsciiAmPm(pm)) candidates.push('a.m.', 'p.m.');\n        fields.pm = name(candidates) % 2 === 1;\n        break;\n      }\n      case 'mm':\n        fields.minute = Number(digits(2, 2));\n        break;\n      case 'm':\n        fields.minute = Number(digits(1, 2));\n        break;\n      case 'ss':\n        fields.second = Number(digits(2, 2));\n        break;\n      case 's':\n        fields.second = Number(digits(1, 2));\n        break;\n      case 'SSS':\n      case 'SS':\n      case 'S':\n        fields.millisecond = Number(digits(token.length, token.length).padEnd(3, '0'));\n        break;\n      default:\n        if (/^[Xx]+$/.test(token)) {\n          const match = text\n            .slice(position)\n            .match(token[0] === 'X' ? /^(Z|[+-]\\d{2}(:?\\d{2}){0,2})/ : /^[+-]\\d{2}(:?\\d{2}){0,2}/);\n          if (!match) throw fail(`expected a UTC offset at position ${position}`);\n          position += match[0].length;\n          fields.offset = match[0] === 'Z' ? '+00:00' : normalizeOffset(match[0]);\n          break;\n        }\n        throw new RangeError(\n          token === 'yy'\n            ? 'parse does not read two-digit years (yy); the century would be a guess'\n            : token === 'T' || token === 't'\n              ? 'parse does not read timestamps (T, t); use toInstant'\n              : `parse does not support the \"${token}\" token`\n        );\n    }\n  }\n\n  if (position !== text.length) {\n    throw fail(`unexpected \"${text.slice(position)}\" at position ${position}`);\n  }\n  return fields;\n}\n\n// \"+0530\" and \"+05:30\" both become \"+05:30\", which Temporal reads.\nfunction normalizeOffset(offset: string): string {\n  const numbers = offset.slice(1).replaceAll(':', '');\n  const parts = numbers.match(/\\d{2}/g)!;\n  return `${offset[0]}${parts.length === 1 ? `${parts[0]}:00` : parts.join(':')}`;\n}\n\n// Names come from Intl exactly as format writes them, so what format writes, parse reads.\nfunction intlPart(\n  locale: string,\n  options: Intl.DateTimeFormatOptions,\n  type: Intl.DateTimeFormatPartTypes,\n  date: Temporal.PlainDateTime\n): string {\n  const epochMilliseconds = date.toZonedDateTime('UTC').epochMilliseconds;\n  return (\n    new Intl.DateTimeFormat(locale, { ...options, timeZone: 'UTC' })\n      .formatToParts(epochMilliseconds)\n      .find((part) => part.type === type)?.value ?? ''\n  );\n}\n\nfunction monthNames(locale: string, style: 'long' | 'short'): string[] {\n  return Array.from({ length: 12 }, (_, index) =>\n    intlPart(\n      locale,\n      { month: style },\n      'month',\n      Temporal.PlainDateTime.from({ year: 2000, month: index + 1, day: 15 })\n    )\n  );\n}\n\nfunction weekdayNames(locale: string, style: 'long' | 'short'): string[] {\n  // 3 January 2000 was a Monday.\n  return Array.from({ length: 7 }, (_, index) =>\n    intlPart(\n      locale,\n      { weekday: style },\n      'weekday',\n      Temporal.PlainDateTime.from({ year: 2000, month: 1, day: 3 + index })\n    )\n  );\n}\n\nfunction dayPeriods(locale: string): [am: string, pm: string] {\n  const at = (hour: number) =>\n    intlPart(\n      locale,\n      { hour: 'numeric', hour12: true },\n      'dayPeriod',\n      Temporal.PlainDateTime.from({ year: 2000, month: 1, day: 3, hour })\n    );\n  return [at(9), at(15)];\n}\n\nfunction isAsciiAmPm(period: string): boolean {\n  const normalized = period.toUpperCase().replace(/[.\\s]/g, '');\n  return normalized === 'AM' || normalized === 'PM';\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-426MJGNT.js → chunk-3X2U6I44.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -16,4 +16,4 @@ function addWeeks(input, weeks) {
 export {
   addWeeks
 };
-//# sourceMappingURL=chunk-426MJGNT.js.map
+//# sourceMappingURL=chunk-3X2U6I44.js.map

package/dist/chunk-3X2U6I44.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of weeks to a datetime or date.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param weeks - Number of weeks to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, 2);\n * // 2025-02-03T12:00:00+00:00[UTC] (2 weeks later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addWeeks(zoned, 2);\n * // 2025-02-03T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract weeks\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, -1);\n * // 2025-01-13T12:00:00+00:00[UTC] (1 week earlier)\n * ```\n */\nexport function addWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ weeks });\n  }\n  return normalizeTemporalInput(input).add({ weeks });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,SACd,OACA,OAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,MAAM,CAAC;AAAA,EAC5B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC;AACpD;","names":[]}

package/dist/{chunk-EBQ25TEY.js → chunk-3XGUCQ2A.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isSameMicrosecond.ts
 function isSameMicrosecond(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMicrosecond(date1, date2) {
 export {
   isSameMicrosecond
 };
-//# sourceMappingURL=chunk-EBQ25TEY.js.map
+//# sourceMappingURL=chunk-3XGUCQ2A.js.map

package/dist/chunk-3XGUCQ2A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMicrosecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same microsecond.\n * Compares the year, month, day, hour, minute, second, millisecond, and microsecond fields directly.\n * Ignores sub-microsecond precision (nanoseconds).\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same microsecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same microsecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456999+00:00[UTC]');\n *\n * isSameMicrosecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different microseconds\n * const us456 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456+00:00[UTC]');\n * const us457 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123457+00:00[UTC]');\n *\n * isSameMicrosecond(us456, us457); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local microseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local microseconds from each person's perspective\n * isSameMicrosecond(ny, tokyo); // false (14:30:45.123456 in NY, 04:30:45.123456 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMicrosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMicrosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456999Z');\n *\n * isSameMicrosecond(instant1, instant2); // true (both 14:30:45.123456 in UTC)\n * ```\n */\nexport function isSameMicrosecond(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second &&\n    zoned1.millisecond === zoned2.millisecond &&\n    zoned1.microsecond === zoned2.microsecond\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,kBACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO,UACzB,OAAO,gBAAgB,OAAO,eAC9B,OAAO,gBAAgB,OAAO;AAElC;","names":[]}

package/dist/chunk-42IFQS4W.js

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

package/dist/chunk-42IFQS4W.js.map

@@ -0,0 +1 @@
+{"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 and any holidays\n * you pass. Equivalent to `addBusinessDays(input, -days, holidays)`.\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 * @param holidays - Dates that are not business days. For Instant and ZonedDateTime\n *   inputs they are matched against the input's own date (UTC for Instant).\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(\n  input: Temporal.PlainDate,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.PlainDate;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.ZonedDateTime;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addBusinessDays overload.\n  return isPlainDate(input)\n    ? addBusinessDays(input, -days, holidays)\n    : addBusinessDays(input, -days, holidays);\n}\n"],"mappings":";;;;;;;;AAkCO,SAAS,gBACd,OACA,MACA,UAC6C;AAE7C,SAAO,YAAY,KAAK,IACpB,gBAAgB,OAAO,CAAC,MAAM,QAAQ,IACtC,gBAAgB,OAAO,CAAC,MAAM,QAAQ;AAC5C;","names":[]}

package/dist/{chunk-R3PZ56AD.js → chunk-4FQCY75E.js}

@@ -1,12 +1,12 @@
-import {
-  quarterStartMonth
-} from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
 } from "./chunk-NMMMAMKP.js";
+import {
+  quarterStartMonth
+} from "./chunk-XS2HUADA.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -32,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-R3PZ56AD.js.map
+//# sourceMappingURL=chunk-4FQCY75E.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport type { Timezone } from \"./types\";\nimport { getEndOfDay } from \"./shared/endOfDay\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the last moment of the quarter\n * (last day of the quarter's ending month at 23:59:59.999999999).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the quarter at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const end = endOfQuarter(instant);\n * // 2025-06-30T23:59:59.999999999+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-02-15T15:30:00-05:00[America/New_York]');\n * const end = endOfQuarter(zoned);\n * // 2025-03-31T23:59:59.999999999-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From a PlainDate in a timezone\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const end = endOfQuarter(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function endOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfQuarter(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → last day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    const endMonth = input.with({\n      month: quarterStartMonth(input.month) + 2,\n      day: 1,\n    });\n    return endMonth.with({ day: endMonth.daysInMonth });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const endMonth = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month) + 2,\n    day: 1,\n  });\n  const lastDay = endMonth.with({ day: endMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;;;;AA4CO,SAAS,aACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,YAAW,MAAM,KAAK;AAAA,MAC1B,OAAO,kBAAkB,MAAM,KAAK,IAAI;AAAA,MACxC,KAAK;AAAA,IACP,CAAC;AACD,WAAOA,UAAS,KAAK,EAAE,KAAKA,UAAS,YAAY,CAAC;AAAA,EACpD;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK,IAAI;AAAA,IAChD,KAAK;AAAA,EACP,CAAC;AACD,QAAM,UAAU,SAAS,KAAK,EAAE,KAAK,SAAS,YAAY,CAAC;AAC3D,SAAO,YAAY,OAAO;AAC5B;","names":["endMonth"]}

package/dist/{chunk-TWRJEIBO.js → chunk-4GEF7B7W.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function nowZoned() {
 export {
   nowZoned
 };
-//# sourceMappingURL=chunk-TWRJEIBO.js.map
+//# sourceMappingURL=chunk-4GEF7B7W.js.map

package/dist/{chunk-V36MCE25.js → chunk-4KAIF44F.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -16,4 +16,4 @@ function addDays(input, days) {
 export {
   addDays
 };
-//# sourceMappingURL=chunk-V36MCE25.js.map
+//# sourceMappingURL=chunk-4KAIF44F.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of days to a datetime or date.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param days - Number of days to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with days added\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addDays(instant, 5);\n * // 2025-01-25T12:00:00+00:00[UTC] (5 days later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addDays(zoned, 10);\n * // 2025-01-30T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract days\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addDays(instant, -7);\n * // 2025-01-13T12:00:00+00:00[UTC] (7 days earlier)\n * ```\n */\nexport function addDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function addDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function addDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ days });\n  }\n  return normalizeTemporalInput(input).add({ days });\n}\n"],"mappings":";;;;;;;;AA4CO,SAAS,QACd,OACA,MAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,KAAK,CAAC;AAAA,EAC3B;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;AACnD;","names":[]}

package/dist/{chunk-YHQSI4WC.js → chunk-4VWUTQKP.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   Temporal,
   isPlainDate
@@ -62,4 +62,4 @@ function eachQuarterStart(start, end, make) {
 export {
   eachQuarterOfInterval
 };
-//# sourceMappingURL=chunk-YHQSI4WC.js.map
+//# sourceMappingURL=chunk-4VWUTQKP.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachQuarterOfInterval.ts"],"sourcesContent":["import { isPlainDateAfter } from './isPlainDateAfter';\nimport { Temporal } from \"./shared/temporal\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array with the start of each quarter within the interval, inclusive\n * of both the start and end quarters.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec. Each element\n * is the first moment of the quarter (1st day of the quarter's starting month at\n * midnight) for Instant/ZonedDateTime inputs, or the first day as a PlainDate for\n * PlainDate inputs.\n *\n * For Instant inputs, UTC is used. For ZonedDateTime inputs, the timezone of the\n * start date is preserved. PlainDate inputs need no timezone and return PlainDate[].\n *\n * @param interval - The interval with start and end\n * @returns Array of ZonedDateTime (or PlainDate) at the start of each quarter\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-02-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-11-20T14:00:00+00:00[UTC]');\n * eachQuarterOfInterval({ start, end });\n * // [2025-01-01…, 2025-04-01…, 2025-07-01…, 2025-10-01…]\n * ```\n *\n * @example\n * ```ts\n * // PlainDate interval returns PlainDate quarter starts (no timezone)\n * eachQuarterOfInterval({\n *   start: Temporal.PlainDate.from('2025-02-15'),\n *   end: Temporal.PlainDate.from('2025-08-20'),\n * });\n * // [2025-01-01, 2025-04-01, 2025-07-01]\n * ```\n */\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachQuarterOfInterval(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    return eachQuarterStart(interval.start, interval.end.withCalendar(interval.start.calendarId), (ym) => ym.toPlainDate({ day: 1 }));\n  }\n\n  const startZoned = normalizeTemporalInput(\n    interval.start as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  const endZoned = normalizeTemporalInput(\n    interval.end as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n  const timezone = startZoned.timeZoneId;\n\n  return eachQuarterStart(startZoned, endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId), (ym) =>\n    ym.toPlainDate({ day: 1 }).toZonedDateTime({\n      timeZone: timezone,\n      plainTime: new Temporal.PlainTime(),\n    }),\n  );\n}\n\n/**\n * Walks quarter-aligned year-months from start to end (inclusive) and maps each\n * to a result. Both bounds are snapped to their quarter's starting month.\n */\nfunction eachQuarterStart<T>(\n  start: { year: number; month: number; calendarId: string },\n  end: { year: number; month: number; calendarId: string },\n  make: (ym: Temporal.PlainYearMonth) => T,\n): T[] {\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: start.year,\n    month: quarterStartMonth(start.month),\n    calendar: start.calendarId,\n  });\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: end.year,\n    month: quarterStartMonth(end.month),\n    calendar: start.calendarId,\n  });\n\n  const out: T[] = [];\n  let current = startYearMonth;\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    out.push(make(current));\n    // A calendar can have thirteen months; realign after crossing its year end.\n    const next = current.add({ months: 3 });\n    current = next.with({ month: quarterStartMonth(next.month) });\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkDO,SAAS,sBAAsB,UAGc;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,WAAO,iBAAiB,SAAS,OAAO,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;AAAA,EAClI;AAEA,QAAM,aAAa;AAAA,IACjB,SAAS;AAAA,EACX;AACA,QAAM,WAAW;AAAA,IACf,SAAS;AAAA,EACX;AACA,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AACrE,QAAM,WAAW,WAAW;AAE5B,SAAO;AAAA,IAAiB;AAAA,IAAY,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AAAA,IAAG,CAAC,OACxG,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,EAAE,gBAAgB;AAAA,MACzC,UAAU;AAAA,MACV,WAAW,IAAI,SAAS,UAAU;AAAA,IACpC,CAAC;AAAA,EACH;AACF;AAMA,SAAS,iBACP,OACA,KACA,MACK;AACL,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,MAAM;AAAA,IACZ,OAAO,kBAAkB,MAAM,KAAK;AAAA,IACpC,UAAU,MAAM;AAAA,EAClB,CAAC;AACD,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,IAAI;AAAA,IACV,OAAO,kBAAkB,IAAI,KAAK;AAAA,IAClC,UAAU,MAAM;AAAA,EAClB,CAAC;AAED,QAAM,MAAW,CAAC;AAClB,MAAI,UAAU;AACd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,QAAI,KAAK,KAAK,OAAO,CAAC;AAEtB,UAAM,OAAO,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AACtC,cAAU,KAAK,KAAK,EAAE,OAAO,kBAAkB,KAAK,KAAK,EAAE,CAAC;AAAA,EAC9D;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-4YCEFGZA.js

@@ -0,0 +1,61 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/businessDays.ts
+function isWeekendDay(dayOfWeek) {
+  return dayOfWeek >= 6;
+}
+function addWeekdays(start, days) {
+  if (!Number.isInteger(days)) {
+    throw new RangeError("Business day counts must be integers");
+  }
+  const step = days < 0 ? -1 : 1;
+  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));
+  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });
+  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0; ) {
+    result = result.add({ days: step });
+    if (!isWeekendDay(result.dayOfWeek)) remaining--;
+  }
+  return result;
+}
+function isoDate(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();
+  return Temporal.PlainDate.from(date.toString()).withCalendar("iso8601");
+}
+function addBusinessDaysSkipping(start, days, holidays) {
+  let result = addWeekdays(start, days);
+  const dates = weekdayHolidays(holidays);
+  if (dates.length === 0 || days === 0) return result;
+  const step = days < 0 ? -1 : 1;
+  for (let from = isoDate(start); ; ) {
+    const to = isoDate(result);
+    const skipped = dates.filter(
+      (date) => step > 0 ? Temporal.PlainDate.compare(date, from) > 0 && Temporal.PlainDate.compare(date, to) <= 0 : Temporal.PlainDate.compare(date, from) < 0 && Temporal.PlainDate.compare(date, to) >= 0
+    ).length;
+    if (skipped === 0) return result;
+    from = to;
+    result = addWeekdays(result, step * skipped);
+  }
+}
+function weekdayHolidays(holidays) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const holiday of holidays) {
+    const date = isoDate(holiday);
+    if (!isWeekendDay(date.dayOfWeek)) unique.set(date.toString(), date);
+  }
+  return [...unique.values()];
+}
+
+export {
+  isWeekendDay,
+  addWeekdays,
+  isoDate,
+  addBusinessDaysSkipping,
+  weekdayHolidays
+};
+//# sourceMappingURL=chunk-4YCEFGZA.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/businessDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\n/**\n * @internal\n * Saturday (6) and Sunday (7) in Temporal's Monday-based dayOfWeek.\n */\nexport function isWeekendDay(dayOfWeek: number): boolean {\n  return dayOfWeek >= 6;\n}\n\n/**\n * @internal\n * Adds days counting only Monday–Friday. The result keeps the input's type,\n * time of day, and timezone.\n */\nexport function addWeekdays<T extends { dayOfWeek: number; add(duration: { days: number }): T }>(\n  start: T,\n  days: number\n): T {\n  if (!Number.isInteger(days)) {\n    throw new RangeError('Business day counts must be integers');\n  }\n  const step = days < 0 ? -1 : 1;\n  // Any 7 consecutive days hold exactly 5 weekdays, so jump whole weeks. Keep\n  // at least one business day to walk so a weekend landing is never returned.\n  const fullWeeks = Math.max(0, Math.trunc((Math.abs(days) - 1) / 5));\n  let result = fullWeeks === 0 ? start : start.add({ days: step * fullWeeks * 7 });\n  for (let remaining = Math.abs(days) - fullWeeks * 5; remaining > 0;) {\n    result = result.add({ days: step });\n    if (!isWeekendDay(result.dayOfWeek)) remaining--;\n  }\n  return result;\n}\n\n/**\n * @internal\n * The calendar date of a value as an ISO PlainDate from this library's\n * Temporal implementation. Instant uses UTC; ZonedDateTime uses its timezone.\n */\nexport function isoDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): Temporal.PlainDate {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();\n  return Temporal.PlainDate.from(date.toString()).withCalendar('iso8601');\n}\n\n/**\n * @internal\n * Adds days counting only Monday–Friday that are not holidays. Holidays are\n * matched by ISO date; those on weekends are already skipped.\n */\nexport function addBusinessDaysSkipping<\n  T extends (Temporal.ZonedDateTime | Temporal.PlainDate) & {\n    add(duration: { days: number }): T;\n  }\n>(start: T, days: number, holidays: readonly Temporal.PlainDate[]): T {\n  let result = addWeekdays<T>(start, days);\n  const dates = weekdayHolidays(holidays);\n  if (dates.length === 0 || days === 0) return result;\n\n  // Each holiday passed over pushes the result one more business day along.\n  // Repeat until a stretch passes no holiday, which also leaves the result off one.\n  const step = days < 0 ? -1 : 1;\n  for (let from = isoDate(start); ;) {\n    const to = isoDate(result);\n    const skipped = dates.filter((date) =>\n      step > 0\n        ? Temporal.PlainDate.compare(date, from) > 0 && Temporal.PlainDate.compare(date, to) <= 0\n        : Temporal.PlainDate.compare(date, from) < 0 && Temporal.PlainDate.compare(date, to) >= 0\n    ).length;\n    if (skipped === 0) return result;\n    from = to;\n    result = addWeekdays<T>(result, step * skipped);\n  }\n}\n\n/**\n * @internal\n * Distinct holidays that fall Monday–Friday, as ISO PlainDates.\n */\nexport function weekdayHolidays(holidays: readonly Temporal.PlainDate[]): Temporal.PlainDate[] {\n  const unique = new Map<string, Temporal.PlainDate>();\n  for (const holiday of holidays) {\n    const date = isoDate(holiday);\n    if (!isWeekendDay(date.dayOfWeek)) unique.set(date.toString(), date);\n  }\n  return [...unique.values()];\n}\n"],"mappings":";;;;;;;;;AAOO,SAAS,aAAa,WAA4B;AACvD,SAAO,aAAa;AACtB;AAOO,SAAS,YACd,OACA,MACG;AACH,MAAI,CAAC,OAAO,UAAU,IAAI,GAAG;AAC3B,UAAM,IAAI,WAAW,sCAAsC;AAAA,EAC7D;AACA,QAAM,OAAO,OAAO,IAAI,KAAK;AAG7B,QAAM,YAAY,KAAK,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC;AAClE,MAAI,SAAS,cAAc,IAAI,QAAQ,MAAM,IAAI,EAAE,MAAM,OAAO,YAAY,EAAE,CAAC;AAC/E,WAAS,YAAY,KAAK,IAAI,IAAI,IAAI,YAAY,GAAG,YAAY,KAAI;AACnE,aAAS,OAAO,IAAI,EAAE,MAAM,KAAK,CAAC;AAClC,QAAI,CAAC,aAAa,OAAO,SAAS,EAAG;AAAA,EACvC;AACA,SAAO;AACT;AAOO,SAAS,QACd,OACoB;AACpB,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK,EAAE,YAAY;AACpF,SAAO,SAAS,UAAU,KAAK,KAAK,SAAS,CAAC,EAAE,aAAa,SAAS;AACxE;AAOO,SAAS,wBAId,OAAU,MAAc,UAA4C;AACpE,MAAI,SAAS,YAAe,OAAO,IAAI;AACvC,QAAM,QAAQ,gBAAgB,QAAQ;AACtC,MAAI,MAAM,WAAW,KAAK,SAAS,EAAG,QAAO;AAI7C,QAAM,OAAO,OAAO,IAAI,KAAK;AAC7B,WAAS,OAAO,QAAQ,KAAK,OAAM;AACjC,UAAM,KAAK,QAAQ,MAAM;AACzB,UAAM,UAAU,MAAM;AAAA,MAAO,CAAC,SAC5B,OAAO,IACH,SAAS,UAAU,QAAQ,MAAM,IAAI,IAAI,KAAK,SAAS,UAAU,QAAQ,MAAM,EAAE,KAAK,IACtF,SAAS,UAAU,QAAQ,MAAM,IAAI,IAAI,KAAK,SAAS,UAAU,QAAQ,MAAM,EAAE,KAAK;AAAA,IAC5F,EAAE;AACF,QAAI,YAAY,EAAG,QAAO;AAC1B,WAAO;AACP,aAAS,YAAe,QAAQ,OAAO,OAAO;AAAA,EAChD;AACF;AAMO,SAAS,gBAAgB,UAA+D;AAC7F,QAAM,SAAS,oBAAI,IAAgC;AACnD,aAAW,WAAW,UAAU;AAC9B,UAAM,OAAO,QAAQ,OAAO;AAC5B,QAAI,CAAC,aAAa,KAAK,SAAS,EAAG,QAAO,IAAI,KAAK,SAAS,GAAG,IAAI;AAAA,EACrE;AACA,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC;AAC5B;","names":[]}