@gobrand/tiempo 3.1.3 → 3.2.1

package/dist/{chunk-ZW32E6EJ.js.map → chunk-QKIREPRK.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/intlFormatDistance.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\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":[]}
+{"version":3,"sources":["../src/intlFormatDistance.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\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-LMOAA73F.js → chunk-QPE2V3MY.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/differenceInYears.ts
 function differenceInYears(laterDate, earlierDate, options) {
@@ -25,4 +25,4 @@ function differenceInYears(laterDate, earlierDate, options) {
 export {
   differenceInYears
 };
-//# sourceMappingURL=chunk-LMOAA73F.js.map
+//# sourceMappingURL=chunk-QPE2V3MY.js.map

package/dist/{chunk-2AID4P2C.js → chunk-R6CQ6XSS.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/shared/plainDateToZonedDateTime.ts
 function plainDateToZonedDateTime(date, timezone) {
@@ -13,4 +13,4 @@ function plainDateToZonedDateTime(date, timezone) {
 export {
   plainDateToZonedDateTime
 };
-//# sourceMappingURL=chunk-2AID4P2C.js.map
+//# sourceMappingURL=chunk-R6CQ6XSS.js.map

package/dist/{chunk-2AID4P2C.js.map → chunk-R6CQ6XSS.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/shared/plainDateToZonedDateTime.ts"],"sourcesContent":["import { Temporal } from './temporal';\nimport type { Timezone } from '../types';\n\n/**\n * @internal\n * Converts a PlainDate to a ZonedDateTime at midnight in the specified timezone.\n * This is an internal helper - do not use directly.\n */\nexport function plainDateToZonedDateTime(\n  date: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime {\n  return date.toZonedDateTime({\n    timeZone: timezone,\n    plainTime: Temporal.PlainTime.from('00:00'),\n  });\n}\n"],"mappings":";;;;;AAQO,SAAS,yBACd,MACA,UACwB;AACxB,SAAO,KAAK,gBAAgB;AAAA,IAC1B,UAAU;AAAA,IACV,WAAW,SAAS,UAAU,KAAK,OAAO;AAAA,EAC5C,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../src/shared/plainDateToZonedDateTime.ts"],"sourcesContent":["import { Temporal } from './temporal';\nimport type { Timezone } from '../types';\n\n/**\n * @internal\n * Converts a PlainDate to a ZonedDateTime at midnight in the specified timezone.\n * This is an internal helper - do not use directly.\n */\nexport function plainDateToZonedDateTime(\n  date: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime {\n  return date.toZonedDateTime({\n    timeZone: timezone,\n    plainTime: Temporal.PlainTime.from('00:00')\n  });\n}\n"],"mappings":";;;;;AAQO,SAAS,yBACd,MACA,UACwB;AACxB,SAAO,KAAK,gBAAgB;AAAA,IAC1B,UAAU;AAAA,IACV,WAAW,SAAS,UAAU,KAAK,OAAO;AAAA,EAC5C,CAAC;AACH;","names":[]}

package/dist/{chunk-6QH4NCPA.js → chunk-RCX6YW4I.js}

@@ -1,6 +1,6 @@
 import {
   addMilliseconds
-} from "./chunk-AUOZACFS.js";
+} from "./chunk-KISBF5GX.js";
 
 // src/subMilliseconds.ts
 function subMilliseconds(input, milliseconds) {
@@ -10,4 +10,4 @@ function subMilliseconds(input, milliseconds) {
 export {
   subMilliseconds
 };
-//# sourceMappingURL=chunk-6QH4NCPA.js.map
+//# sourceMappingURL=chunk-RCX6YW4I.js.map

package/dist/{chunk-EAO2SO4N.js → chunk-RFUXK65B.js}

@@ -1,6 +1,6 @@
 import {
   addMinutes
-} from "./chunk-GXSVYUCG.js";
+} from "./chunk-GZKKAIXF.js";
 
 // src/subMinutes.ts
 function subMinutes(input, minutes) {
@@ -10,4 +10,4 @@ function subMinutes(input, minutes) {
 export {
   subMinutes
 };
-//# sourceMappingURL=chunk-EAO2SO4N.js.map
+//# sourceMappingURL=chunk-RFUXK65B.js.map

package/dist/chunk-RMVIA3NK.js

@@ -0,0 +1,19 @@
+import {
+  quarterOfMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  calendarDates
+} from "./chunk-HXB6CDB4.js";
+
+// src/differenceInCalendarQuarters.ts
+function differenceInCalendarQuarters(laterDate, earlierDate) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate).map(
+    (date) => date.withCalendar("iso8601")
+  );
+  return (later.year - earlier.year) * 4 + quarterOfMonth(later.month) - quarterOfMonth(earlier.month);
+}
+
+export {
+  differenceInCalendarQuarters
+};
+//# sourceMappingURL=chunk-RMVIA3NK.js.map

package/dist/chunk-RMVIA3NK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarQuarters.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\nimport { quarterOfMonth } from './shared/quarter';\n\n/**\n * Returns the number of calendar quarters between two dates, ignoring the\n * position within the quarter. Quarters follow ISO months: Q1 is January–March.\n *\n * PlainDate inputs are compared as given. Instant inputs use their UTC date and\n * ZonedDateTime inputs use the date in their own timezone; convert both to one\n * timezone first to count from a single point of view. Mixing a PlainDate with\n * an Instant or ZonedDateTime throws a TypeError.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @returns Calendar quarters from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const endOfQ1 = Temporal.PlainDate.from('2025-03-31');\n * const startOfQ2 = Temporal.PlainDate.from('2025-04-01');\n *\n * differenceInCalendarQuarters(startOfQ2, endOfQ1); // 1\n * differenceInQuarters(startOfQ2, endOfQ1); // 0\n * ```\n */\nexport function differenceInCalendarQuarters(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarQuarters(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarQuarters(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): number {\n  const [later, earlier] = calendarDates(laterDate, earlierDate).map((date) =>\n    date.withCalendar('iso8601')\n  ) as [Temporal.PlainDate, Temporal.PlainDate];\n  return (\n    (later.year - earlier.year) * 4 + quarterOfMonth(later.month) - quarterOfMonth(earlier.month)\n  );\n}\n"],"mappings":";;;;;;;;AAkCO,SAAS,6BACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW,EAAE;AAAA,IAAI,CAAC,SAClE,KAAK,aAAa,SAAS;AAAA,EAC7B;AACA,UACG,MAAM,OAAO,QAAQ,QAAQ,IAAI,eAAe,MAAM,KAAK,IAAI,eAAe,QAAQ,KAAK;AAEhG;","names":[]}

package/dist/chunk-S5CDK44R.js

@@ -0,0 +1,22 @@
+import {
+  addBusinessDaysSkipping
+} from "./chunk-QFQHFBN4.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-UTM7YAT4.js";
+import {
+  isPlainDate
+} from "./chunk-M4ESIRFH.js";
+
+// src/addBusinessDays.ts
+function addBusinessDays(input, days, holidays = []) {
+  if (isPlainDate(input)) {
+    return addBusinessDaysSkipping(input, days, holidays);
+  }
+  return addBusinessDaysSkipping(normalizeTemporalInput(input), days, holidays);
+}
+
+export {
+  addBusinessDays
+};
+//# sourceMappingURL=chunk-S5CDK44R.js.map

package/dist/chunk-S5CDK44R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { addBusinessDaysSkipping } from './shared/businessDays';\n\n/**\n * Adds business days (Monday–Friday), skipping weekends and any holidays you pass.\n *\n * Starting on a weekend, the first business day counted is the next Monday\n * (or the previous Friday for negative values). Adding 0 returns the input's\n * date unchanged, even on a weekend.\n *\n * Instant inputs are converted to UTC. ZonedDateTime inputs keep their\n * timezone and time of day. PlainDate inputs stay dates.\n *\n * @param input - An Instant (UTC), ZonedDateTime, or PlainDate\n * @param days - Whole business days to add (negative to subtract)\n * @param holidays - Dates that are not business days. For Instant and ZonedDateTime\n *   inputs they are matched against the input's own date (UTC for Instant).\n * @returns PlainDate for a date input; otherwise ZonedDateTime\n * @throws RangeError if days is not an integer\n *\n * @example\n * ```ts\n * const friday = Temporal.PlainDate.from('2025-01-24');\n *\n * addBusinessDays(friday, 1); // 2025-01-27 (Monday)\n * addBusinessDays(friday, 5); // 2025-01-31 (Friday)\n * ```\n *\n * @example\n * ```ts\n * // Skip holidays too\n * const christmasEve = Temporal.PlainDate.from('2025-12-24');\n * const holidays = [Temporal.PlainDate.from('2025-12-25'), Temporal.PlainDate.from('2025-12-26')];\n *\n * addBusinessDays(christmasEve, 1, holidays).toString(); // \"2025-12-29\"\n * ```\n */\nexport function addBusinessDays(\n  input: Temporal.PlainDate,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.PlainDate;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number,\n  holidays?: readonly Temporal.PlainDate[]\n): Temporal.ZonedDateTime;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number,\n  holidays: readonly Temporal.PlainDate[] = []\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return addBusinessDaysSkipping(input, days, holidays);\n  }\n  return addBusinessDaysSkipping(normalizeTemporalInput(input), days, holidays);\n}\n"],"mappings":";;;;;;;;;;;AAgDO,SAAS,gBACd,OACA,MACA,WAA0C,CAAC,GACE;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,wBAAwB,OAAO,MAAM,QAAQ;AAAA,EACtD;AACA,SAAO,wBAAwB,uBAAuB,KAAK,GAAG,MAAM,QAAQ;AAC9E;","names":[]}

package/dist/{chunk-GU3CZAIN.js → chunk-SKHUBXIN.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/differenceInHours.ts
 function differenceInHours(laterDate, earlierDate, options) {
@@ -13,4 +13,4 @@ function differenceInHours(laterDate, earlierDate, options) {
 export {
   differenceInHours
 };
-//# sourceMappingURL=chunk-GU3CZAIN.js.map
+//# sourceMappingURL=chunk-SKHUBXIN.js.map

package/dist/chunk-SURP2NUP.js

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

package/dist/chunk-SURP2NUP.js.map

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

package/dist/chunk-TH6YVPP4.js

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

package/dist/chunk-TH6YVPP4.js.map

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

package/dist/{chunk-V2NSN6ET.js → chunk-TP3VDQLF.js}

@@ -1,6 +1,6 @@
 import {
   compare
-} from "./chunk-OMYVTYHI.js";
+} from "./chunk-DAWWOF5W.js";
 
 // src/isEqual.ts
 function isEqual(date1, date2) {
@@ -10,4 +10,4 @@ function isEqual(date1, date2) {
 export {
   isEqual
 };
-//# sourceMappingURL=chunk-V2NSN6ET.js.map
+//# sourceMappingURL=chunk-TP3VDQLF.js.map

package/dist/{chunk-3X2U6I44.js → chunk-TZ4NUY3W.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/addWeeks.ts
 function addWeeks(input, weeks) {
@@ -16,4 +16,4 @@ function addWeeks(input, weeks) {
 export {
   addWeeks
 };
-//# sourceMappingURL=chunk-3X2U6I44.js.map
+//# sourceMappingURL=chunk-TZ4NUY3W.js.map

package/dist/{chunk-6QOLNYFY.js → chunk-UB3F342R.js}

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

package/dist/chunk-UB3F342R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/roundToNearestMinute.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Options for rounding to nearest minute.\n */\nexport interface RoundToNearestMinuteOptions {\n  /**\n   * The rounding mode to use.\n   *\n   * Given time 14:37:20:\n   * - `'round'` → 14:37 (20 sec < 30, rounds DOWN to nearest)\n   * - `'ceil'`  → 14:38 (always rounds UP to next minute)\n   * - `'floor'` → 14:37 (always rounds DOWN to current minute)\n   *\n   * Given time 14:37:00 with nearestTo: 15:\n   * - `'round'` → 14:30 (37 is closer to 30 than 45)\n   * - `'ceil'`  → 14:45 (always rounds UP to next 15-min slot)\n   * - `'floor'` → 14:30 (always rounds DOWN to current 15-min slot)\n   *\n   * @default 'round'\n   */\n  mode?: 'round' | 'ceil' | 'floor';\n  /**\n   * Round to the nearest N minutes. Must divide evenly into 60.\n   * Valid values: 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30\n   * @example nearestTo: 15 rounds to quarter-hour marks (00, 15, 30, 45)\n   */\n  nearestTo?: 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30;\n}\n\nconst MODE_TO_ROUNDING_MODE = {\n  round: 'halfExpand',\n  ceil: 'ceil',\n  floor: 'floor'\n} as const;\n\n/**\n * Rounds a datetime to the nearest minute boundary.\n *\n * ## Mode comparison (given 14:37 with 15-min slots)\n *\n * ```\n * 14:30 ─────────●───────────────────── 14:45\n *              14:37\n *\n * 'round' → 14:30  (nearest slot - 37 is closer to 30 than 45)\n * 'ceil'  → 14:45  (next slot - always up)\n * 'floor' → 14:30  (current slot - always down)\n * ```\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param options - Rounding options\n * @returns ZonedDateTime rounded to the minute boundary\n *\n * @example\n * ```ts\n * // 15-minute booking slots at 14:37\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:00[America/New_York]');\n *\n * roundToNearestMinute(time, { nearestTo: 15 });                    // → 14:30 (nearest)\n * roundToNearestMinute(time, { mode: 'ceil', nearestTo: 15 });      // → 14:45 (next slot)\n * roundToNearestMinute(time, { mode: 'floor', nearestTo: 15 });     // → 14:30 (current slot)\n * ```\n *\n * @example\n * ```ts\n * // Basic minute rounding (no slots)\n * const time = Temporal.ZonedDateTime.from('2025-01-20T14:37:42[America/New_York]');\n *\n * roundToNearestMinute(time);                     // → 14:38 (42 sec >= 30)\n * roundToNearestMinute(time, { mode: 'ceil' });   // → 14:38 (always up)\n * roundToNearestMinute(time, { mode: 'floor' });  // → 14:37 (always down)\n * ```\n *\n * @example\n * ```ts\n * // Billing: round up to 30-minute increments\n * const sessionEnd = Temporal.ZonedDateTime.from('2025-01-20T11:07:00[America/New_York]');\n * roundToNearestMinute(sessionEnd, { mode: 'ceil', nearestTo: 30 });\n * // → 11:30 (bill for 30 mins even though session was 7 mins)\n * ```\n */\nexport function roundToNearestMinute(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: RoundToNearestMinuteOptions\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  const mode = options?.mode ?? 'round';\n  const nearestTo = options?.nearestTo ?? 1;\n\n  return zonedDateTime.round({\n    smallestUnit: 'minute',\n    roundingMode: MODE_TO_ROUNDING_MODE[mode],\n    roundingIncrement: nearestTo\n  });\n}\n"],"mappings":";;;;;AA+BA,IAAM,wBAAwB;AAAA,EAC5B,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AACT;AAgDO,SAAS,qBACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,QAAM,OAAO,SAAS,QAAQ;AAC9B,QAAM,YAAY,SAAS,aAAa;AAExC,SAAO,cAAc,MAAM;AAAA,IACzB,cAAc;AAAA,IACd,cAAc,sBAAsB,IAAI;AAAA,IACxC,mBAAmB;AAAA,EACrB,CAAC;AACH;","names":[]}

package/dist/{chunk-YSDLXJHE.js → chunk-UIOLC7XM.js}

@@ -1,6 +1,6 @@
 import {
   compare
-} from "./chunk-OMYVTYHI.js";
+} from "./chunk-DAWWOF5W.js";
 
 // src/min.ts
 function min(values) {
@@ -13,4 +13,4 @@ function min(values) {
 export {
   min
 };
-//# sourceMappingURL=chunk-YSDLXJHE.js.map
+//# sourceMappingURL=chunk-UIOLC7XM.js.map

package/dist/{chunk-PAM6VJQM.js → chunk-UP5M7NHW.js}

@@ -1,9 +1,9 @@
 import {
   differenceInMonths
-} from "./chunk-KZCSP3DU.js";
+} from "./chunk-5YKAVRED.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/differenceInQuarters.ts
 function differenceInQuarters(laterDate, earlierDate, options) {
@@ -22,4 +22,4 @@ function differenceInQuarters(laterDate, earlierDate, options) {
 export {
   differenceInQuarters
 };
-//# sourceMappingURL=chunk-PAM6VJQM.js.map
+//# sourceMappingURL=chunk-UP5M7NHW.js.map

package/dist/chunk-UP5M7NHW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInQuarters.ts"],"sourcesContent":["import { type Temporal, 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  // Serialize the other date to preserve its calendar across implementations.\n  const months =\n    isPlainDate(laterDate) && isPlainDate(earlierDate)\n      ? earlierDate.until(laterDate.toString()).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":";;;;;;;;AA0CO,SAAS,qBACd,WACA,aACA,SACQ;AAGR,QAAM,SACJ,YAAY,SAAS,KAAK,YAAY,WAAW,IAC7C,YAAY,MAAM,UAAU,SAAS,CAAC,EAAE,MAAM;AAAA,IAC5C,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-UPWUAGEV.js

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

package/dist/chunk-UPWUAGEV.js.map

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

package/dist/{chunk-TI6WBLCB.js → chunk-UQ5GR6IX.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/addMicroseconds.ts
 function addMicroseconds(input, microseconds) {
@@ -11,4 +11,4 @@ function addMicroseconds(input, microseconds) {
 export {
   addMicroseconds
 };
-//# sourceMappingURL=chunk-TI6WBLCB.js.map
+//# sourceMappingURL=chunk-UQ5GR6IX.js.map

package/dist/{chunk-Q6QLOUXJ.js → chunk-UTM7YAT4.js}

@@ -1,7 +1,7 @@
 import {
   isInstant,
   isZonedDateTime
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/shared/normalizeTemporalInput.ts
 function normalizeTemporalInput(input) {
@@ -15,4 +15,4 @@ function normalizeTemporalInput(input) {
 export {
   normalizeTemporalInput
 };
-//# sourceMappingURL=chunk-Q6QLOUXJ.js.map
+//# sourceMappingURL=chunk-UTM7YAT4.js.map

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

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

package/dist/{chunk-HT6L4VRQ.js.map → chunk-UYHQBNQ4.js.map}

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

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

package/dist/{chunk-R2DCUSBY.js → chunk-WALS2M6Z.js}

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

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

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

package/dist/{chunk-3D4YR2SR.js → chunk-WVBZIXQP.js}

@@ -1,9 +1,9 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-TCB3IDJM.js";
+} from "./chunk-QCIY5PSJ.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/startOfMonth.ts
 function startOfMonth(input, timezone) {
@@ -18,4 +18,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-3D4YR2SR.js.map
+//# sourceMappingURL=chunk-WVBZIXQP.js.map

package/dist/{chunk-3D4YR2SR.js.map → chunk-WVBZIXQP.js.map}

@@ -1 +1 @@
-{"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:00+00:00[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":[]}
+{"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:00+00:00[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(input: Temporal.PlainDate, timezone: Timezone): 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":";;;;;;;;AAgDO,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-525OLFRD.js → chunk-WWCLSC2B.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 import {
   isPlainDate
-} from "./chunk-BSVOJYJ7.js";
+} from "./chunk-M4ESIRFH.js";
 
 // src/getQuarter.ts
 function getQuarter(input) {
@@ -17,4 +17,4 @@ function getQuarter(input) {
 export {
   getQuarter
 };
-//# sourceMappingURL=chunk-525OLFRD.js.map
+//# sourceMappingURL=chunk-WWCLSC2B.js.map

package/dist/chunk-WWCLSC2B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/getQuarter.ts"],"sourcesContent":["import { type Temporal, 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":";;;;;;;;;;;AAsBO,SAAS,WACd,OACe;AACf,QAAM,QAAQ,YAAY,KAAK,IAAI,MAAM,QAAQ,uBAAuB,KAAK,EAAE;AAC/E,SAAO,eAAe,KAAK;AAC7B;","names":[]}

package/dist/chunk-X4ULMQ53.js

@@ -0,0 +1,14 @@
+import {
+  calendarDates
+} from "./chunk-HXB6CDB4.js";
+
+// src/differenceInCalendarMonths.ts
+function differenceInCalendarMonths(laterDate, earlierDate) {
+  const [later, earlier] = calendarDates(laterDate, earlierDate);
+  return earlier.with({ day: 1 }).until(later.with({ day: 1 }), { largestUnit: "months" }).months;
+}
+
+export {
+  differenceInCalendarMonths
+};
+//# sourceMappingURL=chunk-X4ULMQ53.js.map

package/dist/chunk-X4ULMQ53.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInCalendarMonths.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { calendarDates } from './shared/calendarDates';\n\n/**\n * Returns the number of calendar months between two dates, ignoring the day of\n * the month. Unlike differenceInMonths, which counts complete months, January 31\n * to February 1 is one calendar month.\n *\n * PlainDate inputs are compared as given. Instant inputs use their UTC date and\n * ZonedDateTime inputs use the date in their own timezone; convert both to one\n * timezone first to count from a single point of view. Mixing a PlainDate with\n * an Instant or ZonedDateTime throws a TypeError.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @returns Calendar months from earlierDate to laterDate; negative if laterDate is earlier\n *\n * @example\n * ```ts\n * const jan31 = Temporal.PlainDate.from('2025-01-31');\n * const feb1 = Temporal.PlainDate.from('2025-02-01');\n *\n * differenceInCalendarMonths(feb1, jan31); // 1\n * differenceInMonths(feb1, jan31); // 0\n * ```\n */\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInCalendarMonths(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): number {\n  const [later, earlier] = calendarDates(laterDate, earlierDate);\n  return earlier.with({ day: 1 }).until(later.with({ day: 1 }), { largestUnit: 'months' }).months;\n}\n"],"mappings":";;;;;AAkCO,SAAS,2BACd,WACA,aACQ;AACR,QAAM,CAAC,OAAO,OAAO,IAAI,cAAc,WAAW,WAAW;AAC7D,SAAO,QAAQ,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,aAAa,SAAS,CAAC,EAAE;AAC3F;","names":[]}

package/dist/{chunk-OEPVYNB6.js → chunk-XD4JKMGT.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-Q6QLOUXJ.js";
+} from "./chunk-UTM7YAT4.js";
 
 // src/differenceInMinutes.ts
 function differenceInMinutes(laterDate, earlierDate, options) {
@@ -13,4 +13,4 @@ function differenceInMinutes(laterDate, earlierDate, options) {
 export {
   differenceInMinutes
 };
-//# sourceMappingURL=chunk-OEPVYNB6.js.map
+//# sourceMappingURL=chunk-XD4JKMGT.js.map