@gobrand/tiempo 2.8.1 → 2.9.1

package/dist/{chunk-5BYRBC7H.js → chunk-7EVZGEAI.js}

@@ -1,27 +1,27 @@
 import {
   differenceInMonths
-} from "./chunk-BIAPE4MR.js";
+} from "./chunk-OVFO6CZ7.js";
 import {
   differenceInSeconds
-} from "./chunk-QVOEXF46.js";
+} from "./chunk-TUOGC2TY.js";
 import {
   differenceInWeeks
-} from "./chunk-PVAOUYXF.js";
+} from "./chunk-EOXULNBC.js";
 import {
   differenceInYears
-} from "./chunk-CHW2EN2O.js";
+} from "./chunk-X3T7QMBA.js";
 import {
   differenceInDays
-} from "./chunk-6IP245MS.js";
+} from "./chunk-DC5JXNIC.js";
 import {
   differenceInHours
-} from "./chunk-PMJD5N5J.js";
+} from "./chunk-SGHPW77A.js";
 import {
   differenceInMinutes
-} from "./chunk-B2R2G5YK.js";
+} from "./chunk-XVAVCEKT.js";
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/intlFormatDistance.ts
 function intlFormatDistance(laterDate, earlierDate, options) {
@@ -32,9 +32,9 @@ function intlFormatDistance(laterDate, earlierDate, options) {
     const absSeconds = Math.abs(differenceInSeconds(zoned1, zoned2));
     const absMinutes = Math.abs(differenceInMinutes(zoned1, zoned2));
     const absHours = Math.abs(differenceInHours(zoned1, zoned2));
-    const absDays = Math.abs(differenceInDays(zoned1, zoned2));
-    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2));
-    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2));
+    const absDays = Math.abs(differenceInDays(zoned1, zoned2, { fractional: true }));
+    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2, { fractional: true }));
+    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2, { fractional: true }));
     if (absSeconds < 60) {
       unit = "second";
     } else if (absMinutes < 60) {
@@ -62,20 +62,21 @@ function intlFormatDistance(laterDate, earlierDate, options) {
     case "hour":
       value = Math.round(differenceInHours(zoned1, zoned2));
       break;
+    // calendar units were fractional pre-2.x; sub-day units stay truncated so Math.round is a no-op
     case "day":
-      value = Math.round(differenceInDays(zoned1, zoned2));
+      value = Math.round(differenceInDays(zoned1, zoned2, { fractional: true }));
       break;
     case "week":
-      value = Math.round(differenceInWeeks(zoned1, zoned2));
+      value = Math.round(differenceInWeeks(zoned1, zoned2, { fractional: true }));
       break;
     case "month":
-      value = Math.round(differenceInMonths(zoned1, zoned2));
+      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }));
       break;
     case "quarter":
-      value = Math.round(differenceInMonths(zoned1, zoned2) / 3);
+      value = Math.round(differenceInMonths(zoned1, zoned2, { fractional: true }) / 3);
       break;
     case "year":
-      value = Math.round(differenceInYears(zoned1, zoned2));
+      value = Math.round(differenceInYears(zoned1, zoned2, { fractional: true }));
       break;
     default:
       value = Math.round(differenceInSeconds(zoned1, zoned2));
@@ -91,4 +92,4 @@ function intlFormatDistance(laterDate, earlierDate, options) {
 export {
   intlFormatDistance
 };
-//# sourceMappingURL=chunk-5BYRBC7H.js.map
+//# sourceMappingURL=chunk-7EVZGEAI.js.map

package/dist/{chunk-5BYRBC7H.js.map → chunk-7EVZGEAI.js.map}

@@ -1 +1 @@
-{"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    const absDays = Math.abs(differenceInDays(zoned1, zoned2));\n    const absWeeks = Math.abs(differenceInWeeks(zoned1, zoned2));\n    const absMonths = Math.abs(differenceInMonths(zoned1, zoned2));\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    case 'day':\n      value = Math.round(differenceInDays(zoned1, zoned2));\n      break;\n    case 'week':\n      value = Math.round(differenceInWeeks(zoned1, zoned2));\n      break;\n    case 'month':\n      value = Math.round(differenceInMonths(zoned1, zoned2));\n      break;\n    case 'quarter':\n      value = Math.round(differenceInMonths(zoned1, zoned2) / 3);\n      break;\n    case 'year':\n      value = Math.round(differenceInYears(zoned1, zoned2));\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;AAC3D,UAAM,UAAU,KAAK,IAAI,iBAAiB,QAAQ,MAAM,CAAC;AACzD,UAAM,WAAW,KAAK,IAAI,kBAAkB,QAAQ,MAAM,CAAC;AAC3D,UAAM,YAAY,KAAK,IAAI,mBAAmB,QAAQ,MAAM,CAAC;AAE7D,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,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,iBAAiB,QAAQ,MAAM,CAAC;AACnD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,MAAM,CAAC;AACpD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,MAAM,CAAC;AACrD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,mBAAmB,QAAQ,MAAM,IAAI,CAAC;AACzD;AAAA,IACF,KAAK;AACH,cAAQ,KAAK,MAAM,kBAAkB,QAAQ,MAAM,CAAC;AACpD;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 '@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-4NJMCCUM.js → chunk-7JL3U64G.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/addHours.ts
 function addHours(input, hours) {
@@ -11,4 +11,4 @@ function addHours(input, hours) {
 export {
   addHours
 };
-//# sourceMappingURL=chunk-4NJMCCUM.js.map
+//# sourceMappingURL=chunk-7JL3U64G.js.map

package/dist/{chunk-JNA3AFOC.js → chunk-AHBTUFRW.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/shared/plainDateToZonedDateTime.ts
-import { Temporal } from "@js-temporal/polyfill";
 function plainDateToZonedDateTime(date, timezone) {
   return date.toZonedDateTime({
     timeZone: timezone,
@@ -10,4 +13,4 @@ function plainDateToZonedDateTime(date, timezone) {
 export {
   plainDateToZonedDateTime
 };
-//# sourceMappingURL=chunk-JNA3AFOC.js.map
+//# sourceMappingURL=chunk-AHBTUFRW.js.map

package/dist/chunk-AHBTUFRW.js.map

@@ -0,0 +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":[]}

package/dist/chunk-AI5MRREC.js

@@ -0,0 +1,22 @@
+// src/shared/temporal.ts
+import { Temporal } from "@js-temporal/polyfill";
+function brand(value) {
+  return typeof value === "object" && value !== null ? value[Symbol.toStringTag] : void 0;
+}
+function isInstant(value) {
+  return brand(value) === "Temporal.Instant";
+}
+function isZonedDateTime(value) {
+  return brand(value) === "Temporal.ZonedDateTime";
+}
+function isPlainDate(value) {
+  return brand(value) === "Temporal.PlainDate";
+}
+
+export {
+  Temporal,
+  isInstant,
+  isZonedDateTime,
+  isPlainDate
+};
+//# sourceMappingURL=chunk-AI5MRREC.js.map

package/dist/chunk-AI5MRREC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/temporal.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\n/**\n * @internal\n * Single source of the Temporal implementation.\n *\n * Currently always uses `@js-temporal/polyfill`. A previous attempt to prefer\n * the runtime's native `globalThis.Temporal` was reverted: tiempo passes\n * caller-provided Temporal objects into static methods\n * (`Temporal.ZonedDateTime.compare`, etc.), and a native static method throws\n * (\"Must specify time zone.\") when handed an object created by a different\n * implementation than the one tiempo resolved. Native-first can return once\n * inputs are normalized into the resolved implementation at the boundary, with\n * a native-Temporal CI runner guarding it.\n *\n * Import `Temporal` from here so the implementation choice stays in one place.\n */\nexport { Temporal };\n\n/**\n * @internal\n * Implementation-agnostic type guards. The Temporal spec requires every\n * implementation to set `Symbol.toStringTag`, so these work regardless of which\n * implementation produced the object.\n */\nfunction brand(value: unknown): string | undefined {\n  return typeof value === 'object' && value !== null\n    ? (value as { [Symbol.toStringTag]?: string })[Symbol.toStringTag]\n    : undefined;\n}\n\nexport function isInstant(value: unknown): value is Temporal.Instant {\n  return brand(value) === 'Temporal.Instant';\n}\n\nexport function isZonedDateTime(\n  value: unknown\n): value is Temporal.ZonedDateTime {\n  return brand(value) === 'Temporal.ZonedDateTime';\n}\n\nexport function isPlainDate(value: unknown): value is Temporal.PlainDate {\n  return brand(value) === 'Temporal.PlainDate';\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAyBzB,SAAS,MAAM,OAAoC;AACjD,SAAO,OAAO,UAAU,YAAY,UAAU,OACzC,MAA4C,OAAO,WAAW,IAC/D;AACN;AAEO,SAAS,UAAU,OAA2C;AACnE,SAAO,MAAM,KAAK,MAAM;AAC1B;AAEO,SAAS,gBACd,OACiC;AACjC,SAAO,MAAM,KAAK,MAAM;AAC1B;AAEO,SAAS,YAAY,OAA6C;AACvE,SAAO,MAAM,KAAK,MAAM;AAC1B;","names":[]}

package/dist/{chunk-RW3C2677.js → chunk-ALAAO5GL.js}

@@ -1,9 +1,8 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isSameDay.ts
-import "@js-temporal/polyfill";
 function isSameDay(date1, date2) {
   const zoned1 = normalizeTemporalInput(date1);
   const zoned2 = normalizeTemporalInput(date2);
@@ -13,4 +12,4 @@ function isSameDay(date1, date2) {
 export {
   isSameDay
 };
-//# sourceMappingURL=chunk-RW3C2677.js.map
+//# sourceMappingURL=chunk-ALAAO5GL.js.map

package/dist/chunk-ALAAO5GL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall on the same calendar day.\n * Compares the year, month, and day fields directly.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are on the same calendar day, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same day\n * const morning = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]');\n * const evening = Temporal.ZonedDateTime.from('2025-01-20T23:00:00Z[UTC]');\n *\n * isSameDay(morning, evening); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different days\n * const today = Temporal.ZonedDateTime.from('2025-01-20T23:59:59Z[UTC]');\n * const tomorrow = Temporal.ZonedDateTime.from('2025-01-21T00:00:00Z[UTC]');\n *\n * isSameDay(today, tomorrow); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar days\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar days from each person's perspective\n * isSameDay(ny, tokyo); // false (Jan 20 in NY, Jan 21 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameDay(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Jan 21 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameDay(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan 20 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T10:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T23:00:00Z');\n *\n * isSameDay(instant1, instant2); // true (both Jan 20 in UTC)\n * ```\n */\nexport function isSameDay(\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  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,UACd,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;AAE1B;","names":[]}

package/dist/{chunk-A5VVBYNT.js → chunk-ATEVQYB6.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/addMilliseconds.ts
 function addMilliseconds(input, milliseconds) {
@@ -11,4 +11,4 @@ function addMilliseconds(input, milliseconds) {
 export {
   addMilliseconds
 };
-//# sourceMappingURL=chunk-A5VVBYNT.js.map
+//# sourceMappingURL=chunk-ATEVQYB6.js.map

package/dist/{chunk-OQ4CWKJT.js → chunk-BO5WXWO2.js}

@@ -1,12 +1,11 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 
 // src/endOfMonth.ts
-import "@js-temporal/polyfill";
 function endOfMonth(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });
@@ -16,4 +15,4 @@ function endOfMonth(input, timezone) {
 export {
   endOfMonth
 };
-//# sourceMappingURL=chunk-OQ4CWKJT.js.map
+//# sourceMappingURL=chunk-BO5WXWO2.js.map

package/dist/chunk-BO5WXWO2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfMonth.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last moment of the month (last day at 23:59:59.999999999).\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the month at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const end = endOfMonth(instant);\n * // 2025-01-31T23:59:59.999999999Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-02-15T15:30:00-05:00[America/New_York]');\n * const end = endOfMonth(zoned);\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date, 'America/New_York');\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;AA0CO,SAAS,WACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,UAAU,cAAc,KAAK,EAAE,KAAK,cAAc,YAAY,CAAC;AACrE,SAAO,YAAY,OAAO;AAC5B;","names":[]}

package/dist/{chunk-4PSMM55Q.js → chunk-BQHSXMGZ.js}

@@ -1,5 +1,9 @@
+import {
+  Temporal,
+  isInstant
+} from "./chunk-AI5MRREC.js";
+
 // src/toZonedTime.ts
-import { Temporal } from "@js-temporal/polyfill";
 function toZonedTime(input, timezone) {
   if (typeof input === "string") {
     return Temporal.Instant.from(input).toZonedDateTimeISO(timezone);
@@ -10,7 +14,7 @@ function toZonedTime(input, timezone) {
   if (input instanceof Date) {
     return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone);
   }
-  if (input instanceof Temporal.Instant) {
+  if (isInstant(input)) {
     return input.toZonedDateTimeISO(timezone);
   }
   return input.toInstant().toZonedDateTimeISO(timezone);
@@ -19,4 +23,4 @@ function toZonedTime(input, timezone) {
 export {
   toZonedTime
 };
-//# sourceMappingURL=chunk-4PSMM55Q.js.map
+//# sourceMappingURL=chunk-BQHSXMGZ.js.map

package/dist/chunk-BQHSXMGZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toZonedTime.ts"],"sourcesContent":["import { Temporal, isInstant } from './shared/temporal';\nimport type { Timezone } from './types';\n\n/**\n * Convert a UTC ISO string, Unix timestamp, Date, Instant, or ZonedDateTime to a ZonedDateTime in the specified timezone.\n *\n * @param input - A UTC ISO 8601 string, Unix timestamp (milliseconds), Date object, Temporal.Instant, or Temporal.ZonedDateTime\n * @param timezone - IANA timezone identifier (e.g., \"America/New_York\", \"Europe/London\") or \"UTC\"\n * @returns A Temporal.ZonedDateTime in the specified timezone\n *\n * @example\n * ```typescript\n * import { toZonedTime, browserTimezone } from '@gobrand/tiempo';\n *\n * // Server-side: Convert to UTC\n * const utcTime = toZonedTime(\"2025-01-20T20:00:00Z\", \"UTC\");\n *\n * // Server-side: Convert to user's timezone (from DB/preferences)\n * const userTime = toZonedTime(\"2025-01-20T20:00:00Z\", user.timezone);\n *\n * // Client-side: Convert to browser's timezone\n * const localTime = toZonedTime(\"2025-01-20T20:00:00Z\", browserTimezone());\n *\n * // From Unix timestamp (e.g., from database BIGINT or API response)\n * const timestamp = 1737403200000;\n * const zoned = toZonedTime(timestamp, \"America/New_York\");\n *\n * // From Date (e.g., from Drizzle ORM)\n * const date = new Date(\"2025-01-20T20:00:00.000Z\");\n * const zoned2 = toZonedTime(date, \"America/New_York\");\n *\n * // From Instant\n * const instant = Temporal.Instant.from(\"2025-01-20T20:00:00Z\");\n * const zoned3 = toZonedTime(instant, \"Asia/Tokyo\");\n *\n * // From ZonedDateTime (convert to different timezone)\n * const nyTime = Temporal.ZonedDateTime.from(\"2025-01-20T15:00:00-05:00[America/New_York]\");\n * const tokyoTime = toZonedTime(nyTime, \"Asia/Tokyo\");\n * ```\n */\nexport function toZonedTime(\n  input: string | number | Date | Temporal.Instant | Temporal.ZonedDateTime,\n  timezone: Timezone\n): Temporal.ZonedDateTime {\n  if (typeof input === 'string') {\n    return Temporal.Instant.from(input).toZonedDateTimeISO(timezone);\n  }\n\n  if (typeof input === 'number') {\n    return Temporal.Instant.fromEpochMilliseconds(input).toZonedDateTimeISO(timezone);\n  }\n\n  if (input instanceof Date) {\n    return Temporal.Instant.from(input.toISOString()).toZonedDateTimeISO(timezone);\n  }\n\n  if (isInstant(input)) {\n    return input.toZonedDateTimeISO(timezone);\n  }\n\n  return input.toInstant().toZonedDateTimeISO(timezone);\n}\n"],"mappings":";;;;;;AAwCO,SAAS,YACd,OACA,UACwB;AACxB,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,SAAS,QAAQ,KAAK,KAAK,EAAE,mBAAmB,QAAQ;AAAA,EACjE;AAEA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,SAAS,QAAQ,sBAAsB,KAAK,EAAE,mBAAmB,QAAQ;AAAA,EAClF;AAEA,MAAI,iBAAiB,MAAM;AACzB,WAAO,SAAS,QAAQ,KAAK,MAAM,YAAY,CAAC,EAAE,mBAAmB,QAAQ;AAAA,EAC/E;AAEA,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO,MAAM,mBAAmB,QAAQ;AAAA,EAC1C;AAEA,SAAO,MAAM,UAAU,EAAE,mBAAmB,QAAQ;AACtD;","names":[]}

package/dist/{chunk-776JOVV6.js → chunk-C4UZJHM7.js}

@@ -1,12 +1,11 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 
 // src/endOfYear.ts
-import "@js-temporal/polyfill";
 function endOfYear(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });
@@ -17,4 +16,4 @@ function endOfYear(input, timezone) {
 export {
   endOfYear
 };
-//# sourceMappingURL=chunk-776JOVV6.js.map
+//# sourceMappingURL=chunk-C4UZJHM7.js.map

package/dist/chunk-C4UZJHM7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfYear.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last moment of the year (last day at 23:59:59.999999999).\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 (requires timezone)\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(\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 {\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":";;;;;;;;AA0CO,SAAS,UACd,OACA,UACwB;AACxB,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":[]}

package/dist/{chunk-VZJGCDAG.js → chunk-C5O6LIWR.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/isPlainTimeEqual.ts
-import { Temporal } from "@js-temporal/polyfill";
 function isPlainTimeEqual(time1, time2) {
   return Temporal.PlainTime.compare(time1, time2) === 0;
 }
@@ -7,4 +10,4 @@ function isPlainTimeEqual(time1, time2) {
 export {
   isPlainTimeEqual
 };
-//# sourceMappingURL=chunk-VZJGCDAG.js.map
+//# sourceMappingURL=chunk-C5O6LIWR.js.map

package/dist/chunk-C5O6LIWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isPlainTimeEqual.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\n/**\n * Returns true if the two plain times are equal.\n * Compares wall-clock times without date or timezone considerations.\n *\n * @param time1 - First plain time\n * @param time2 - Second plain time\n * @returns true if time1 equals time2, false otherwise\n *\n * @example\n * ```ts\n * const nineAM_a = Temporal.PlainTime.from('09:00');\n * const nineAM_b = Temporal.PlainTime.from('09:00');\n * const fivePM = Temporal.PlainTime.from('17:00');\n *\n * isPlainTimeEqual(nineAM_a, nineAM_b); // true\n * isPlainTimeEqual(nineAM_a, fivePM); // false\n * ```\n */\nexport function isPlainTimeEqual(\n  time1: Temporal.PlainTime,\n  time2: Temporal.PlainTime\n): boolean {\n  return Temporal.PlainTime.compare(time1, time2) === 0;\n}\n"],"mappings":";;;;;AAoBO,SAAS,iBACd,OACA,OACS;AACT,SAAO,SAAS,UAAU,QAAQ,OAAO,KAAK,MAAM;AACtD;","names":[]}

package/dist/{chunk-LDO6PRNJ.js → chunk-C7SIOWMA.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isSameMinute.ts
 function isSameMinute(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMinute(date1, date2) {
 export {
   isSameMinute
 };
-//# sourceMappingURL=chunk-LDO6PRNJ.js.map
+//# sourceMappingURL=chunk-C7SIOWMA.js.map

package/dist/{chunk-FSD3DDFC.js → chunk-CKOIGPND.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/now.ts
-import { Temporal } from "@js-temporal/polyfill";
 function now(timezone) {
   return Temporal.Now.zonedDateTimeISO(timezone);
 }
@@ -7,4 +10,4 @@ function now(timezone) {
 export {
   now
 };
-//# sourceMappingURL=chunk-FSD3DDFC.js.map
+//# sourceMappingURL=chunk-CKOIGPND.js.map

package/dist/chunk-CKOIGPND.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/now.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\n\n/**\n * Get the current date and time in the specified timezone.\n *\n * @param timezone - IANA timezone identifier (e.g., \"America/New_York\", \"Europe/London\") or \"UTC\"\n * @returns A Temporal.ZonedDateTime representing the current date and time\n *\n * @example\n * ```typescript\n * import { now, browserTimezone } from '@gobrand/tiempo';\n *\n * // Server-side: Get now in UTC\n * const nowUtc = now(\"UTC\");\n *\n * // Server-side: Get now in user's timezone (from DB/preferences)\n * const nowUser = now(user.timezone);\n *\n * // Client-side: Get now in browser's timezone\n * const nowLocal = now(browserTimezone());\n *\n * // Get now in a specific timezone\n * const nowInMadrid = now(\"Europe/Madrid\");\n * ```\n */\nexport function now(timezone: Timezone): Temporal.ZonedDateTime {\n  return Temporal.Now.zonedDateTimeISO(timezone);\n}\n"],"mappings":";;;;;AA0BO,SAAS,IAAI,UAA4C;AAC9D,SAAO,SAAS,IAAI,iBAAiB,QAAQ;AAC/C;","names":[]}

package/dist/{chunk-6IP245MS.js → chunk-DC5JXNIC.js}

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

package/dist/chunk-DC5JXNIC.js.map

@@ -0,0 +1 @@
+{"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-HOCNCQTC.js → chunk-E2MU2P66.js}

@@ -1,12 +1,11 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 
 // src/endOfDay.ts
-import "@js-temporal/polyfill";
 function endOfDay(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   return getEndOfDay(zonedDateTime);
@@ -15,4 +14,4 @@ function endOfDay(input, timezone) {
 export {
   endOfDay
 };
-//# sourceMappingURL=chunk-HOCNCQTC.js.map
+//# sourceMappingURL=chunk-E2MU2P66.js.map

package/dist/chunk-E2MU2P66.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfDay.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the last nanosecond of the day.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const end = endOfDay(instant);\n * // 2025-01-20T23:59:59.999999999Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const end = endOfDay(zoned);\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-01-20');\n * const end = endOfDay(date, 'America/New_York');\n * // 2025-01-20T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return getEndOfDay(zonedDateTime);\n}\n"],"mappings":";;;;;;;;AA0CO,SAAS,SACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,YAAY,aAAa;AAClC;","names":[]}

package/dist/{chunk-ADQTZVMH.js → chunk-EKR6BYFM.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/isSameMonth.ts
 function isSameMonth(date1, date2) {
@@ -12,4 +12,4 @@ function isSameMonth(date1, date2) {
 export {
   isSameMonth
 };
-//# sourceMappingURL=chunk-ADQTZVMH.js.map
+//# sourceMappingURL=chunk-EKR6BYFM.js.map

package/dist/{chunk-PVAOUYXF.js → chunk-EOXULNBC.js}

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

package/dist/chunk-EOXULNBC.js.map

@@ -0,0 +1 @@
+{"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-BV6CLVSI.js → chunk-EW3MVOID.js}

@@ -1,12 +1,11 @@
 import {
   differenceInMilliseconds
-} from "./chunk-AJ4JBKJK.js";
+} from "./chunk-VXOQ7IG5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-MJSZNWCV.js";
+} from "./chunk-65RGM7EG.js";
 
 // src/differenceInMilliseconds.ts
-import "@js-temporal/polyfill";
 function differenceInMilliseconds2(laterDate, earlierDate) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
@@ -16,4 +15,4 @@ function differenceInMilliseconds2(laterDate, earlierDate) {
 export {
   differenceInMilliseconds2 as differenceInMilliseconds
 };
-//# sourceMappingURL=chunk-BV6CLVSI.js.map
+//# sourceMappingURL=chunk-EW3MVOID.js.map

package/dist/chunk-EW3MVOID.js.map

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

package/dist/{chunk-WUAIUEH7.js → chunk-EZJDWFFE.js}

@@ -1,5 +1,8 @@
+import {
+  Temporal
+} from "./chunk-AI5MRREC.js";
+
 // src/shared/isBefore.ts
-import { Temporal } from "@js-temporal/polyfill";
 function isBefore(date1, date2) {
   return Temporal.ZonedDateTime.compare(date1, date2) < 0;
 }
@@ -7,4 +10,4 @@ function isBefore(date1, date2) {
 export {
   isBefore
 };
-//# sourceMappingURL=chunk-WUAIUEH7.js.map
+//# sourceMappingURL=chunk-EZJDWFFE.js.map

package/dist/chunk-EZJDWFFE.js.map

@@ -0,0 +1 @@
+{"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-BQBLSXK2.js → chunk-FLRHLAMD.js}

@@ -1,6 +1,6 @@
 import {
   addMicroseconds
-} from "./chunk-V27NUBXQ.js";
+} from "./chunk-WWLDINLH.js";
 
 // src/subMicroseconds.ts
 function subMicroseconds(input, microseconds) {
@@ -10,4 +10,4 @@ function subMicroseconds(input, microseconds) {
 export {
   subMicroseconds
 };
-//# sourceMappingURL=chunk-BQBLSXK2.js.map
+//# sourceMappingURL=chunk-FLRHLAMD.js.map

package/dist/{chunk-TGKWBQ7L.js → chunk-GSVAMMHA.js}

@@ -1,7 +1,10 @@
+import {
+  isInstant
+} from "./chunk-AI5MRREC.js";
+
 // src/toDate.ts
-import { Temporal } from "@js-temporal/polyfill";
 function toDate(input) {
-  if (input instanceof Temporal.Instant) {
+  if (isInstant(input)) {
     return new Date(input.toString());
   }
   return new Date(input.toInstant().toString());
@@ -10,4 +13,4 @@ function toDate(input) {
 export {
   toDate
 };
-//# sourceMappingURL=chunk-TGKWBQ7L.js.map
+//# sourceMappingURL=chunk-GSVAMMHA.js.map

package/dist/chunk-GSVAMMHA.js.map

@@ -0,0 +1 @@
+{"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-3TSFIPUR.js → chunk-HDTIOOWB.js}

@@ -1,9 +1,8 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-KGVUENQO.js";
+} from "./chunk-TWZNSMKO.js";
 
 // src/startOfYear.ts
-import "@js-temporal/polyfill";
 function startOfYear(input, timezone) {
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const firstDay = zonedDateTime.with({ month: 1, day: 1 });
@@ -13,4 +12,4 @@ function startOfYear(input, timezone) {
 export {
   startOfYear
 };
-//# sourceMappingURL=chunk-3TSFIPUR.js.map
+//# sourceMappingURL=chunk-HDTIOOWB.js.map

package/dist/chunk-HDTIOOWB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfYear.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns a ZonedDateTime representing the first moment of the year (January 1 at midnight).\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at January 1st at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const start = startOfYear(instant);\n * // 2025-01-01T00:00:00Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-05:00[America/New_York]');\n * const start = startOfYear(zoned);\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const start = startOfYear(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ month: 1, day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;AAyCO,SAAS,YACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACxD,SAAO,SAAS,WAAW;AAC7B;","names":[]}