@gobrand/tiempo 3.0.1 → 3.1.3

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-OVBZ2NBB.js

@@ -0,0 +1,30 @@
+import {
+  isWeekendDay,
+  isoDate
+} from "./chunk-K7CLBBBM.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-OVBZ2NBB.js.map

package/dist/chunk-OVBZ2NBB.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-KPB5ENNM.js → chunk-PAM6VJQM.js}

@@ -1,13 +1,13 @@
 import {
   differenceInMonths
-} from "./chunk-CIA46DWB.js";
+} from "./chunk-KZCSP3DU.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/differenceInQuarters.ts
 function differenceInQuarters(laterDate, earlierDate, options) {
-  const months = isPlainDate(laterDate) && isPlainDate(earlierDate) ? earlierDate.until(laterDate).total({
+  const months = isPlainDate(laterDate) && isPlainDate(earlierDate) ? earlierDate.until(laterDate.toString()).total({
     unit: "months",
     relativeTo: earlierDate
   }) : differenceInMonths(
@@ -22,4 +22,4 @@ function differenceInQuarters(laterDate, earlierDate, options) {
 export {
   differenceInQuarters
 };
-//# sourceMappingURL=chunk-KPB5ENNM.js.map
+//# sourceMappingURL=chunk-PAM6VJQM.js.map

package/dist/chunk-PAM6VJQM.js.map

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

package/dist/chunk-Q6QLOUXJ.js

@@ -0,0 +1,18 @@
+import {
+  isInstant,
+  isZonedDateTime
+} from "./chunk-BSVOJYJ7.js";
+
+// src/shared/normalizeTemporalInput.ts
+function normalizeTemporalInput(input) {
+  if (isInstant(input)) return input.toZonedDateTimeISO("UTC");
+  if (isZonedDateTime(input)) return input;
+  throw new TypeError(
+    `Expected a Temporal.Instant or Temporal.ZonedDateTime, got ${Object.prototype.toString.call(input).slice(8, -1)}`
+  );
+}
+
+export {
+  normalizeTemporalInput
+};
+//# sourceMappingURL=chunk-Q6QLOUXJ.js.map

package/dist/chunk-Q6QLOUXJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeTemporalInput.ts"],"sourcesContent":["import { type Temporal, isInstant, isZonedDateTime } from './temporal';\n\n/**\n * @internal\n * Normalizes input to ZonedDateTime. Converts Instant to UTC, or returns existing ZonedDateTime.\n * Anything else (a PlainDate, a string, a Date) throws, so a wrong-domain value can never\n * flow through as if it were a moment.\n * This is an internal helper - do not use directly.\n */\nexport function normalizeTemporalInput(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime {\n  if (isInstant(input)) return input.toZonedDateTimeISO('UTC');\n  if (isZonedDateTime(input)) return input;\n  throw new TypeError(\n    `Expected a Temporal.Instant or Temporal.ZonedDateTime, got ${Object.prototype.toString.call(input).slice(8, -1)}`\n  );\n}\n"],"mappings":";;;;;;AASO,SAAS,uBACd,OACwB;AACxB,MAAI,UAAU,KAAK,EAAG,QAAO,MAAM,mBAAmB,KAAK;AAC3D,MAAI,gBAAgB,KAAK,EAAG,QAAO;AACnC,QAAM,IAAI;AAAA,IACR,8DAA8D,OAAO,UAAU,SAAS,KAAK,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC;AAAA,EAClH;AACF;","names":[]}

package/dist/{chunk-UQ2F3I2S.js → chunk-QDY2KMYX.js}

@@ -1,9 +1,9 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/addQuarters.ts
 function addQuarters(input, quarters) {
@@ -16,4 +16,4 @@ function addQuarters(input, quarters) {
 export {
   addQuarters
 };
-//# sourceMappingURL=chunk-UQ2F3I2S.js.map
+//# sourceMappingURL=chunk-QDY2KMYX.js.map

package/dist/chunk-QDY2KMYX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addQuarters.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\n\n/**\n * Adds the specified number of quarters (3-month blocks) to a datetime or date.\n *\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC; ZonedDateTime inputs preserve their\n * timezone. PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC), Temporal.ZonedDateTime, or Temporal.PlainDate\n * @param quarters - Number of quarters to add (can be negative to subtract)\n * @returns PlainDate for a date input; otherwise ZonedDateTime with the quarters added\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * addQuarters(instant, 2);\n * // 2025-07-20T12:00:00+00:00[UTC] (6 months later)\n * ```\n *\n * @example\n * ```ts\n * // Calendar arithmetic on a date stays a date\n * addQuarters(Temporal.PlainDate.from('2025-01-31'), 1);\n * // 2025-04-30 (Jan 31 → Apr 30)\n * ```\n */\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function addQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function addQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input)) {\n    return input.add({ months: quarters * 3 });\n  }\n  return normalizeTemporalInput(input).add({ months: quarters * 3 });\n}\n"],"mappings":";;;;;;;;AAiCO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AAAA,EAC3C;AACA,SAAO,uBAAuB,KAAK,EAAE,IAAI,EAAE,QAAQ,WAAW,EAAE,CAAC;AACnE;","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-7OEGJCW7.js → chunk-QNZJR53W.js}

@@ -1,12 +1,12 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.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-QNZJR53W.js.map

package/dist/chunk-QNZJR53W.js.map

@@ -0,0 +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.999999999+00:00[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-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-MENMDB6M.js → chunk-QZ6WXAUO.js}

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

package/dist/chunk-QZ6WXAUO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameHour.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 hour.\n * Compares the year, month, day, and hour 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 hour, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same hour\n * const start = Temporal.ZonedDateTime.from('2025-01-20T14:00:00+00:00[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999+00:00[UTC]');\n *\n * isSameHour(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different hours\n * const hour14 = Temporal.ZonedDateTime.from('2025-01-20T14:59:59+00:00[UTC]');\n * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00+00:00[UTC]');\n *\n * isSameHour(hour14, hour15); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local hours\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local hours from each person's perspective\n * isSameHour(ny, tokyo); // false (14:xx in NY, 04:xx in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameHour(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:xx in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameHour(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:xx in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:15:30Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:45:50Z');\n *\n * isSameHour(instant1, instant2); // true (both 14:xx in UTC)\n * ```\n */\nexport function isSameHour(\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  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,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;AAE3B;","names":[]}

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

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

package/dist/chunk-R2DCUSBY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameYear.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 calendar year.\n * Compares the year field 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 calendar year, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same year\n * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00+00:00[UTC]');\n * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59+00:00[UTC]');\n *\n * isSameYear(jan, dec); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different years\n * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59+00:00[UTC]');\n * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00+00:00[UTC]');\n *\n * isSameYear(endOf2024, startOf2025); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar years\n * const ny = Temporal.ZonedDateTime.from('2024-12-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar years from each person's perspective\n * isSameYear(ny, tokyo); // false (2024 in NY, 2025 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameYear(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 2025 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameYear(ny, tokyo.withTimeZone('America/New_York')); // true (both 2024 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-12-31T23:59:59Z');\n *\n * isSameYear(instant1, instant2); // true (both 2025 in UTC)\n * ```\n */\nexport function isSameYear(\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 zoned1.year === zoned2.year;\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO;AAChC;","names":[]}

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

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

package/dist/chunk-R5XRTUWH.js.map

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

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

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

package/dist/chunk-SHKSAHJO.js.map

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

package/dist/chunk-SLH6TKGN.js

@@ -0,0 +1,16 @@
+import {
+  addWeeks
+} from "./chunk-3X2U6I44.js";
+import {
+  isPlainDate
+} from "./chunk-BSVOJYJ7.js";
+
+// src/subWeeks.ts
+function subWeeks(input, weeks) {
+  return isPlainDate(input) ? addWeeks(input, -weeks) : addWeeks(input, -weeks);
+}
+
+export {
+  subWeeks
+};
+//# sourceMappingURL=chunk-SLH6TKGN.js.map

package/dist/chunk-SLH6TKGN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subWeeks.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './shared/temporal';\nimport { addWeeks } from './addWeeks';\n\n/**\n * Subtracts the specified number of weeks from a datetime or date.\n *\n * This is a convenience wrapper around addWeeks with negated value.\n * Properly handles DST transitions 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 weeks - Number of weeks to subtract\n * @returns PlainDate for a date input; otherwise ZonedDateTime with weeks subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-02-03T12:00:00Z');\n * const result = subWeeks(instant, 2);\n * // 2025-01-20T12:00:00+00:00[UTC] (2 weeks earlier)\n * ```\n */\nexport function subWeeks(input: Temporal.PlainDate, weeks: number): Temporal.PlainDate;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime;\nexport function subWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  weeks: number\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Narrow each branch to the matching addWeeks overload.\n  return isPlainDate(input) ? addWeeks(input, -weeks) : addWeeks(input, -weeks);\n}\n"],"mappings":";;;;;;;;AA2BO,SAAS,SACd,OACA,OAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK,IAAI,SAAS,OAAO,CAAC,KAAK;AAC9E;","names":[]}

package/dist/{chunk-ZOHYNJUD.js → chunk-TCB3IDJM.js}

@@ -1,12 +1,12 @@
 import {
   plainDateToZonedDateTime
-} from "./chunk-L5AMAEWX.js";
+} from "./chunk-2AID4P2C.js";
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.js";
 import {
   isPlainDate
-} from "./chunk-R7ZCA6AQ.js";
+} from "./chunk-BSVOJYJ7.js";
 
 // src/shared/normalizeWithPlainDate.ts
 function normalizeWithPlainDate(input, timezone) {
@@ -16,4 +16,4 @@ function normalizeWithPlainDate(input, timezone) {
 export {
   normalizeWithPlainDate
 };
-//# sourceMappingURL=chunk-ZOHYNJUD.js.map
+//# sourceMappingURL=chunk-TCB3IDJM.js.map

package/dist/chunk-TCB3IDJM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/normalizeWithPlainDate.ts"],"sourcesContent":["import { type Temporal, isPlainDate } from './temporal';\nimport type { Timezone } from '../types';\nimport { normalizeTemporalInput } from './normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './plainDateToZonedDateTime';\n\n/**\n * @internal\n * Normalizes any temporal input (Instant, ZonedDateTime, or PlainDate) to ZonedDateTime.\n * - Instant → UTC ZonedDateTime\n * - ZonedDateTime → returned as-is\n * - PlainDate → ZonedDateTime at midnight in the specified timezone\n *\n * This is an internal helper - do not use directly.\n */\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime;\nexport function normalizeWithPlainDate(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  return isPlainDate(input)\n    ? plainDateToZonedDateTime(input, timezone!)\n    : normalizeTemporalInput(input);\n}\n"],"mappings":";;;;;;;;;;;AAyBO,SAAS,uBACd,OACA,UACwB;AACxB,SAAO,YAAY,KAAK,IACpB,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAClC;","names":[]}

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

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

package/dist/chunk-TD6MVGV2.js.map

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

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

@@ -1,6 +1,6 @@
 import {
   normalizeTemporalInput
-} from "./chunk-NTMT5XGC.js";
+} from "./chunk-Q6QLOUXJ.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-TI6WBLCB.js.map

package/dist/chunk-TI6WBLCB.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.000500+00:00[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.000500+00:00[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-VKXN4FQD.js → chunk-TIZJRCAA.js}

@@ -1,6 +1,6 @@
 import {
   normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+} from "./chunk-TCB3IDJM.js";
 
 // src/startOfDay.ts
 function startOfDay(input, timezone) {
@@ -11,4 +11,4 @@ function startOfDay(input, timezone) {
 export {
   startOfDay
 };
-//# sourceMappingURL=chunk-VKXN4FQD.js.map
+//# sourceMappingURL=chunk-TIZJRCAA.js.map

package/dist/chunk-TIZJRCAA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfDay.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 day (midnight).\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const start = startOfDay(instant);\n * // 2025-01-20T00:00:00+00:00[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const start = startOfDay(zoned);\n * // 2025-01-20T00: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-01-20');\n * const start = startOfDay(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfDay(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfDay(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  return zonedDateTime.startOfDay();\n}\n"],"mappings":";;;;;AAyCO,SAAS,WACd,OACA,UACwB;AACxB,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,SAAO,cAAc,WAAW;AAClC;","names":[]}

package/dist/chunk-TU3LNQKW.js

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

package/dist/chunk-TU3LNQKW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/differenceInWeeks.ts"],"sourcesContent":["import { Temporal, isPlainDate } from './shared/temporal';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport type { DifferenceOptions } from './shared/differenceOptions';\n\n/**\n * Two PlainDates use calendar arithmetic without a timezone. Their calendars must match.\n * Native and polyfill inputs may be mixed within the same Temporal domain.\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.PlainDate,\n  earlierDate: Temporal.PlainDate,\n  options?: DifferenceOptions\n): number;\nexport function differenceInWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime,\n  options?: DifferenceOptions\n): number;\nexport function differenceInWeeks(\n  laterDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  earlierDate: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  options?: DifferenceOptions\n): number {\n  if (isPlainDate(laterDate) || isPlainDate(earlierDate)) {\n    if (!isPlainDate(laterDate) || !isPlainDate(earlierDate)) {\n      throw new TypeError('PlainDate differences require two PlainDate values');\n    }\n    const duration = earlierDate.until(laterDate.toString(), { largestUnit: 'days' });\n    const precise = duration.total({ unit: 'weeks', relativeTo: earlierDate });\n    return options?.fractional ? precise : Math.trunc(precise);\n  }\n  const zoned1 = normalizeTemporalInput(laterDate);\n  const zoned2 = normalizeTemporalInput(earlierDate);\n\n  // A canonical string preserves zone, calendar, and precision across implementations.\n  const duration = zoned2.until(zoned1.toString(), { largestUnit: 'hours' });\n  const precise = duration.total({ unit: 'weeks', relativeTo: zoned2 });\n  return options?.fractional ? precise : Math.trunc(precise);\n}\n"],"mappings":";;;;;;;;AA0DO,SAAS,kBACd,WACA,aACA,SACQ;AACR,MAAI,YAAY,SAAS,KAAK,YAAY,WAAW,GAAG;AACtD,QAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,WAAW,GAAG;AACxD,YAAM,IAAI,UAAU,oDAAoD;AAAA,IAC1E;AACA,UAAMA,YAAW,YAAY,MAAM,UAAU,SAAS,GAAG,EAAE,aAAa,OAAO,CAAC;AAChF,UAAMC,WAAUD,UAAS,MAAM,EAAE,MAAM,SAAS,YAAY,YAAY,CAAC;AACzE,WAAO,SAAS,aAAaC,WAAU,KAAK,MAAMA,QAAO;AAAA,EAC3D;AACA,QAAM,SAAS,uBAAuB,SAAS;AAC/C,QAAM,SAAS,uBAAuB,WAAW;AAGjD,QAAM,WAAW,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,aAAa,QAAQ,CAAC;AACzE,QAAM,UAAU,SAAS,MAAM,EAAE,MAAM,SAAS,YAAY,OAAO,CAAC;AACpE,SAAO,SAAS,aAAa,UAAU,KAAK,MAAM,OAAO;AAC3D;","names":["duration","precise"]}

package/dist/{chunk-PXF3RMFH.js → chunk-TWXUGWYX.js}

@@ -166,9 +166,11 @@ function formatToken(token, date, locale) {
 }
 function formatPart(date, part, style, locale) {
   const options = {
-    [part]: style
+    [part]: style,
+    timeZone: "UTC",
+    calendar: date.calendarId === "iso8601" ? void 0 : date.calendarId
   };
-  return date.toLocaleString(locale, options);
+  return new Intl.DateTimeFormat(locale, options).formatToParts(date.toZonedDateTime("UTC").epochMilliseconds).find((value) => value.type === part)?.value ?? "";
 }
 function getOrdinalSuffix(num) {
   const j = num % 10;
@@ -182,4 +184,4 @@ function getOrdinalSuffix(num) {
 export {
   formatPlainDate
 };
-//# sourceMappingURL=chunk-PXF3RMFH.js.map
+//# sourceMappingURL=chunk-TWXUGWYX.js.map

package/dist/{chunk-PXF3RMFH.js.map → chunk-TWXUGWYX.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/formatPlainDate.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\nexport interface FormatPlainDateOptions {\n  locale?: string;\n}\n\n/**\n * Format a Temporal.PlainDate using date-fns-like format tokens.\n * Uses Intl.DateTimeFormat under the hood for locale support.\n *\n * Only supports date-related tokens (no time or timezone tokens).\n *\n * @param date - A Temporal.PlainDate to format\n * @param formatStr - Format string using date-fns tokens (e.g., \"yyyy-MM-dd\")\n * @param options - Optional configuration for locale\n * @returns Formatted date string\n *\n * @example\n * ```typescript\n * const date = Temporal.PlainDate.from(\"2025-01-20\");\n *\n * formatPlainDate(date, \"yyyy-MM-dd\"); // \"2025-01-20\"\n * formatPlainDate(date, \"MMMM d, yyyy\"); // \"January 20, 2025\"\n * formatPlainDate(date, \"EEEE, MMMM do, yyyy\"); // \"Monday, January 20th, 2025\"\n *\n * // With locale\n * formatPlainDate(date, \"MMMM d, yyyy\", { locale: \"es-ES\" }); // \"enero 20, 2025\"\n * ```\n */\nexport function formatPlainDate(\n  date: Temporal.PlainDate,\n  formatStr: string,\n  options: FormatPlainDateOptions = {}\n): string {\n  const { locale = 'en-US' } = options;\n\n  let result = '';\n  let i = 0;\n  const len = formatStr.length;\n\n  while (i < len) {\n    const char = formatStr[i];\n    if (!char) break;\n\n    // Handle escaped text\n    if (char === \"'\") {\n      // Check for double single quote (not inside a string, just '')\n      if (i + 1 < len && formatStr[i + 1] === \"'\") {\n        result += \"'\";\n        i += 2;\n        continue;\n      }\n      // Find closing quote, handling '' inside the string\n      i++;\n      while (i < len) {\n        if (formatStr[i] === \"'\") {\n          // Check if it's a doubled quote ''\n          if (i + 1 < len && formatStr[i + 1] === \"'\") {\n            result += \"'\";\n            i += 2;\n          } else {\n            // End of quoted string\n            i++;\n            break;\n          }\n        } else {\n          result += formatStr[i];\n          i++;\n        }\n      }\n      continue;\n    }\n\n    // Check for tokens by looking ahead\n    const token = consumeToken(formatStr, i, char);\n    if (token !== null) {\n      result += formatToken(token, date, locale);\n      i += token.length;\n    } else {\n      result += char;\n      i++;\n    }\n  }\n\n  return result;\n}\n\nfunction consumeToken(formatStr: string, start: number, char: string): string | null {\n  // Special case for 'Mo' and 'do' - these end with 'o'\n  if (char === 'M' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'Mo';\n  }\n  if (char === 'd' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'do';\n  }\n\n  // Count how many consecutive identical characters\n  let end = start;\n  while (end < formatStr.length && formatStr[end] === char) {\n    end++;\n  }\n  const count = end - start;\n\n  // Valid tokens for PlainDate (date-only, no time/timezone)\n  const validTokens = [\n    // Era\n    'GGGGG',\n    'GGGG',\n    'GGG',\n    'GG',\n    'G',\n    // Year\n    'yyyy',\n    'yyy',\n    'yy',\n    'y',\n    // Quarter\n    'QQQQQ',\n    'QQQQ',\n    'QQQ',\n    'QQ',\n    'Q',\n    // Month\n    'MMMMM',\n    'MMMM',\n    'MMM',\n    'MM',\n    'M',\n    // Day\n    'dd',\n    'd',\n    // Weekday\n    'EEEEEE',\n    'EEEEE',\n    'EEEE',\n    'EEE',\n    'EE',\n    'E',\n  ];\n\n  // Try to match from longest to shortest\n  for (let len = Math.min(count, 6); len > 0; len--) {\n    const candidate = char.repeat(len);\n    if (validTokens.includes(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n\nfunction formatToken(token: string, date: Temporal.PlainDate, locale: string): string {\n  switch (token) {\n    // Era\n    case 'GGGGG':\n      return formatPart(date, 'era', 'narrow', locale);\n    case 'GGGG':\n      return formatPart(date, 'era', 'long', locale);\n    case 'GGG':\n    case 'GG':\n    case 'G':\n      return formatPart(date, 'era', 'short', locale);\n\n    // Year\n    case 'yyyy':\n      return date.year.toString().padStart(4, '0');\n    case 'yyy':\n      return date.year.toString().padStart(3, '0');\n    case 'yy':\n      return (date.year % 100).toString().padStart(2, '0');\n    case 'y':\n      return date.year.toString();\n\n    // Quarter\n    case 'QQQQQ':\n      return Math.ceil(date.month / 3).toString();\n    case 'QQQQ': {\n      const quarter = Math.ceil(date.month / 3);\n      return `${quarter}${getOrdinalSuffix(quarter)} quarter`;\n    }\n    case 'QQQ':\n      return `Q${Math.ceil(date.month / 3)}`;\n    case 'QQ':\n      return Math.ceil(date.month / 3)\n        .toString()\n        .padStart(2, '0');\n    case 'Q':\n      return Math.ceil(date.month / 3).toString();\n\n    // Month\n    case 'MMMMM':\n      return formatPart(date, 'month', 'narrow', locale);\n    case 'MMMM':\n      return formatPart(date, 'month', 'long', locale);\n    case 'MMM':\n      return formatPart(date, 'month', 'short', locale);\n    case 'MM':\n      return date.month.toString().padStart(2, '0');\n    case 'Mo':\n      return `${date.month}${getOrdinalSuffix(date.month)}`;\n    case 'M':\n      return date.month.toString();\n\n    // Day of month\n    case 'do':\n      return `${date.day}${getOrdinalSuffix(date.day)}`;\n    case 'dd':\n      return date.day.toString().padStart(2, '0');\n    case 'd':\n      return date.day.toString();\n\n    // Day of week\n    case 'EEEEEE':\n      return formatPart(date, 'weekday', 'short', locale).slice(0, 2);\n    case 'EEEEE':\n      return formatPart(date, 'weekday', 'narrow', locale);\n    case 'EEEE':\n      return formatPart(date, 'weekday', 'long', locale);\n    case 'EEE':\n    case 'EE':\n    case 'E':\n      return formatPart(date, 'weekday', 'short', locale);\n\n    default:\n      return token;\n  }\n}\n\nfunction formatPart(\n  date: Temporal.PlainDate,\n  part: 'era' | 'year' | 'month' | 'weekday' | 'day',\n  style: 'narrow' | 'short' | 'long' | 'numeric' | '2-digit',\n  locale: string\n): string {\n  const options: Intl.DateTimeFormatOptions = {\n    [part]: style,\n  };\n\n  return date.toLocaleString(locale, options);\n}\n\nfunction getOrdinalSuffix(num: number): string {\n  const j = num % 10;\n  const k = num % 100;\n  if (j === 1 && k !== 11) return 'st';\n  if (j === 2 && k !== 12) return 'nd';\n  if (j === 3 && k !== 13) return 'rd';\n  return 'th';\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/formatPlainDate.ts"],"sourcesContent":["import { Temporal } from './shared/temporal';\n\nexport interface FormatPlainDateOptions {\n  locale?: string;\n}\n\n/**\n * Format a Temporal.PlainDate using date-fns-like format tokens.\n * Uses Intl.DateTimeFormat under the hood for locale support.\n *\n * Only supports date-related tokens (no time or timezone tokens).\n *\n * @param date - A Temporal.PlainDate to format\n * @param formatStr - Format string using date-fns tokens (e.g., \"yyyy-MM-dd\")\n * @param options - Optional configuration for locale\n * @returns Formatted date string\n *\n * @example\n * ```typescript\n * const date = Temporal.PlainDate.from(\"2025-01-20\");\n *\n * formatPlainDate(date, \"yyyy-MM-dd\"); // \"2025-01-20\"\n * formatPlainDate(date, \"MMMM d, yyyy\"); // \"January 20, 2025\"\n * formatPlainDate(date, \"EEEE, MMMM do, yyyy\"); // \"Monday, January 20th, 2025\"\n *\n * // With locale\n * formatPlainDate(date, \"MMMM d, yyyy\", { locale: \"es-ES\" }); // \"enero 20, 2025\"\n * ```\n */\nexport function formatPlainDate(\n  date: Temporal.PlainDate,\n  formatStr: string,\n  options: FormatPlainDateOptions = {}\n): string {\n  const { locale = 'en-US' } = options;\n\n  let result = '';\n  let i = 0;\n  const len = formatStr.length;\n\n  while (i < len) {\n    const char = formatStr[i];\n    if (!char) break;\n\n    // Handle escaped text\n    if (char === \"'\") {\n      // Check for double single quote (not inside a string, just '')\n      if (i + 1 < len && formatStr[i + 1] === \"'\") {\n        result += \"'\";\n        i += 2;\n        continue;\n      }\n      // Find closing quote, handling '' inside the string\n      i++;\n      while (i < len) {\n        if (formatStr[i] === \"'\") {\n          // Check if it's a doubled quote ''\n          if (i + 1 < len && formatStr[i + 1] === \"'\") {\n            result += \"'\";\n            i += 2;\n          } else {\n            // End of quoted string\n            i++;\n            break;\n          }\n        } else {\n          result += formatStr[i];\n          i++;\n        }\n      }\n      continue;\n    }\n\n    // Check for tokens by looking ahead\n    const token = consumeToken(formatStr, i, char);\n    if (token !== null) {\n      result += formatToken(token, date, locale);\n      i += token.length;\n    } else {\n      result += char;\n      i++;\n    }\n  }\n\n  return result;\n}\n\nfunction consumeToken(formatStr: string, start: number, char: string): string | null {\n  // Special case for 'Mo' and 'do' - these end with 'o'\n  if (char === 'M' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'Mo';\n  }\n  if (char === 'd' && start + 1 < formatStr.length && formatStr[start + 1] === 'o') {\n    return 'do';\n  }\n\n  // Count how many consecutive identical characters\n  let end = start;\n  while (end < formatStr.length && formatStr[end] === char) {\n    end++;\n  }\n  const count = end - start;\n\n  // Valid tokens for PlainDate (date-only, no time/timezone)\n  const validTokens = [\n    // Era\n    'GGGGG',\n    'GGGG',\n    'GGG',\n    'GG',\n    'G',\n    // Year\n    'yyyy',\n    'yyy',\n    'yy',\n    'y',\n    // Quarter\n    'QQQQQ',\n    'QQQQ',\n    'QQQ',\n    'QQ',\n    'Q',\n    // Month\n    'MMMMM',\n    'MMMM',\n    'MMM',\n    'MM',\n    'M',\n    // Day\n    'dd',\n    'd',\n    // Weekday\n    'EEEEEE',\n    'EEEEE',\n    'EEEE',\n    'EEE',\n    'EE',\n    'E',\n  ];\n\n  // Try to match from longest to shortest\n  for (let len = Math.min(count, 6); len > 0; len--) {\n    const candidate = char.repeat(len);\n    if (validTokens.includes(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n\nfunction formatToken(token: string, date: Temporal.PlainDate, locale: string): string {\n  switch (token) {\n    // Era\n    case 'GGGGG':\n      return formatPart(date, 'era', 'narrow', locale);\n    case 'GGGG':\n      return formatPart(date, 'era', 'long', locale);\n    case 'GGG':\n    case 'GG':\n    case 'G':\n      return formatPart(date, 'era', 'short', locale);\n\n    // Year\n    case 'yyyy':\n      return date.year.toString().padStart(4, '0');\n    case 'yyy':\n      return date.year.toString().padStart(3, '0');\n    case 'yy':\n      return (date.year % 100).toString().padStart(2, '0');\n    case 'y':\n      return date.year.toString();\n\n    // Quarter\n    case 'QQQQQ':\n      return Math.ceil(date.month / 3).toString();\n    case 'QQQQ': {\n      const quarter = Math.ceil(date.month / 3);\n      return `${quarter}${getOrdinalSuffix(quarter)} quarter`;\n    }\n    case 'QQQ':\n      return `Q${Math.ceil(date.month / 3)}`;\n    case 'QQ':\n      return Math.ceil(date.month / 3)\n        .toString()\n        .padStart(2, '0');\n    case 'Q':\n      return Math.ceil(date.month / 3).toString();\n\n    // Month\n    case 'MMMMM':\n      return formatPart(date, 'month', 'narrow', locale);\n    case 'MMMM':\n      return formatPart(date, 'month', 'long', locale);\n    case 'MMM':\n      return formatPart(date, 'month', 'short', locale);\n    case 'MM':\n      return date.month.toString().padStart(2, '0');\n    case 'Mo':\n      return `${date.month}${getOrdinalSuffix(date.month)}`;\n    case 'M':\n      return date.month.toString();\n\n    // Day of month\n    case 'do':\n      return `${date.day}${getOrdinalSuffix(date.day)}`;\n    case 'dd':\n      return date.day.toString().padStart(2, '0');\n    case 'd':\n      return date.day.toString();\n\n    // Day of week\n    case 'EEEEEE':\n      return formatPart(date, 'weekday', 'short', locale).slice(0, 2);\n    case 'EEEEE':\n      return formatPart(date, 'weekday', 'narrow', locale);\n    case 'EEEE':\n      return formatPart(date, 'weekday', 'long', locale);\n    case 'EEE':\n    case 'EE':\n    case 'E':\n      return formatPart(date, 'weekday', 'short', locale);\n\n    default:\n      return token;\n  }\n}\n\nfunction formatPart(\n  date: Temporal.PlainDate,\n  part: 'era' | 'year' | 'month' | 'weekday' | 'day',\n  style: 'narrow' | 'short' | 'long' | 'numeric' | '2-digit',\n  locale: string\n): string {\n  const options: Intl.DateTimeFormatOptions = {\n    [part]: style,\n    timeZone: 'UTC',\n    calendar: date.calendarId === 'iso8601' ? undefined : date.calendarId,\n  };\n\n  return new Intl.DateTimeFormat(locale, options)\n    .formatToParts(date.toZonedDateTime('UTC').epochMilliseconds)\n    .find(value => value.type === part)?.value ?? '';\n}\n\nfunction getOrdinalSuffix(num: number): string {\n  const j = num % 10;\n  const k = num % 100;\n  if (j === 1 && k !== 11) return 'st';\n  if (j === 2 && k !== 12) return 'nd';\n  if (j === 3 && k !== 13) return 'rd';\n  return 'th';\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-U7VOIXLY.js

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