@gobrand/tiempo 3.0.1 → 3.1.3

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addYears.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of years to a datetime.\n *\n * Properly handles leap years and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param years - Number of years to add (can be negative to subtract)\n * @returns ZonedDateTime with years 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 = addYears(instant, 2);\n * // 2027-01-20T12:00:00Z[UTC] (2 years later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addYears(zoned, 1);\n * // 2026-01-20T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Leap year handling\n * const instant = Temporal.Instant.from('2024-02-29T12:00:00Z');\n * const result = addYears(instant, 1);\n * // 2025-02-28T12:00:00Z[UTC] (Feb 29 → Feb 28)\n * ```\n */\nexport function addYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ years });\n}\n"],"mappings":";;;;;AAqCO,SAAS,SACd,OACA,OACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,MAAM,CAAC;AACpC;","names":[]}

package/dist/chunk-7K5BJ6F7.js

@@ -1,18 +0,0 @@
-import {
-  isAfter
-} from "./chunk-LSKER4FN.js";
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/isAfter.ts
-function isAfter2(date1, date2) {
-  const zoned1 = normalizeTemporalInput(date1);
-  const zoned2 = normalizeTemporalInput(date2);
-  return isAfter(zoned1, zoned2);
-}
-
-export {
-  isAfter2 as isAfter
-};
-//# sourceMappingURL=chunk-7K5BJ6F7.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isAfter.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isAfter as isAfterInternal } from './shared/isAfter';\n\n/**\n * Returns true if the first datetime is after the second datetime.\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\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 the previous day (same instant)\n * ```\n */\nexport function isAfter(\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 isAfterInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAyCO,SAASA,SACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,QAAgB,QAAQ,MAAM;AACvC;","names":["isAfter"]}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/startOfQuarter.ts"],"sourcesContent":["import { isPlainDate } from \"./shared/temporal\";\nimport type { Temporal } from \"@js-temporal/polyfill\";\nimport type { Timezone } from \"./types\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the first moment of the quarter\n * (first day of the quarter's starting month at midnight).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the 1st day of the quarter at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const start = startOfQuarter(instant);\n * // 2025-04-01T00:00:00Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-08-15T15:30:00-05:00[America/New_York]');\n * const start = startOfQuarter(zoned);\n * // 2025-07-01T00:00:00-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const start = startOfQuarter(date, 'America/New_York');\n * // 2025-10-01T00:00:00-04:00[America/New_York]\n * ```\n */\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfQuarter(\n  input: Temporal.PlainDate,\n  timezone: Timezone,\n): Temporal.ZonedDateTime;\nexport function startOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → first day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ month: quarterStartMonth(input.month), day: 1 });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month),\n    day: 1,\n  });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AA+CO,SAAS,eACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,OAAO,kBAAkB,MAAM,KAAK,GAAG,KAAK,EAAE,CAAC;AAAA,EACrE;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK;AAAA,IAC5C,KAAK;AAAA,EACP,CAAC;AACD,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/chunk-A42NID5P.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isPast.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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-AVGNRINZ.js

@@ -1,9 +0,0 @@
-// src/shared/endOfDay.ts
-function getEndOfDay(zonedDateTime) {
-  return zonedDateTime.startOfDay().add({ days: 1 }).subtract({ nanoseconds: 1 });
-}
-
-export {
-  getEndOfDay
-};
-//# sourceMappingURL=chunk-AVGNRINZ.js.map

package/dist/chunk-AVGNRINZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/shared/endOfDay.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\n\n/**\n * Internal helper: Returns the last nanosecond of a given ZonedDateTime's day.\n * Used by endOfDay() and endOfWeek() to ensure consistent DST-safe behavior.\n */\nexport function getEndOfDay(\n  zonedDateTime: Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  return zonedDateTime\n    .startOfDay()\n    .add({ days: 1 })\n    .subtract({ nanoseconds: 1 });\n}\n"],"mappings":";AAMO,SAAS,YACd,eACwB;AACxB,SAAO,cACJ,WAAW,EACX,IAAI,EAAE,MAAM,EAAE,CAAC,EACf,SAAS,EAAE,aAAa,EAAE,CAAC;AAChC;","names":[]}

package/dist/chunk-BEGD73DT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/format.ts"],"sourcesContent":["import { isInstant } from './shared/temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { Timezone } from './types';\n\nexport interface FormatOptions {\n  locale?: string;\n  timeZone?: Timezone;\n}\n\n/**\n * Format a Temporal.Instant or ZonedDateTime using date-fns-like format tokens.\n * Uses Intl.DateTimeFormat under the hood via Temporal's toLocaleString() for zero dependencies.\n *\n * @param input - A Temporal.Instant or Temporal.ZonedDateTime 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.Instant | Temporal.ZonedDateTime,\n  formatStr: string,\n  options: FormatOptions = {}\n): string {\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      const offset = getTimezoneOffset(zonedDateTime);\n      return offset === '+00:00' ? 'Z' : offset;\n    }\n    case 'XXXX': {\n      const offset = getTimezoneOffset(zonedDateTime).replace(':', '');\n      return offset === '+0000' ? 'Z' : offset;\n    }\n    case 'XXX': {\n      const offset = getTimezoneOffset(zonedDateTime);\n      return offset === '+00:00' ? 'Z' : offset;\n    }\n    case 'XX': {\n      const offset = getTimezoneOffset(zonedDateTime).replace(':', '');\n      return offset === '+0000' ? 'Z' : offset;\n    }\n    case 'X': {\n      const offset = getTimezoneOffset(zonedDateTime); // \"+05:30\" / \"+00:00\"\n      if (offset === '+00:00') return 'Z';\n      const [hours, minutes] = offset.split(':');\n      return minutes === '00' ? hours! : `${hours}${minutes}`;\n    }\n    case 'xxxxx':\n      return getTimezoneOffset(zonedDateTime);\n    case 'xxxx':\n      return getTimezoneOffset(zonedDateTime).replace(':', '');\n    case 'xxx':\n      return getTimezoneOffset(zonedDateTime);\n    case 'xx':\n      return getTimezoneOffset(zonedDateTime).replace(':', '');\n    case 'x': {\n      const offset = getTimezoneOffset(zonedDateTime); // \"+05:30\" / \"+00:00\"\n      const [hours, minutes] = offset.split(':');\n      return minutes === '00' ? hours! : `${hours}${minutes}`;\n    }\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  options[part] = style as any;\n  return zonedDateTime.toLocaleString(locale, options);\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 getTimezoneOffset(zonedDateTime: Temporal.ZonedDateTime): string {\n  const offsetNs = zonedDateTime.offsetNanoseconds;\n  const offsetMinutes = offsetNs / (60 * 1e9);\n  const sign = offsetMinutes >= 0 ? '+' : '-';\n  const absMinutes = Math.abs(offsetMinutes);\n  const hours = Math.floor(absMinutes / 60);\n  const minutes = absMinutes % 60;\n  return `${sign}${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;\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(new Date(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-BTXU3OGV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/subNanoseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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-BV32K227.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/startOfMonth.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 month.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the 1st day of the month at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const start = startOfMonth(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-01-15T15:30:00-05:00[America/New_York]');\n * const start = startOfMonth(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-01-15');\n * const start = startOfMonth(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-01-15');\n * const start = startOfMonth(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ day: 1 });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;AAmDO,SAAS,aACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;AAAA,EAC9B;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,KAAK,EAAE,CAAC;AAC9C,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/chunk-CCVPCHUO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isFuture.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isAfter } from './shared/isAfter';\nimport { nowZoned } from './shared/nowZoned';\n\n/**\n * Returns true if the given datetime is in the future.\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 after the current instant, false otherwise\n *\n * @example\n * ```ts\n * const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });\n * const yesterday = Temporal.Now.zonedDateTimeISO().subtract({ days: 1 });\n *\n * isFuture(tomorrow); // true\n * isFuture(yesterday); // false\n * ```\n *\n * @example\n * ```ts\n * // Works with Instant too\n * const futureInstant = Temporal.Now.instant().add({ hours: 1 });\n *\n * isFuture(futureInstant); // true\n * ```\n *\n * @example\n * ```ts\n * // Works with any timezone\n * const futureInTokyo = Temporal.ZonedDateTime.from('2100-01-01T00:00:00+09:00[Asia/Tokyo]');\n *\n * isFuture(futureInTokyo); // true\n * ```\n */\nexport function isFuture(\n  date: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned = normalizeTemporalInput(date);\n\n  return isAfter(zoned, nowZoned());\n}\n"],"mappings":";;;;;;;;;;;AAqCO,SAAS,SACd,MACS;AACT,QAAM,QAAQ,uBAAuB,IAAI;AAEzC,SAAO,QAAQ,OAAO,SAAS,CAAC;AAClC;","names":[]}

package/dist/chunk-CIA46DWB.js

@@ -1,17 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/differenceInMonths.ts
-function differenceInMonths(laterDate, earlierDate, options) {
-  const zoned1 = normalizeTemporalInput(laterDate);
-  const zoned2 = normalizeTemporalInput(earlierDate);
-  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
-  const precise = duration.total({ unit: "months", relativeTo: zoned2 });
-  return options?.fractional ? precise : Math.trunc(precise);
-}
-
-export {
-  differenceInMonths
-};
-//# sourceMappingURL=chunk-CIA46DWB.js.map

package/dist/chunk-CIA46DWB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInMonths.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 months between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * months with different numbers of days (28, 29, 30, or 31).\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of months 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-04-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInMonths(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-15T15:00:00-05:00[America/New_York]');\n *\n * differenceInMonths(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-02-05T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInMonths(later, earlier);                     // 0\n * differenceInMonths(later, earlier, { fractional: true }); // ~0.5\n * ```\n */\nexport function differenceInMonths(\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 duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'months', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;AA8CO,SAAS,mBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,UAAU,YAAY,OAAO,CAAC;AACrE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-CSOSM46M.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isSameSecond.ts"],"sourcesContent":["import type{ Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same second.\n * Compares the year, month, day, hour, minute, and second fields directly.\n * Ignores sub-second precision (milliseconds, microseconds, nanoseconds).\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same second, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same second\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999Z[UTC]');\n *\n * isSameSecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different seconds\n * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45Z[UTC]');\n * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46Z[UTC]');\n *\n * isSameSecond(sec45, sec46); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local seconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local seconds from each person's perspective\n * isSameSecond(ny, tokyo); // false (14:30:45 in NY, 04:30:45 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameSecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameSecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45 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.123Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.999Z');\n *\n * isSameSecond(instant1, instant2); // true (both 14:30:45 in UTC)\n * ```\n */\nexport function isSameSecond(\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  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,aACd,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;AAE7B;","names":[]}

package/dist/chunk-DCCHY45G.js

@@ -1,17 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/differenceInYears.ts
-function differenceInYears(laterDate, earlierDate, options) {
-  const zoned1 = normalizeTemporalInput(laterDate);
-  const zoned2 = normalizeTemporalInput(earlierDate);
-  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
-  const precise = duration.total({ unit: "years", relativeTo: zoned2 });
-  return options?.fractional ? precise : Math.trunc(precise);
-}
-
-export {
-  differenceInYears
-};
-//# sourceMappingURL=chunk-DCCHY45G.js.map

package/dist/chunk-DCCHY45G.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInYears.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 years between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * leap years (366 days) and regular years (365 days).\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of years between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2028-01-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2030-06-15T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-06-15T15:00:00-05:00[America/New_York]');\n *\n * differenceInYears(later, earlier); // 5\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInYears(later, earlier);                     // 0\n * differenceInYears(later, earlier, { fractional: true }); // ~0.5\n * ```\n */\nexport function differenceInYears(\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 duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'years', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;AA8CO,SAAS,kBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-DCFRBZBY.js

@@ -1,32 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-import {
-  Temporal
-} from "./chunk-R7ZCA6AQ.js";
-
-// src/eachYearOfInterval.ts
-function eachYearOfInterval(interval) {
-  const startZoned = normalizeTemporalInput(interval.start);
-  const endZoned = normalizeTemporalInput(interval.end);
-  const timezone = startZoned.timeZoneId;
-  const startYear = startZoned.year;
-  const endInTimezone = endZoned.withTimeZone(timezone);
-  const endYear = endInTimezone.year;
-  const years = [];
-  for (let year = startYear; year <= endYear; year++) {
-    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1 });
-    years.push(
-      firstOfYear.toZonedDateTime({
-        timeZone: timezone,
-        plainTime: new Temporal.PlainTime()
-      })
-    );
-  }
-  return years;
-}
-
-export {
-  eachYearOfInterval
-};
-//# sourceMappingURL=chunk-DCFRBZBY.js.map

package/dist/chunk-DCFRBZBY.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eachYearOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each year within the interval.\n * Each element represents the first moment of the year (January 1st at midnight).\n * The interval is inclusive of both start and end years.\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 year in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2022-06-15T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-03-20T14:00:00Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2022-01-01T00:00:00Z[UTC],\n * //   2023-01-01T00:00:00Z[UTC],\n * //   2024-01-01T00:00:00Z[UTC],\n * //   2025-01-01T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single year\n * const start = Temporal.ZonedDateTime.from('2025-01-15T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [2025-01-01T00:00:00Z[UTC]]\n * ```\n *\n * @example\n * ```ts\n * // With timezone\n * const start = Temporal.ZonedDateTime.from('2024-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2026-06-15T00:00:00-04:00[America/New_York]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2024-01-01T00:00:00-05:00[America/New_York],\n * //   2025-01-01T00:00:00-05:00[America/New_York],\n * //   2026-01-01T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n */\nexport function eachYearOfInterval(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  const startYear = startZoned.year;\n\n  // Get end year in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endYear = endInTimezone.year;\n\n  const years: Temporal.ZonedDateTime[] = [];\n\n  for (let year = startYear; year <= endYear; year++) {\n    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1 });\n    years.push(\n      firstOfYear.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n  }\n\n  return years;\n}\n"],"mappings":";;;;;;;;AAoDO,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAC5B,QAAM,YAAY,WAAW;AAG7B,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,UAAU,cAAc;AAE9B,QAAM,QAAkC,CAAC;AAEzC,WAAS,OAAO,WAAW,QAAQ,SAAS,QAAQ;AAClD,UAAM,cAAc,SAAS,UAAU,KAAK,EAAE,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC;AACtE,UAAM;AAAA,MACJ,YAAY,gBAAgB;AAAA,QAC1B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-DHFBKOFZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addHours.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of hours to a datetime.\n *\n * Properly handles DST transitions through Temporal API.\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 hours - Number of hours to add (can be negative to subtract)\n * @returns ZonedDateTime with hours 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 = addHours(instant, 3);\n * // 2025-01-20T15:00:00Z[UTC] (3 hours 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 = addHours(zoned, 24);\n * // 2025-01-21T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract hours\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addHours(instant, -5);\n * // 2025-01-20T07:00:00Z[UTC] (5 hours earlier)\n * ```\n */\nexport function addHours(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  hours: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ hours });\n}\n"],"mappings":";;;;;AAqCO,SAAS,SACd,OACA,OACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,MAAM,CAAC;AACpC;","names":[]}

package/dist/chunk-DMFV2AL7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/intlFormatDistance.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { differenceInDays } from './differenceInDays.js';\nimport { differenceInHours } from './differenceInHours.js';\nimport { differenceInMinutes } from './differenceInMinutes.js';\nimport { differenceInMonths } from './differenceInMonths.js';\nimport { differenceInSeconds } from './differenceInSeconds.js';\nimport { differenceInWeeks } from './differenceInWeeks.js';\nimport { differenceInYears } from './differenceInYears.js';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput.js';\n\nexport interface IntlFormatDistanceOptions {\n  /**\n   * The unit to force formatting in. If not specified, the unit will be automatically selected.\n   */\n  unit?: Intl.RelativeTimeFormatUnit;\n  /**\n   * The locale to use for formatting. Defaults to the system locale.\n   */\n  locale?: string | string[];\n  /**\n   * The locale matching algorithm to use.\n   */\n  localeMatcher?: 'best fit' | 'lookup';\n  /**\n   * Whether to use numeric values always, or use special strings like \"yesterday\", \"tomorrow\", etc.\n   * Defaults to 'auto'.\n   */\n  numeric?: 'always' | 'auto';\n  /**\n   * The formatting style to use.\n   */\n  style?: 'long' | 'short' | 'narrow';\n}\n\n/**\n * Formats the distance between two dates as a human-readable, internationalized string.\n *\n * The function automatically picks the most appropriate unit based on the distance between dates.\n * For example, if the distance is a few hours, it returns \"in X hours\". If the distance is a few\n * months, it returns \"in X months\".\n *\n * You can force a specific unit using the `options.unit` parameter.\n *\n * @param laterDate - The later date to compare\n * @param earlierDate - The earlier date to compare with\n * @param options - Formatting options\n * @returns The formatted distance string\n *\n * @example\n * ```typescript\n * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');\n *\n * intlFormatDistance(later, earlier);\n * // => 'in 1 hour'\n *\n * intlFormatDistance(earlier, later);\n * // => '1 hour ago'\n * ```\n *\n * @example\n * ```typescript\n * // Force a specific unit\n * const later = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');\n *\n * intlFormatDistance(later, earlier, { unit: 'quarter' });\n * // => 'in 4 quarters'\n * ```\n *\n * @example\n * ```typescript\n * // Use a different locale\n * const later = Temporal.Instant.from('2024-01-01T12:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T11:00:00Z');\n *\n * intlFormatDistance(later, earlier, { locale: 'es' });\n * // => 'dentro de 1 hora'\n * ```\n *\n * @example\n * ```typescript\n * // Use numeric: 'always' to avoid special strings\n * const later = Temporal.Instant.from('2024-01-02T00:00:00Z');\n * const earlier = Temporal.Instant.from('2024-01-01T00:00:00Z');\n *\n * intlFormatDistance(later, earlier, { numeric: 'auto' });\n * // => 'tomorrow'\n *\n * intlFormatDistance(later, earlier, { numeric: 'always' });\n * // => 'in 1 day'\n * ```\n */\nexport function intlFormatDistance(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: IntlFormatDistanceOptions\n): string {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // Determine unit if not specified\n  let unit = options?.unit;\n  if (!unit) {\n    const absSeconds = Math.abs(differenceInSeconds(zoned1, zoned2));\n    const absMinutes = Math.abs(differenceInMinutes(zoned1, zoned2));\n    const absHours = Math.abs(differenceInHours(zoned1, zoned2));\n    // calendar units were fractional pre-2.x; sub-day units stay truncated so Math.round below is a no-op\n    const absDays = Math.abs(differenceInDays(zoned1, zoned2, { fractional: true }));\n    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2, { fractional: true }));\n    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2, { fractional: true }));\n\n    if (absSeconds < 60) {\n      unit = 'second';\n    } else if (absMinutes < 60) {\n      unit = 'minute';\n    } else if (absHours < 24) {\n      unit = 'hour';\n    } else if (absDays < 7) {\n      unit = 'day';\n    } else if (absWeeks < 4) {\n      unit = 'week';\n    } else if (absMonths < 12) {\n      unit = 'month';\n    } else {\n      unit = 'year';\n    }\n  }\n\n  // Calculate value for the selected unit\n  let value: number;\n  switch (unit) {\n    case 'second':\n      value = Math.round(differenceInSeconds(zoned1, zoned2));\n      break;\n    case 'minute':\n      value = Math.round(differenceInMinutes(zoned1, zoned2));\n      break;\n    case 'hour':\n      value = Math.round(differenceInHours(zoned1, zoned2));\n      break;\n    // calendar units were fractional pre-2.x; sub-day units stay truncated so Math.round is a no-op\n    case 'day':\n      value = Math.round(differenceInDays(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'week':\n      value = Math.round(differenceInWeeks(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'month':\n      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }));\n      break;\n    case 'quarter':\n      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }) / 3);\n      break;\n    case 'year':\n      value = Math.round(differenceInYears(zoned1, zoned2, { fractional: true }));\n      break;\n    default:\n      // For any other unit type, try to use it directly\n      value = Math.round(differenceInSeconds(zoned1, zoned2));\n  }\n\n  // Format using Intl.RelativeTimeFormat\n  const formatter = new Intl.RelativeTimeFormat(options?.locale, {\n    localeMatcher: options?.localeMatcher,\n    numeric: options?.numeric ?? 'auto',\n    style: options?.style,\n  });\n\n  return formatter.format(value, unit);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6FO,SAAS,mBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,MAAI,OAAO,SAAS;AACpB,MAAI,CAAC,MAAM;AACT,UAAM,aAAa,KAAK,IAAI,oBAAoB,QAAQ,MAAM,CAAC;AAC/D,UAAM,aAAa,KAAK,IAAI,oBAAoB,QAAQ,MAAM,CAAC;AAC/D,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,MAAM,CAAC;AAE3D,UAAM,UAAU,KAAK,IAAI,iBAAiB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC/E,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AACjF,UAAM,YAAY,KAAK,IAAI,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAEnF,QAAI,aAAa,IAAI;AACnB,aAAO;AAAA,IACT,WAAW,aAAa,IAAI;AAC1B,aAAO;AAAA,IACT,WAAW,WAAW,IAAI;AACxB,aAAO;AAAA,IACT,WAAW,UAAU,GAAG;AACtB,aAAO;AAAA,IACT,WAAW,WAAW,GAAG;AACvB,aAAO;AAAA,IACT,WAAW,YAAY,IAAI;AACzB,aAAO;AAAA,IACT,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI;AACJ,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AACtD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AACtD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,MAAM,CAAC;AACpD;AAAA;AAAA,IAEF,KAAK;AACH,cAAQ,KAAK,MAAM,iBAAiB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AACzE;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC1E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC3E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,IAAI,CAAC;AAC/E;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,QAAQ,EAAE,YAAY,KAAK,CAAC,CAAC;AAC1E;AAAA,IACF;AAEE,cAAQ,KAAK,MAAM,oBAAoB,QAAQ,MAAM,CAAC;AAAA,EAC1D;AAGA,QAAM,YAAY,IAAI,KAAK,mBAAmB,SAAS,QAAQ;AAAA,IAC7D,eAAe,SAAS;AAAA,IACxB,SAAS,SAAS,WAAW;AAAA,IAC7B,OAAO,SAAS;AAAA,EAClB,CAAC;AAED,SAAO,UAAU,OAAO,OAAO,IAAI;AACrC;","names":[]}

package/dist/chunk-EBVLBLR3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInSeconds.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\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 *\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 precise = differenceInMilliseconds(zoned1, zoned2) / 1000;\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,UAAU,yBAAyB,QAAQ,MAAM,IAAI;AAC3D,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-EMZFQEWM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInMinutes.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { differenceInMilliseconds } from './shared/differenceInMilliseconds';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Returns the number of minutes between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\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 minutes 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:45:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:30:00Z');\n *\n * differenceInMinutes(later, earlier); // 15\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-20T16: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 * differenceInMinutes(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 * differenceInMinutes(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInMinutes(\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 precise = differenceInMilliseconds(zoned1, zoned2) / 60000;\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AAwCO,SAAS,oBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,UAAU,yBAAyB,QAAQ,MAAM,IAAI;AAC3D,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-EU3SYJHM.js

@@ -1,17 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/differenceInDays.ts
-function differenceInDays(laterDate, earlierDate, options) {
-  const zoned1 = normalizeTemporalInput(laterDate);
-  const zoned2 = normalizeTemporalInput(earlierDate);
-  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
-  const precise = duration.total({ unit: "days", relativeTo: zoned2 });
-  return options?.fractional ? precise : Math.trunc(precise);
-}
-
-export {
-  differenceInDays
-};
-//# sourceMappingURL=chunk-EU3SYJHM.js.map

package/dist/chunk-EU3SYJHM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInDays.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 days between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * DST transitions where days can be 23, 24, or 25 hours long.\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of 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.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 duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'days', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;AA6CO,SAAS,iBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,QAAQ,YAAY,OAAO,CAAC;AACnE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-EVEMK2K2.js

@@ -1,13 +0,0 @@
-import {
-  Temporal
-} from "./chunk-R7ZCA6AQ.js";
-
-// src/shared/isBefore.ts
-function isBefore(date1, date2) {
-  return Temporal.ZonedDateTime.compare(date1, date2) < 0;
-}
-
-export {
-  isBefore
-};
-//# sourceMappingURL=chunk-EVEMK2K2.js.map

package/dist/chunk-EVEMK2K2.js.map

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

package/dist/chunk-FCJO72WG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addMilliseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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.500Z[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.250Z[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-G2U5WGRP.js

@@ -1,14 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/addDays.ts
-function addDays(input, days) {
-  const zonedDateTime = normalizeTemporalInput(input);
-  return zonedDateTime.add({ days });
-}
-
-export {
-  addDays
-};
-//# sourceMappingURL=chunk-G2U5WGRP.js.map

package/dist/chunk-G2U5WGRP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addDays.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of days to a datetime.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\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 days - Number of days to add (can be negative to subtract)\n * @returns ZonedDateTime with days 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 = addDays(instant, 5);\n * // 2025-01-25T12:00:00Z[UTC] (5 days 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 = addDays(zoned, 10);\n * // 2025-01-30T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract days\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addDays(instant, -7);\n * // 2025-01-13T12:00:00Z[UTC] (7 days earlier)\n * ```\n */\nexport function addDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ days });\n}\n"],"mappings":";;;;;AAqCO,SAAS,QACd,OACA,MACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,KAAK,CAAC;AACnC;","names":[]}

package/dist/chunk-GR7322AQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/getQuarter.ts"],"sourcesContent":["import type { Temporal } from \"@js-temporal/polyfill\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterOfMonth } from \"./shared/quarter\";\n\n/**\n * Returns the quarter (1-4) that a datetime or date falls in.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * A quarter is intrinsic to the calendar date, so no timezone is ever needed.\n * `Instant` inputs are interpreted in UTC; `ZonedDateTime` inputs use their own\n * timezone; `PlainDate` inputs use their calendar month directly.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @returns The quarter number: 1, 2, 3, or 4\n *\n * @example\n * ```ts\n * getQuarter(Temporal.Instant.from('2025-05-15T12:00:00Z'));   // 2\n * getQuarter(Temporal.PlainDate.from('2025-11-15'));           // 4\n * ```\n */\nexport function getQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n): 1 | 2 | 3 | 4 {\n  const month = isPlainDate(input) ? input.month : normalizeTemporalInput(input).month;\n  return quarterOfMonth(month);\n}\n"],"mappings":";;;;;;;;;;;AAuBO,SAAS,WACd,OACe;AACf,QAAM,QAAQ,YAAY,KAAK,IAAI,MAAM,QAAQ,uBAAuB,KAAK,EAAE;AAC/E,SAAO,eAAe,KAAK;AAC7B;","names":[]}

package/dist/chunk-H5BHFVEN.js.map

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

package/dist/chunk-IAXVREU5.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/roundToNearestMinute.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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-JBM7DESQ.js

@@ -1,13 +0,0 @@
-import {
-  addDays
-} from "./chunk-G2U5WGRP.js";
-
-// src/subDays.ts
-function subDays(input, days) {
-  return addDays(input, -days);
-}
-
-export {
-  subDays
-};
-//# sourceMappingURL=chunk-JBM7DESQ.js.map

package/dist/chunk-JBM7DESQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/subDays.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addDays } from './addDays';\n\n/**\n * Subtracts the specified number of days from a datetime.\n *\n * This is a convenience wrapper around addDays with negated value.\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param days - Number of days to subtract\n * @returns ZonedDateTime with days subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-25T12:00:00Z');\n * const result = subDays(instant, 5);\n * // 2025-01-20T12:00:00Z[UTC] (5 days earlier)\n * ```\n */\nexport function subDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime {\n  return addDays(input, -days);\n}\n"],"mappings":";;;;;AAoBO,SAAS,QACd,OACA,MACwB;AACxB,SAAO,QAAQ,OAAO,CAAC,IAAI;AAC7B;","names":[]}

package/dist/chunk-JK4WDDWU.js

@@ -1,28 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-import {
-  Temporal
-} from "./chunk-R7ZCA6AQ.js";
-
-// src/eachHourOfInterval.ts
-function eachHourOfInterval(interval) {
-  const startZoned = normalizeTemporalInput(interval.start);
-  const endZoned = normalizeTemporalInput(interval.end);
-  const timezone = startZoned.timeZoneId;
-  const startHour = startZoned.round({ smallestUnit: "hour", roundingMode: "floor" });
-  const endInTimezone = endZoned.withTimeZone(timezone);
-  const endHour = endInTimezone.round({ smallestUnit: "hour", roundingMode: "floor" });
-  const hours = [];
-  let current = startHour;
-  while (Temporal.ZonedDateTime.compare(current, endHour) <= 0) {
-    hours.push(current);
-    current = current.add({ hours: 1 });
-  }
-  return hours;
-}
-
-export {
-  eachHourOfInterval
-};
-//# sourceMappingURL=chunk-JK4WDDWU.js.map

package/dist/chunk-JK4WDDWU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eachHourOfInterval.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns an array of ZonedDateTime objects for each hour within the interval.\n * Each element represents the start of the hour (minute/second/etc. set to 0).\n * The interval is inclusive of both start and end hours.\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 * Note: During DST transitions, some hours may be skipped (spring forward) or\n * the array may contain fewer/more hours than expected based on wall-clock time.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each hour 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-06T14:15:00Z[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T10:00:00Z[UTC],\n * //   2025-01-06T11:00:00Z[UTC],\n * //   2025-01-06T12:00:00Z[UTC],\n * //   2025-01-06T13:00:00Z[UTC],\n * //   2025-01-06T14:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Cross-day boundary\n * const start = Temporal.ZonedDateTime.from('2025-01-06T22:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-07T02:00:00Z[UTC]');\n *\n * const hours = eachHourOfInterval({ start, end });\n * // [\n * //   2025-01-06T22:00:00Z[UTC],\n * //   2025-01-06T23:00:00Z[UTC],\n * //   2025-01-07T00:00:00Z[UTC],\n * //   2025-01-07T01:00:00Z[UTC],\n * //   2025-01-07T02:00:00Z[UTC]\n * // ]\n * ```\n */\nexport function eachHourOfInterval(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 hour\n  const startHour = startZoned.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n\n  // Get start of the ending hour in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone);\n  const endHour = endInTimezone.round({ smallestUnit: 'hour', roundingMode: 'floor' });\n\n  const hours: Temporal.ZonedDateTime[] = [];\n  let current = startHour;\n\n  while (Temporal.ZonedDateTime.compare(current, endHour) <= 0) {\n    hours.push(current);\n    current = current.add({ hours: 1 });\n  }\n\n  return hours;\n}\n"],"mappings":";;;;;;;;AAgDO,SAAS,mBAAmB,UAGN;AAC3B,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AAEpD,QAAM,WAAW,WAAW;AAG5B,QAAM,YAAY,WAAW,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAGlF,QAAM,gBAAgB,SAAS,aAAa,QAAQ;AACpD,QAAM,UAAU,cAAc,MAAM,EAAE,cAAc,QAAQ,cAAc,QAAQ,CAAC;AAEnF,QAAM,QAAkC,CAAC;AACzC,MAAI,UAAU;AAEd,SAAO,SAAS,cAAc,QAAQ,SAAS,OAAO,KAAK,GAAG;AAC5D,UAAM,KAAK,OAAO;AAClB,cAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-JQFD563S.js.map

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

package/dist/chunk-KGO3G2QB.js

@@ -1,18 +0,0 @@
-import {
-  isBefore
-} from "./chunk-EVEMK2K2.js";
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/isBefore.ts
-function isBefore2(date1, date2) {
-  const zoned1 = normalizeTemporalInput(date1);
-  const zoned2 = normalizeTemporalInput(date2);
-  return isBefore(zoned1, zoned2);
-}
-
-export {
-  isBefore2 as isBefore
-};
-//# sourceMappingURL=chunk-KGO3G2QB.js.map

package/dist/chunk-KGO3G2QB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/isBefore.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { isBefore as isBeforeInternal } from './shared/isBefore';\n\n/**\n * Returns true if the first datetime is before the second datetime.\n * Compares by the underlying instant (epoch time), not by calendar date/time.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if date1 is before 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 * isBefore(earlier, later); // true\n * isBefore(later, earlier); // false\n * isBefore(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 * isBefore(instant1, instant2); // 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 * isBefore(ny, tokyo); // true\n * // NY 10:00 is 15:00 UTC, Tokyo 00:00 is 15:00 UTC the previous day\n * ```\n */\nexport function isBefore(\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 isBeforeInternal(zoned1, zoned2);\n}\n"],"mappings":";;;;;;;;AAyCO,SAASA,UACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,SAAiB,QAAQ,MAAM;AACxC;","names":["isBefore"]}

package/dist/chunk-KPB5ENNM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInQuarters.ts"],"sourcesContent":["import type { Temporal } from \"@js-temporal/polyfill\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { differenceInMonths } from \"./differenceInMonths\";\nimport type { DifferenceOptions } from \"./shared/differenceOptions\";\n\n/**\n * Returns the number of quarters (3-month blocks) between two datetimes or dates.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * Uses calendar-aware, elapsed-time calculation (a quarter is three months).\n * Instant inputs are converted to UTC; ZonedDateTime inputs keep their timezone.\n * PlainDate inputs are compared directly — no timezone needed.\n *\n * @param laterDate - The later Instant or ZonedDateTime\n * @param earlierDate - The earlier Instant or ZonedDateTime\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of quarters, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * differenceInQuarters(later, earlier); // 2\n * ```\n *\n * @example\n * ```ts\n * // PlainDate comparison needs no timezone\n * const later = Temporal.PlainDate.from('2025-07-20');\n * const earlier = Temporal.PlainDate.from('2025-01-20');\n * differenceInQuarters(later, earlier); // 2\n * ```\n */\nexport function differenceInQuarters(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions,\n): number;\nexport function differenceInQuarters(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions,\n): number;\nexport function differenceInQuarters(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: DifferenceOptions,\n): number {\n  // A quarter is three months, so work in elapsed months and divide by 3.\n  const months =\n    isPlainDate(laterDate) && isPlainDate(earlierDate)\n      ? earlierDate.until(laterDate).total({\n          unit: \"months\",\n          relativeTo: earlierDate,\n        })\n      : differenceInMonths(\n          laterDate as Temporal.Instant | Temporal.ZonedDateTime,\n          earlierDate as Temporal.Instant | Temporal.ZonedDateTime,\n          { fractional: true },\n        );\n\n  const quarters = months / 3;\n  return options?.fractional ? quarters : Math.trunc(quarters);\n}\n"],"mappings":";;;;;;;;AA2CO,SAAS,qBACd,WACA,aACA,SACQ;AAER,QAAM,SACJ,YAAY,SAAS,KAAK,YAAY,WAAW,IAC7C,YAAY,MAAM,SAAS,EAAE,MAAM;AAAA,IACjC,MAAM;AAAA,IACN,YAAY;AAAA,EACd,CAAC,IACD;AAAA,IACE;AAAA,IACA;AAAA,IACA,EAAE,YAAY,KAAK;AAAA,EACrB;AAEN,QAAM,WAAW,SAAS;AAC1B,SAAO,SAAS,aAAa,WAAW,KAAK,MAAM,QAAQ;AAC7D;","names":[]}

package/dist/chunk-LAITZAIG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addSeconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\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:45Z[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:30Z[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-LODULPI3.js

@@ -1,17 +0,0 @@
-import {
-  normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
-
-// src/differenceInWeeks.ts
-function differenceInWeeks(laterDate, earlierDate, options) {
-  const zoned1 = normalizeTemporalInput(laterDate);
-  const zoned2 = normalizeTemporalInput(earlierDate);
-  const duration = zoned2.until(zoned1, { largestUnit: "hours" });
-  const precise = duration.total({ unit: "weeks", relativeTo: zoned2 });
-  return options?.fractional ? precise : Math.trunc(precise);
-}
-
-export {
-  differenceInWeeks
-};
-//# sourceMappingURL=chunk-LODULPI3.js.map

package/dist/chunk-LODULPI3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/differenceInWeeks.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 weeks between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n *\n * This function uses calendar-aware calculation, which means it properly handles\n * DST transitions and calendar weeks.\n *\n * Instant inputs are converted to UTC for calendar calculations.\n * For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of weeks between the dates, truncated toward zero (pass { fractional: true } for the precise value)\n *\n * @example\n * ```ts\n * const later = Temporal.Instant.from('2025-02-10T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-02-10T15:00:00-05:00[America/New_York]');\n * const earlier = Temporal.ZonedDateTime.from('2025-01-20T15:00:00-05:00[America/New_York]');\n *\n * differenceInWeeks(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Pass { fractional: true } for partial-unit precision\n * const later = Temporal.Instant.from('2025-01-27T12:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T12:00:00Z');\n *\n * differenceInWeeks(later, earlier); // 1\n * ```\n */\nexport function differenceInWeeks(\n  laterDate: Temporal.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 duration = zoned2.until(zoned1, { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'weeks', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;AA6CO,SAAS,kBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,WAAW,OAAO,MAAM,QAAQ,EAAE,aAAa,QAAQ,CAAC;AAC9D,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":[]}

package/dist/chunk-LSKER4FN.js

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

package/dist/chunk-LSKER4FN.js.map

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

package/dist/chunk-M7Y67IAB.js.map

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

package/dist/chunk-MDXN3WMH.js

@@ -1,13 +0,0 @@
-import {
-  addWeeks
-} from "./chunk-ZG4ROOWI.js";
-
-// src/subWeeks.ts
-function subWeeks(input, weeks) {
-  return addWeeks(input, -weeks);
-}
-
-export {
-  subWeeks
-};
-//# sourceMappingURL=chunk-MDXN3WMH.js.map