@gobrand/tiempo 3.0.1 → 3.1.3

package/dist/chunk-6QOLNYFY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/roundToNearestMinute.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Options for rounding to nearest minute.\n */\nexport interface RoundToNearestMinuteOptions {\n  /**\n   * The rounding mode to use.\n   *\n   * Given time 14:37:20:\n   * - `'round'` → 14:37 (20 sec < 30, rounds DOWN to nearest)\n   * - `'ceil'`  → 14:38 (always rounds UP to next minute)\n   * - `'floor'` → 14:37 (always rounds DOWN to current minute)\n   *\n   * Given time 14:37:00 with nearestTo: 15:\n   * - `'round'` → 14:30 (37 is closer to 30 than 45)\n   * - `'ceil'`  → 14:45 (always rounds UP to next 15-min slot)\n   * - `'floor'` → 14:30 (always rounds DOWN to current 15-min slot)\n   *\n   * @default 'round'\n   */\n  mode?: 'round' | 'ceil' | 'floor';\n  /**\n   * Round to the nearest N minutes. Must divide evenly into 60.\n   * Valid values: 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30\n   * @example nearestTo: 15 rounds to quarter-hour marks (00, 15, 30, 45)\n   */\n  nearestTo?: 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30;\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 minute boundary.\n *\n * ## Mode comparison (given 14:37 with 15-min slots)\n *\n * ```\n * 14:30 ─────────●───────────────────── 14:45\n *              14:37\n *\n * 'round' → 14:30  (nearest slot - 37 is closer to 30 than 45)\n * 'ceil'  → 14:45  (next slot - always up)\n * 'floor' → 14:30  (current slot - 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 minute boundary\n *\n * @example\n * ```ts\n * // 15-minute booking slots at 14:37\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:00[America/New_York]');\n *\n * roundToNearestMinute(time, { nearestTo: 15 });                    // → 14:30 (nearest)\n * roundToNearestMinute(time, { mode: 'ceil', nearestTo: 15 });      // → 14:45 (next slot)\n * roundToNearestMinute(time, { mode: 'floor', nearestTo: 15 });     // → 14:30 (current slot)\n * ```\n *\n * @example\n * ```ts\n * // Basic minute rounding (no slots)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:42[America/New_York]');\n *\n * roundToNearestMinute(time);                     // → 14:38 (42 sec >= 30)\n * roundToNearestMinute(time, { mode: 'ceil' });   // → 14:38 (always up)\n * roundToNearestMinute(time, { mode: 'floor' });  // → 14:37 (always down)\n * ```\n *\n * @example\n * ```ts\n * // Billing: round up to 30-minute increments\n * const sessionEnd = Temporal.ZonedDateTime.from('2025-01-20T11:07:00[America/New_York]');\n * roundToNearestMinute(sessionEnd, { mode: 'ceil', nearestTo: 30 });\n * // → 11:30 (bill for 30 mins even though session was 7 mins)\n * ```\n */\nexport function roundToNearestMinute(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: RoundToNearestMinuteOptions\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: 'minute',\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;AAgDO,SAAS,qBACd,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-6QZUAJVF.js

@@ -0,0 +1,20 @@
+import {
+  isWeekendDay
+} from "./chunk-K7CLBBBM.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/isWeekend.ts
+function isWeekend(input) {
+  const date = isPlainDate(input) ? input : normalizeTemporalInput(input);
+  return isWeekendDay(date.dayOfWeek);
+}
+
+export {
+  isWeekend
+};
+//# sourceMappingURL=chunk-6QZUAJVF.js.map

package/dist/chunk-6QZUAJVF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isWeekend.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isWeekendDay } from './shared/businessDays';\n\n/**\n * Returns true if the value falls on a Saturday or Sunday.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs use their own\n * timezone. PlainDate inputs use their date directly.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @returns true on Saturday or Sunday, false otherwise\n *\n * @example\n * ```ts\n * isWeekend(Temporal.PlainDate.from('2025-01-25')); // true (Saturday)\n * isWeekend(Temporal.PlainDate.from('2025-01-27')); // false (Monday)\n * ```\n */\nexport function isWeekend(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): boolean {\n  const date = isPlainDate(input) ? input : normalizeTemporalInput(input);\n  return isWeekendDay(date.dayOfWeek);\n}\n"],"mappings":";;;;;;;;;;;AAmBO,SAAS,UACd,OACS;AACT,QAAM,OAAO,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACtE,SAAO,aAAa,KAAK,SAAS;AACpC;","names":[]}

package/dist/{chunk-PURKYS5T.js → chunk-6XEHR3MG.js}

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

package/dist/{chunk-LAITZAIG.js → chunk-7IKCDOCT.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addSeconds.ts
 function addSeconds(input, seconds) {
@@ -11,4 +11,4 @@ function addSeconds(input, seconds) {
 export {
   addSeconds
 };
-//# sourceMappingURL=chunk-LAITZAIG.js.map
+//# sourceMappingURL=chunk-7IKCDOCT.js.map

package/dist/chunk-7IKCDOCT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addSeconds.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of seconds 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 seconds - Number of seconds to add (can be negative to subtract)\n * @returns ZonedDateTime with seconds 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 = addSeconds(instant, 45);\n * // 2025-01-20T12:00:45+00:00[UTC] (45 seconds 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 = addSeconds(zoned, 3600);\n * // 2025-01-20T16:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract seconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addSeconds(instant, -30);\n * // 2025-01-20T11:59:30+00:00[UTC] (30 seconds earlier)\n * ```\n */\nexport function addSeconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  seconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ seconds });\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-7NGP7SAD.js

@@ -0,0 +1,66 @@
+import {
+  isPlainDateBefore
+} from "./chunk-ZM32S3YU.js";
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachMonthOfInterval.ts
+function eachMonthOfInterval(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({ day: 1 });
+    let current2 = interval.start.with({ day: 1 });
+    const dates = [];
+    while (isPlainDateBefore(current2, last)) {
+      dates.push(current2);
+      current2 = current2.add({ months: 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 startYearMonth = Temporal.PlainYearMonth.from({
+    year: startZoned.year,
+    month: startZoned.month,
+    calendar: startZoned.calendarId
+  });
+  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);
+  const endYearMonth = Temporal.PlainYearMonth.from({
+    year: endInTimezone.year,
+    month: endInTimezone.month,
+    calendar: startZoned.calendarId
+  });
+  const months = [];
+  let current = startYearMonth;
+  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {
+    const firstOfMonth = current.toPlainDate({ day: 1 });
+    months.push(
+      firstOfMonth.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: new Temporal.PlainTime()
+      })
+    );
+    current = current.add({ months: 1 });
+  }
+  return months;
+}
+
+export {
+  eachMonthOfInterval
+};
+//# sourceMappingURL=chunk-7NGP7SAD.js.map

package/dist/chunk-7NGP7SAD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachMonthOfInterval.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 * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array of ZonedDateTime objects for each month within the interval.\n * Each element represents the first moment of the month (day 1 at midnight).\n * The interval is inclusive of both start and end months.\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 month in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-15T10:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-04-20T14:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC],\n * //   2025-03-01T00:00:00+00:00[UTC],\n * //   2025-04-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-11-15T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-02-15T00:00:00+00:00[UTC]');\n *\n * const months = eachMonthOfInterval({ start, end });\n * // [\n * //   2024-11-01T00:00:00+00:00[UTC],\n * //   2024-12-01T00:00:00+00:00[UTC],\n * //   2025-01-01T00:00:00+00:00[UTC],\n * //   2025-02-01T00:00:00+00:00[UTC]\n * // ]\n * ```\n */\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachMonthOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachMonthOfInterval(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.with({ day: 1 });\n    let current = interval.start.with({ day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ months: 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 start of the starting month\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: startZoned.year,\n    month: startZoned.month,\n    calendar: startZoned.calendarId,\n  });\n\n  // Get end month in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: endInTimezone.year,\n    month: endInTimezone.month,\n    calendar: startZoned.calendarId,\n  });\n\n  const months: Temporal.ZonedDateTime[] = [];\n  let current = startYearMonth;\n\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    const firstOfMonth = current.toPlainDate({ day: 1 });\n    months.push(\n      firstOfMonth.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n    current = current.add({ months: 1 });\n  }\n\n  return months;\n}\n"],"mappings":";;;;;;;;;;;;;;;AA2DO,SAAS,oBAAoB,UAGgB;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,KAAK,EAAE,KAAK,EAAE,CAAC;AAChC,QAAIA,WAAU,SAAS,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAC5C,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,IACrC;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;AAG5B,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,WAAW;AAAA,IACjB,OAAO,WAAW;AAAA,IAClB,UAAU,WAAW;AAAA,EACvB,CAAC;AAGD,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,cAAc;AAAA,IACpB,OAAO,cAAc;AAAA,IACrB,UAAU,WAAW;AAAA,EACvB,CAAC;AAED,QAAM,SAAmC,CAAC;AAC1C,MAAI,UAAU;AAEd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,UAAM,eAAe,QAAQ,YAAY,EAAE,KAAK,EAAE,CAAC;AACnD,WAAO;AAAA,MACL,aAAa,gBAAgB;AAAA,QAC3B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AACA,cAAU,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;","names":["current"]}

package/dist/{chunk-RL2NW7HP.js → chunk-A34P5Z5O.js}

@@ -1,6 +1,6 @@
 import {
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toIso9075.ts
 function toIso9075(input, options = {}) {
@@ -30,4 +30,4 @@ function pad(n) {
 export {
   toIso9075
 };
-//# sourceMappingURL=chunk-RL2NW7HP.js.map
+//# sourceMappingURL=chunk-A34P5Z5O.js.map

package/dist/chunk-A34P5Z5O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toIso9075.ts"],"sourcesContent":["import { type Temporal, isInstant } from './shared/temporal';\n\nexport type Iso9075Mode = 'utc' | 'local';\nexport type Iso9075Representation = 'complete' | 'date' | 'time';\n\nexport interface ToIso9075Options {\n  /**\n   * Which time to output.\n   * - 'utc' (default): convert to UTC before formatting\n   * - 'local': use the local time of the ZonedDateTime\n   */\n  mode?: Iso9075Mode;\n  /**\n   * What to include in the output.\n   * - 'complete' (default): date and time (2019-09-18 19:00:52)\n   * - 'date': date only (2019-09-18)\n   * - 'time': time only (19:00:52)\n   */\n  representation?: Iso9075Representation;\n}\n\n/**\n * Convert a Temporal.Instant to an ISO 9075 (SQL) formatted string in UTC.\n */\nexport function toIso9075(\n  input: Temporal.Instant,\n  options?: Omit<ToIso9075Options, 'mode'>\n): string;\n\n/**\n * Convert a Temporal.ZonedDateTime to an ISO 9075 (SQL) formatted string.\n *\n * @param input - A Temporal.ZonedDateTime\n * @param options - Format options\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n *\n * toIso9075(zoned);                       // \"2025-01-20 20:00:00\" (UTC, default)\n * toIso9075(zoned, { mode: 'utc' });      // \"2025-01-20 20:00:00\"\n * toIso9075(zoned, { mode: 'local' });    // \"2025-01-20 15:00:00\"\n * toIso9075(zoned, { representation: 'date' }); // \"2025-01-20\"\n * toIso9075(zoned, { representation: 'time' }); // \"20:00:00\"\n * ```\n */\nexport function toIso9075(\n  input: Temporal.ZonedDateTime,\n  options?: ToIso9075Options\n): string;\n\nexport function toIso9075(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options: ToIso9075Options = {}\n): string {\n  const { mode = 'utc', representation = 'complete' } = options;\n\n  let zdt: Temporal.ZonedDateTime;\n\n  if (isInstant(input)) {\n    zdt = input.toZonedDateTimeISO('UTC');\n  } else {\n    // ZonedDateTime: apply mode\n    zdt = mode === 'utc' ? input.toInstant().toZonedDateTimeISO('UTC') : input;\n  }\n\n  const year = zdt.year;\n  const month = zdt.month;\n  const day = zdt.day;\n  const hour = zdt.hour;\n  const minute = zdt.minute;\n  const second = zdt.second;\n\n  const datePart = `${year}-${pad(month)}-${pad(day)}`;\n  const timePart = `${pad(hour)}:${pad(minute)}:${pad(second)}`;\n\n  if (representation === 'date') return datePart;\n  if (representation === 'time') return timePart;\n  return `${datePart} ${timePart}`;\n}\n\nfunction pad(n: number): string {\n  return n.toString().padStart(2, '0');\n}\n"],"mappings":";;;;;AAmDO,SAAS,UACd,OACA,UAA4B,CAAC,GACrB;AACR,QAAM,EAAE,OAAO,OAAO,iBAAiB,WAAW,IAAI;AAEtD,MAAI;AAEJ,MAAI,UAAU,KAAK,GAAG;AACpB,UAAM,MAAM,mBAAmB,KAAK;AAAA,EACtC,OAAO;AAEL,UAAM,SAAS,QAAQ,MAAM,UAAU,EAAE,mBAAmB,KAAK,IAAI;AAAA,EACvE;AAEA,QAAM,OAAO,IAAI;AACjB,QAAM,QAAQ,IAAI;AAClB,QAAM,MAAM,IAAI;AAChB,QAAM,OAAO,IAAI;AACjB,QAAM,SAAS,IAAI;AACnB,QAAM,SAAS,IAAI;AAEnB,QAAM,WAAW,GAAG,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC;AAClD,QAAM,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC;AAE3D,MAAI,mBAAmB,OAAQ,QAAO;AACtC,MAAI,mBAAmB,OAAQ,QAAO;AACtC,SAAO,GAAG,QAAQ,IAAI,QAAQ;AAChC;AAEA,SAAS,IAAI,GAAmB;AAC9B,SAAO,EAAE,SAAS,EAAE,SAAS,GAAG,GAAG;AACrC;","names":[]}

package/dist/chunk-ADPVFELS.js

@@ -0,0 +1,16 @@
+import {
+  Temporal
+} from "./chunk-BSVOJYJ7.js";
+
+// src/isPlainDateAfter.ts
+function isPlainDateAfter(date1, date2) {
+  return Temporal.PlainDate.compare(
+    Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),
+    Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()
+  ) > 0;
+}
+
+export {
+  isPlainDateAfter
+};
+//# sourceMappingURL=chunk-ADPVFELS.js.map

package/dist/{chunk-NEHYVVTH.js.map → chunk-ADPVFELS.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isPlainDateAfter.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is after the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is after date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateAfter(jan25, jan20); // true\n * isPlainDateAfter(jan20, jan25); // false\n * isPlainDateAfter(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateAfter(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  return Temporal.PlainDate.compare(date1, date2) > 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,iBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,IAAI;AACpD;","names":[]}
+{"version":3,"sources":["../src/isPlainDateAfter.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the first plain date is after the second plain date.\n * Compares calendar dates without time or timezone considerations.\n *\n * @param date1 - First plain date\n * @param date2 - Second plain date\n * @returns true if date1 is after date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20 = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateAfter(jan25, jan20); // true\n * isPlainDateAfter(jan20, jan25); // false\n * isPlainDateAfter(jan20, jan20); // false\n * ```\n */\nexport function isPlainDateAfter(\n  date1: Temporal.PlainDate,\n  date2: Temporal.PlainDate\n): boolean {\n  // Only foreign objects need conversion; strings retain their calendar annotations.\n  return Temporal.PlainDate.compare(\n    Temporal.PlainDate.prototype.isPrototypeOf(date1) ? date1 : date1.toString(),\n    Temporal.PlainDate.prototype.isPrototypeOf(date2) ? date2 : date2.toString()\n  ) > 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,iBACd,OACA,OACS;AAET,SAAO,SAAS,UAAU;AAAA,IACxB,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,IAC3E,SAAS,UAAU,UAAU,cAAc,KAAK,IAAI,QAAQ,MAAM,SAAS;AAAA,EAC7E,IAAI;AACN;","names":[]}

package/dist/chunk-AOODDNHA.js

@@ -0,0 +1,53 @@
+import {
+  isPlainDateBefore
+} from "./chunk-ZM32S3YU.js";
+import {
+  isPlainDateAfter
+} from "./chunk-ADPVFELS.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-Q6QLOUXJ.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-AOODDNHA.js.map

package/dist/chunk-AOODDNHA.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:00+00:00[UTC]'); // Monday\n * const end = Temporal.ZonedDateTime.from('2025-01-22T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Week 2\n * //   2025-01-13T00:00:00+00:00[UTC],  // Week 3\n * //   2025-01-20T00:00:00+00:00[UTC]   // Week 4\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Mid-week start\n * const start = Temporal.ZonedDateTime.from('2025-01-08T10:00:00+00:00[UTC]'); // Wednesday\n * const end = Temporal.ZonedDateTime.from('2025-01-15T14:00:00+00:00[UTC]');   // Wednesday\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2025-01-06T00:00:00+00:00[UTC],  // Monday of week containing Jan 8\n * //   2025-01-13T00:00:00+00:00[UTC]   // Monday of week containing Jan 15\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-year boundary\n * const start = Temporal.ZonedDateTime.from('2024-12-25T00:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-08T00:00:00+00:00[UTC]');\n *\n * const weeks = eachWeekOfInterval({ start, end });\n * // [\n * //   2024-12-23T00:00:00+00:00[UTC],  // Monday of week containing Dec 25\n * //   2024-12-30T00:00:00+00:00[UTC],  // Monday of week containing Dec 30\n * //   2025-01-06T00:00:00+00:00[UTC]   // Monday of week containing Jan 8\n * // ]\n * ```\n */\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachWeekOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n}): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    const end = interval.end.withCalendar(interval.start.calendarId);\n    const last = end.subtract({ days: end.dayOfWeek - 1 });\n    let current = interval.start.subtract({ days: interval.start.dayOfWeek - 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ weeks: 1 });\n    }\n    dates.push(current);\n    return dates;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const timezone = startZoned.timeZoneId;\n\n  // Get Monday of the starting week\n  // dayOfWeek: 1 = Monday, 7 = Sunday (ISO 8601)\n  const daysToSubtractStart = startZoned.dayOfWeek - 1;\n  const startMonday = startZoned.subtract({ days: daysToSubtractStart }).startOfDay();\n\n  // Get Monday of the ending week\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const daysToSubtractEnd = endInTimezone.dayOfWeek - 1;\n  const endMonday = endInTimezone.subtract({ days: daysToSubtractEnd }).startOfDay();\n\n  const weeks: Temporal.ZonedDateTime[] = [];\n  let current = startMonday;\n\n  while (current.epochNanoseconds <= endMonday.epochNanoseconds) {\n    weeks.push(current);\n    current = current.add({ weeks: 1 });\n  }\n\n  return weeks;\n}\n"],"mappings":";;;;;;;;;;;;;;AAoEO,SAAS,mBAAmB,UAGiB;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,UAAM,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAC/D,UAAM,OAAO,IAAI,SAAS,EAAE,MAAM,IAAI,YAAY,EAAE,CAAC;AACrD,QAAIA,WAAU,SAAS,MAAM,SAAS,EAAE,MAAM,SAAS,MAAM,YAAY,EAAE,CAAC;AAC5E,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkBA,UAAS,IAAI,GAAG;AACvC,YAAM,KAAKA,QAAO;AAClB,MAAAA,WAAUA,SAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAKA,QAAO;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,WAAW,WAAW;AAI5B,QAAM,sBAAsB,WAAW,YAAY;AACnD,QAAM,cAAc,WAAW,SAAS,EAAE,MAAM,oBAAoB,CAAC,EAAE,WAAW;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,oBAAoB,cAAc,YAAY;AACpD,QAAM,YAAY,cAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC,EAAE,WAAW;AAEjF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,UAAU,kBAAkB;AAC7D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":["current"]}

package/dist/{chunk-FCJO72WG.js → chunk-AUOZACFS.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/addMilliseconds.ts
 function addMilliseconds(input, milliseconds) {
@@ -11,4 +11,4 @@ function addMilliseconds(input, milliseconds) {
 export {
   addMilliseconds
 };
-//# sourceMappingURL=chunk-FCJO72WG.js.map
+//# sourceMappingURL=chunk-AUOZACFS.js.map

package/dist/chunk-AUOZACFS.js.map

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

package/dist/{chunk-A42NID5P.js → chunk-BI42E23Z.js}

@@ -1,12 +1,12 @@
 import {
   isBefore
-} from "./chunk-EVEMK2K2.js";
+} from "./chunk-BMX7CIRD.js";
 import {
   nowZoned
-} from "./chunk-6RETOV6A.js";
+} from "./chunk-4GEF7B7W.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 
 // src/isPast.ts
 function isPast(date) {
@@ -17,4 +17,4 @@ function isPast(date) {
 export {
   isPast
 };
-//# sourceMappingURL=chunk-A42NID5P.js.map
+//# sourceMappingURL=chunk-BI42E23Z.js.map

package/dist/chunk-BI42E23Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore } from './shared/isBefore';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the past.\n * Compares by the underlying instant (epoch time) against the current time.\n *\n * @param date - Datetime to check (Instant or ZonedDateTime)\n * @returns true if date is before the current instant, false otherwise\n *\n * @example\n * ```ts\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n *\n * isPast(yesterday); // true\n * isPast(tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const pastInstant = Temporal.Now.instant().subtract({ hours: 1 });\n *\n * isPast(pastInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const pastInTokyo = Temporal.ZonedDateTime.from('1970-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isPast(pastInTokyo); // true\n * ```\n */\nexport function isPast(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isBefore(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,OACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,SAAS,OAAO,SAAS,CAAC;AACnC;","names":[]}

package/dist/chunk-BMX7CIRD.js

@@ -0,0 +1,9 @@
+// src/shared/isBefore.ts
+function isBefore(date1, date2) {
+  return date1.epochNanoseconds < date2.epochNanoseconds;
+}
+
+export {
+  isBefore
+};
+//# sourceMappingURL=chunk-BMX7CIRD.js.map

package/dist/chunk-BMX7CIRD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/isBefore.ts"],"sourcesContent":["import type { Temporal } from './temporal';\n\nexport function isBefore(\n  date1: Temporal.ZonedDateTime,\n  date2: Temporal.ZonedDateTime\n): boolean {\n  return date1.epochNanoseconds < date2.epochNanoseconds;\n}\n"],"mappings":";AAEO,SAAS,SACd,OACA,OACS;AACT,SAAO,MAAM,mBAAmB,MAAM;AACxC;","names":[]}

package/dist/{chunk-25CVKMFC.js → chunk-BPMS34GV.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/isSameQuarter.ts
 function isSameQuarter(date1, date2) {
@@ -18,4 +18,4 @@ function isSameQuarter(date1, date2) {
 export {
   isSameQuarter
 };
-//# sourceMappingURL=chunk-25CVKMFC.js.map
+//# sourceMappingURL=chunk-BPMS34GV.js.map

package/dist/chunk-BPMS34GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterOfMonth } from \"./shared/quarter\";\n\n/**\n * Returns true if both inputs fall in the same calendar quarter and year.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * Instant inputs are converted to UTC; ZonedDateTime inputs keep their own\n * timezone. PlainDate inputs are compared directly — a quarter is intrinsic to\n * the calendar date, so no timezone is needed.\n *\n * @param date1 - First Instant or ZonedDateTime\n * @param date2 - Second Instant or ZonedDateTime\n * @returns true if both are in the same calendar quarter, false otherwise\n *\n * @example\n * ```ts\n * const jan = Temporal.ZonedDateTime.from('2025-01-15T08:00:00+00:00[UTC]');\n * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59+00:00[UTC]');\n * isSameQuarter(jan, mar); // true\n * ```\n *\n * @example\n * ```ts\n * // PlainDate comparison needs no timezone\n * const a = Temporal.PlainDate.from('2025-04-05');\n * const b = Temporal.PlainDate.from('2025-06-28');\n * isSameQuarter(a, b); // true (both Q2)\n * ```\n */\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime,\n): boolean;\nexport function isSameQuarter(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  date2: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n): boolean {\n  const a = isPlainDate(date1) ? date1 : normalizeTemporalInput(date1);\n  const b = isPlainDate(date2) ? date2 : normalizeTemporalInput(date2);\n\n  return a.year === b.year && quarterOfMonth(a.month) === quarterOfMonth(b.month);\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,cACd,OACA,OACS;AACT,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACnE,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AAEnE,SAAO,EAAE,SAAS,EAAE,QAAQ,eAAe,EAAE,KAAK,MAAM,eAAe,EAAE,KAAK;AAChF;","names":[]}

package/dist/{chunk-R7ZCA6AQ.js → chunk-BSVOJYJ7.js}

@@ -1,6 +1,6 @@
 // src/shared/temporal.ts
 import { Temporal as PolyfillTemporal } from "@js-temporal/polyfill";
-var useNative = process.env.TIEMPO_TEMPORAL === "native" && "Temporal" in globalThis;
+var useNative = typeof process !== "undefined" && process.env?.TIEMPO_TEMPORAL === "native" && "Temporal" in globalThis;
 var Temporal = useNative ? globalThis.Temporal : PolyfillTemporal;
 function brand(value) {
   return typeof value === "object" && value !== null ? value[Symbol.toStringTag] : void 0;
@@ -14,11 +14,15 @@ function isZonedDateTime(value) {
 function isPlainDate(value) {
   return brand(value) === "Temporal.PlainDate";
 }
+function isPlainTime(value) {
+  return brand(value) === "Temporal.PlainTime";
+}
 
 export {
   Temporal,
   isInstant,
   isZonedDateTime,
-  isPlainDate
+  isPlainDate,
+  isPlainTime
 };
-//# sourceMappingURL=chunk-R7ZCA6AQ.js.map
+//# sourceMappingURL=chunk-BSVOJYJ7.js.map

package/dist/chunk-BSVOJYJ7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/temporal.ts"],"sourcesContent":["import { Temporal as PolyfillTemporal } from \"@js-temporal/polyfill\";\n\n/**\n * @internal\n * Single source of the Temporal implementation.\n *\n * Shipping behavior is unchanged: production code always resolves to\n * `@js-temporal/polyfill`. Native-first was reverted because tiempo passes\n * caller-provided Temporal objects into methods that may require matching\n * implementations. Timeline comparisons use epoch nanoseconds; calendar differences bridge\n * implementations with canonical strings. Conversion and interval input boundaries are\n * audited as well. Runtime support and declaration migration still gate removal\n * of the bundled polyfill; constructor identity is not uniform across outputs.\n *\n * For tests only, `TIEMPO_TEMPORAL` selects the implementation so the same\n * suite runs against both the polyfill and the runtime's native `Temporal`:\n *   - `TIEMPO_TEMPORAL=polyfill` forces the polyfill (any Node version).\n *   - `TIEMPO_TEMPORAL=native` uses `globalThis.Temporal` (Node >= 26).\n *   - unset defaults to the polyfill, matching shipped behavior.\n * Tests import `Temporal` from here so both lib and test objects come from the\n * same implementation. timelineInterop.test.ts separately covers native,\n * polyfill and mixed timeline inputs against both selections.\n *\n * Import `Temporal` from here so the implementation choice stays in one place.\n */\nconst useNative =\n  typeof process !== \"undefined\" &&\n  process.env?.TIEMPO_TEMPORAL === \"native\" &&\n  \"Temporal\" in globalThis;\n\nexport const Temporal = useNative\n  ? (globalThis as unknown as { Temporal: typeof PolyfillTemporal }).Temporal\n  : PolyfillTemporal;\n\n/**\n * @internal\n * Type-side of `Temporal`, merged with the runtime value above so a single\n * `import { Temporal } from './shared/temporal'` serves both `Temporal.from(...)`\n * (value) and `: Temporal.ZonedDateTime` (type). Types are identical across\n * implementations and erased at build, so they always come from the polyfill.\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace Temporal {\n  // Add new Temporal.* member types here the first time they are referenced\n  // from this module. Omissions fail loudly at typecheck, never silently.\n  export type Instant = PolyfillTemporal.Instant;\n  export type ZonedDateTime = PolyfillTemporal.ZonedDateTime;\n  export type PlainDate = PolyfillTemporal.PlainDate;\n  export type PlainDateLike = PolyfillTemporal.PlainDateLike;\n  export type PlainDateTime = PolyfillTemporal.PlainDateTime;\n  export type PlainTime = PolyfillTemporal.PlainTime;\n  export type PlainTimeLike = PolyfillTemporal.PlainTimeLike;\n  export type PlainYearMonth = PolyfillTemporal.PlainYearMonth;\n}\n\n/**\n * @internal\n * Implementation-agnostic type guards. The Temporal spec requires every\n * implementation to set `Symbol.toStringTag`, so these work regardless of which\n * implementation produced the object.\n */\nfunction brand(value: unknown): string | undefined {\n  return typeof value === \"object\" && value !== null\n    ? (value as { [Symbol.toStringTag]?: string })[Symbol.toStringTag]\n    : undefined;\n}\n\nexport function isInstant(value: unknown): value is Temporal.Instant {\n  return brand(value) === \"Temporal.Instant\";\n}\n\nexport function isZonedDateTime(value: unknown): value is Temporal.ZonedDateTime {\n  return brand(value) === \"Temporal.ZonedDateTime\";\n}\n\nexport function isPlainDate(value: unknown): value is Temporal.PlainDate {\n  return brand(value) === \"Temporal.PlainDate\";\n}\n\nexport function isPlainTime(value: unknown): value is Temporal.PlainTime {\n  return brand(value) === \"Temporal.PlainTime\";\n}\n"],"mappings":";AAAA,SAAS,YAAY,wBAAwB;AAyB7C,IAAM,YACJ,OAAO,YAAY,eACnB,QAAQ,KAAK,oBAAoB,YACjC,cAAc;AAET,IAAM,WAAW,YACnB,WAAgE,WACjE;AA6BJ,SAAS,MAAM,OAAoC;AACjD,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,MAA4C,OAAO,WAAW,IAC/D;AACN;AAEO,SAAS,UAAU,OAA2C;AACnE,SAAO,MAAM,KAAK,MAAM;AAC1B;AAEO,SAAS,gBAAgB,OAAiD;AAC/E,SAAO,MAAM,KAAK,MAAM;AAC1B;AAEO,SAAS,YAAY,OAA6C;AACvE,SAAO,MAAM,KAAK,MAAM;AAC1B;AAEO,SAAS,YAAY,OAA6C;AACvE,SAAO,MAAM,KAAK,MAAM;AAC1B;","names":[]}

package/dist/{chunk-BEGD73DT.js → chunk-BYPHFTFD.js}

@@ -1,12 +1,22 @@
+import {
+  formatPlainDate
+} from "./chunk-TWXUGWYX.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
-  isInstant
-} from "./chunk-R7ZCA6AQ.js";
+  isInstant,
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
 
 // src/format.ts
 function format(input, formatStr, options = {}) {
+  if (isPlainDate(input)) {
+    if (options.timeZone !== void 0) {
+      throw new TypeError("PlainDate formatting does not accept a timezone");
+    }
+    return formatPlainDate(input, formatStr, options);
+  }
   const { locale = "en-US", timeZone } = options;
   let zonedDateTime;
   if (timeZone) {
@@ -248,41 +258,17 @@ function formatToken(token, zonedDateTime, locale) {
     case "S":
       return Math.floor(zonedDateTime.millisecond / 100).toString();
     // Timezone
-    case "XXXXX": {
-      const offset = getTimezoneOffset(zonedDateTime);
-      return offset === "+00:00" ? "Z" : offset;
-    }
-    case "XXXX": {
-      const offset = getTimezoneOffset(zonedDateTime).replace(":", "");
-      return offset === "+0000" ? "Z" : offset;
-    }
-    case "XXX": {
-      const offset = getTimezoneOffset(zonedDateTime);
-      return offset === "+00:00" ? "Z" : offset;
-    }
-    case "XX": {
-      const offset = getTimezoneOffset(zonedDateTime).replace(":", "");
-      return offset === "+0000" ? "Z" : offset;
-    }
-    case "X": {
-      const offset = getTimezoneOffset(zonedDateTime);
-      if (offset === "+00:00") return "Z";
-      const [hours, minutes] = offset.split(":");
-      return minutes === "00" ? hours : `${hours}${minutes}`;
-    }
+    case "XXXXX":
+    case "XXXX":
+    case "XXX":
+    case "XX":
+    case "X":
     case "xxxxx":
-      return getTimezoneOffset(zonedDateTime);
     case "xxxx":
-      return getTimezoneOffset(zonedDateTime).replace(":", "");
     case "xxx":
-      return getTimezoneOffset(zonedDateTime);
     case "xx":
-      return getTimezoneOffset(zonedDateTime).replace(":", "");
-    case "x": {
-      const offset = getTimezoneOffset(zonedDateTime);
-      const [hours, minutes] = offset.split(":");
-      return minutes === "00" ? hours : `${hours}${minutes}`;
-    }
+    case "x":
+      return formatTimezoneOffset(zonedDateTime, token);
     case "zzzz":
       return formatPart(zonedDateTime, "timeZoneName", "long", locale);
     case "zzz":
@@ -299,9 +285,12 @@ function formatToken(token, zonedDateTime, locale) {
   }
 }
 function formatPart(zonedDateTime, part, style, locale) {
-  const options = {};
-  options[part] = style;
-  return zonedDateTime.toLocaleString(locale, options);
+  const options = {
+    [part]: style,
+    timeZone: zonedDateTime.timeZoneId,
+    calendar: zonedDateTime.calendarId === "iso8601" ? void 0 : zonedDateTime.calendarId
+  };
+  return new Intl.DateTimeFormat(locale, options).formatToParts(zonedDateTime.epochMilliseconds).find((value) => value.type === part)?.value ?? "";
 }
 function getOrdinalSuffix(num) {
   const j = num % 10;
@@ -311,21 +300,18 @@ function getOrdinalSuffix(num) {
   if (j === 3 && k !== 13) return "rd";
   return "th";
 }
-function getTimezoneOffset(zonedDateTime) {
-  const offsetNs = zonedDateTime.offsetNanoseconds;
-  const offsetMinutes = offsetNs / (60 * 1e9);
-  const sign = offsetMinutes >= 0 ? "+" : "-";
-  const absMinutes = Math.abs(offsetMinutes);
-  const hours = Math.floor(absMinutes / 60);
-  const minutes = absMinutes % 60;
-  return `${sign}${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+function formatTimezoneOffset(zonedDateTime, token) {
+  if (token[0] === "X" && zonedDateTime.offsetNanoseconds === 0) return "Z";
+  const offset = token.length >= 4 ? zonedDateTime.offset : zonedDateTime.offset.slice(0, 6);
+  if (token.length === 1 && offset.endsWith(":00")) return offset.slice(0, 3);
+  return token.length === 3 || token.length === 5 ? offset : offset.replaceAll(":", "");
 }
 function getDayPeriod(zonedDateTime, locale) {
   const parts = new Intl.DateTimeFormat(locale, {
     hour: "numeric",
     hour12: true,
     timeZone: zonedDateTime.timeZoneId
-  }).formatToParts(new Date(zonedDateTime.epochMilliseconds));
+  }).formatToParts(zonedDateTime.epochMilliseconds);
   return parts.find((p) => p.type === "dayPeriod")?.value ?? "";
 }
 function isAsciiAmPm(period) {
@@ -339,4 +325,4 @@ function isAm(period) {
 export {
   format
 };
-//# sourceMappingURL=chunk-BEGD73DT.js.map
+//# sourceMappingURL=chunk-BYPHFTFD.js.map

package/dist/chunk-BYPHFTFD.js.map

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

package/dist/chunk-CDKIT7D3.js

@@ -0,0 +1,9 @@
+// src/shared/isAfter.ts
+function isAfter(date1, date2) {
+  return date1.epochNanoseconds > date2.epochNanoseconds;
+}
+
+export {
+  isAfter
+};
+//# sourceMappingURL=chunk-CDKIT7D3.js.map

package/dist/chunk-CDKIT7D3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/isAfter.ts"],"sourcesContent":["import type { Temporal } from './temporal';\n\nexport function isAfter(\n  date1: Temporal.ZonedDateTime,\n  date2: Temporal.ZonedDateTime\n): boolean {\n  return date1.epochNanoseconds > date2.epochNanoseconds;\n}\n"],"mappings":";AAEO,SAAS,QACd,OACA,OACS;AACT,SAAO,MAAM,mBAAmB,MAAM;AACxC;","names":[]}

package/dist/chunk-CN3OICYB.js

@@ -0,0 +1,13 @@
+import {
+  compare
+} from "./chunk-OMYVTYHI.js";
+
+// src/isAfter.ts
+function isAfter(date1, date2) {
+  return compare(date1, date2) > 0;
+}
+
+export {
+  isAfter
+};
+//# sourceMappingURL=chunk-CN3OICYB.js.map

package/dist/chunk-CN3OICYB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isAfter.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { compare, type Comparable } from './shared/compare';\n\n/**\n * Returns true if the first datetime is after the second datetime.\n * Timeline values compare by their instant. PlainDate pairs compare dates;\n * PlainTime pairs compare wall-clock times without wrapping at midnight.\n *\n * @param date1 - First value in a matching date, time, or timeline pair\n * @param date2 - Second value in the same comparison domain\n * @returns true if date1 is after date2, false otherwise\n *\n * @example\n * ```ts\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16:00:00-05:00[America/New_York]');\n *\n * isAfter(later, earlier); // true\n * isAfter(earlier, later); // false\n * isAfter(earlier, earlier); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const instant1 = Temporal.Instant.from('2025-01-20T15:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T16:00:00Z');\n *\n * isAfter(instant2, instant1); // true\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares by instant\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n *\n * isAfter(tokyo, ny); // false\n * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC on January 20 (same instant)\n * ```\n */\nexport function isAfter(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;\nexport function isAfter(date1: Temporal.PlainTime, date2: Temporal.PlainTime): boolean;\nexport function isAfter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean;\nexport function isAfter(date1: Comparable, date2: Comparable): boolean {\n  return compare(date1, date2) > 0;\n}\n"],"mappings":";;;;;AA+CO,SAAS,QAAQ,OAAmB,OAA4B;AACrE,SAAO,QAAQ,OAAO,KAAK,IAAI;AACjC;","names":[]}