@gobrand/tiempo 3.1.3 → 3.2.0

package/dist/addBusinessDays.d.ts

@@ -1,7 +1,6 @@
 import { type Temporal } from './shared/temporal.js';
 /**
- * Adds business days (Monday–Friday), skipping weekends. Holidays are not
- * considered.
+ * Adds business days (Monday–Friday), skipping weekends and any holidays you pass.
  *
  * Starting on a weekend, the first business day counted is the next Monday
  * (or the previous Friday for negative values). Adding 0 returns the input's
@@ -12,6 +11,8 @@ import { type Temporal } from './shared/temporal.js';
  *
  * @param input - An Instant (UTC), ZonedDateTime, or PlainDate
  * @param days - Whole business days to add (negative to subtract)
+ * @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
  *
@@ -22,7 +23,16 @@ import { type Temporal } from './shared/temporal.js';
  * addBusinessDays(friday, 1); // 2025-01-27 (Monday)
  * addBusinessDays(friday, 5); // 2025-01-31 (Friday)
  * ```
+ *
+ * @example
+ * ```ts
+ * // Skip holidays too
+ * const christmasEve = Temporal.PlainDate.from('2025-12-24');
+ * const holidays = [Temporal.PlainDate.from('2025-12-25'), Temporal.PlainDate.from('2025-12-26')];
+ *
+ * addBusinessDays(christmasEve, 1, holidays).toString(); // "2025-12-29"
+ * ```
  */
-export declare function addBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;
-export declare function addBusinessDays(input: Temporal.Instant | Temporal.ZonedDateTime, days: number): Temporal.ZonedDateTime;
+export declare function addBusinessDays(input: Temporal.PlainDate, days: number, holidays?: readonly Temporal.PlainDate[]): Temporal.PlainDate;
+export declare function addBusinessDays(input: Temporal.Instant | Temporal.ZonedDateTime, days: number, holidays?: readonly Temporal.PlainDate[]): Temporal.ZonedDateTime;
 //# sourceMappingURL=addBusinessDays.d.ts.map

package/dist/addBusinessDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addBusinessDays.d.ts","sourceRoot":"","sources":["../src/addBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAI/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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":"addBusinessDays.d.ts","sourceRoot":"","sources":["../src/addBusinessDays.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,mBAAmB,CAAC;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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/addBusinessDays.js

@@ -1,7 +1,7 @@
 import {
   addBusinessDays
-} from "./chunk-D3N7BT44.js";
-import "./chunk-K7CLBBBM.js";
+} from "./chunk-2JXI3CAL.js";
+import "./chunk-4YCEFGZA.js";
 import "./chunk-Q6QLOUXJ.js";
 import "./chunk-BSVOJYJ7.js";
 export {

package/dist/areIntervalsOverlapping.d.ts

@@ -0,0 +1,60 @@
+import type { Temporal } from './shared/temporal.js';
+import { type Timeline } from './shared/compare.js';
+/**
+ * Returns true if two intervals share any time.
+ *
+ * By default an interval that ends exactly where the other starts does not
+ * overlap it, so back-to-back bookings are allowed. Pass `{ inclusive: true }`
+ * to count a shared endpoint, as for inclusive date ranges.
+ *
+ * Instants and ZonedDateTimes compare by the moment they represent. PlainDate
+ * intervals compare by date. Mixing PlainDate and timeline endpoints throws a
+ * TypeError; an interval whose start is after its end throws a RangeError.
+ *
+ * @param left - The first interval
+ * @param right - The second interval
+ * @param options - `inclusive`: count intervals that only touch as overlapping
+ * @returns true if the intervals overlap
+ *
+ * @example
+ * ```ts
+ * const meeting = {
+ *   start: Temporal.ZonedDateTime.from('2025-01-20T09:00:00+01:00[Europe/Madrid]'),
+ *   end: Temporal.ZonedDateTime.from('2025-01-20T10:00:00+01:00[Europe/Madrid]')
+ * };
+ * const call = {
+ *   start: Temporal.Instant.from('2025-01-20T08:30:00Z'), // 09:30 in Madrid
+ *   end: Temporal.Instant.from('2025-01-20T09:30:00Z')
+ * };
+ *
+ * areIntervalsOverlapping(meeting, call); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * const firstStay = { start: Temporal.PlainDate.from('2025-07-01'), end: Temporal.PlainDate.from('2025-07-04') };
+ * const nextStay = { start: Temporal.PlainDate.from('2025-07-04'), end: Temporal.PlainDate.from('2025-07-08') };
+ *
+ * areIntervalsOverlapping(firstStay, nextStay); // false
+ * areIntervalsOverlapping(firstStay, nextStay, { inclusive: true }); // true
+ * ```
+ */
+export declare function areIntervalsOverlapping(left: {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}, right: {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}, options?: {
+    inclusive?: boolean;
+}): boolean;
+export declare function areIntervalsOverlapping(left: {
+    start: Timeline;
+    end: Timeline;
+}, right: {
+    start: Timeline;
+    end: Timeline;
+}, options?: {
+    inclusive?: boolean;
+}): boolean;
+//# sourceMappingURL=areIntervalsOverlapping.d.ts.map

package/dist/areIntervalsOverlapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areIntervalsOverlapping.d.ts","sourceRoot":"","sources":["../src/areIntervalsOverlapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAW,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,EAC5D,KAAK,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAA;CAAE,EAC7D,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,OAAO,CAAC;AACX,wBAAgB,uBAAuB,CACrC,IAAI,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAA;CAAE,EACxC,KAAK,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAA;CAAE,EACzC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,OAAO,CAAC"}

package/dist/areIntervalsOverlapping.js

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

package/dist/areIntervalsOverlapping.js.map

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

package/dist/chunk-2JXI3CAL.js

@@ -0,0 +1,22 @@
+import {
+  addBusinessDaysSkipping
+} from "./chunk-4YCEFGZA.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/addBusinessDays.ts
+function addBusinessDays(input, days, holidays = []) {
+  if (isPlainDate(input)) {
+    return addBusinessDaysSkipping(input, days, holidays);
+  }
+  return addBusinessDaysSkipping(normalizeTemporalInput(input), days, holidays);
+}
+
+export {
+  addBusinessDays
+};
+//# sourceMappingURL=chunk-2JXI3CAL.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { addBusinessDaysSkipping } from './shared/businessDays';\n\n/**\n * Adds business days (Monday–Friday), skipping weekends and any holidays you pass.\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 * @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 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 *\n * @example\n * ```ts\n * // Skip holidays too\n * const christmasEve = Temporal.PlainDate.from('2025-12-24');\n * const holidays = [Temporal.PlainDate.from('2025-12-25'), Temporal.PlainDate.from('2025-12-26')];\n *\n * addBusinessDays(christmasEve, 1, holidays).toString(); // \"2025-12-29\"\n * ```\n */\nexport function addBusinessDays(\n  input: Temporal.PlainDate,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.PlainDate;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.ZonedDateTime;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number,\n  holidays: readonly Temporal.PlainDate[] = []\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return addBusinessDaysSkipping(input, days, holidays);\n  }\n  return addBusinessDaysSkipping(normalizeTemporalInput(input), days, holidays);\n}\n"],"mappings":";;;;;;;;;;;AAgDO,SAAS,gBACd,OACA,MACA,WAA0C,CAAC,GACE;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,wBAAwB,OAAO,MAAM,QAAQ;AAAA,EACtD;AACA,SAAO,wBAAwB,uBAAuB,KAAK,GAAG,MAAM,QAAQ;AAC9E;","names":[]}

package/dist/{chunk-BYPHFTFD.js → chunk-2LT2XOAL.js}

@@ -1,3 +1,6 @@
+import {
+  consumeToken
+} from "./chunk-HH2HTC44.js";
 import {
   formatPlainDate
 } from "./chunk-TWXUGWYX.js";
@@ -65,87 +68,6 @@ function format(input, formatStr, options = {}) {
   }
   return result;
 }
-function consumeToken(formatStr, start, char) {
-  if (char === "M" && start + 1 < formatStr.length && formatStr[start + 1] === "o") {
-    return "Mo";
-  }
-  if (char === "d" && start + 1 < formatStr.length && formatStr[start + 1] === "o") {
-    return "do";
-  }
-  let end = start;
-  while (end < formatStr.length && formatStr[end] === char) {
-    end++;
-  }
-  const count = end - start;
-  const validTokens = [
-    "GGGGG",
-    "GGGG",
-    "GGG",
-    "GG",
-    "G",
-    "yyyy",
-    "yyy",
-    "yy",
-    "y",
-    "QQQQQ",
-    "QQQQ",
-    "QQQ",
-    "QQ",
-    "Q",
-    "MMMMM",
-    "MMMM",
-    "MMM",
-    "MM",
-    "M",
-    "dd",
-    "d",
-    "EEEEEE",
-    "EEEEE",
-    "EEEE",
-    "EEE",
-    "EE",
-    "E",
-    "aaaaa",
-    "aaaa",
-    "aaa",
-    "aa",
-    "a",
-    "HH",
-    "H",
-    "hh",
-    "h",
-    "mm",
-    "m",
-    "ss",
-    "s",
-    "SSS",
-    "SS",
-    "S",
-    "XXXXX",
-    "XXXX",
-    "XXX",
-    "XX",
-    "X",
-    "xxxxx",
-    "xxxx",
-    "xxx",
-    "xx",
-    "x",
-    "zzzz",
-    "zzz",
-    "zz",
-    "z",
-    "T",
-    "t"
-  ];
-  for (let len = Math.min(count, 6); len > 0; len--) {
-    const candidate = char.repeat(len);
-    if (validTokens.includes(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
 function formatToken(token, zonedDateTime, locale) {
   switch (token) {
     // Era
@@ -325,4 +247,4 @@ function isAm(period) {
 export {
   format
 };
-//# sourceMappingURL=chunk-BYPHFTFD.js.map
+//# sourceMappingURL=chunk-2LT2XOAL.js.map

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

@@ -0,0 +1 @@
+{"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';\nimport { consumeToken } from './shared/formatTokens';\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 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":";;;;;;;;;;;;;;;AA4CO,SAAS,OACd,OACA,WACA,UAAyB,CAAC,GAClB;AACR,MAAI,YAAY,KAAK,GAAG;AACtB,QAAI,QAAQ,aAAa,QAAW;AAClC,YAAM,IAAI,UAAU,iDAAiD;AAAA,IACvE;AACA,WAAO,gBAAgB,OAAO,WAAW,OAAO;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,SAAS,SAAS,IAAI;AAGvC,MAAI;AACJ,MAAI,UAAU;AAEZ,UAAM,UAAU,UAAU,KAAK,IAAI,QAAQ,MAAM,UAAU;AAC3D,oBAAgB,QAAQ,mBAAmB,QAAQ;AAAA,EACrD,OAAO;AAEL,oBAAgB,uBAAuB,KAAK;AAAA,EAC9C;AAEA,MAAI,SAAS;AACb,MAAI,IAAI;AACR,QAAM,MAAM,UAAU;AAEtB,SAAO,IAAI,KAAK;AACd,UAAM,OAAO,UAAU,CAAC;AACxB,QAAI,CAAC,KAAM;AAGX,QAAI,SAAS,KAAK;AAEhB,UAAI,IAAI,IAAI,OAAO,UAAU,IAAI,CAAC,MAAM,KAAK;AAC3C,kBAAU;AACV,aAAK;AACL;AAAA,MACF;AAEA;AACA,aAAO,IAAI,KAAK;AACd,YAAI,UAAU,CAAC,MAAM,KAAK;AAExB,cAAI,IAAI,IAAI,OAAO,UAAU,IAAI,CAAC,MAAM,KAAK;AAC3C,sBAAU;AACV,iBAAK;AAAA,UACP,OAAO;AAEL;AACA;AAAA,UACF;AAAA,QACF,OAAO;AACL,oBAAU,UAAU,CAAC;AACrB;AAAA,QACF;AAAA,MACF;AACA;AAAA,IACF;AAGA,UAAM,QAAQ,aAAa,WAAW,GAAG,IAAI;AAC7C,QAAI,UAAU,MAAM;AAClB,gBAAU,YAAY,OAAO,eAAe,MAAM;AAClD,WAAK,MAAM;AAAA,IACb,OAAO;AACL,gBAAU;AACV;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,YAAY,OAAe,eAAuC,QAAwB;AACjG,UAAQ,OAAO;AAAA;AAAA,IAEb,KAAK;AACH,aAAO,WAAW,eAAe,OAAO,UAAU,MAAM;AAAA,IAC1D,KAAK;AACH,aAAO,WAAW,eAAe,OAAO,QAAQ,MAAM;AAAA,IACxD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,WAAW,eAAe,OAAO,SAAS,MAAM;AAAA;AAAA,IAGzD,KAAK;AACH,aAAO,cAAc,KAAK,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACtD,KAAK;AACH,aAAO,cAAc,KAAK,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACtD,KAAK;AACH,cAAQ,cAAc,OAAO,KAAK,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IAC9D,KAAK;AACH,aAAO,cAAc,KAAK,SAAS;AAAA;AAAA,IAGrC,KAAK;AACH,aAAO,KAAK,KAAK,cAAc,QAAQ,CAAC,EAAE,SAAS;AAAA,IACrD,KAAK,QAAQ;AACX,YAAM,UAAU,KAAK,KAAK,cAAc,QAAQ,CAAC;AACjD,aAAO,GAAG,OAAO,GAAG,iBAAiB,OAAO,CAAC;AAAA,IAC/C;AAAA,IACA,KAAK;AACH,aAAO,IAAI,KAAK,KAAK,cAAc,QAAQ,CAAC,CAAC;AAAA,IAC/C,KAAK;AACH,aAAO,KAAK,KAAK,cAAc,QAAQ,CAAC,EACrC,SAAS,EACT,SAAS,GAAG,GAAG;AAAA,IACpB,KAAK;AACH,aAAO,KAAK,KAAK,cAAc,QAAQ,CAAC,EAAE,SAAS;AAAA;AAAA,IAGrD,KAAK;AACH,aAAO,WAAW,eAAe,SAAS,UAAU,MAAM;AAAA,IAC5D,KAAK;AACH,aAAO,WAAW,eAAe,SAAS,QAAQ,MAAM;AAAA,IAC1D,KAAK;AACH,aAAO,WAAW,eAAe,SAAS,SAAS,MAAM;AAAA,IAC3D,KAAK;AACH,aAAO,cAAc,MAAM,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACvD,KAAK;AACH,aAAO,GAAG,cAAc,KAAK,GAAG,iBAAiB,cAAc,KAAK,CAAC;AAAA,IACvE,KAAK;AACH,aAAO,cAAc,MAAM,SAAS;AAAA;AAAA,IAGtC,KAAK;AACH,aAAO,GAAG,cAAc,GAAG,GAAG,iBAAiB,cAAc,GAAG,CAAC;AAAA,IACnE,KAAK;AACH,aAAO,cAAc,IAAI,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACrD,KAAK;AACH,aAAO,cAAc,IAAI,SAAS;AAAA;AAAA,IAGpC,KAAK;AACH,aAAO,WAAW,eAAe,WAAW,SAAS,MAAM,EAAE,MAAM,GAAG,CAAC;AAAA,IACzE,KAAK;AACH,aAAO,WAAW,eAAe,WAAW,UAAU,MAAM;AAAA,IAC9D,KAAK;AACH,aAAO,WAAW,eAAe,WAAW,QAAQ,MAAM;AAAA,IAC5D,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,WAAW,eAAe,WAAW,SAAS,MAAM;AAAA;AAAA,IAG7D,KAAK,SAAS;AACZ,YAAM,SAAS,aAAa,eAAe,MAAM;AACjD,UAAI,YAAY,MAAM,EAAG,QAAO,KAAK,MAAM,IAAI,MAAM;AACrD,aAAO,OAAO,OAAO,CAAC,EAAE,YAAY;AAAA,IACtC;AAAA,IACA,KAAK,QAAQ;AACX,YAAM,SAAS,aAAa,eAAe,MAAM;AACjD,UAAI,YAAY,MAAM,EAAG,QAAO,KAAK,MAAM,IAAI,SAAS;AACxD,aAAO;AAAA,IACT;AAAA,IACA,KAAK;AACH,aAAO,aAAa,eAAe,MAAM,EAAE,YAAY;AAAA,IACzD,KAAK;AAAA,IACL,KAAK;AACH,aAAO,aAAa,eAAe,MAAM;AAAA;AAAA,IAG3C,KAAK;AACH,aAAO,cAAc,KAAK,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACtD,KAAK;AACH,aAAO,cAAc,KAAK,SAAS;AAAA;AAAA,IAGrC,KAAK,MAAM;AACT,YAAM,SAAS,cAAc,OAAO,MAAM;AAC1C,aAAO,OAAO,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IAC1C;AAAA,IACA,KAAK,KAAK;AACR,YAAM,SAAS,cAAc,OAAO,MAAM;AAC1C,aAAO,OAAO,SAAS;AAAA,IACzB;AAAA;AAAA,IAGA,KAAK;AACH,aAAO,cAAc,OAAO,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACxD,KAAK;AACH,aAAO,cAAc,OAAO,SAAS;AAAA;AAAA,IAGvC,KAAK;AACH,aAAO,cAAc,OAAO,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IACxD,KAAK;AACH,aAAO,cAAc,OAAO,SAAS;AAAA;AAAA,IAGvC,KAAK;AACH,aAAO,cAAc,YAAY,SAAS,EAAE,SAAS,GAAG,GAAG;AAAA,IAC7D,KAAK;AACH,aAAO,KAAK,MAAM,cAAc,cAAc,EAAE,EAC7C,SAAS,EACT,SAAS,GAAG,GAAG;AAAA,IACpB,KAAK;AACH,aAAO,KAAK,MAAM,cAAc,cAAc,GAAG,EAAE,SAAS;AAAA;AAAA,IAG9D,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,qBAAqB,eAAe,KAAK;AAAA,IAClD,KAAK;AACH,aAAO,WAAW,eAAe,gBAAgB,QAAQ,MAAM;AAAA,IACjE,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,WAAW,eAAe,gBAAgB,SAAS,MAAM;AAAA;AAAA,IAGlE,KAAK;AACH,aAAO,cAAc,kBAAkB,SAAS;AAAA,IAClD,KAAK;AACH,aAAO,KAAK,MAAM,cAAc,oBAAoB,GAAI,EAAE,SAAS;AAAA,IAErE;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,WACP,eACA,MACA,OACA,QACQ;AACR,QAAM,UAAsC;AAAA,IAC1C,CAAC,IAAI,GAAG;AAAA,IACR,UAAU,cAAc;AAAA,IACxB,UAAU,cAAc,eAAe,YAAY,SAAY,cAAc;AAAA,EAC/E;AACA,SAAO,IAAI,KAAK,eAAe,QAAQ,OAAO,EAC3C,cAAc,cAAc,iBAAiB,EAC7C,KAAK,WAAS,MAAM,SAAS,IAAI,GAAG,SAAS;AAClD;AAEA,SAAS,iBAAiB,KAAqB;AAC7C,QAAM,IAAI,MAAM;AAChB,QAAM,IAAI,MAAM;AAChB,MAAI,MAAM,KAAK,MAAM,GAAI,QAAO;AAChC,MAAI,MAAM,KAAK,MAAM,GAAI,QAAO;AAChC,MAAI,MAAM,KAAK,MAAM,GAAI,QAAO;AAChC,SAAO;AACT;AAEA,SAAS,qBAAqB,eAAuC,OAAuB;AAC1F,MAAI,MAAM,CAAC,MAAM,OAAO,cAAc,sBAAsB,EAAG,QAAO;AAItE,QAAM,SAAS,MAAM,UAAU,IAAI,cAAc,SAAS,cAAc,OAAO,MAAM,GAAG,CAAC;AACzF,MAAI,MAAM,WAAW,KAAK,OAAO,SAAS,KAAK,EAAG,QAAO,OAAO,MAAM,GAAG,CAAC;AAC1E,SAAO,MAAM,WAAW,KAAK,MAAM,WAAW,IAAI,SAAS,OAAO,WAAW,KAAK,EAAE;AACtF;AAMA,SAAS,aAAa,eAAuC,QAAwB;AACnF,QAAM,QAAQ,IAAI,KAAK,eAAe,QAAQ;AAAA,IAC5C,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,UAAU,cAAc;AAAA,EAC1B,CAAC,EAAE,cAAc,cAAc,iBAAiB;AAChD,SAAO,MAAM,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,GAAG,SAAS;AAC7D;AAGA,SAAS,YAAY,QAAyB;AAC5C,QAAM,aAAa,OAAO,YAAY,EAAE,QAAQ,UAAU,EAAE;AAC5D,SAAO,eAAe,QAAQ,eAAe;AAC/C;AAGA,SAAS,KAAK,QAAyB;AACrC,SAAO,OAAO,YAAY,EAAE,QAAQ,UAAU,EAAE,EAAE,WAAW,GAAG;AAClE;","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-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-MXYAZTDE.js → chunk-4FQCY75E.js}

@@ -1,12 +1,12 @@
-import {
-  quarterStartMonth
-} from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
 } 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-MXYAZTDE.js.map
+//# sourceMappingURL=chunk-4FQCY75E.js.map