@gobrand/tiempo 3.1.2 → 3.2.0

package/dist/{chunk-5ST6IOPN.js → chunk-GXSVYUCG.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addMinutes.ts
 function addMinutes(input, minutes) {
@@ -11,4 +11,4 @@ function addMinutes(input, minutes) {
 export {
   addMinutes
 };
-//# sourceMappingURL=chunk-5ST6IOPN.js.map
+//# sourceMappingURL=chunk-GXSVYUCG.js.map

package/dist/chunk-GXSVYUCG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMinutes.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of minutes 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 minutes - Number of minutes to add (can be negative to subtract)\n * @returns ZonedDateTime with minutes 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 = addMinutes(instant, 30);\n * // 2025-01-20T12:30:00+00:00[UTC] (30 minutes 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 = addMinutes(zoned, 90);\n * // 2025-01-20T17:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract minutes\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMinutes(instant, -15);\n * // 2025-01-20T11:45:00+00:00[UTC] (15 minutes earlier)\n * ```\n */\nexport function addMinutes(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  minutes: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ minutes });\n}\n"],"mappings":";;;;;AAoCO,SAAS,WACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,QAAQ,CAAC;AACtC;","names":[]}

package/dist/chunk-H43LMOCK.js

@@ -0,0 +1,26 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/calendarDates.ts
+function calendarDates(laterDate, earlierDate) {
+  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {
+    throw new TypeError("PlainDate differences require two PlainDate values");
+  }
+  const later = dateOf(laterDate);
+  const earlier = dateOf(earlierDate);
+  return [later.withCalendar(earlier.calendarId), earlier];
+}
+function dateOf(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();
+  return Temporal.PlainDate.from(date.toString());
+}
+
+export {
+  calendarDates
+};
+//# sourceMappingURL=chunk-H43LMOCK.js.map

package/dist/chunk-H43LMOCK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/calendarDates.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './temporal';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\n\n/**\n * @internal\n * The calendar dates behind a differenceInCalendar* pair: PlainDates as given,\n * Instants by their UTC date, ZonedDateTimes by the date in their own timezone.\n * Both come back in this implementation and in the earlier date's calendar.\n */\nexport function calendarDates(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): [later: Temporal.PlainDate, earlier: Temporal.PlainDate] {\n  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {\n    throw new TypeError('PlainDate differences require two PlainDate values');\n  }\n  const later = dateOf(laterDate);\n  const earlier = dateOf(earlierDate);\n  return [later.withCalendar(earlier.calendarId), earlier];\n}\n\nfunction dateOf(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): Temporal.PlainDate {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input).toPlainDate();\n  // A canonical string brings dates from another Temporal implementation across.\n  return Temporal.PlainDate.from(date.toString());\n}\n"],"mappings":";;;;;;;;;AASO,SAAS,cACd,WACA,aAC0D;AAC1D,MAAI,YAAY,SAAS,MAAM,YAAY,WAAW,GAAG;AACvD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,QAAM,QAAQ,OAAO,SAAS;AAC9B,QAAM,UAAU,OAAO,WAAW;AAClC,SAAO,CAAC,MAAM,aAAa,QAAQ,UAAU,GAAG,OAAO;AACzD;AAEA,SAAS,OACP,OACoB;AACpB,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK,EAAE,YAAY;AAEpF,SAAO,SAAS,UAAU,KAAK,KAAK,SAAS,CAAC;AAChD;","names":[]}

package/dist/{chunk-B6VZ2AKN.js → chunk-HCORON7B.js}

@@ -1,6 +1,6 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
 } from "./chunk-NMMMAMKP.js";
@@ -21,4 +21,4 @@ function endOfMonth(input, timezone) {
 export {
   endOfMonth
 };
-//# sourceMappingURL=chunk-B6VZ2AKN.js.map
+//# sourceMappingURL=chunk-HCORON7B.js.map

package/dist/chunk-HCORON7B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfMonth.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the last 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 last day of the month at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const end = endOfMonth(instant);\n * // 2025-01-31T23: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 = endOfMonth(zoned);\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date);\n * // 2025-02-28\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date, 'America/New_York');\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfMonth(\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: input.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AAoDO,SAAS,WACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,MAAM,YAAY,CAAC;AAAA,EAC9C;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,UAAU,cAAc,KAAK,EAAE,KAAK,cAAc,YAAY,CAAC;AACrE,SAAO,YAAY,OAAO;AAC5B;","names":[]}

package/dist/chunk-HH2HTC44.js

@@ -0,0 +1,87 @@
+// src/shared/formatTokens.ts
+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;
+}
+
+export {
+  consumeToken
+};
+//# sourceMappingURL=chunk-HH2HTC44.js.map

package/dist/chunk-HH2HTC44.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/formatTokens.ts"],"sourcesContent":["/**\n * @internal\n * Reads the format token that starts at `start`, or null if `char` does not\n * start one. A run of one letter longer than any token splits into several,\n * longest first. Shared by format and parse so both read a pattern the same way.\n */\nexport function consumeToken(formatStr: string, start: number, char: string): string | null {\n  // Special case for 'Mo' and 'do' - these end with 'o'\n  if (char === 'M' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'Mo';\n  }\n  if (char === 'd' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'do';\n  }\n\n  // Count how many consecutive identical characters\n  let end = start;\n  while (end < formatStr.length && formatStr[end] === char) {\n    end++;\n  }\n  const count = end - start;\n\n  // Check if this is a valid token pattern\n  const validTokens = [\n    'GGGGG',\n    'GGGG',\n    'GGG',\n    'GG',\n    'G',\n    'yyyy',\n    'yyy',\n    'yy',\n    'y',\n    'QQQQQ',\n    'QQQQ',\n    'QQQ',\n    'QQ',\n    'Q',\n    'MMMMM',\n    'MMMM',\n    'MMM',\n    'MM',\n    'M',\n    'dd',\n    'd',\n    'EEEEEE',\n    'EEEEE',\n    'EEEE',\n    'EEE',\n    'EE',\n    'E',\n    'aaaaa',\n    'aaaa',\n    'aaa',\n    'aa',\n    'a',\n    'HH',\n    'H',\n    'hh',\n    'h',\n    'mm',\n    'm',\n    'ss',\n    's',\n    'SSS',\n    'SS',\n    'S',\n    'XXXXX',\n    'XXXX',\n    'XXX',\n    'XX',\n    'X',\n    'xxxxx',\n    'xxxx',\n    'xxx',\n    'xx',\n    'x',\n    'zzzz',\n    'zzz',\n    'zz',\n    'z',\n    'T',\n    't'\n  ];\n\n  // Try to match from longest to shortest\n  for (let len = Math.min(count, 6); len > 0; len--) {\n    const candidate = char.repeat(len);\n    if (validTokens.includes(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n"],"mappings":";AAMO,SAAS,aAAa,WAAmB,OAAe,MAA6B;AAE1F,MAAI,SAAS,OAAO,QAAQ,IAAI,UAAU,UAAU,UAAU,QAAQ,CAAC,MAAM,KAAK;AAChF,WAAO;AAAA,EACT;AACA,MAAI,SAAS,OAAO,QAAQ,IAAI,UAAU,UAAU,UAAU,QAAQ,CAAC,MAAM,KAAK;AAChF,WAAO;AAAA,EACT;AAGA,MAAI,MAAM;AACV,SAAO,MAAM,UAAU,UAAU,UAAU,GAAG,MAAM,MAAM;AACxD;AAAA,EACF;AACA,QAAM,QAAQ,MAAM;AAGpB,QAAM,cAAc;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAGA,WAAS,MAAM,KAAK,IAAI,OAAO,CAAC,GAAG,MAAM,GAAG,OAAO;AACjD,UAAM,YAAY,KAAK,OAAO,GAAG;AACjC,QAAI,YAAY,SAAS,SAAS,GAAG;AACnC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-FL33IWLY.js → chunk-HRCTWTP3.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 addYears(input, years) {
 export {
   addYears
 };
-//# sourceMappingURL=chunk-FL33IWLY.js.map
+//# sourceMappingURL=chunk-HRCTWTP3.js.map

package/dist/chunk-HRCTWTP3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addYears.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of years to a datetime or date.\n *\n * Properly handles leap years 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 years - Number of years to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with years 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 = addYears(instant, 2);\n * // 2027-01-20T12:00:00+00:00[UTC] (2 years 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 = addYears(zoned, 1);\n * // 2026-01-20T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Leap year handling\n * const instant = Temporal.Instant.from('2024-02-29T12:00:00Z');\n * const result = addYears(instant, 1);\n * // 2025-02-28T12:00:00+00:00[UTC] (Feb 29 → Feb 28)\n * ```\n */\nexport function addYears(input: Temporal.PlainDate, years: number): Temporal.PlainDate;\nexport function addYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime;\nexport function addYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  years: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ years });\n  }\n  return normalizeTemporalInput(input).add({ years });\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-FUVG6A7U.js → chunk-HYSGJJUR.js}

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

package/dist/chunk-HYSGJJUR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMonth.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 calendar month and year.\n * Compares the year and month fields directly.\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 calendar month, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same month\n * const start = Temporal.ZonedDateTime.from('2025-01-01T08:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');\n *\n * isSameMonth(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different months\n * const jan = Temporal.ZonedDateTime.from('2025-01-31T23:59:59+00:00[UTC]');\n * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00+00:00[UTC]');\n *\n * isSameMonth(jan, feb); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar months\n * const ny = Temporal.ZonedDateTime.from('2025-01-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-02-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar months from each person's perspective\n * isSameMonth(ny, tokyo); // false (Jan in NY, Feb in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMonth(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Feb in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMonth(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-31T23:59:59Z');\n *\n * isSameMonth(instant1, instant2); // true (both Jan 2025 in UTC)\n * ```\n */\nexport function isSameMonth(\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 zoned1.year === zoned2.year && zoned1.month === zoned2.month;\n}\n"],"mappings":";;;;;AA0DO,SAAS,YACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO,QAAQ,OAAO,UAAU,OAAO;AAChE;","names":[]}

package/dist/chunk-IDB3R3G5.js

@@ -0,0 +1,21 @@
+import {
+  assertDayOfWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/nextDay.ts
+function nextDay(input, day) {
+  assertDayOfWeek(day, "day");
+  const value = isPlainDate(input) ? input : normalizeTemporalInput(input);
+  return value.add({ days: (day - value.dayOfWeek + 6) % 7 + 1 });
+}
+
+export {
+  nextDay
+};
+//# sourceMappingURL=chunk-IDB3R3G5.js.map

package/dist/chunk-IDB3R3G5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nextDay.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { assertDayOfWeek, type DayOfWeek } from './shared/week';\n\n/**\n * Returns the next date that falls on the given day of the week, always after\n * the input: next Friday from a Friday is a week later.\n *\n * Days are numbered as Temporal numbers them: 1 = Monday … 7 = Sunday.\n * PlainDate inputs stay dates. Instant inputs are read in UTC and ZonedDateTime\n * inputs keep their timezone; both keep their wall-clock time.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param day - The day of the week to find, 1 = Monday … 7 = Sunday\n * @returns The next date on that day of the week\n *\n * @example\n * ```ts\n * const wednesday = Temporal.PlainDate.from('2025-01-22');\n *\n * nextDay(wednesday, 5).toString(); // \"2025-01-24\"\n * nextDay(wednesday, 3).toString(); // \"2025-01-29\"\n * ```\n *\n * @example\n * ```ts\n * // Keeps the wall-clock time across a DST change\n * const fridayEvening = Temporal.ZonedDateTime.from('2025-03-07T18:00:00-05:00[America/New_York]');\n *\n * nextDay(fridayEvening, 1).toString(); // \"2025-03-10T18:00:00-04:00[America/New_York]\"\n * ```\n */\nexport function nextDay(input: Temporal.PlainDate, day: DayOfWeek): Temporal.PlainDate;\nexport function nextDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  day: DayOfWeek\n): Temporal.ZonedDateTime;\nexport function nextDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  day: DayOfWeek\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  assertDayOfWeek(day, 'day');\n  const value = isPlainDate(input) ? input : normalizeTemporalInput(input);\n  return value.add({ days: ((day - value.dayOfWeek + 6) % 7) + 1 });\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,QACd,OACA,KAC6C;AAC7C,kBAAgB,KAAK,KAAK;AAC1B,QAAM,QAAQ,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACvE,SAAO,MAAM,IAAI,EAAE,OAAQ,MAAM,MAAM,YAAY,KAAK,IAAK,EAAE,CAAC;AAClE;","names":[]}

package/dist/chunk-IIEHQPKE.js

@@ -0,0 +1,36 @@
+import {
+  isBefore
+} from "./chunk-BMX7CIRD.js";
+import {
+  isAfter
+} from "./chunk-CDKIT7D3.js";
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate,
+  isPlainTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/isWithinInterval.ts
+function isWithinInterval(date, interval) {
+  const { start, end } = interval;
+  if ([date, start, end].some((value) => isPlainDate(value) || isPlainTime(value))) {
+    const afterStart = compare(date, start) >= 0;
+    const beforeEnd = compare(date, end) <= 0;
+    if (isPlainTime(start) && compare(start, end) > 0) return afterStart || beforeEnd;
+    return afterStart && beforeEnd;
+  }
+  const normalizedDate = normalizeTemporalInput(date);
+  const normalizedStart = normalizeTemporalInput(start);
+  const normalizedEnd = normalizeTemporalInput(end);
+  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);
+}
+
+export {
+  isWithinInterval
+};
+//# sourceMappingURL=chunk-IIEHQPKE.js.map

package/dist/chunk-IIEHQPKE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isWithinInterval.ts"],"sourcesContent":["import { type Temporal, isPlainDate, isPlainTime } from './shared/temporal';\nimport { compare, type Comparable, type Timeline } from './shared/compare';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { isAfter } from './shared/isAfter';\n\n/**\n * Returns true if the given value is within the interval (inclusive of start and end).\n *\n * Instants and ZonedDateTimes compare by the moment they represent, not by\n * calendar date/time. PlainDates compare by date. PlainTimes compare by\n * wall-clock time, and an interval whose start is later than its end wraps\n * past midnight: 22:00 to 02:00 contains 23:30 and 01:00. A reversed timeline\n * or PlainDate interval contains nothing.\n *\n * Mixing PlainDate, PlainTime, and timeline values throws a TypeError.\n *\n * @param date - The value to check\n * @param interval - The interval with start and end values of the same kind\n * @returns true if the value is within the interval, false otherwise\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date outside the interval\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n * const date = Temporal.ZonedDateTime.from('2025-01-10T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // false\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval start (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(start, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Date equal to interval end (inclusive)\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+00:00[UTC]');\n *\n * isWithinInterval(end, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const start = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const end = Temporal.Instant.from('2025-01-07T00:00:00Z');\n * const date = Temporal.Instant.from('2025-01-03T00:00:00Z');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const start = Temporal.ZonedDateTime.from('2025-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T00:00:00+09:00[Asia/Tokyo]');\n * const date = Temporal.ZonedDateTime.from('2025-01-03T12:00:00+00:00[UTC]');\n *\n * isWithinInterval(date, { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Dates\n * const start = Temporal.PlainDate.from('2025-07-01');\n * const end = Temporal.PlainDate.from('2025-07-15');\n *\n * isWithinInterval(Temporal.PlainDate.from('2025-07-15'), { start, end }); // true\n * ```\n *\n * @example\n * ```ts\n * // Opening hours that run past midnight\n * const start = Temporal.PlainTime.from('22:00');\n * const end = Temporal.PlainTime.from('02:00');\n *\n * isWithinInterval(Temporal.PlainTime.from('23:30'), { start, end }); // true\n * isWithinInterval(Temporal.PlainTime.from('01:00'), { start, end }); // true\n * isWithinInterval(Temporal.PlainTime.from('12:00'), { start, end }); // false\n * ```\n */\nexport function isWithinInterval(\n  date: Temporal.PlainDate,\n  interval: { start: Temporal.PlainDate; end: Temporal.PlainDate }\n): boolean;\nexport function isWithinInterval(\n  date: Temporal.PlainTime,\n  interval: { start: Temporal.PlainTime; end: Temporal.PlainTime }\n): boolean;\nexport function isWithinInterval(\n  date: Temporal.Instant | Temporal.ZonedDateTime,\n  interval: {\n    start: Temporal.Instant | Temporal.ZonedDateTime;\n    end: Temporal.Instant | Temporal.ZonedDateTime;\n  }\n): boolean;\nexport function isWithinInterval(\n  date: Comparable,\n  interval: { start: Comparable; end: Comparable }\n): boolean {\n  const { start, end } = interval;\n  if ([date, start, end].some((value) => isPlainDate(value) || isPlainTime(value))) {\n    const afterStart = compare(date, start) >= 0;\n    const beforeEnd = compare(date, end) <= 0;\n    if (isPlainTime(start) && compare(start, end) > 0) return afterStart || beforeEnd;\n    return afterStart && beforeEnd;\n  }\n\n  const normalizedDate = normalizeTemporalInput(date as Timeline);\n  const normalizedStart = normalizeTemporalInput(start as Timeline);\n  const normalizedEnd = normalizeTemporalInput(end as Timeline);\n\n  return !isBefore(normalizedDate, normalizedStart) && !isAfter(normalizedDate, normalizedEnd);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiHO,SAAS,iBACd,MACA,UACS;AACT,QAAM,EAAE,OAAO,IAAI,IAAI;AACvB,MAAI,CAAC,MAAM,OAAO,GAAG,EAAE,KAAK,CAAC,UAAU,YAAY,KAAK,KAAK,YAAY,KAAK,CAAC,GAAG;AAChF,UAAM,aAAa,QAAQ,MAAM,KAAK,KAAK;AAC3C,UAAM,YAAY,QAAQ,MAAM,GAAG,KAAK;AACxC,QAAI,YAAY,KAAK,KAAK,QAAQ,OAAO,GAAG,IAAI,EAAG,QAAO,cAAc;AACxE,WAAO,cAAc;AAAA,EACvB;AAEA,QAAM,iBAAiB,uBAAuB,IAAgB;AAC9D,QAAM,kBAAkB,uBAAuB,KAAiB;AAChE,QAAM,gBAAgB,uBAAuB,GAAe;AAE5D,SAAO,CAAC,SAAS,gBAAgB,eAAe,KAAK,CAAC,QAAQ,gBAAgB,aAAa;AAC7F;","names":[]}

package/dist/{chunk-C5OJIIJP.js → chunk-IWVSM77B.js}

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

package/dist/{chunk-C5OJIIJP.js.map → chunk-IWVSM77B.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subNanoseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addNanoseconds } from './addNanoseconds';\n\n/**\n * Subtracts the specified number of nanoseconds from a datetime.\n *\n * This is a convenience wrapper around addNanoseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param nanoseconds - Number of nanoseconds to subtract\n * @returns ZonedDateTime with nanoseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = subNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function subNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  return addNanoseconds(input, -nanoseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,eACd,OACA,aACwB;AACxB,SAAO,eAAe,OAAO,CAAC,WAAW;AAC3C;","names":[]}
+{"version":3,"sources":["../src/subNanoseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addNanoseconds } from './addNanoseconds';\n\n/**\n * Subtracts the specified number of nanoseconds from a datetime.\n *\n * This is a convenience wrapper around addNanoseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param nanoseconds - Number of nanoseconds to subtract\n * @returns ZonedDateTime with nanoseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = subNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500+00:00[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function subNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  return addNanoseconds(input, -nanoseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,eACd,OACA,aACwB;AACxB,SAAO,eAAe,OAAO,CAAC,WAAW;AAC3C;","names":[]}

package/dist/{chunk-XIVWFVVX.js → chunk-IXNGK5OF.js}

@@ -1,6 +1,6 @@
 import {
   addMicroseconds
-} from "./chunk-PU6PU2JM.js";
+} from "./chunk-TI6WBLCB.js";
 
 // src/subMicroseconds.ts
 function subMicroseconds(input, microseconds) {
@@ -10,4 +10,4 @@ function subMicroseconds(input, microseconds) {
 export {
   subMicroseconds
 };
-//# sourceMappingURL=chunk-XIVWFVVX.js.map
+//# sourceMappingURL=chunk-IXNGK5OF.js.map

package/dist/{chunk-XIVWFVVX.js.map → chunk-IXNGK5OF.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subMicroseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMicroseconds } from './addMicroseconds';\n\n/**\n * Subtracts the specified number of microseconds from a datetime.\n *\n * This is a convenience wrapper around addMicroseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param microseconds - Number of microseconds to subtract\n * @returns ZonedDateTime with microseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.001Z');\n * const result = subMicroseconds(instant, 500);\n * // 2025-01-20T12:00:00.000500Z[UTC] (500 microseconds earlier)\n * ```\n */\nexport function subMicroseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  microseconds: number\n): Temporal.ZonedDateTime {\n  return addMicroseconds(input, -microseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}
+{"version":3,"sources":["../src/subMicroseconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addMicroseconds } from './addMicroseconds';\n\n/**\n * Subtracts the specified number of microseconds from a datetime.\n *\n * This is a convenience wrapper around addMicroseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param microseconds - Number of microseconds to subtract\n * @returns ZonedDateTime with microseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.001Z');\n * const result = subMicroseconds(instant, 500);\n * // 2025-01-20T12:00:00.000500+00:00[UTC] (500 microseconds earlier)\n * ```\n */\nexport function subMicroseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  microseconds: number\n): Temporal.ZonedDateTime {\n  return addMicroseconds(input, -microseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}

package/dist/{chunk-XR7Q6IP6.js → chunk-JA5ER27P.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/roundToNearestSecond.ts
 var MODE_TO_ROUNDING_MODE = {
@@ -22,4 +22,4 @@ function roundToNearestSecond(input, options) {
 export {
   roundToNearestSecond
 };
-//# sourceMappingURL=chunk-XR7Q6IP6.js.map
+//# sourceMappingURL=chunk-JA5ER27P.js.map

package/dist/{chunk-E5HJJFUI.js → chunk-JGPTGV5X.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -23,4 +23,4 @@ function differenceInDays(laterDate, earlierDate, options) {
 export {
   differenceInDays
 };
-//# sourceMappingURL=chunk-E5HJJFUI.js.map
+//# sourceMappingURL=chunk-JGPTGV5X.js.map

package/dist/{chunk-4E5OJUMN.js → chunk-K3L6MJJB.js}

@@ -1,6 +1,6 @@
 import {
   addSeconds
-} from "./chunk-WY5I452J.js";
+} from "./chunk-7IKCDOCT.js";
 
 // src/subSeconds.ts
 function subSeconds(input, seconds) {
@@ -10,4 +10,4 @@ function subSeconds(input, seconds) {
 export {
   subSeconds
 };
-//# sourceMappingURL=chunk-4E5OJUMN.js.map
+//# sourceMappingURL=chunk-K3L6MJJB.js.map

package/dist/{chunk-4E5OJUMN.js.map → chunk-K3L6MJJB.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subSeconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addSeconds } from './addSeconds';\n\n/**\n * Subtracts the specified number of seconds from a datetime.\n *\n * This is a convenience wrapper around addSeconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param seconds - Number of seconds to subtract\n * @returns ZonedDateTime with seconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:45Z');\n * const result = subSeconds(instant, 30);\n * // 2025-01-20T12:00:15Z[UTC] (30 seconds earlier)\n * ```\n */\nexport function subSeconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  seconds: number\n): Temporal.ZonedDateTime {\n  return addSeconds(input, -seconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,WACd,OACA,SACwB;AACxB,SAAO,WAAW,OAAO,CAAC,OAAO;AACnC;","names":[]}
+{"version":3,"sources":["../src/subSeconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { addSeconds } from './addSeconds';\n\n/**\n * Subtracts the specified number of seconds from a datetime.\n *\n * This is a convenience wrapper around addSeconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param seconds - Number of seconds to subtract\n * @returns ZonedDateTime with seconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:45Z');\n * const result = subSeconds(instant, 30);\n * // 2025-01-20T12:00:15+00:00[UTC] (30 seconds earlier)\n * ```\n */\nexport function subSeconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  seconds: number\n): Temporal.ZonedDateTime {\n  return addSeconds(input, -seconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,WACd,OACA,SACwB;AACxB,SAAO,WAAW,OAAO,CAAC,OAAO;AACnC;","names":[]}

package/dist/{chunk-MCPKXTX7.js → chunk-K6NQZIAW.js}

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

package/dist/chunk-K6NQZIAW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMillisecond.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 millisecond.\n * Compares the year, month, day, hour, minute, second, and millisecond fields directly.\n * Ignores sub-millisecond precision (microseconds, 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 millisecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same millisecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999+00:00[UTC]');\n *\n * isSameMillisecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different milliseconds\n * const ms123 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123+00:00[UTC]');\n * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124+00:00[UTC]');\n *\n * isSameMillisecond(ms123, ms124); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local milliseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local milliseconds from each person's perspective\n * isSameMillisecond(ny, tokyo); // false (14:30:45.123 in NY, 04:30:45.123 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMillisecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMillisecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123 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.123456Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123999Z');\n *\n * isSameMillisecond(instant1, instant2); // true (both 14:30:45.123 in UTC)\n * ```\n */\nexport function isSameMillisecond(\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  );\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;AAElC;","names":[]}

package/dist/{chunk-RQ5CX67T.js → chunk-K7SY2MAX.js}

@@ -1,13 +1,15 @@
 import {
   isWeekendDay,
-  isoDate
-} from "./chunk-Z7I7YCKN.js";
+  isoDate,
+  weekdayHolidays
+} from "./chunk-4YCEFGZA.js";
 import {
+  Temporal,
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
 
 // src/differenceInBusinessDays.ts
-function differenceInBusinessDays(laterDate, earlierDate) {
+function differenceInBusinessDays(laterDate, earlierDate, holidays = []) {
   if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {
     throw new TypeError("PlainDate differences require two PlainDate values");
   }
@@ -21,10 +23,14 @@ function differenceInBusinessDays(laterDate, earlierDate) {
     if (!isWeekendDay(day.dayOfWeek)) count++;
     day = day.add({ days: 1 });
   }
+  const end = from.add({ days: span });
+  count -= weekdayHolidays(holidays).filter(
+    (date) => Temporal.PlainDate.compare(date, from) >= 0 && Temporal.PlainDate.compare(date, end) < 0
+  ).length;
   return days < 0 && count !== 0 ? -count : count;
 }
 
 export {
   differenceInBusinessDays
 };
-//# sourceMappingURL=chunk-RQ5CX67T.js.map
+//# sourceMappingURL=chunk-K7SY2MAX.js.map

package/dist/chunk-K7SY2MAX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInBusinessDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isWeekendDay, isoDate, weekdayHolidays } from './shared/businessDays';\n\n/**\n * Returns the number of business days (Monday–Friday) from earlierDate up to\n * laterDate: the earlier date counts, the later date does not. Dates in\n * `holidays` are not counted. Swapping the arguments negates the result.\n *\n * Only calendar dates matter; times of day are ignored. Instant inputs use\n * their UTC date and ZonedDateTime inputs use their own timezone's date.\n * Convert both to one timezone first to count from a single perspective.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @param holidays - Dates that are not business days, matched by date\n * @returns Business days between the dates (negative if laterDate is earlier)\n *\n * @example\n * ```ts\n * const friday = Temporal.PlainDate.from('2025-01-24');\n * const nextFriday = Temporal.PlainDate.from('2025-01-31');\n *\n * differenceInBusinessDays(nextFriday, friday); // 5\n * differenceInBusinessDays(friday, nextFriday); // -5\n * differenceInBusinessDays(nextFriday, friday, [Temporal.PlainDate.from('2025-01-27')]); // 4\n * ```\n */\nexport function differenceInBusinessDays(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  holidays?: readonly Temporal.PlainDate[]\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  holidays?: readonly Temporal.PlainDate[]\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  holidays: readonly Temporal.PlainDate[] = []\n): number {\n  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {\n    throw new TypeError('PlainDate differences require two PlainDate values');\n  }\n  const later = isoDate(laterDate);\n  const earlier = isoDate(earlierDate);\n  const days = earlier.until(later, { largestUnit: 'days' }).days;\n  const [from, span] = days < 0 ? [later, -days] : [earlier, days];\n\n  // Every full week holds five business days; walk the remainder.\n  const fullWeeks = Math.trunc(span / 7);\n  let count = fullWeeks * 5;\n  for (let day = from.add({ days: fullWeeks * 7 }), i = fullWeeks * 7; i < span; i++) {\n    if (!isWeekendDay(day.dayOfWeek)) count++;\n    day = day.add({ days: 1 });\n  }\n  const end = from.add({ days: span });\n  count -= weekdayHolidays(holidays).filter(\n    (date) =>\n      Temporal.PlainDate.compare(date, from) >= 0 && Temporal.PlainDate.compare(date, end) < 0\n  ).length;\n  return days < 0 && count !== 0 ? -count : count;\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,yBACd,WACA,aACA,WAA0C,CAAC,GACnC;AACR,MAAI,YAAY,SAAS,MAAM,YAAY,WAAW,GAAG;AACvD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,OAAO,QAAQ,MAAM,OAAO,EAAE,aAAa,OAAO,CAAC,EAAE;AAC3D,QAAM,CAAC,MAAM,IAAI,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI;AAG/D,QAAM,YAAY,KAAK,MAAM,OAAO,CAAC;AACrC,MAAI,QAAQ,YAAY;AACxB,WAAS,MAAM,KAAK,IAAI,EAAE,MAAM,YAAY,EAAE,CAAC,GAAG,IAAI,YAAY,GAAG,IAAI,MAAM,KAAK;AAClF,QAAI,CAAC,aAAa,IAAI,SAAS,EAAG;AAClC,UAAM,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;AAAA,EAC3B;AACA,QAAM,MAAM,KAAK,IAAI,EAAE,MAAM,KAAK,CAAC;AACnC,WAAS,gBAAgB,QAAQ,EAAE;AAAA,IACjC,CAAC,SACC,SAAS,UAAU,QAAQ,MAAM,IAAI,KAAK,KAAK,SAAS,UAAU,QAAQ,MAAM,GAAG,IAAI;AAAA,EAC3F,EAAE;AACF,SAAO,OAAO,KAAK,UAAU,IAAI,CAAC,QAAQ;AAC5C;","names":[]}

package/dist/{chunk-XZS6J4LM.js → chunk-KYS54PLJ.js}

@@ -1,6 +1,6 @@
 import {
   addQuarters
-} from "./chunk-YR26F7OA.js";
+} from "./chunk-QDY2KMYX.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subQuarters(input, quarters) {
 export {
   subQuarters
 };
-//# sourceMappingURL=chunk-XZS6J4LM.js.map
+//# sourceMappingURL=chunk-KYS54PLJ.js.map

package/dist/chunk-KYS54PLJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { addQuarters } from \"./addQuarters\";\n\n/**\n * Subtracts the specified number of quarters (3-month blocks) from a datetime or date.\n *\n * This is a convenience wrapper around addQuarters with the count negated.\n * PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param quarters - Number of quarters to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * subQuarters(instant, 2);\n * // 2025-01-20T12:00:00+00:00[UTC] (6 months earlier)\n * ```\n *\n * @example\n * ```ts\n * subQuarters(Temporal.PlainDate.from('2025-07-20'), 1);\n * // 2025-04-20\n * ```\n */\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function subQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Branch so each call resolves to the matching addQuarters overload.\n  return isPlainDate(input) ? addQuarters(input, -quarters) : addQuarters(input, -quarters);\n}\n"],"mappings":";;;;;;;;AA+BO,SAAS,YACd,OACA,UAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,YAAY,OAAO,CAAC,QAAQ,IAAI,YAAY,OAAO,CAAC,QAAQ;AAC1F;","names":[]}

package/dist/{chunk-2LN57UVR.js → chunk-KZCSP3DU.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -25,4 +25,4 @@ function differenceInMonths(laterDate, earlierDate, options) {
 export {
   differenceInMonths
 };
-//# sourceMappingURL=chunk-2LN57UVR.js.map
+//# sourceMappingURL=chunk-KZCSP3DU.js.map

package/dist/chunk-KZYWHHAQ.js

@@ -0,0 +1,19 @@
+import {
+  daysIntoWeek
+} from "./chunk-M2XB72L5.js";
+import {
+  calendarDates
+} from "./chunk-H43LMOCK.js";
+
+// src/differenceInCalendarWeeks.ts
+function differenceInCalendarWeeks(laterDate, earlierDate, options) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate);
+  const laterStart = later.subtract({ days: daysIntoWeek(later.dayOfWeek, options) });
+  const earlierStart = earlier.subtract({ days: daysIntoWeek(earlier.dayOfWeek, options) });
+  return earlierStart.until(laterStart, { largestUnit: "days" }).days / 7;
+}
+
+export {
+  differenceInCalendarWeeks
+};
+//# sourceMappingURL=chunk-KZYWHHAQ.js.map

package/dist/chunk-KZYWHHAQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarWeeks.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\nimport { daysIntoWeek, type WeekOptions } from './shared/week';\n\n/**\n * Returns the number of week boundaries crossed between two dates, ignoring the\n * day within the week. Weeks start on Monday (ISO 8601) unless `weekStartsOn`\n * says otherwise.\n *\n * PlainDate inputs are compared as given. Instant inputs use their UTC date and\n * ZonedDateTime inputs use the date in their own timezone; convert both to one\n * timezone first to count from a single point of view. Mixing a PlainDate with\n * an Instant or ZonedDateTime throws a TypeError.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @param options - `weekStartsOn`: 1 = Monday (default) … 7 = Sunday\n * @returns Calendar weeks from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const sunday = Temporal.PlainDate.from('2025-01-26');\n * const monday = Temporal.PlainDate.from('2025-01-27');\n *\n * differenceInCalendarWeeks(monday, sunday); // 1\n * differenceInCalendarWeeks(monday, sunday, { weekStartsOn: 7 }); // 0\n * ```\n */\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: WeekOptions\n): number;\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: WeekOptions\n): number;\nexport function differenceInCalendarWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: WeekOptions\n): number {\n  const [later, earlier] = calendarDates(laterDate, earlierDate);\n  const laterStart = later.subtract({ days: daysIntoWeek(later.dayOfWeek, options) });\n  const earlierStart = earlier.subtract({ days: daysIntoWeek(earlier.dayOfWeek, options) });\n  return earlierStart.until(laterStart, { largestUnit: 'days' }).days / 7;\n}\n"],"mappings":";;;;;;;;AAsCO,SAAS,0BACd,WACA,aACA,SACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,QAAM,aAAa,MAAM,SAAS,EAAE,MAAM,aAAa,MAAM,WAAW,OAAO,EAAE,CAAC;AAClF,QAAM,eAAe,QAAQ,SAAS,EAAE,MAAM,aAAa,QAAQ,WAAW,OAAO,EAAE,CAAC;AACxF,SAAO,aAAa,MAAM,YAAY,EAAE,aAAa,OAAO,CAAC,EAAE,OAAO;AACxE;","names":[]}

package/dist/{chunk-35IJG3T2.js → chunk-LMOAA73F.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-JNAWZ4RN.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -25,4 +25,4 @@ function differenceInYears(laterDate, earlierDate, options) {
 export {
   differenceInYears
 };
-//# sourceMappingURL=chunk-35IJG3T2.js.map
+//# sourceMappingURL=chunk-LMOAA73F.js.map

package/dist/chunk-M2XB72L5.js

@@ -0,0 +1,17 @@
+// src/shared/week.ts
+function assertDayOfWeek(day, name) {
+  if (!Number.isInteger(day) || day < 1 || day > 7) {
+    throw new RangeError(`${name} must be 1 (Monday) through 7 (Sunday), got ${day}`);
+  }
+}
+function daysIntoWeek(dayOfWeek, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  assertDayOfWeek(weekStartsOn, "weekStartsOn");
+  return (dayOfWeek - weekStartsOn + 7) % 7;
+}
+
+export {
+  assertDayOfWeek,
+  daysIntoWeek
+};
+//# sourceMappingURL=chunk-M2XB72L5.js.map

package/dist/chunk-M2XB72L5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/week.ts"],"sourcesContent":["/**\n * Day of the week, numbered as Temporal numbers it: 1 = Monday … 7 = Sunday.\n */\nexport type DayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;\n\n/**\n * Options for functions that need to know where a week begins.\n */\nexport interface WeekOptions {\n  /**\n   * The first day of the week: 1 = Monday … 7 = Sunday.\n   * @default 1 (Monday, as in ISO 8601)\n   */\n  weekStartsOn?: DayOfWeek;\n}\n\n/**\n * @internal\n * Checks a day-of-week argument. date-fns numbers Sunday 0; Temporal numbers it 7,\n * so 0 is rejected rather than silently meaning something else.\n */\nexport function assertDayOfWeek(day: number, name: string): asserts day is DayOfWeek {\n  if (!Number.isInteger(day) || day < 1 || day > 7) {\n    throw new RangeError(`${name} must be 1 (Monday) through 7 (Sunday), got ${day}`);\n  }\n}\n\n/**\n * @internal\n * Days from the start of the week to a given day of the week (0–6).\n */\nexport function daysIntoWeek(dayOfWeek: number, options: WeekOptions | undefined): number {\n  const weekStartsOn = options?.weekStartsOn ?? 1;\n  assertDayOfWeek(weekStartsOn, 'weekStartsOn');\n  return (dayOfWeek - weekStartsOn + 7) % 7;\n}\n"],"mappings":";AAqBO,SAAS,gBAAgB,KAAa,MAAwC;AACnF,MAAI,CAAC,OAAO,UAAU,GAAG,KAAK,MAAM,KAAK,MAAM,GAAG;AAChD,UAAM,IAAI,WAAW,GAAG,IAAI,+CAA+C,GAAG,EAAE;AAAA,EAClF;AACF;AAMO,SAAS,aAAa,WAAmB,SAA0C;AACxF,QAAM,eAAe,SAAS,gBAAgB;AAC9C,kBAAgB,cAAc,cAAc;AAC5C,UAAQ,YAAY,eAAe,KAAK;AAC1C;","names":[]}

package/dist/{chunk-NNUATTN7.js → chunk-MVGBYHG5.js}

@@ -1,6 +1,6 @@
 import {
   addMonths
-} from "./chunk-WJZHUNF5.js";
+} from "./chunk-ZXKU4SKR.js";
 import {
   isPlainDate
 } from "./chunk-BSVOJYJ7.js";
@@ -13,4 +13,4 @@ function subMonths(input, months) {
 export {
   subMonths
 };
-//# sourceMappingURL=chunk-NNUATTN7.js.map
+//# sourceMappingURL=chunk-MVGBYHG5.js.map

package/dist/{chunk-NNUATTN7.js.map → chunk-MVGBYHG5.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates 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 months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}
+{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates 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 months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00+00:00[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}

package/dist/{chunk-FAVYJIRM.js → chunk-NOWUJERX.js}

@@ -1,6 +1,6 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-2MFBXSTL.js";
+} from "./chunk-TCB3IDJM.js";
 import {
   getEndOfDay
 } from "./chunk-NMMMAMKP.js";
@@ -14,4 +14,4 @@ function endOfDay(input, timezone) {
 export {
   endOfDay
 };
-//# sourceMappingURL=chunk-FAVYJIRM.js.map
+//# sourceMappingURL=chunk-NOWUJERX.js.map

package/dist/chunk-NOWUJERX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last nanosecond of the day.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const end = endOfDay(instant);\n * // 2025-01-20T23: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-01-20T15:30:00-05:00[America/New_York]');\n * const end = endOfDay(zoned);\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-01-20');\n * const end = endOfDay(date, 'America/New_York');\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return getEndOfDay(zonedDateTime);\n}\n"],"mappings":";;;;;;;;AA0CO,SAAS,SACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,YAAY,aAAa;AAClC;","names":[]}