@gobrand/tiempo 3.0.1 → 3.1.2

package/dist/chunk-NKXMLC6T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachYearOfInterval.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { isPlainDateAfter } from './isPlainDateAfter';\nimport { isPlainDateBefore } from './isPlainDateBefore';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * PlainDate endpoints return date-only period starts in the start calendar.\n * Mixed date-only/timeline endpoints are rejected. Reversed endpoints return [].\n *\n * Uses the start endpoint's calendar and timezone, including for the end bound.\n * Native and polyfill endpoints may be mixed.\n *\n * Returns an array of ZonedDateTime objects for each year within the interval.\n * Each element represents the first moment of the year (January 1st at midnight).\n * The interval is inclusive of both start and end years.\n *\n * For Instant inputs, UTC is used as the timezone.\n * For ZonedDateTime inputs, the timezone of the start date is preserved.\n *\n * @param interval - The interval with start and end datetimes\n * @returns Array of ZonedDateTime at start of each year in the interval\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2022-06-15T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-03-20T14:00:00Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2022-01-01T00:00:00Z[UTC],\n * //   2023-01-01T00:00:00Z[UTC],\n * //   2024-01-01T00:00:00Z[UTC],\n * //   2025-01-01T00:00:00Z[UTC]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * // Single year\n * const start = Temporal.ZonedDateTime.from('2025-01-15T00:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [2025-01-01T00:00:00Z[UTC]]\n * ```\n *\n * @example\n * ```ts\n * // With timezone\n * const start = Temporal.ZonedDateTime.from('2024-01-01T00:00:00-05:00[America/New_York]');\n * const end = Temporal.ZonedDateTime.from('2026-06-15T00:00:00-04:00[America/New_York]');\n *\n * const years = eachYearOfInterval({ start, end });\n * // [\n * //   2024-01-01T00:00:00-05:00[America/New_York],\n * //   2025-01-01T00:00:00-05:00[America/New_York],\n * //   2026-01-01T00:00:00-05:00[America/New_York]\n * // ]\n * ```\n */\nexport function eachYearOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachYearOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachYearOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n  end: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate;\n}): Temporal.ZonedDateTime[] | Temporal.PlainDate[] {\n  if (isPlainDate(interval.start) || isPlainDate(interval.end)) {\n    if (!isPlainDate(interval.start) || !isPlainDate(interval.end)) {\n      throw new TypeError('PlainDate intervals require two PlainDate endpoints');\n    }\n    if (isPlainDateAfter(interval.start, interval.end)) return [];\n    const end = interval.end.withCalendar(interval.start.calendarId);\n    const last = end.with({ month: 1, day: 1 });\n    let current = interval.start.with({ month: 1, day: 1 });\n    const dates: Temporal.PlainDate[] = [];\n    while (isPlainDateBefore(current, last)) {\n      dates.push(current);\n      current = current.add({ years: 1 });\n    }\n    dates.push(current);\n    return dates;\n  }\n  const startZoned = normalizeTemporalInput(interval.start);\n  const endZoned = normalizeTemporalInput(interval.end);\n  if (startZoned.epochNanoseconds > endZoned.epochNanoseconds) return [];\n\n  const timezone = startZoned.timeZoneId;\n  const startYear = startZoned.year;\n\n  // Get end year in the same timezone\n  const endInTimezone = endZoned.withTimeZone(timezone).withCalendar(startZoned.calendarId);\n  const endYear = endInTimezone.year;\n\n  const years: Temporal.ZonedDateTime[] = [];\n\n  for (let year = startYear; year <= endYear; year++) {\n    const firstOfYear = Temporal.PlainDate.from({ year, month: 1, day: 1, calendar: startZoned.calendarId });\n    years.push(\n      firstOfYear.toZonedDateTime({\n        timeZone: timezone,\n        plainTime: new Temporal.PlainTime(),\n      })\n    );\n  }\n\n  return years;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoEO,SAAS,mBAAmB,UAGiB;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,QAAI,CAAC,YAAY,SAAS,KAAK,KAAK,CAAC,YAAY,SAAS,GAAG,GAAG;AAC9D,YAAM,IAAI,UAAU,qDAAqD;AAAA,IAC3E;AACA,QAAI,iBAAiB,SAAS,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC;AAC5D,UAAM,MAAM,SAAS,IAAI,aAAa,SAAS,MAAM,UAAU;AAC/D,UAAM,OAAO,IAAI,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AAC1C,QAAI,UAAU,SAAS,MAAM,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACtD,UAAM,QAA8B,CAAC;AACrC,WAAO,kBAAkB,SAAS,IAAI,GAAG;AACvC,YAAM,KAAK,OAAO;AAClB,gBAAU,QAAQ,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,IACpC;AACA,UAAM,KAAK,OAAO;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,uBAAuB,SAAS,KAAK;AACxD,QAAM,WAAW,uBAAuB,SAAS,GAAG;AACpD,MAAI,WAAW,mBAAmB,SAAS,iBAAkB,QAAO,CAAC;AAErE,QAAM,WAAW,WAAW;AAC5B,QAAM,YAAY,WAAW;AAG7B,QAAM,gBAAgB,SAAS,aAAa,QAAQ,EAAE,aAAa,WAAW,UAAU;AACxF,QAAM,UAAU,cAAc;AAE9B,QAAM,QAAkC,CAAC;AAEzC,WAAS,OAAO,WAAW,QAAQ,SAAS,QAAQ;AAClD,UAAM,cAAc,SAAS,UAAU,KAAK,EAAE,MAAM,OAAO,GAAG,KAAK,GAAG,UAAU,WAAW,WAAW,CAAC;AACvG,UAAM;AAAA,MACJ,YAAY,gBAAgB;AAAA,QAC1B,UAAU;AAAA,QACV,WAAW,IAAI,SAAS,UAAU;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-PX2I4GCF.js → chunk-NL5MQVGD.js}

@@ -1,6 +1,6 @@
 import {
   Temporal
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/today.ts
 function today(timezone) {
@@ -10,4 +10,4 @@ function today(timezone) {
 export {
   today
 };
-//# sourceMappingURL=chunk-PX2I4GCF.js.map
+//# sourceMappingURL=chunk-NL5MQVGD.js.map

package/dist/chunk-NMMMAMKP.js

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

package/dist/chunk-NMMMAMKP.js.map

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

package/dist/chunk-NNUATTN7.js

@@ -0,0 +1,16 @@
+import {
+  addMonths
+} from "./chunk-WJZHUNF5.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subMonths.ts
+function subMonths(input, months) {
+  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);
+}
+
+export {
+  subMonths
+};
+//# sourceMappingURL=chunk-NNUATTN7.js.map

package/dist/chunk-NNUATTN7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime or date.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n *\n * PlainDate inputs stay in calendar space, preserving their calendar without a timezone.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param months - Number of months to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with months subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(input: Temporal.PlainDate, months: number): Temporal.PlainDate;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime;\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  months: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addMonths overload.\n  return isPlainDate(input) ? addMonths(input, -months) : addMonths(input, -months);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,UACd,OACA,QAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,UAAU,OAAO,CAAC,MAAM,IAAI,UAAU,OAAO,CAAC,MAAM;AAClF;","names":[]}

package/dist/{chunk-7OEGJCW7.js → chunk-NRYKSDVP.js}

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

package/dist/{chunk-7OEGJCW7.js.map → chunk-NRYKSDVP.js.map}

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

package/dist/{chunk-VC7RTDJP.js → chunk-NST7NM5Q.js}

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/differenceInNanoseconds.ts
 function differenceInNanoseconds(laterDate, earlierDate) {
@@ -12,4 +12,4 @@ function differenceInNanoseconds(laterDate, earlierDate) {
 export {
   differenceInNanoseconds
 };
-//# sourceMappingURL=chunk-VC7RTDJP.js.map
+//# sourceMappingURL=chunk-NST7NM5Q.js.map

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

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

package/dist/chunk-NYM3EW3M.js.map

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

package/dist/chunk-NZLRMN35.js

@@ -0,0 +1,13 @@
+import {
+  isDaysFromToday
+} from "./chunk-MWUVGTKC.js";
+
+// src/isToday.ts
+function isToday(date, timezone) {
+  return isDaysFromToday(date, timezone, 0);
+}
+
+export {
+  isToday
+};
+//# sourceMappingURL=chunk-NZLRMN35.js.map

package/dist/chunk-NZLRMN35.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isToday.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { isDaysFromToday } from './shared/relativeDay';\n\n/**\n * Returns true if the value falls on today's date in the given timezone.\n *\n * \"Today\" depends on where you are, so the timezone is required. Instant and\n * ZonedDateTime inputs are converted to that timezone before taking their\n * date. PlainDate inputs are compared to today's date there directly.\n *\n * @param date - An Instant, ZonedDateTime, or PlainDate\n * @param timezone - The timezone that defines \"today\"\n * @returns true if date is today in timezone, false otherwise\n *\n * @example\n * ```ts\n * isToday(Temporal.Now.instant(), 'America/New_York'); // true\n * isToday(Temporal.Now.instant().add({ hours: 48 }), 'America/New_York'); // false\n * ```\n */\nexport function isToday(\n  date: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone\n): boolean {\n  return isDaysFromToday(date, timezone, 0);\n}\n"],"mappings":";;;;;AAqBO,SAAS,QACd,MACA,UACS;AACT,SAAO,gBAAgB,MAAM,UAAU,CAAC;AAC1C;","names":[]}

package/dist/{chunk-CCVPCHUO.js → chunk-O4YU4N6Q.js}

@@ -1,12 +1,12 @@
 import {
   isAfter
-} from "./chunk-LSKER4FN.js";
+} from "./chunk-CDKIT7D3.js";
 import {
   nowZoned
-} from "./chunk-6RETOV6A.js";
+} from "./chunk-TWRJEIBO.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/isFuture.ts
 function isFuture(date) {
@@ -17,4 +17,4 @@ function isFuture(date) {
 export {
   isFuture
 };
-//# sourceMappingURL=chunk-CCVPCHUO.js.map
+//# sourceMappingURL=chunk-O4YU4N6Q.js.map

package/dist/chunk-O4YU4N6Q.js.map

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

package/dist/chunk-OMYVTYHI.js

@@ -0,0 +1,47 @@
+import {
+  Temporal,
+  isPlainDate,
+  isPlainTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/compare.ts
+function assertSameDomain(a, b) {
+  if ((isPlainDate(a) || isPlainDate(b)) && !(isPlainDate(a) && isPlainDate(b))) {
+    throw new TypeError("PlainDate comparisons require two PlainDate values");
+  }
+  if ((isPlainTime(a) || isPlainTime(b)) && !(isPlainTime(a) && isPlainTime(b))) {
+    throw new TypeError("PlainTime comparisons require two PlainTime values");
+  }
+}
+function compare(a, b) {
+  assertSameDomain(a, b);
+  if (isPlainDate(a)) {
+    return Temporal.PlainDate.compare(ownDate(a), ownDate(b));
+  }
+  if (isPlainTime(a)) {
+    return Temporal.PlainTime.compare(a, b);
+  }
+  const difference = a.epochNanoseconds - b.epochNanoseconds;
+  return difference < 0n ? -1 : difference > 0n ? 1 : 0;
+}
+function position(value) {
+  if (isPlainDate(value)) {
+    return Temporal.PlainDate.from(ownDate(value)).toZonedDateTime("UTC").epochNanoseconds;
+  }
+  if (isPlainTime(value)) {
+    const seconds = (value.hour * 60 + value.minute) * 60 + value.second;
+    const subsecond = value.millisecond * 1e6 + value.microsecond * 1e3 + value.nanosecond;
+    return BigInt(seconds) * 1000000000n + BigInt(subsecond);
+  }
+  return value.epochNanoseconds;
+}
+function ownDate(date) {
+  return Temporal.PlainDate.prototype.isPrototypeOf(date) ? date : date.toString();
+}
+
+export {
+  assertSameDomain,
+  compare,
+  position
+};
+//# sourceMappingURL=chunk-OMYVTYHI.js.map

package/dist/chunk-OMYVTYHI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/compare.ts"],"sourcesContent":["import { Temporal, isPlainDate, isPlainTime } from './temporal';\n\nexport type Timeline = Temporal.Instant | Temporal.ZonedDateTime;\nexport type Comparable = Timeline | Temporal.PlainDate | Temporal.PlainTime;\n\n/**\n * @internal\n * Throws unless both values share a domain: two PlainDates, two PlainTimes,\n * or two timeline values (Instant/ZonedDateTime in any combination).\n */\nexport function assertSameDomain(a: Comparable, b: Comparable): void {\n  if ((isPlainDate(a) || isPlainDate(b)) && !(isPlainDate(a) && isPlainDate(b))) {\n    throw new TypeError('PlainDate comparisons require two PlainDate values');\n  }\n  if ((isPlainTime(a) || isPlainTime(b)) && !(isPlainTime(a) && isPlainTime(b))) {\n    throw new TypeError('PlainTime comparisons require two PlainTime values');\n  }\n}\n\n/**\n * @internal\n * Orders two values from one domain: timeline values by exact instant,\n * PlainDates by ISO date, PlainTimes by clock time. Mixed domains throw.\n */\nexport function compare(a: Comparable, b: Comparable): -1 | 0 | 1 {\n  assertSameDomain(a, b);\n  if (isPlainDate(a)) {\n    return Temporal.PlainDate.compare(ownDate(a), ownDate(b as Temporal.PlainDate));\n  }\n  if (isPlainTime(a)) {\n    return Temporal.PlainTime.compare(a, b as Temporal.PlainTime);\n  }\n  const difference = a.epochNanoseconds - (b as Timeline).epochNanoseconds;\n  return difference < 0n ? -1 : difference > 0n ? 1 : 0;\n}\n\n/**\n * @internal\n * Places a value on a nanosecond axis within its domain so distances between\n * values of the same domain can be measured. Callers check domains first.\n */\nexport function position(value: Comparable): bigint {\n  if (isPlainDate(value)) {\n    return Temporal.PlainDate.from(ownDate(value)).toZonedDateTime('UTC').epochNanoseconds;\n  }\n  if (isPlainTime(value)) {\n    const seconds = (value.hour * 60 + value.minute) * 60 + value.second;\n    const subsecond = value.millisecond * 1_000_000 + value.microsecond * 1_000 + value.nanosecond;\n    return BigInt(seconds) * 1_000_000_000n + BigInt(subsecond);\n  }\n  return value.epochNanoseconds;\n}\n\n// Dates from another Temporal implementation cross over as canonical strings,\n// which keep their calendar annotation.\nfunction ownDate(date: Temporal.PlainDate): Temporal.PlainDate | string {\n  return Temporal.PlainDate.prototype.isPrototypeOf(date) ? date : date.toString();\n}\n"],"mappings":";;;;;;;AAUO,SAAS,iBAAiB,GAAe,GAAqB;AACnE,OAAK,YAAY,CAAC,KAAK,YAAY,CAAC,MAAM,EAAE,YAAY,CAAC,KAAK,YAAY,CAAC,IAAI;AAC7E,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,OAAK,YAAY,CAAC,KAAK,YAAY,CAAC,MAAM,EAAE,YAAY,CAAC,KAAK,YAAY,CAAC,IAAI;AAC7E,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACF;AAOO,SAAS,QAAQ,GAAe,GAA2B;AAChE,mBAAiB,GAAG,CAAC;AACrB,MAAI,YAAY,CAAC,GAAG;AAClB,WAAO,SAAS,UAAU,QAAQ,QAAQ,CAAC,GAAG,QAAQ,CAAuB,CAAC;AAAA,EAChF;AACA,MAAI,YAAY,CAAC,GAAG;AAClB,WAAO,SAAS,UAAU,QAAQ,GAAG,CAAuB;AAAA,EAC9D;AACA,QAAM,aAAa,EAAE,mBAAoB,EAAe;AACxD,SAAO,aAAa,KAAK,KAAK,aAAa,KAAK,IAAI;AACtD;AAOO,SAAS,SAAS,OAA2B;AAClD,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,SAAS,UAAU,KAAK,QAAQ,KAAK,CAAC,EAAE,gBAAgB,KAAK,EAAE;AAAA,EACxE;AACA,MAAI,YAAY,KAAK,GAAG;AACtB,UAAM,WAAW,MAAM,OAAO,KAAK,MAAM,UAAU,KAAK,MAAM;AAC9D,UAAM,YAAY,MAAM,cAAc,MAAY,MAAM,cAAc,MAAQ,MAAM;AACpF,WAAO,OAAO,OAAO,IAAI,cAAiB,OAAO,SAAS;AAAA,EAC5D;AACA,SAAO,MAAM;AACf;AAIA,SAAS,QAAQ,MAAuD;AACtE,SAAO,SAAS,UAAU,UAAU,cAAc,IAAI,IAAI,OAAO,KAAK,SAAS;AACjF;","names":[]}

package/dist/chunk-OOOVMKOG.js

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

package/dist/chunk-OOOVMKOG.js.map

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

package/dist/{chunk-EMZFQEWM.js → chunk-OYTQWJ2O.js}

@@ -1,19 +1,16 @@
-import {
-  differenceInMilliseconds
-} from "./chunk-VXOQ7IG5.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 
 // src/differenceInMinutes.ts
 function differenceInMinutes(laterDate, earlierDate, options) {
   const zoned1 = normalizeTemporalInput(laterDate);
   const zoned2 = normalizeTemporalInput(earlierDate);
-  const precise = differenceInMilliseconds(zoned1, zoned2) / 6e4;
-  return options?.fractional ? precise : Math.trunc(precise);
+  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return options?.fractional ? Number(nanoseconds) / 6e10 : Number(nanoseconds / 60000000000n);
 }
 
 export {
   differenceInMinutes
 };
-//# sourceMappingURL=chunk-EMZFQEWM.js.map
+//# sourceMappingURL=chunk-OYTQWJ2O.js.map

package/dist/chunk-OYTQWJ2O.js.map

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

package/dist/{chunk-IAXVREU5.js → chunk-PU6PU2JM.js}

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

package/dist/chunk-PU6PU2JM.js.map

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

package/dist/{chunk-CSOSM46M.js → chunk-PYV7MWJJ.js}

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

package/dist/chunk-PYV7MWJJ.js.map

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

package/dist/chunk-QD3ROUIT.js

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

package/dist/chunk-QD3ROUIT.js.map

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

package/dist/{chunk-TQUKIG26.js → chunk-QJYU5TLL.js}

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

package/dist/{chunk-VQAGV72H.js → chunk-QVSHSIA3.js}

@@ -1,7 +1,7 @@
 import {
   Temporal,
   isInstant
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/toInstant.ts
 function toInstant(input) {
@@ -20,4 +20,4 @@ function toInstant(input) {
 export {
   toInstant
 };
-//# sourceMappingURL=chunk-VQAGV72H.js.map
+//# sourceMappingURL=chunk-QVSHSIA3.js.map

package/dist/{chunk-OSBVYUOQ.js → chunk-R3PZ56AD.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-2MFBXSTL.js";
 import {
   getEndOfDay
-} from "./chunk-AVGNRINZ.js";
+} from "./chunk-NMMMAMKP.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/endOfQuarter.ts
 function endOfQuarter(input, timezone) {
@@ -32,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-OSBVYUOQ.js.map
+//# sourceMappingURL=chunk-R3PZ56AD.js.map

package/dist/chunk-R3PZ56AD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfQuarter.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport type { Timezone } from \"./types\";\nimport { getEndOfDay } from \"./shared/endOfDay\";\nimport { normalizeWithPlainDate } from \"./shared/normalizeWithPlainDate\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns a ZonedDateTime representing the last moment of the quarter\n * (last day of the quarter's ending month at 23:59:59.999999999).\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the quarter at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-05-15T12:00:00Z');\n * const end = endOfQuarter(instant);\n * // 2025-06-30T23: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 = endOfQuarter(zoned);\n * // 2025-03-31T23:59:59.999999999-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (requires timezone)\n * const date = Temporal.PlainDate.from('2025-11-15');\n * const end = endOfQuarter(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n): Temporal.ZonedDateTime;\nexport function endOfQuarter(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfQuarter(input: Temporal.PlainDate, timezone: Timezone): Temporal.ZonedDateTime;\nexport function endOfQuarter(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // PlainDate with no timezone stays in calendar space → last day of quarter.\n  if (isPlainDate(input) && timezone === undefined) {\n    const endMonth = input.with({\n      month: quarterStartMonth(input.month) + 2,\n      day: 1,\n    });\n    return endMonth.with({ day: endMonth.daysInMonth });\n  }\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const endMonth = zonedDateTime.with({\n    month: quarterStartMonth(zonedDateTime.month) + 2,\n    day: 1,\n  });\n  const lastDay = endMonth.with({ day: endMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;;;;AA4CO,SAAS,aACd,OACA,UAC6C;AAE7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,YAAW,MAAM,KAAK;AAAA,MAC1B,OAAO,kBAAkB,MAAM,KAAK,IAAI;AAAA,MACxC,KAAK;AAAA,IACP,CAAC;AACD,WAAOA,UAAS,KAAK,EAAE,KAAKA,UAAS,YAAY,CAAC;AAAA,EACpD;AACA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK;AAAA,IAClC,OAAO,kBAAkB,cAAc,KAAK,IAAI;AAAA,IAChD,KAAK;AAAA,EACP,CAAC;AACD,QAAM,UAAU,SAAS,KAAK,EAAE,KAAK,SAAS,YAAY,CAAC;AAC3D,SAAO,YAAY,OAAO;AAC5B;","names":["endMonth"]}

package/dist/chunk-RDMDCTHJ.js

@@ -0,0 +1,13 @@
+import {
+  isDaysFromToday
+} from "./chunk-MWUVGTKC.js";
+
+// src/isTomorrow.ts
+function isTomorrow(date, timezone) {
+  return isDaysFromToday(date, timezone, 1);
+}
+
+export {
+  isTomorrow
+};
+//# sourceMappingURL=chunk-RDMDCTHJ.js.map

package/dist/chunk-RDMDCTHJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isTomorrow.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { isDaysFromToday } from './shared/relativeDay';\n\n/**\n * Returns true if the value falls on tomorrow's date in the given timezone.\n *\n * Instant and ZonedDateTime inputs are converted to the timezone before taking\n * their date. PlainDate inputs are compared to tomorrow's date there directly.\n *\n * @param date - An Instant, ZonedDateTime, or PlainDate\n * @param timezone - The timezone that defines \"today\"\n * @returns true if date is tomorrow in timezone, false otherwise\n *\n * @example\n * ```ts\n * const delivery = Temporal.Now.instant().add({ hours: 24 });\n * isTomorrow(delivery, 'Asia/Tokyo'); // true\n * ```\n */\nexport function isTomorrow(\n  date: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone: Timezone\n): boolean {\n  return isDaysFromToday(date, timezone, 1);\n}\n"],"mappings":";;;;;AAoBO,SAAS,WACd,MACA,UACS;AACT,SAAO,gBAAgB,MAAM,UAAU,CAAC;AAC1C;","names":[]}

package/dist/chunk-RQ5CX67T.js

@@ -0,0 +1,30 @@
+import {
+  isWeekendDay,
+  isoDate
+} from "./chunk-Z7I7YCKN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/differenceInBusinessDays.ts
+function differenceInBusinessDays(laterDate, earlierDate) {
+  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {
+    throw new TypeError("PlainDate differences require two PlainDate values");
+  }
+  const later = isoDate(laterDate);
+  const earlier = isoDate(earlierDate);
+  const days = earlier.until(later, { largestUnit: "days" }).days;
+  const [from, span] = days < 0 ? [later, -days] : [earlier, days];
+  const fullWeeks = Math.trunc(span / 7);
+  let count = fullWeeks * 5;
+  for (let day = from.add({ days: fullWeeks * 7 }), i = fullWeeks * 7; i < span; i++) {
+    if (!isWeekendDay(day.dayOfWeek)) count++;
+    day = day.add({ days: 1 });
+  }
+  return days < 0 && count !== 0 ? -count : count;
+}
+
+export {
+  differenceInBusinessDays
+};
+//# sourceMappingURL=chunk-RQ5CX67T.js.map

package/dist/chunk-RQ5CX67T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInBusinessDays.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { isWeekendDay, isoDate } from './shared/businessDays';\n\n/**\n * Returns the number of business days (Monday–Friday) from earlierDate up to\n * laterDate: the earlier date counts, the later date does not. Holidays are\n * not considered. Swapping the arguments negates the result.\n *\n * Only calendar dates matter; times of day are ignored. Instant inputs use\n * their UTC date and ZonedDateTime inputs use their own timezone's date.\n * Convert both to one timezone first to count from a single perspective.\n *\n * @param laterDate - The later date\n * @param earlierDate - The earlier date\n * @returns Business days between the dates (negative if laterDate is earlier)\n *\n * @example\n * ```ts\n * const friday = Temporal.PlainDate.from('2025-01-24');\n * const nextFriday = Temporal.PlainDate.from('2025-01-31');\n *\n * differenceInBusinessDays(nextFriday, friday); // 5\n * differenceInBusinessDays(friday, nextFriday); // -5\n * ```\n */\nexport function differenceInBusinessDays(\n  laterDate: Temporal.PlainDate,\n  earlierDate: Temporal.PlainDate\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime\n): number;\nexport function differenceInBusinessDays(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate\n): number {\n  if (isPlainDate(laterDate) !== isPlainDate(earlierDate)) {\n    throw new TypeError('PlainDate differences require two PlainDate values');\n  }\n  const later = isoDate(laterDate);\n  const earlier = isoDate(earlierDate);\n  const days = earlier.until(later, { largestUnit: 'days' }).days;\n  const [from, span] = days < 0 ? [later, -days] : [earlier, days];\n\n  // Every full week holds five business days; walk the remainder.\n  const fullWeeks = Math.trunc(span / 7);\n  let count = fullWeeks * 5;\n  for (let day = from.add({ days: fullWeeks * 7 }), i = fullWeeks * 7; i < span; i++) {\n    if (!isWeekendDay(day.dayOfWeek)) count++;\n    day = day.add({ days: 1 });\n  }\n  return days < 0 && count !== 0 ? -count : count;\n}\n"],"mappings":";;;;;;;;;AAiCO,SAAS,yBACd,WACA,aACQ;AACR,MAAI,YAAY,SAAS,MAAM,YAAY,WAAW,GAAG;AACvD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,OAAO,QAAQ,MAAM,OAAO,EAAE,aAAa,OAAO,CAAC,EAAE;AAC3D,QAAM,CAAC,MAAM,IAAI,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI;AAG/D,QAAM,YAAY,KAAK,MAAM,OAAO,CAAC;AACrC,MAAI,QAAQ,YAAY;AACxB,WAAS,MAAM,KAAK,IAAI,EAAE,MAAM,YAAY,EAAE,CAAC,GAAG,IAAI,YAAY,GAAG,IAAI,MAAM,KAAK;AAClF,QAAI,CAAC,aAAa,IAAI,SAAS,EAAG;AAClC,UAAM,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;AAAA,EAC3B;AACA,SAAO,OAAO,KAAK,UAAU,IAAI,CAAC,QAAQ;AAC5C;","names":[]}

package/dist/{chunk-MNV2H4N6.js → chunk-SATEE2TL.js}

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

package/dist/chunk-SATEE2TL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameWeek.ts"],"sourcesContent":["import type { Temporal } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same ISO 8601 week.\n * Uses ISO week numbering where weeks start on Monday and the first week\n * of the year is the week containing January 4th.\n *\n * Compares the yearOfWeek and weekOfYear 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 in the same ISO week, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same week (both in week 4 of 2025)\n * const monday = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]'); // Monday, Week 4\n * const sunday = Temporal.ZonedDateTime.from('2025-01-26T23:59:59Z[UTC]'); // Sunday, Week 4\n *\n * isSameWeek(monday, sunday); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different weeks\n * const week3 = Temporal.ZonedDateTime.from('2025-01-19T23:59:59Z[UTC]'); // Sunday, Week 3\n * const week4 = Temporal.ZonedDateTime.from('2025-01-20T00:00:00Z[UTC]'); // Monday, Week 4\n *\n * isSameWeek(week3, week4); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar weeks\n * const ny = Temporal.ZonedDateTime.from('2025-01-26T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-27T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local weeks from each person's perspective\n * isSameWeek(ny, tokyo); // false (Week 4 Sun in NY, Week 5 Mon in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameWeek(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Week 5 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameWeek(ny, tokyo.withTimeZone('America/New_York')); // true (both Week 4 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T00:00:00Z'); // Monday, Week 4\n * const instant2 = Temporal.Instant.from('2025-01-26T23:59:59Z'); // Sunday, Week 4\n *\n * isSameWeek(instant1, instant2); // true (both Week 4 2025 in UTC)\n * ```\n *\n * @example\n * ```ts\n * // ISO week years can differ from calendar years\n * // December 29, 2024 is in Week 52 of 2024\n * const dec29 = Temporal.ZonedDateTime.from('2024-12-29T12:00:00Z[UTC]');\n * // January 5, 2025 is in Week 1 of 2025\n * const jan5 = Temporal.ZonedDateTime.from('2025-01-05T12:00:00Z[UTC]');\n *\n * isSameWeek(dec29, jan5); // false (different ISO weeks)\n * ```\n */\nexport function isSameWeek(\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.yearOfWeek === zoned2.yearOfWeek &&\n    zoned1.weekOfYear === zoned2.weekOfYear\n  );\n}\n"],"mappings":";;;;;AAwEO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,eAAe,OAAO,cAC7B,OAAO,eAAe,OAAO;AAEjC;","names":[]}

package/dist/chunk-SLBDEPBP.js

@@ -0,0 +1,16 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+
+// src/differenceInHours.ts
+function differenceInHours(laterDate, earlierDate, options) {
+  const zoned1 = normalizeTemporalInput(laterDate);
+  const zoned2 = normalizeTemporalInput(earlierDate);
+  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;
+  return options?.fractional ? Number(nanoseconds) / 36e11 : Number(nanoseconds / 3600000000000n);
+}
+
+export {
+  differenceInHours
+};
+//# sourceMappingURL=chunk-SLBDEPBP.js.map

package/dist/chunk-SLBDEPBP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInHours.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 hours between two datetimes.\n * The result is positive if laterDate is after earlierDate, negative if before.\n * Whole units are truncated toward zero after subtracting epoch nanoseconds.\n * Numeric results use JavaScript number precision; use differenceInNanoseconds\n * when an exact bigint elapsed difference is required.\n *\n * @param laterDate - The later datetime (Instant or ZonedDateTime)\n * @param earlierDate - The earlier datetime (Instant or ZonedDateTime)\n * @param options - Optional { fractional } to return the precise value\n * @returns The number of hours 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-20T18:00:00Z');\n * const earlier = Temporal.Instant.from('2025-01-20T15:00:00Z');\n *\n * differenceInHours(later, earlier); // 3\n * ```\n *\n * @example\n * ```ts\n * // Works with ZonedDateTime\n * const later = Temporal.ZonedDateTime.from('2025-01-21T00: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 * differenceInHours(later, earlier); // 9\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 * differenceInHours(tokyo, ny); // 0 (same instant)\n * ```\n */\nexport function differenceInHours(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number {\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  const nanoseconds = zoned1.epochNanoseconds - zoned2.epochNanoseconds;\n  return options?.fractional\n    ? Number(nanoseconds) / 3_600_000_000_000\n    : Number(nanoseconds / 3_600_000_000_000n);\n}\n"],"mappings":";;;;;AA0CO,SAAS,kBACd,WACA,aACA,SACQ;AACR,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAEjD,QAAM,cAAc,OAAO,mBAAmB,OAAO;AACrD,SAAO,SAAS,aACZ,OAAO,WAAW,IAAI,QACtB,OAAO,cAAc,cAAkB;AAC7C;","names":[]}

package/dist/chunk-SMMVTXL4.js

@@ -0,0 +1,22 @@
+import {
+  addWeekdays
+} from "./chunk-Z7I7YCKN.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-JNAWZ4RN.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/addBusinessDays.ts
+function addBusinessDays(input, days) {
+  if (isPlainDate(input)) {
+    return addWeekdays(input, days);
+  }
+  return addWeekdays(normalizeTemporalInput(input), days);
+}
+
+export {
+  addBusinessDays
+};
+//# sourceMappingURL=chunk-SMMVTXL4.js.map

package/dist/chunk-SMMVTXL4.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 { addWeekdays } from './shared/businessDays';\n\n/**\n * Adds business days (Monday–Friday), skipping weekends. Holidays are not\n * considered.\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 * @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 */\nexport function addBusinessDays(input: Temporal.PlainDate, days: number): Temporal.PlainDate;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  days: number\n): Temporal.ZonedDateTime;\nexport function addBusinessDays(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  days: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return addWeekdays(input, days);\n  }\n  return addWeekdays(normalizeTemporalInput(input), days);\n}\n"],"mappings":";;;;;;;;;;;AAiCO,SAAS,gBACd,OACA,MAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,YAAY,OAAO,IAAI;AAAA,EAChC;AACA,SAAO,YAAY,uBAAuB,KAAK,GAAG,IAAI;AACxD;","names":[]}

package/dist/{chunk-GR7322AQ.js → chunk-SUONQGAH.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-XS2HUADA.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-JNAWZ4RN.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/getQuarter.ts
 function getQuarter(input) {
@@ -17,4 +17,4 @@ function getQuarter(input) {
 export {
   getQuarter
 };
-//# sourceMappingURL=chunk-GR7322AQ.js.map
+//# sourceMappingURL=chunk-SUONQGAH.js.map

package/dist/chunk-SUONQGAH.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":[]}