@gobrand/tiempo 3.0.1 → 3.1.2

package/dist/chunk-FL33IWLY.js

@@ -0,0 +1,19 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/addYears.ts
+function addYears(input, years) {
+  if (isPlainDate(input)) {
+    return input.add({ years });
+  }
+  return normalizeTemporalInput(input).add({ years });
+}
+
+export {
+  addYears
+};
+//# sourceMappingURL=chunk-FL33IWLY.js.map

package/dist/chunk-FL33IWLY.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:00Z[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:00Z[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-6UMISP3B.js → chunk-FLVULRGY.js}

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

package/dist/chunk-FLVULRGY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/roundToNearestHour.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Options for rounding to nearest hour.\n */\nexport interface RoundToNearestHourOptions {\n  /**\n   * The rounding mode to use.\n   *\n   * Given time 14:20:\n   * - `'round'` → 14:00 (20 min < 30, rounds DOWN to nearest)\n   * - `'ceil'`  → 15:00 (always rounds UP to next hour)\n   * - `'floor'` → 14:00 (always rounds DOWN to current hour)\n   *\n   * Given time 14:40:\n   * - `'round'` → 15:00 (40 min >= 30, rounds UP to nearest)\n   * - `'ceil'`  → 15:00 (always rounds UP to next hour)\n   * - `'floor'` → 14:00 (always rounds DOWN to current hour)\n   *\n   * @default 'round'\n   */\n  mode?: 'round' | 'ceil' | 'floor';\n  /**\n   * Round to the nearest N hours. Must divide evenly into 24.\n   * Valid values: 1, 2, 3, 4, 6, 8, 12\n   * @example nearestTo: 6 rounds to 00:00, 06:00, 12:00, or 18:00\n   */\n  nearestTo?: 1 | 2 | 3 | 4 | 6 | 8 | 12;\n}\n\nconst MODE_TO_ROUNDING_MODE = {\n  round: 'halfExpand',\n  ceil: 'ceil',\n  floor: 'floor',\n} as const;\n\n/**\n * Rounds a datetime to the nearest hour boundary.\n *\n * ## Mode comparison (given 14:20)\n *\n * ```\n * 14:00 ─────────────●───────────────── 15:00\n *                  14:20\n *\n * 'round' → 14:00  (nearest hour - 20 min < 30)\n * 'ceil'  → 15:00  (next hour - always up)\n * 'floor' → 14:00  (current hour - always down)\n * ```\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param options - Rounding options\n * @returns ZonedDateTime rounded to the hour boundary\n *\n * @example\n * ```ts\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:20:00[America/New_York]');\n *\n * roundToNearestHour(time);                     // → 14:00 (nearest)\n * roundToNearestHour(time, { mode: 'ceil' });   // → 15:00 (always up)\n * roundToNearestHour(time, { mode: 'floor' });  // → 14:00 (always down)\n * ```\n *\n * @example\n * ```ts\n * // With 37 minutes (past the halfway point)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:00[America/New_York]');\n *\n * roundToNearestHour(time);                     // → 15:00 (nearest - 37 >= 30)\n * roundToNearestHour(time, { mode: 'ceil' });   // → 15:00 (always up)\n * roundToNearestHour(time, { mode: 'floor' });  // → 14:00 (always down)\n * ```\n *\n * @example\n * ```ts\n * // Round to 6-hour blocks (shift scheduling)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:00:00[America/New_York]');\n *\n * roundToNearestHour(time, { nearestTo: 6 });                    // → 12:00\n * roundToNearestHour(time, { mode: 'ceil', nearestTo: 6 });      // → 18:00\n * roundToNearestHour(time, { mode: 'floor', nearestTo: 6 });     // → 12:00\n * ```\n */\nexport function roundToNearestHour(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: RoundToNearestHourOptions\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  const mode = options?.mode ?? 'round';\n  const nearestTo = options?.nearestTo ?? 1;\n\n  return zonedDateTime.round({\n    smallestUnit: 'hour',\n    roundingMode: MODE_TO_ROUNDING_MODE[mode],\n    roundingIncrement: nearestTo,\n  });\n}\n"],"mappings":";;;;;AA+BA,IAAM,wBAAwB;AAAA,EAC5B,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AACT;AAiDO,SAAS,mBACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,QAAM,OAAO,SAAS,QAAQ;AAC9B,QAAM,YAAY,SAAS,aAAa;AAExC,SAAO,cAAc,MAAM;AAAA,IACzB,cAAc;AAAA,IACd,cAAc,sBAAsB,IAAI;AAAA,IACxC,mBAAmB;AAAA,EACrB,CAAC;AACH;","names":[]}

package/dist/{chunk-SCD2JNY3.js → chunk-FUVG6A7U.js}

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

package/dist/chunk-FUVG6A7U.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:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[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:59Z[UTC]');\n * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00Z[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-GQXJICRA.js

@@ -0,0 +1,26 @@
+import {
+  assertSameDomain,
+  position
+} from "./chunk-OMYVTYHI.js";
+
+// src/closestTo.ts
+function closestTo(target, candidates) {
+  const origin = position(target);
+  let closest;
+  let closestDistance = 0n;
+  for (const candidate of candidates) {
+    assertSameDomain(target, candidate);
+    const offset = position(candidate) - origin;
+    const distance = offset < 0n ? -offset : offset;
+    if (closest === void 0 || distance < closestDistance) {
+      closest = candidate;
+      closestDistance = distance;
+    }
+  }
+  return closest;
+}
+
+export {
+  closestTo
+};
+//# sourceMappingURL=chunk-GQXJICRA.js.map

package/dist/chunk-GQXJICRA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/closestTo.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { assertSameDomain, position, type Comparable, type Timeline } from './shared/compare';\n\n/**\n * Returns the candidate nearest to the target, or undefined when there are no\n * candidates. Ties return the first. The candidate is returned as given.\n *\n * Timeline values measure exact elapsed time, PlainDates whole days, and\n * PlainTimes time within one day (no wrapping at midnight). Mixed domains throw\n * a TypeError.\n *\n * @param target - The value to measure from\n * @param candidates - Values from the same domain as target\n * @returns The nearest candidate, or undefined if candidates is empty\n *\n * @example\n * ```ts\n * const now = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const slots = [\n *   Temporal.Instant.from('2025-01-20T09:00:00Z'),\n *   Temporal.Instant.from('2025-01-20T13:30:00Z'),\n * ];\n *\n * closestTo(now, slots); // 2025-01-20T13:30:00Z\n * closestTo(now, []); // undefined\n * ```\n */\nexport function closestTo<T extends Timeline>(\n  target: Timeline,\n  candidates: readonly T[]\n): T | undefined;\nexport function closestTo(\n  target: Temporal.PlainDate,\n  candidates: readonly Temporal.PlainDate[]\n): Temporal.PlainDate | undefined;\nexport function closestTo(\n  target: Temporal.PlainTime,\n  candidates: readonly Temporal.PlainTime[]\n): Temporal.PlainTime | undefined;\nexport function closestTo(\n  target: Comparable,\n  candidates: readonly Comparable[]\n): Comparable | undefined {\n  const origin = position(target);\n  let closest: Comparable | undefined;\n  let closestDistance = 0n;\n\n  for (const candidate of candidates) {\n    assertSameDomain(target, candidate);\n    const offset = position(candidate) - origin;\n    const distance = offset < 0n ? -offset : offset;\n    if (closest === undefined || distance < closestDistance) {\n      closest = candidate;\n      closestDistance = distance;\n    }\n  }\n  return closest;\n}\n"],"mappings":";;;;;;AAuCO,SAAS,UACd,QACA,YACwB;AACxB,QAAM,SAAS,SAAS,MAAM;AAC9B,MAAI;AACJ,MAAI,kBAAkB;AAEtB,aAAW,aAAa,YAAY;AAClC,qBAAiB,QAAQ,SAAS;AAClC,UAAM,SAAS,SAAS,SAAS,IAAI;AACrC,UAAM,WAAW,SAAS,KAAK,CAAC,SAAS;AACzC,QAAI,YAAY,UAAa,WAAW,iBAAiB;AACvD,gBAAU;AACV,wBAAkB;AAAA,IACpB;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-H544BC2X.js

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

package/dist/chunk-H544BC2X.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. Holidays are\n * not considered. Equivalent to `addBusinessDays(input, -days)`.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs keep their\n * timezone and time of day. PlainDate inputs stay dates.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @param days - Whole business days to subtract (negative to add)\n * @returns PlainDate for a date input; otherwise ZonedDateTime\n * @throws RangeError if days is not an integer\n *\n * @example\n * ```ts\n * const monday = Temporal.PlainDate.from('2025-01-27');\n *\n * subBusinessDays(monday, 1); // 2025-01-24 (Friday)\n * ```\n */\nexport function subBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function subBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addBusinessDays overload.\n  return isPlainDate(input) ? addBusinessDays(input, -days) : addBusinessDays(input, -days);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,gBACd,OACA,MAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,gBAAgB,OAAO,CAAC,IAAI,IAAI,gBAAgB,OAAO,CAAC,IAAI;AAC1F;","names":[]}

package/dist/{chunk-H5BHFVEN.js → chunk-HCVE7FSF.js}

@@ -1,6 +1,6 @@
 import {
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toIso.ts
 function toIso(input, options = {}) {
@@ -17,4 +17,4 @@ function toIso(input, options = {}) {
 export {
   toIso
 };
-//# sourceMappingURL=chunk-H5BHFVEN.js.map
+//# sourceMappingURL=chunk-HCVE7FSF.js.map

package/dist/chunk-HCVE7FSF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toIso.ts"],"sourcesContent":["import { type Temporal, isInstant } from './shared/temporal';\n\nexport type IsoMode = 'utc' | 'offset';\n\nexport interface ToIsoOptions {\n  /**\n   * Output mode for time zone designator.\n   * - 'utc' (default): UTC time with Z suffix\n   * - 'offset': local time with offset suffix\n   */\n  mode?: IsoMode;\n}\n\n/**\n * Convert a Temporal.Instant to a UTC ISO 8601 string.\n */\nexport function toIso(input: Temporal.Instant): string;\n\n/**\n * Convert a Temporal.ZonedDateTime to an ISO 8601 string.\n *\n * @param input - A Temporal.ZonedDateTime\n * @param options - Output options\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n *\n * toIso(zoned);                    // \"2025-01-20T20:00:00Z\"\n * toIso(zoned, { mode: 'utc' });   // \"2025-01-20T20:00:00Z\"\n * toIso(zoned, { mode: 'offset' }); // \"2025-01-20T15:00:00-05:00\"\n * ```\n */\nexport function toIso(\n  input: Temporal.ZonedDateTime,\n  options?: ToIsoOptions\n): string;\n\nexport function toIso(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options: ToIsoOptions = {}\n): string {\n  const { mode = 'utc' } = options;\n\n  if (isInstant(input)) {\n    return input.toString();\n  }\n\n  if (mode === 'offset') {\n    return input.toString({ timeZoneName: 'never' });\n  }\n\n  return input.toInstant().toString();\n}\n"],"mappings":";;;;;AAsCO,SAAS,MACd,OACA,UAAwB,CAAC,GACjB;AACR,QAAM,EAAE,OAAO,MAAM,IAAI;AAEzB,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO,MAAM,SAAS;AAAA,EACxB;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,MAAM,SAAS,EAAE,cAAc,QAAQ,CAAC;AAAA,EACjD;AAEA,SAAO,MAAM,UAAU,EAAE,SAAS;AACpC;","names":[]}

package/dist/{chunk-BV32K227.js → chunk-HQ3YMKQ5.js}

@@ -1,9 +1,9 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-2MFBXSTL.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/startOfMonth.ts
 function startOfMonth(input, timezone) {
@@ -18,4 +18,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-BV32K227.js.map
+//# sourceMappingURL=chunk-HQ3YMKQ5.js.map

package/dist/chunk-HSJMG5T7.js

@@ -0,0 +1,16 @@
+import {
+  addDays
+} from "./chunk-V36MCE25.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subDays.ts
+function subDays(input, days) {
+  return isPlainDate(input) ? addDays(input, -days) : addDays(input, -days);
+}
+
+export {
+  subDays
+};
+//# sourceMappingURL=chunk-HSJMG5T7.js.map

package/dist/chunk-HSJMG5T7.js.map

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

package/dist/{chunk-M7Y67IAB.js → chunk-HT6L4VRQ.js}

@@ -1,6 +1,6 @@
 import {
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toDate.ts
 function toDate(input) {
@@ -13,4 +13,4 @@ function toDate(input) {
 export {
   toDate
 };
-//# sourceMappingURL=chunk-M7Y67IAB.js.map
+//# sourceMappingURL=chunk-HT6L4VRQ.js.map

package/dist/chunk-HT6L4VRQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toDate.ts"],"sourcesContent":["import { type Temporal, isInstant } from './shared/temporal';\n\n/**\n * Convert a Temporal.Instant or ZonedDateTime to a Date object.\n *\n * @param input - A Temporal.Instant or Temporal.ZonedDateTime\n * @returns A Date object representing the same moment in time\n *\n * @example\n * ```typescript\n * // From Instant\n * const instant = Temporal.Instant.from(\"2025-01-20T20:00:00Z\");\n * const date = toDate(instant);\n * // date.toISOString() === \"2025-01-20T20:00:00.000Z\"\n *\n * // From ZonedDateTime\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n * const date2 = toDate(zoned);\n * // date2.toISOString() === \"2025-01-20T20:00:00.000Z\"\n *\n * // Use with Drizzle ORM (for storing back to database)\n * async function publish(id: string, at: Temporal.Instant) {\n *   await db.update(posts).set({ publishedAt: toDate(at) }).where(eq(posts.id, id));\n * }\n * ```\n */\nexport function toDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Date {\n  if (isInstant(input)) {\n    return new Date(input.toString());\n  }\n\n  return new Date(input.toInstant().toString());\n}\n"],"mappings":";;;;;AA0BO,SAAS,OACd,OACM;AACN,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO,IAAI,KAAK,MAAM,SAAS,CAAC;AAAA,EAClC;AAEA,SAAO,IAAI,KAAK,MAAM,UAAU,EAAE,SAAS,CAAC;AAC9C;","names":[]}

package/dist/{chunk-3TS3D7WD.js → chunk-ITQ6OJAL.js}

@@ -1,12 +1,12 @@
 import {
   plainDateToZonedDateTime
-} from "./chunk-L5AMAEWX.js";
+} from "./chunk-2AID4P2C.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/startOfWeek.ts
 function startOfWeek(input, timezone) {
@@ -23,4 +23,4 @@ function startOfWeek(input, timezone) {
 export {
   startOfWeek
 };
-//# sourceMappingURL=chunk-3TS3D7WD.js.map
+//# sourceMappingURL=chunk-ITQ6OJAL.js.map

package/dist/chunk-ITQ6OJAL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfWeek.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the first boundary of the week (Monday).\n * Uses ISO 8601 week definition: weeks start on Monday.\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 Monday 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const start = startOfWeek(instant);\n * // 2025-01-20T00:00:00Z[UTC] (same day, it's already Monday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const start = startOfWeek(zoned);\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date);\n * // 2025-01-20 (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n */\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfWeek(\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.subtract({ days: input.dayOfWeek - 1 });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to subtract to get to Monday\n  const daysToSubtract = dayOfWeek - 1;\n\n  // Go to Monday, then get start of that day\n  const monday = zonedDateTime.subtract({ days: daysToSubtract });\n\n  return monday.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AAqDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,SAAS,EAAE,MAAM,MAAM,YAAY,EAAE,CAAC;AAAA,EACrD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,iBAAiB,YAAY;AAGnC,QAAM,SAAS,cAAc,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9D,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/{chunk-NTMT5XGC.js → chunk-JNAWZ4RN.js}

@@ -1,6 +1,6 @@
 import {
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/shared/normalizeTemporalInput.ts
 function normalizeTemporalInput(input) {
@@ -10,4 +10,4 @@ function normalizeTemporalInput(input) {
 export {
   normalizeTemporalInput
 };
-//# sourceMappingURL=chunk-NTMT5XGC.js.map
+//# sourceMappingURL=chunk-JNAWZ4RN.js.map

package/dist/chunk-JNAWZ4RN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeTemporalInput.ts"],"sourcesContent":["import { type Temporal, isInstant } from './temporal';\n\n/**\n * @internal\n * Normalizes input to ZonedDateTime. Converts Instant to UTC, or returns existing ZonedDateTime.\n * This is an internal helper - do not use directly.\n */\nexport function normalizeTemporalInput(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  return isInstant(input)\n    ? input.toZonedDateTimeISO('UTC')\n    : input;\n}\n"],"mappings":";;;;;AAOO,SAAS,uBACd,OACwB;AACxB,SAAO,UAAU,KAAK,IAClB,MAAM,mBAAmB,KAAK,IAC9B;AACN;","names":[]}

package/dist/chunk-JQ4Z4JTW.js

@@ -0,0 +1,16 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/max.ts
+function max(values) {
+  if (values.length === 0) {
+    throw new RangeError("max requires at least one value");
+  }
+  return values.reduce((latest, value) => compare(value, latest) > 0 ? value : latest);
+}
+
+export {
+  max
+};
+//# sourceMappingURL=chunk-JQ4Z4JTW.js.map

package/dist/chunk-JQ4Z4JTW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/max.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable, type Timeline } from './shared/compare';\n\n/**\n * Returns the latest value in a non-empty array. The value is returned as\n * given, with its type, timezone, and calendar intact. Ties return the first.\n *\n * Timeline values compare by exact instant, PlainDates by date, and\n * PlainTimes by wall-clock time. Mixed domains throw a TypeError.\n *\n * @param values - Values from one domain; at least one is required\n * @returns The latest value\n * @throws RangeError if values is empty\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T11:00:00-05:00[America/New_York]');\n *\n * max([instant, ny]); // 2025-01-20T11:00:00-05:00[America/New_York]\n * ```\n */\nexport function max<T extends Timeline>(values: readonly T[]): T;\nexport function max(values: readonly Temporal.PlainDate[]): Temporal.PlainDate;\nexport function max(values: readonly Temporal.PlainTime[]): Temporal.PlainTime;\nexport function max(values: readonly Comparable[]): Comparable {\n  if (values.length === 0) {\n    throw new RangeError('max requires at least one value');\n  }\n  return values.reduce((latest, value) => (compare(value, latest) > 0 ? value : latest));\n}\n"],"mappings":";;;;;AAyBO,SAAS,IAAI,QAA2C;AAC7D,MAAI,OAAO,WAAW,GAAG;AACvB,UAAM,IAAI,WAAW,iCAAiC;AAAA,EACxD;AACA,SAAO,OAAO,OAAO,CAAC,QAAQ,UAAW,QAAQ,OAAO,MAAM,IAAI,IAAI,QAAQ,MAAO;AACvF;","names":[]}

package/dist/chunk-JWYRXPR4.js

@@ -0,0 +1,53 @@
+import {
+  isPlainDateBefore
+} from "./chunk-ZM32S3YU.js";
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachWeekOfInterval.ts
+function eachWeekOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    if (isPlainDateAfter(interval.start, interval.end)) return [];
+    const end = interval.end.withCalendar(interval.start.calendarId);
+    const last = end.subtract({ days: end.dayOfWeek - 1 });
+    let current2 = interval.start.subtract({ days: interval.start.dayOfWeek - 1 });
+    const dates = [];
+    while (isPlainDateBefore(current2, last)) {
+      dates.push(current2);
+      current2 = current2.add({ weeks: 1 });
+    }
+    dates.push(current2);
+    return dates;
+  }
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const timezone = startZoned.timeZoneId;
+  const daysToSubtractStart = startZoned.dayOfWeek - 1;
+  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();
+  const endInTimezone = endZoned.withTimeZone(timezone);
+  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;
+  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();
+  const weeks = [];
+  let current = startMonday;
+  while (current.epochNanoseconds <= endMonday.epochNanoseconds) {
+    weeks.push(current);
+    current = current.add({ weeks: 1 });
+  }
+  return weeks;
+}
+
+export {
+  eachWeekOfInterval
+};
+//# sourceMappingURL=chunk-JWYRXPR4.js.map

package/dist/chunk-JWYRXPR4.js.map

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

package/dist/{chunk-NX7MXLFS.js → chunk-KTMCYEU5.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/isPlainTimeBefore.ts
 function isPlainTimeBefore(time1, time2) {
@@ -10,4 +10,4 @@ function isPlainTimeBefore(time1, time2) {
 export {
   isPlainTimeBefore
 };
-//# sourceMappingURL=chunk-NX7MXLFS.js.map
+//# sourceMappingURL=chunk-KTMCYEU5.js.map

package/dist/{chunk-JQFD563S.js → chunk-LKF7U4O4.js}

@@ -1,6 +1,6 @@
 import {
   addMinutes
-} from "./chunk-4PGGOVSG.js";
+} from "./chunk-5ST6IOPN.js";
 
 // src/subMinutes.ts
 function subMinutes(input, minutes) {
@@ -10,4 +10,4 @@ function subMinutes(input, minutes) {
 export {
   subMinutes
 };
-//# sourceMappingURL=chunk-JQFD563S.js.map
+//# sourceMappingURL=chunk-LKF7U4O4.js.map

package/dist/chunk-LKF7U4O4.js.map

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

package/dist/{chunk-2E4KCD3Y.js → chunk-LQ3EQYIX.js}

@@ -1,8 +1,9 @@
 import {
   Temporal,
   isInstant,
+  isPlainDate,
   isZonedDateTime
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toPlainDate.ts
 var PLAIN_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
@@ -37,10 +38,10 @@ function toPlainDate(input, timezone) {
     }
     throw new Error("Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string");
   }
-  return Temporal.PlainDate.from(input);
+  return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);
 }
 
 export {
   toPlainDate
 };
-//# sourceMappingURL=chunk-2E4KCD3Y.js.map
+//# sourceMappingURL=chunk-LQ3EQYIX.js.map

package/dist/chunk-LQ3EQYIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toPlainDate.ts"],"sourcesContent":["import { Temporal, isInstant, isZonedDateTime, isPlainDate } from './shared/temporal';\nimport type { Timezone } from './types';\n\n// Pattern to detect plain date strings: YYYY-MM-DD\nconst PLAIN_DATE_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n/**\n * Parse a plain date or extract the calendar date from a datetime.\n *\n * @param input - A PlainDateLike object, plain date string (YYYY-MM-DD), ZonedDateTime, or datetime input requiring timezone\n * @param timezone - IANA timezone identifier. Required for ISO strings, Date, and Instant inputs.\n * @returns A Temporal.PlainDate representing the calendar date\n *\n * @example\n * ```typescript\n * import { toPlainDate, toZonedTime } from '@gobrand/tiempo';\n *\n * // From PlainDateLike object (no timezone needed)\n * const date = toPlainDate({ year: 2025, month: 1, day: 20 }); // 2025-01-20\n *\n * // From plain date string (no timezone needed)\n * const date2 = toPlainDate(\"2025-01-20\"); // 2025-01-20\n *\n * // From ZonedDateTime (no timezone needed)\n * const zdt = toZonedTime(\"2025-01-20T15:30:00Z\", \"America/New_York\");\n * const date3 = toPlainDate(zdt); // 2025-01-20\n *\n * // From UTC string with timezone\n * const date4 = toPlainDate(\"2025-01-20T15:30:00Z\", \"America/New_York\"); // 2025-01-20\n *\n * // From Date with timezone\n * const jsDate = new Date(\"2025-01-20T15:30:00.000Z\");\n * const date5 = toPlainDate(jsDate, \"Europe/London\"); // 2025-01-20\n *\n * // Date boundary crossing: 23:00 UTC on Jan 20 → Jan 21 in Tokyo\n * const date6 = toPlainDate(\"2025-01-20T23:00:00Z\", \"Asia/Tokyo\"); // 2025-01-21\n * ```\n */\nexport function toPlainDate(input: Temporal.ZonedDateTime): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime,\n  timezone: Timezone\n): Temporal.PlainDate;\nexport function toPlainDate(input: Temporal.PlainDateLike | string): Temporal.PlainDate;\nexport function toPlainDate(\n  input: string | Date | Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDateLike,\n  timezone?: Timezone\n): Temporal.PlainDate {\n  // ZonedDateTime without timezone override\n  if (isZonedDateTime(input) && timezone === undefined) {\n    return input.toPlainDate();\n  }\n\n  // Date requires timezone\n  if (input instanceof Date) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // Instant requires timezone\n  if (isInstant(input)) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return input.toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // ZonedDateTime with timezone override\n  if (isZonedDateTime(input)) {\n    if (timezone === undefined) {\n      throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n    }\n    return input.toInstant().toZonedDateTimeISO(timezone).toPlainDate();\n  }\n\n  // String: ISO datetime (requires timezone) or plain date (no timezone)\n  if (typeof input === 'string') {\n    if (timezone !== undefined) {\n      return Temporal.Instant.from(input).toZonedDateTimeISO(timezone).toPlainDate();\n    }\n    if (PLAIN_DATE_PATTERN.test(input)) {\n      return Temporal.PlainDate.from(input);\n    }\n    throw new Error('Timezone is required unless input is a ZonedDateTime, PlainDateLike, or plain date string');\n  }\n\n  // Foreign PlainDate objects expose calendarId, while property bags use calendar.\n  // A canonical string keeps the ISO date and calendar together across implementations.\n  return Temporal.PlainDate.from(isPlainDate(input) ? input.toString() : input);\n}\n"],"mappings":";;;;;;;;AAIA,IAAM,qBAAqB;AAwCpB,SAAS,YACd,OACA,UACoB;AAEpB,MAAI,gBAAgB,KAAK,KAAK,aAAa,QAAW;AACpD,WAAO,MAAM,YAAY;AAAA,EAC3B;AAGA,MAAI,iBAAiB,MAAM;AACzB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,SAAS,QAAQ,KAAK,MAAM,YAAY,CAAC,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EAC7F;AAGA,MAAI,UAAU,KAAK,GAAG;AACpB,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,MAAM,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACxD;AAGA,MAAI,gBAAgB,KAAK,GAAG;AAC1B,QAAI,aAAa,QAAW;AAC1B,YAAM,IAAI,MAAM,2FAA2F;AAAA,IAC7G;AACA,WAAO,MAAM,UAAU,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,EACpE;AAGA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,aAAa,QAAW;AAC1B,aAAO,SAAS,QAAQ,KAAK,KAAK,EAAE,mBAAmB,QAAQ,EAAE,YAAY;AAAA,IAC/E;AACA,QAAI,mBAAmB,KAAK,KAAK,GAAG;AAClC,aAAO,SAAS,UAAU,KAAK,KAAK;AAAA,IACtC;AACA,UAAM,IAAI,MAAM,2FAA2F;AAAA,EAC7G;AAIA,SAAO,SAAS,UAAU,KAAK,YAAY,KAAK,IAAI,MAAM,SAAS,IAAI,KAAK;AAC9E;","names":[]}

package/dist/{chunk-ELUSLRWQ.js → chunk-LRIVI5ZC.js}

@@ -1,7 +1,7 @@
 import {
   Temporal,
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toZonedTime.ts
 function toZonedTime(input, timezone) {
@@ -23,4 +23,4 @@ function toZonedTime(input, timezone) {
 export {
   toZonedTime
 };
-//# sourceMappingURL=chunk-ELUSLRWQ.js.map
+//# sourceMappingURL=chunk-LRIVI5ZC.js.map

package/dist/{chunk-M4KDJ4I4.js → chunk-LXOLIOAD.js}

@@ -2,7 +2,7 @@ import {
   Temporal,
   isInstant,
   isZonedDateTime
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toPlainTime.ts
 var PLAIN_TIME_PATTERN = /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/;
@@ -43,4 +43,4 @@ function toPlainTime(input, timezone) {
 export {
   toPlainTime
 };
-//# sourceMappingURL=chunk-M4KDJ4I4.js.map
+//# sourceMappingURL=chunk-LXOLIOAD.js.map

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

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

package/dist/chunk-MCPKXTX7.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.123Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123999Z[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.123Z[UTC]');\n * const ms124 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.124Z[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-MWUVGTKC.js

@@ -0,0 +1,23 @@
+import {
+  today
+} from "./chunk-NL5MQVGD.js";
+import {
+  toPlainDate
+} from "./chunk-LQ3EQYIX.js";
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/relativeDay.ts
+function isDaysFromToday(input, timezone, days) {
+  const date = isPlainDate(input) ? input : toPlainDate(input, timezone);
+  return compare(date, today(timezone).add({ days })) === 0;
+}
+
+export {
+  isDaysFromToday
+};
+//# sourceMappingURL=chunk-MWUVGTKC.js.map

package/dist/chunk-MWUVGTKC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/relativeDay.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './temporal';\nimport type { Timezone } from '../types';\nimport { compare } from './compare';\nimport { toPlainDate } from '../toPlainDate';\nimport { today } from '../today';\n\n/**\n * @internal\n * True when the input's calendar date in `timezone` is `days` away from\n * today's date in that same timezone. PlainDate inputs are already dates.\n */\nexport function isDaysFromToday(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone,\n  days: number\n): boolean {\n  const date = isPlainDate(input) ? input : toPlainDate(input, timezone);\n  return compare(date, today(timezone).add({ days })) === 0;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWO,SAAS,gBACd,OACA,UACA,MACS;AACT,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,YAAY,OAAO,QAAQ;AACrE,SAAO,QAAQ,MAAM,MAAM,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM;AAC1D;","names":[]}

package/dist/chunk-MXUGDXSG.js

@@ -0,0 +1,28 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/differenceInWeeks.ts
+function differenceInWeeks(laterDate, earlierDate, options) {
+  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {
+    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {
+      throw new TypeError("PlainDate differences require two PlainDate values");
+    }
+    const duration2 = earlierDate.until(laterDate.toString(), { largestUnit: "days" });
+    const precise2 = duration2.total({ unit: "weeks", relativeTo: earlierDate });
+    return options?.fractional ? precise2 : Math.trunc(precise2);
+  }
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const duration = zoned2.until(zoned1.toString(), { largestUnit: "hours" });
+  const precise = duration.total({ unit: "weeks", relativeTo: zoned2 });
+  return options?.fractional ? precise : Math.trunc(precise);
+}
+
+export {
+  differenceInWeeks
+};
+//# sourceMappingURL=chunk-MXUGDXSG.js.map

package/dist/chunk-MXUGDXSG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInWeeks.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Two PlainDates use calendar arithmetic without a timezone. Their calendars must match.\n * Native and polyfill inputs may be mixed within the same Temporal domain.\n *\n * Returns the number of weeks between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * DST transitions and calendar weeks.\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of weeks between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-02-10T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-02-10T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-01-27T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 1\n * ```\n */\nexport function differenceInWeeks(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions\n): number;\nexport function differenceInWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number;\nexport function differenceInWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: DifferenceOptions\n): number {\n  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {\n    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {\n      throw new TypeError('PlainDate differences require two PlainDate values');\n    }\n    const duration = earlierDate.until(laterDate.toString(), { largestUnit: 'days' });\n    const precise = duration.total({ unit: 'weeks', relativeTo: earlierDate });\n    return options?.fractional ? precise : Math.trunc(precise);\n  }\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // A canonical string preserves zone, calendar, and precision across implementations.\n  const duration = zoned2.until(zoned1.toString(), { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'weeks', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AA0DO,SAAS,kBACd,WACA,aACA,SACQ;AACR,MAAI,YAAY,SAAS,KAAK,YAAY,WAAW,GAAG;AACtD,QAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,WAAW,GAAG;AACxD,YAAM,IAAI,UAAU,oDAAoD;AAAA,IAC1E;AACA,UAAMA,YAAW,YAAY,MAAM,UAAU,SAAS,GAAG,EAAE,aAAa,OAAO,CAAC;AAChF,UAAMC,WAAUD,UAAS,MAAM,EAAE,MAAM,SAAS,YAAY,YAAY,CAAC;AACzE,WAAO,SAAS,aAAaC,WAAU,KAAK,MAAMA,QAAO;AAAA,EAC3D;AACA,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,QAAM,WAAW,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,aAAa,QAAQ,CAAC;AACzE,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":["duration","precise"]}

package/dist/chunk-NKXMLC6T.js

@@ -0,0 +1,56 @@
+import {
+  isPlainDateBefore
+} from "./chunk-ZM32S3YU.js";
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachYearOfInterval.ts
+function eachYearOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    if (isPlainDateAfter(interval.start, interval.end)) return [];
+    const end = interval.end.withCalendar(interval.start.calendarId);
+    const last = end.with({ month: 1, day: 1 });
+    let current = interval.start.with({ month: 1, day: 1 });
+    const dates = [];
+    while (isPlainDateBefore(current, last)) {
+      dates.push(current);
+      current = current.add({ years: 1 });
+    }
+    dates.push(current);
+    return dates;
+  }
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const timezone = startZoned.timeZoneId;
+  const startYear = startZoned.year;
+  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);
+  const endYear = endInTimezone.year;
+  const years = [];
+  for (let year = startYear; year <= endYear; year++) {
+    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1, calendar: startZoned.calendarId });
+    years.push(
+      firstOfYear.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: new Temporal.PlainTime()
+      })
+    );
+  }
+  return years;
+}
+
+export {
+  eachYearOfInterval
+};
+//# sourceMappingURL=chunk-NKXMLC6T.js.map