@gobrand/tiempo 3.0.1 → 3.1.2

package/dist/{chunk-IONQ6TOR.js → chunk-5XJEKPO5.js}

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

package/dist/chunk-5XJEKPO5.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-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-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-MM2HIW7M.js → chunk-AA56LFMF.js}

@@ -1,21 +1,19 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-import {
-  Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/eachMinuteOfInterval.ts
 function eachMinuteOfInterval(interval) {
   const startZoned = normalizeTemporalInput(interval.start);
   const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
   const timezone = startZoned.timeZoneId;
   const startMinute = startZoned.round({ smallestUnit: "minute", roundingMode: "floor" });
   const endInTimezone = endZoned.withTimeZone(timezone);
   const endMinute = endInTimezone.round({ smallestUnit: "minute", roundingMode: "floor" });
   const minutes = [];
   let current = startMinute;
-  while (Temporal.ZonedDateTime.compare(current, endMinute) <= 0) {
+  while (current.epochNanoseconds <= endMinute.epochNanoseconds) {
     minutes.push(current);
     current = current.add({ minutes: 1 });
   }
@@ -25,4 +23,4 @@ function eachMinuteOfInterval(interval) {
 export {
   eachMinuteOfInterval
 };
-//# sourceMappingURL=chunk-MM2HIW7M.js.map
+//# sourceMappingURL=chunk-AA56LFMF.js.map

package/dist/{chunk-MM2HIW7M.js.map → chunk-AA56LFMF.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/eachMinuteOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each minute within the interval.\n * Each element represents the start of the minute (seconds/etc. set to 0).\n * The interval is inclusive of both start and end minutes.\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 * Warning: Large intervals can produce very large arrays. For example, a 24-hour\n * interval produces 1,441 elements. Consider whether this is appropriate for your use case.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each minute in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:30:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T10:33:45Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:30:00Z[UTC],\n * //   2025-01-06T10:31:00Z[UTC],\n * //   2025-01-06T10:32:00Z[UTC],\n * //   2025-01-06T10:33:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-hour boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:58:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T11:02:00Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:58:00Z[UTC],\n * //   2025-01-06T10:59:00Z[UTC],\n * //   2025-01-06T11:00:00Z[UTC],\n * //   2025-01-06T11:01:00Z[UTC],\n * //   2025-01-06T11:02:00Z[UTC]\n * // ]\n * ```\n */\nexport function eachMinuteOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[] {\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n\n  const timezone = startZoned.timeZoneId;\n\n  // Get start of the starting minute\n  const startMinute = startZoned.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  // Get start of the ending minute in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endMinute = endInTimezone.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  const minutes: Temporal.ZonedDateTime[] = [];\n  let current = startMinute;\n\n  while (Temporal.ZonedDateTime.compare(current, endMinute) <= 0) {\n    minutes.push(current);\n    current = current.add({ minutes: 1 });\n  }\n\n  return minutes;\n}\n"],"mappings":";;;;;;;;AA+CO,SAAS,qBAAqB,UAGR;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAG5B,QAAM,cAAc,WAAW,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAGtF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,YAAY,cAAc,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAEvF,QAAM,UAAoC,CAAC;AAC3C,MAAI,UAAU;AAEd,SAAO,SAAS,cAAc,QAAQ,SAAS,SAAS,KAAK,GAAG;AAC9D,YAAQ,KAAK,OAAO;AACpB,cAAU,QAAQ,IAAI,EAAE,SAAS,EAAE,CAAC;AAAA,EACtC;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/eachMinuteOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each minute within the interval.\n * Each element represents the start of the minute (seconds/etc. set to 0).\n * The interval is inclusive of both start and end minutes.\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 * Warning: Large intervals can produce very large arrays. For example, a 24-hour\n * interval produces 1,441 elements. Consider whether this is appropriate for your use case.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each minute in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:30:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T10:33:45Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:30:00Z[UTC],\n * //   2025-01-06T10:31:00Z[UTC],\n * //   2025-01-06T10:32:00Z[UTC],\n * //   2025-01-06T10:33:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-hour boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T10:58:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-06T11:02:00Z[UTC]');\n *\n * const minutes = eachMinuteOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:58:00Z[UTC],\n * //   2025-01-06T10:59:00Z[UTC],\n * //   2025-01-06T11:00:00Z[UTC],\n * //   2025-01-06T11:01:00Z[UTC],\n * //   2025-01-06T11:02:00Z[UTC]\n * // ]\n * ```\n */\nexport function eachMinuteOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[] {\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 minute\n  const startMinute = startZoned.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  // Get start of the ending minute in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endMinute = endInTimezone.round({ smallestUnit: 'minute', roundingMode: 'floor' });\n\n  const minutes: Temporal.ZonedDateTime[] = [];\n  let current = startMinute;\n\n  while (current.epochNanoseconds <= endMinute.epochNanoseconds) {\n    minutes.push(current);\n    current = current.add({ minutes: 1 });\n  }\n\n  return minutes;\n}\n"],"mappings":";;;;;AA+CO,SAAS,qBAAqB,UAGR;AAC3B,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,cAAc,WAAW,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAGtF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,YAAY,cAAc,MAAM,EAAE,cAAc,UAAU,cAAc,QAAQ,CAAC;AAEvF,QAAM,UAAoC,CAAC;AAC3C,MAAI,UAAU;AAEd,SAAO,QAAQ,oBAAoB,UAAU,kBAAkB;AAC7D,YAAQ,KAAK,OAAO;AACpB,cAAU,QAAQ,IAAI,EAAE,SAAS,EAAE,CAAC;AAAA,EACtC;AAEA,SAAO;AACT;","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-ASIYAAQV.js

@@ -0,0 +1,42 @@
+import {
+  differenceInDays
+} from "./chunk-E5HJJFUI.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/eachDayOfInterval.ts
+function eachDayOfInterval(interval) {
+  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {
+    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {
+      throw new TypeError("PlainDate intervals require two PlainDate endpoints");
+    }
+    const dayCount = differenceInDays(
+      interval.end.withCalendar(interval.start.calendarId),
+      interval.start
+    );
+    const days2 = [];
+    for (let offset = 0; offset <= dayCount; offset++) {
+      days2.push(interval.start.add({ days: offset }));
+    }
+    return days2;
+  }
+  const startZoned = normalizeTemporalInput(interval.start);
+  const endZoned = normalizeTemporalInput(interval.end);
+  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];
+  const days = [];
+  let current = startZoned.startOfDay();
+  while (current.epochNanoseconds <= endZoned.epochNanoseconds) {
+    days.push(current);
+    current = current.add({ days: 1 }).startOfDay();
+  }
+  return days;
+}
+
+export {
+  eachDayOfInterval
+};
+//# sourceMappingURL=chunk-ASIYAAQV.js.map

package/dist/chunk-ASIYAAQV.js.map

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

package/dist/{chunk-RLVCSGRU.js → chunk-AVPV4BA5.js}

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

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

@@ -1,12 +1,12 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-2MFBXSTL.js";
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/endOfMonth.ts
 function endOfMonth(input, timezone) {
@@ -21,4 +21,4 @@ function endOfMonth(input, timezone) {
 export {
   endOfMonth
 };
-//# sourceMappingURL=chunk-YNLBS34B.js.map
+//# sourceMappingURL=chunk-B6VZ2AKN.js.map

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-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-BTXU3OGV.js → chunk-C5OJIIJP.js}

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

package/dist/chunk-C5OJIIJP.js.map

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

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":[]}

package/dist/{chunk-EBVLBLR3.js → chunk-D3BJEYTR.js}

@@ -1,19 +1,16 @@
-import {
-  differenceInMilliseconds
-} from "./chunk-VXOQ7IG5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/differenceInSeconds.ts
 function differenceInSeconds(laterDate, earlierDate, options) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  const precise = differenceInMilliseconds(zoned1, zoned2) / 1e3;
-  return options?.fractional ? precise : Math.trunc(precise);
+  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return options?.fractional ? Number(nanoseconds) / 1e9 : Number(nanoseconds / 1000000000n);
 }
 
 export {
   differenceInSeconds
 };
-//# sourceMappingURL=chunk-EBVLBLR3.js.map
+//# sourceMappingURL=chunk-D3BJEYTR.js.map

package/dist/chunk-D3BJEYTR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInSeconds.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of seconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n * Whole units are truncated toward zero after subtracting epoch nanoseconds.\n * Numeric results use JavaScript number precision; use differenceInNanoseconds\n * when an exact bigint elapsed difference is required.\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 seconds 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-01-20T12:30:25Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20Z');\n *\n * differenceInSeconds(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:01:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(later, earlier); // 60\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInSeconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInSeconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n  return options?.fractional\n    ? Number(nanoseconds) / 1_000_000_000\n    : Number(nanoseconds / 1_000_000_000n);\n}\n"],"mappings":";;;;;AA0CO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,cAAc,OAAO,mBAAmB,OAAO;AACrD,SAAO,SAAS,aACZ,OAAO,WAAW,IAAI,MACtB,OAAO,cAAc,WAAc;AACzC;","names":[]}

package/dist/{chunk-OVSCDXYN.js → chunk-DCZDGS5G.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/startOfYear.ts
 function startOfYear(input, timezone) {
@@ -18,4 +18,4 @@ function startOfYear(input, timezone) {
 export {
   startOfYear
 };
-//# sourceMappingURL=chunk-OVSCDXYN.js.map
+//# sourceMappingURL=chunk-DCZDGS5G.js.map

package/dist/{chunk-OVSCDXYN.js.map → chunk-DCZDGS5G.js.map}

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

package/dist/{chunk-WTLAKRCT.js → chunk-DHVGDIIO.js}

@@ -1,9 +1,9 @@
 import {
   differenceInMilliseconds
-} from "./chunk-VXOQ7IG5.js";
+} from "./chunk-3KE6GK4R.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/differenceInMilliseconds.ts
 function differenceInMilliseconds2(laterDate, earlierDate) {
@@ -15,4 +15,4 @@ function differenceInMilliseconds2(laterDate, earlierDate) {
 export {
   differenceInMilliseconds2 as differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-WTLAKRCT.js.map
+//# sourceMappingURL=chunk-DHVGDIIO.js.map

package/dist/chunk-DHVGDIIO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInMilliseconds.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds as differenceInMillisecondsInternal } from './shared/differenceInMilliseconds';\n\n/**\n * Returns the number of milliseconds between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n * Whole units are truncated toward zero after subtracting epoch nanoseconds.\n * Numeric results use JavaScript number precision; use differenceInNanoseconds\n * when an exact bigint elapsed difference is required.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @returns The number of milliseconds between the dates\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-01-20T12:30:21.700Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:20.600Z');\n *\n * differenceInMilliseconds(later, earlier); // 1100\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T14:00:00-05:00[America/New_York]');\n *\n * differenceInMilliseconds(later, earlier); // 3600000\n * ```\n *\n * @example\n * ```ts\n * // Handles different timezones - compares by instant\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T00:00:00+09:00[Asia/Tokyo]');\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T10:00:00-05:00[America/New_York]');\n *\n * differenceInMilliseconds(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMilliseconds(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  return differenceInMillisecondsInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAyCO,SAASA,0BACd,WACA,aACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,SAAO,yBAAiC,QAAQ,MAAM;AACxD;","names":["differenceInMilliseconds"]}

package/dist/{chunk-3LTTYG6N.js → chunk-DXSRRBJO.js}

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

package/dist/chunk-DXSRRBJO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameNanosecond.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes represent the exact same nanosecond.\n * Compares all time fields: year, month, day, hour, minute, second, millisecond, microsecond, and nanosecond.\n * This is the most precise comparison possible, representing exact instant equality in their respective timezones.\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 exact same nanosecond, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, exact same nanosecond\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');\n *\n * isSameNanosecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different nanoseconds\n * const ns789 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');\n * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790Z[UTC]');\n *\n * isSameNanosecond(ns789, ns790); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local nanoseconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.123456789+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local nanoseconds from each person's perspective\n * isSameNanosecond(ny, tokyo); // false (14:30:45.123456789 in NY, 04:30:45.123456789 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameNanosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456789 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameNanosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456789 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');\n *\n * isSameNanosecond(instant1, instant2); // true\n * ```\n */\nexport function isSameNanosecond(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second &&\n    zoned1.millisecond === zoned2.millisecond &&\n    zoned1.microsecond === zoned2.microsecond &&\n    zoned1.nanosecond === zoned2.nanosecond\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,iBACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO,UACzB,OAAO,gBAAgB,OAAO,eAC9B,OAAO,gBAAgB,OAAO,eAC9B,OAAO,eAAe,OAAO;AAEjC;","names":[]}

package/dist/chunk-E5HJJFUI.js

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

package/dist/chunk-E5HJJFUI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInDays.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of days between two dates or 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 where days can be 23, 24, or 25 hours long.\n *\n * Two PlainDate inputs return signed whole calendar days without a timezone.\n * Their calendars must match; fractional options do not change date-only results.\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 PlainDate, Instant or ZonedDateTime\n * @param earlierDate - The earlier value in the same Temporal domain\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of days 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-01-25T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInDays(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-25T15: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 * differenceInDays(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Handles DST transitions correctly\n * const afterDst = Temporal.ZonedDateTime.from('2025-03-10T12:00:00-04:00[America/New_York]');\n * const beforeDst = Temporal.ZonedDateTime.from('2025-03-08T12:00:00-05:00[America/New_York]');\n *\n * differenceInDays(afterDst, beforeDst); // 2 (calendar days, not 48 hours)\n * ```\n */\nexport function differenceInDays(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions\n): number;\nexport function differenceInDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number;\nexport function differenceInDays(\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    return earlierDate.until(laterDate.toString(), { largestUnit: 'days' }).days;\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: 'days', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AA0DO,SAAS,iBACd,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,WAAO,YAAY,MAAM,UAAU,SAAS,GAAG,EAAE,aAAa,OAAO,CAAC,EAAE;AAAA,EAC1E;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,QAAQ,YAAY,OAAO,CAAC;AACnE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/{chunk-SDW4W3XE.js → chunk-EBQ25TEY.js}

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

package/dist/chunk-EBQ25TEY.js.map

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

package/dist/chunk-EH4GVGXD.js

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

package/dist/{chunk-OKXCGA4Y.js.map → chunk-EH4GVGXD.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/isPlainDateEqual.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the two plain dates are equal.\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 equals date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20a = Temporal.PlainDate.from('2025-01-20');\n * const jan20b = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateEqual(jan20a, jan20b); // true\n * isPlainDateEqual(jan20a, jan25); // false\n * ```\n */\nexport function isPlainDateEqual(\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,MAAM;AACtD;","names":[]}
+{"version":3,"sources":["../src/isPlainDateEqual.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the two plain dates are equal.\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 equals date2, false otherwise\n *\n * @example\n * ```ts\n * const jan20a = Temporal.PlainDate.from('2025-01-20');\n * const jan20b = Temporal.PlainDate.from('2025-01-20');\n * const jan25 = Temporal.PlainDate.from('2025-01-25');\n *\n * isPlainDateEqual(jan20a, jan20b); // true\n * isPlainDateEqual(jan20a, jan25); // false\n * ```\n */\nexport function isPlainDateEqual(\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,MAAM;AACR;","names":[]}

package/dist/{chunk-WGLZHBJG.js → chunk-ETO77GIW.js}

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

package/dist/chunk-ETO77GIW.js.map

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

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

@@ -1,9 +1,9 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-2MFBXSTL.js";
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 
 // src/endOfDay.ts
 function endOfDay(input, timezone) {
@@ -14,4 +14,4 @@ function endOfDay(input, timezone) {
 export {
   endOfDay
 };
-//# sourceMappingURL=chunk-S7L5KBI4.js.map
+//# sourceMappingURL=chunk-FAVYJIRM.js.map