@gobrand/tiempo 2.10.0 → 3.0.1

package/README.md

@@ -6,7 +6,7 @@
 
 **Timezone conversions that don't suck.** Built on the [Temporal API](https://tc39.es/proposal-temporal/docs/).
 
-👉 **[Documentation](https://eng.gobrand.app/tiempo)**
+👉 **[Documentation](https://tiempo.gobrand.app)**
 
 ![tiempo banner](./tiempo_banner.png)
 
@@ -40,7 +40,7 @@ npm install @gobrand/tiempo
 
 ## Docs
 
-**[eng.gobrand.app/tiempo](https://eng.gobrand.app/tiempo)** — Full API reference, examples, and guides.
+**[tiempo.gobrand.app](https://tiempo.gobrand.app)** — Full API reference, examples, and guides.
 
 ## License
 

package/dist/addQuarters.d.ts

@@ -1,29 +1,29 @@
 import type { Temporal } from "@js-temporal/polyfill";
 /**
- * Adds the specified number of quarters (3-month blocks) to a datetime.
+ * Adds the specified number of quarters (3-month blocks) to a datetime or date.
  *
  * Properly handles month-end dates and calendar edge cases through Temporal API.
- * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ * Instant inputs are converted to UTC; ZonedDateTime inputs preserve their
+ * timezone. PlainDate inputs stay in calendar space and return a PlainDate.
  *
  * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
  * @param quarters - Number of quarters to add (can be negative to subtract)
- * @returns ZonedDateTime with quarters added, in the same timezone as input
+ * @returns A ZonedDateTime (for Instant/ZonedDateTime) with the quarters added
  *
  * @example
  * ```ts
- * // From Instant (always UTC)
  * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
- * const result = addQuarters(instant, 2);
+ * addQuarters(instant, 2);
  * // 2025-07-20T12:00:00Z[UTC] (6 months later)
  * ```
  *
  * @example
  * ```ts
- * // From ZonedDateTime (preserves timezone)
- * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
- * const result = addQuarters(zoned, 1);
- * // 2025-04-20T15:30:00-04:00[America/New_York]
+ * // Calendar arithmetic on a date stays a date
+ * addQuarters(Temporal.PlainDate.from('2025-01-31'), 1);
+ * // 2025-04-30 (Jan 31 → Apr 30)
  * ```
  */
 export declare function addQuarters(input: Temporal.Instant | Temporal.ZonedDateTime, quarters: number): Temporal.ZonedDateTime;
+export declare function addQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;
 //# sourceMappingURL=addQuarters.d.ts.map

package/dist/addQuarters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addQuarters.d.ts","sourceRoot":"","sources":["../src/addQuarters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,QAAQ,EAAE,MAAM,GACf,QAAQ,CAAC,aAAa,CAGxB"}
+{"version":3,"file":"addQuarters.d.ts","sourceRoot":"","sources":["../src/addQuarters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,QAAQ,EAAE,MAAM,GACf,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC"}

package/dist/addQuarters.js

@@ -1,6 +1,6 @@
 import {
   addQuarters
-} from "./chunk-ZEL6JBBH.js";
+} from "./chunk-UQ2F3I2S.js";
 import "./chunk-NTMT5XGC.js";
 import "./chunk-R7ZCA6AQ.js";
 export {

package/dist/browserTimezone.d.ts

@@ -1,4 +1,4 @@
-import type { IANATimezone } from './types/iana-timezones';
+import type { IANATimezone } from './types/iana-timezones.js';
 /**
  * Get the browser/device timezone.
  *

package/dist/chunk-25CVKMFC.js

@@ -0,0 +1,21 @@
+import {
+  quarterOfMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-NTMT5XGC.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/isSameQuarter.ts
+function isSameQuarter(date1, date2) {
+  const a = isPlainDate(date1) ? date1 : normalizeTemporalInput(date1);
+  const b = isPlainDate(date2) ? date2 : normalizeTemporalInput(date2);
+  return a.year === b.year && quarterOfMonth(a.month) === quarterOfMonth(b.month);
+}
+
+export {
+  isSameQuarter
+};
+//# sourceMappingURL=chunk-25CVKMFC.js.map

package/dist/chunk-25CVKMFC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameQuarter.ts"],"sourcesContent":["import type { Temporal } from \"@js-temporal/polyfill\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterOfMonth } from \"./shared/quarter\";\n\n/**\n * Returns true if both inputs fall in the same calendar quarter and year.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec.\n *\n * Instant inputs are converted to UTC; ZonedDateTime inputs keep their own\n * timezone. PlainDate inputs are compared directly — a quarter is intrinsic to\n * the calendar date, so no timezone is needed.\n *\n * @param date1 - First Instant or ZonedDateTime\n * @param date2 - Second Instant or ZonedDateTime\n * @returns true if both are in the same calendar quarter, false otherwise\n *\n * @example\n * ```ts\n * const jan = Temporal.ZonedDateTime.from('2025-01-15T08:00:00Z[UTC]');\n * const mar = Temporal.ZonedDateTime.from('2025-03-31T23:59:59Z[UTC]');\n * isSameQuarter(jan, mar); // true\n * ```\n *\n * @example\n * ```ts\n * // PlainDate comparison needs no timezone\n * const a = Temporal.PlainDate.from('2025-04-05');\n * const b = Temporal.PlainDate.from('2025-06-28');\n * isSameQuarter(a, b); // true (both Q2)\n * ```\n */\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime,\n): boolean;\nexport function isSameQuarter(date1: Temporal.PlainDate, date2: Temporal.PlainDate): boolean;\nexport function isSameQuarter(\n  date1: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  date2: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n): boolean {\n  const a = isPlainDate(date1) ? date1 : normalizeTemporalInput(date1);\n  const b = isPlainDate(date2) ? date2 : normalizeTemporalInput(date2);\n\n  return a.year === b.year && quarterOfMonth(a.month) === quarterOfMonth(b.month);\n}\n"],"mappings":";;;;;;;;;;;AAsCO,SAAS,cACd,OACA,OACS;AACT,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AACnE,QAAM,IAAI,YAAY,KAAK,IAAI,QAAQ,uBAAuB,KAAK;AAEnE,SAAO,EAAE,SAAS,EAAE,QAAQ,eAAe,EAAE,KAAK,MAAM,eAAe,EAAE,KAAK;AAChF;","names":[]}

package/dist/{chunk-SDJJP4HW.js → chunk-3TS3D7WD.js}

@@ -10,6 +10,9 @@ import {
 
 // src/startOfWeek.ts
 function startOfWeek(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.subtract({ days: input.dayOfWeek - 1 });
+  }
   const zonedDateTime = isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
   const dayOfWeek = zonedDateTime.dayOfWeek;
   const daysToSubtract = dayOfWeek - 1;
@@ -20,4 +23,4 @@ function startOfWeek(input, timezone) {
 export {
   startOfWeek
 };
-//# sourceMappingURL=chunk-SDJJP4HW.js.map
+//# sourceMappingURL=chunk-3TS3D7WD.js.map

package/dist/chunk-3TS3D7WD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfWeek.ts"],"sourcesContent":["import { isPlainDate } from './shared/temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from './types';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the first boundary of the week (Monday).\n * Uses ISO 8601 week definition: weeks start on Monday.\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 Monday 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'); // Monday\n * const start = startOfWeek(instant);\n * // 2025-01-20T00:00:00Z[UTC] (same day, it's already Monday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const start = startOfWeek(zoned);\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date);\n * // 2025-01-20 (previous Monday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const start = startOfWeek(date, 'America/New_York');\n * // 2025-01-20T00:00:00-05:00[America/New_York] (previous Monday)\n * ```\n */\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.subtract({ days: input.dayOfWeek - 1 });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to subtract to get to Monday\n  const daysToSubtract = dayOfWeek - 1;\n\n  // Go to Monday, then get start of that day\n  const monday = zonedDateTime.subtract({ days: daysToSubtract });\n\n  return monday.startOfDay();\n}\n"],"mappings":";;;;;;;;;;;AAsDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,SAAS,EAAE,MAAM,MAAM,YAAY,EAAE,CAAC;AAAA,EACrD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,iBAAiB,YAAY;AAGnC,QAAM,SAAS,cAAc,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9D,SAAO,OAAO,WAAW;AAC3B;","names":[]}

package/dist/chunk-5Y5JH32Z.js

@@ -0,0 +1,16 @@
+import {
+  addQuarters
+} from "./chunk-UQ2F3I2S.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/subQuarters.ts
+function subQuarters(input, quarters) {
+  return isPlainDate(input) ? addQuarters(input, -quarters) : addQuarters(input, -quarters);
+}
+
+export {
+  subQuarters
+};
+//# sourceMappingURL=chunk-5Y5JH32Z.js.map

package/dist/chunk-5Y5JH32Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subQuarters.ts"],"sourcesContent":["import type { Temporal } from \"@js-temporal/polyfill\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { addQuarters } from \"./addQuarters\";\n\n/**\n * Subtracts the specified number of quarters (3-month blocks) from a datetime or date.\n *\n * This is a convenience wrapper around addQuarters with the count negated.\n * PlainDate inputs stay in calendar space and return a PlainDate.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param quarters - Number of quarters to subtract\n * @returns A ZonedDateTime (for Instant/ZonedDateTime) with the quarters subtracted\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-07-20T12:00:00Z');\n * subQuarters(instant, 2);\n * // 2025-01-20T12:00:00Z[UTC] (6 months earlier)\n * ```\n *\n * @example\n * ```ts\n * subQuarters(Temporal.PlainDate.from('2025-07-20'), 1);\n * // 2025-04-20\n * ```\n */\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  quarters: number,\n): Temporal.ZonedDateTime;\nexport function subQuarters(input: Temporal.PlainDate, quarters: number): Temporal.PlainDate;\nexport function subQuarters(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  quarters: number,\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  // Branch so each call resolves to the matching addQuarters overload.\n  return isPlainDate(input) ? addQuarters(input, -quarters) : addQuarters(input, -quarters);\n}\n"],"mappings":";;;;;;;;AAgCO,SAAS,YACd,OACA,UAC6C;AAE7C,SAAO,YAAY,KAAK,IAAI,YAAY,OAAO,CAAC,QAAQ,IAAI,YAAY,OAAO,CAAC,QAAQ;AAC1F;","names":[]}

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

@@ -1,12 +1,19 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-ZOHYNJUD.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 import {
-  normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/endOfYear.ts
 function endOfYear(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    const lastMonth2 = input.with({ month: input.monthsInYear });
+    return lastMonth2.with({ day: lastMonth2.daysInMonth });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });
   const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });
@@ -16,4 +23,4 @@ function endOfYear(input, timezone) {
 export {
   endOfYear
 };
-//# sourceMappingURL=chunk-KN45BU3W.js.map
+//# sourceMappingURL=chunk-7OEGJCW7.js.map

package/dist/chunk-7OEGJCW7.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.999999999Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-05:00[America/New_York]');\n * const end = endOfYear(zoned);\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date);\n * // 2025-12-31\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const end = endOfYear(date, 'America/New_York');\n * // 2025-12-31T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfYear(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    const lastMonth = input.with({ month: input.monthsInYear });\n    return lastMonth.with({ day: lastMonth.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastMonth = zonedDateTime.with({ month: zonedDateTime.monthsInYear });\n  const lastDay = lastMonth.with({ day: lastMonth.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AAoDO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,UAAMA,aAAY,MAAM,KAAK,EAAE,OAAO,MAAM,aAAa,CAAC;AAC1D,WAAOA,WAAU,KAAK,EAAE,KAAKA,WAAU,YAAY,CAAC;AAAA,EACtD;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,YAAY,cAAc,KAAK,EAAE,OAAO,cAAc,aAAa,CAAC;AAC1E,QAAM,UAAU,UAAU,KAAK,EAAE,KAAK,UAAU,YAAY,CAAC;AAC7D,SAAO,YAAY,OAAO;AAC5B;","names":["lastMonth"]}

package/dist/{chunk-XMW72PNW.js → chunk-7SCQV77A.js}

@@ -4,9 +4,15 @@ import {
 import {
   normalizeWithPlainDate
 } from "./chunk-ZOHYNJUD.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/startOfQuarter.ts
 function startOfQuarter(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.with({ month: quarterStartMonth(input.month), day: 1 });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const firstDay = zonedDateTime.with({
     month: quarterStartMonth(zonedDateTime.month),
@@ -18,4 +24,4 @@ function startOfQuarter(input, timezone) {
 export {
   startOfQuarter
 };
-//# sourceMappingURL=chunk-XMW72PNW.js.map
+//# sourceMappingURL=chunk-7SCQV77A.js.map

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

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

package/dist/{chunk-5CFWMIHL.js → chunk-BV32K227.js}

@@ -1,9 +1,15 @@
 import {
   normalizeWithPlainDate
 } from "./chunk-ZOHYNJUD.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/startOfMonth.ts
 function startOfMonth(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.with({ day: 1 });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const firstDay = zonedDateTime.with({ day: 1 });
   return firstDay.startOfDay();
@@ -12,4 +18,4 @@ function startOfMonth(input, timezone) {
 export {
   startOfMonth
 };
-//# sourceMappingURL=chunk-5CFWMIHL.js.map
+//# sourceMappingURL=chunk-BV32K227.js.map

package/dist/chunk-BV32K227.js.map

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

package/dist/chunk-GR7322AQ.js

@@ -0,0 +1,20 @@
+import {
+  quarterOfMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-NTMT5XGC.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/getQuarter.ts
+function getQuarter(input) {
+  const month = isPlainDate(input) ? input.month : normalizeTemporalInput(input).month;
+  return quarterOfMonth(month);
+}
+
+export {
+  getQuarter
+};
+//# sourceMappingURL=chunk-GR7322AQ.js.map

package/dist/chunk-GR7322AQ.js.map

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

package/dist/chunk-KPB5ENNM.js

@@ -0,0 +1,25 @@
+import {
+  differenceInMonths
+} from "./chunk-CIA46DWB.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/differenceInQuarters.ts
+function differenceInQuarters(laterDate, earlierDate, options) {
+  const months = isPlainDate(laterDate) && isPlainDate(earlierDate) ? earlierDate.until(laterDate).total({
+    unit: "months",
+    relativeTo: earlierDate
+  }) : differenceInMonths(
+    laterDate,
+    earlierDate,
+    { fractional: true }
+  );
+  const quarters = months / 3;
+  return options?.fractional ? quarters : Math.trunc(quarters);
+}
+
+export {
+  differenceInQuarters
+};
+//# sourceMappingURL=chunk-KPB5ENNM.js.map

package/dist/chunk-KPB5ENNM.js.map

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

package/dist/{chunk-PVOGE6ME.js → chunk-MTDZG4HK.js}

@@ -13,6 +13,9 @@ import {
 
 // src/endOfWeek.ts
 function endOfWeek(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.add({ days: 7 - input.dayOfWeek });
+  }
   const zonedDateTime = isPlainDate(input) ? plainDateToZonedDateTime(input, timezone) : normalizeTemporalInput(input);
   const dayOfWeek = zonedDateTime.dayOfWeek;
   const daysToAdd = 7 - dayOfWeek;
@@ -23,4 +26,4 @@ function endOfWeek(input, timezone) {
 export {
   endOfWeek
 };
-//# sourceMappingURL=chunk-PVOGE6ME.js.map
+//# sourceMappingURL=chunk-MTDZG4HK.js.map

package/dist/chunk-MTDZG4HK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfWeek.ts"],"sourcesContent":["import { isPlainDate } from './shared/temporal';\nimport type { Temporal } from '@js-temporal/polyfill';\nimport type { Timezone } from './types';\nimport { getEndOfDay } from './shared/endOfDay';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\nimport { plainDateToZonedDateTime } from './shared/plainDateToZonedDateTime';\n\n/**\n * Returns the last boundary of the week (Sunday).\n * Uses ISO 8601 week definition: weeks end on Sunday.\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 Sunday 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z'); // Monday\n * const end = endOfWeek(instant);\n * // 2025-01-26T23:59:59.999999999Z[UTC] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-22T15:30:00-05:00[America/New_York]'); // Wednesday\n * const end = endOfWeek(zoned);\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date);\n * // 2025-01-26 (next Sunday)\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-01-22'); // Wednesday\n * const end = endOfWeek(date, 'America/New_York');\n * // 2025-01-26T23:59:59.999999999-05:00[America/New_York] (next Sunday)\n * ```\n */\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfWeek(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfWeek(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfWeek(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.add({ days: 7 - input.dayOfWeek });\n  }\n\n  const zonedDateTime =\n    isPlainDate(input)\n      ? plainDateToZonedDateTime(input, timezone!)\n      : normalizeTemporalInput(input);\n\n  // Get the day of week (1 = Monday, 7 = Sunday in ISO 8601)\n  const dayOfWeek = zonedDateTime.dayOfWeek;\n\n  // Calculate days to add to get to Sunday\n  const daysToAdd = 7 - dayOfWeek;\n\n  // Go to Sunday, then get end of that day\n  const sunday = zonedDateTime.add({ days: daysToAdd });\n\n  return getEndOfDay(sunday);\n}\n"],"mappings":";;;;;;;;;;;;;;AAuDO,SAAS,UACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,IAAI,EAAE,MAAM,IAAI,MAAM,UAAU,CAAC;AAAA,EAChD;AAEA,QAAM,gBACJ,YAAY,KAAK,IACb,yBAAyB,OAAO,QAAS,IACzC,uBAAuB,KAAK;AAGlC,QAAM,YAAY,cAAc;AAGhC,QAAM,YAAY,IAAI;AAGtB,QAAM,SAAS,cAAc,IAAI,EAAE,MAAM,UAAU,CAAC;AAEpD,SAAO,YAAY,MAAM;AAC3B;","names":[]}

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

@@ -1,15 +1,25 @@
 import {
   quarterStartMonth
 } from "./chunk-XS2HUADA.js";
+import {
+  normalizeWithPlainDate
+} from "./chunk-ZOHYNJUD.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 import {
-  normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/endOfQuarter.ts
 function endOfQuarter(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    const endMonth2 = input.with({
+      month: quarterStartMonth(input.month) + 2,
+      day: 1
+    });
+    return endMonth2.with({ day: endMonth2.daysInMonth });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const endMonth = zonedDateTime.with({
     month: quarterStartMonth(zonedDateTime.month) + 2,
@@ -22,4 +32,4 @@ function endOfQuarter(input, timezone) {
 export {
   endOfQuarter
 };
-//# sourceMappingURL=chunk-SPK7C7RP.js.map
+//# sourceMappingURL=chunk-OSBVYUOQ.js.map

package/dist/chunk-OSBVYUOQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfQuarter.ts"],"sourcesContent":["import { isPlainDate } from \"./shared/temporal\";\nimport type { Temporal } from \"@js-temporal/polyfill\";\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":";;;;;;;;;;;;;;AA6CO,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-TGINH5JV.js → chunk-OVSCDXYN.js}

@@ -1,9 +1,15 @@
 import {
   normalizeWithPlainDate
 } from "./chunk-ZOHYNJUD.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/startOfYear.ts
 function startOfYear(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.with({ month: 1, day: 1 });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const firstDay = zonedDateTime.with({ month: 1, day: 1 });
   return firstDay.startOfDay();
@@ -12,4 +18,4 @@ function startOfYear(input, timezone) {
 export {
   startOfYear
 };
-//# sourceMappingURL=chunk-TGINH5JV.js.map
+//# sourceMappingURL=chunk-OVSCDXYN.js.map

package/dist/chunk-OVSCDXYN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/startOfYear.ts"],"sourcesContent":["import { isPlainDate, Temporal } from './shared/temporal';\nimport type { Timezone } from './types';\nimport { normalizeWithPlainDate } from './shared/normalizeWithPlainDate';\n\n/**\n * Returns the first boundary of the 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 January 1st at 00:00:00.000000000\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-06-15T12:00:00Z');\n * const start = startOfYear(instant);\n * // 2025-01-01T00:00:00Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-06-15T15:30:00-05:00[America/New_York]');\n * const start = startOfYear(zoned);\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const start = startOfYear(date);\n * // 2025-01-01\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-06-15');\n * const start = startOfYear(date, 'America/New_York');\n * // 2025-01-01T00:00:00-05:00[America/New_York]\n * ```\n */\nexport function startOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function startOfYear(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function startOfYear(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function startOfYear(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ month: 1, day: 1 });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const firstDay = zonedDateTime.with({ month: 1, day: 1 });\n  return firstDay.startOfDay();\n}\n"],"mappings":";;;;;;;;AAmDO,SAAS,YACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AAAA,EACxC;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,WAAW,cAAc,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAAC;AACxD,SAAO,SAAS,WAAW;AAC7B;","names":[]}

package/dist/{chunk-7HUJC5M6.js → chunk-S7L5KBI4.js}

@@ -1,9 +1,9 @@
-import {
-  getEndOfDay
-} from "./chunk-AVGNRINZ.js";
 import {
   normalizeWithPlainDate
 } from "./chunk-ZOHYNJUD.js";
+import {
+  getEndOfDay
+} from "./chunk-AVGNRINZ.js";
 
 // src/endOfDay.ts
 function endOfDay(input, timezone) {
@@ -14,4 +14,4 @@ function endOfDay(input, timezone) {
 export {
   endOfDay
 };
-//# sourceMappingURL=chunk-7HUJC5M6.js.map
+//# sourceMappingURL=chunk-S7L5KBI4.js.map

package/dist/chunk-UQ2F3I2S.js

@@ -0,0 +1,19 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-NTMT5XGC.js";
+import {
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/addQuarters.ts
+function addQuarters(input, quarters) {
+  if (isPlainDate(input)) {
+    return input.add({ months: quarters * 3 });
+  }
+  return normalizeTemporalInput(input).add({ months: quarters * 3 });
+}
+
+export {
+  addQuarters
+};
+//# sourceMappingURL=chunk-UQ2F3I2S.js.map

package/dist/chunk-UQ2F3I2S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addQuarters.ts"],"sourcesContent":["import type { Temporal } from \"@js-temporal/polyfill\";\nimport { 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) or Temporal.ZonedDateTime\n * @param quarters - Number of quarters to add (can be negative to subtract)\n * @returns A ZonedDateTime (for Instant/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:00Z[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":";;;;;;;;AAkCO,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-RXTGHEHQ.js → chunk-VQAGV72H.js}

@@ -1,9 +1,10 @@
 import {
-  Temporal
+  Temporal,
+  isInstant
 } from "./chunk-R7ZCA6AQ.js";
 
-// src/toUtc.ts
-function toUtc(input) {
+// src/toInstant.ts
+function toInstant(input) {
   if (typeof input === "string") {
     return Temporal.Instant.from(input);
   }
@@ -13,10 +14,10 @@ function toUtc(input) {
   if (input instanceof Date) {
     return Temporal.Instant.from(input.toISOString());
   }
-  return input.toInstant();
+  return isInstant(input) ? input : input.toInstant();
 }
 
 export {
-  toUtc
+  toInstant
 };
-//# sourceMappingURL=chunk-RXTGHEHQ.js.map
+//# sourceMappingURL=chunk-VQAGV72H.js.map

package/dist/chunk-VQAGV72H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toInstant.ts"],"sourcesContent":["import { Temporal, isInstant } from './shared/temporal';\n\n/**\n * Converts a timeline representation to a Temporal.Instant.\n *\n * Instant inputs are returned unchanged. ZonedDateTime inputs preserve their\n * exact moment while dropping timezone and calendar context.\n *\n * @param input - An Instant, ZonedDateTime, UTC ISO string, Unix timestamp, or Date\n * @returns A timezone-independent Temporal.Instant\n *\n * @example\n * ```typescript\n * const instant = toInstant('2025-01-20T20:00:00Z');\n * // 2025-01-20T20:00:00Z\n * ```\n *\n * @example\n * ```typescript\n * const zoned = Temporal.ZonedDateTime.from(\n *   '2025-01-20T15:00:00-05:00[America/New_York]'\n * );\n * const instant = toInstant(zoned);\n * // 2025-01-20T20:00:00Z\n * ```\n */\nexport function toInstant(\n  input: string | number | Date | Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.Instant {\n  if (typeof input === 'string') {\n    return Temporal.Instant.from(input);\n  }\n\n  if (typeof input === 'number') {\n    return Temporal.Instant.fromEpochMilliseconds(input);\n  }\n\n  if (input instanceof Date) {\n    return Temporal.Instant.from(input.toISOString());\n  }\n\n  return isInstant(input) ? input : input.toInstant();\n}\n"],"mappings":";;;;;;AA0BO,SAAS,UACd,OACkB;AAClB,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,SAAS,QAAQ,KAAK,KAAK;AAAA,EACpC;AAEA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,SAAS,QAAQ,sBAAsB,KAAK;AAAA,EACrD;AAEA,MAAI,iBAAiB,MAAM;AACzB,WAAO,SAAS,QAAQ,KAAK,MAAM,YAAY,CAAC;AAAA,EAClD;AAEA,SAAO,UAAU,KAAK,IAAI,QAAQ,MAAM,UAAU;AACpD;","names":[]}

package/dist/{chunk-VCWP3CZE.js → chunk-YNLBS34B.js}

@@ -1,12 +1,18 @@
+import {
+  normalizeWithPlainDate
+} from "./chunk-ZOHYNJUD.js";
 import {
   getEndOfDay
 } from "./chunk-AVGNRINZ.js";
 import {
-  normalizeWithPlainDate
-} from "./chunk-ZOHYNJUD.js";
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
 
 // src/endOfMonth.ts
 function endOfMonth(input, timezone) {
+  if (isPlainDate(input) && timezone === void 0) {
+    return input.with({ day: input.daysInMonth });
+  }
   const zonedDateTime = normalizeWithPlainDate(input, timezone);
   const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });
   return getEndOfDay(lastDay);
@@ -15,4 +21,4 @@ function endOfMonth(input, timezone) {
 export {
   endOfMonth
 };
-//# sourceMappingURL=chunk-VCWP3CZE.js.map
+//# sourceMappingURL=chunk-YNLBS34B.js.map

package/dist/chunk-YNLBS34B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endOfMonth.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 month.\n * PlainDate inputs stay in calendar space unless a timezone is provided.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @returns ZonedDateTime at the last day of the month at 23:59:59.999999999\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-15T12:00:00Z');\n * const end = endOfMonth(instant);\n * // 2025-01-31T23:59:59.999999999Z[UTC]\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (uses its timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-02-15T15:30:00-05:00[America/New_York]');\n * const end = endOfMonth(zoned);\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate (stays a date)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date);\n * // 2025-02-28\n * ```\n *\n * @example\n * ```ts\n * // From PlainDate with a timezone (returns a ZonedDateTime)\n * const date = Temporal.PlainDate.from('2025-02-15');\n * const end = endOfMonth(date, 'America/New_York');\n * // 2025-02-28T23:59:59.999999999-05:00[America/New_York]\n * ```\n */\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime\n): Temporal.ZonedDateTime;\nexport function endOfMonth(input: Temporal.PlainDate): Temporal.PlainDate;\nexport function endOfMonth(\n  input: Temporal.PlainDate,\n  timezone: Timezone\n): Temporal.ZonedDateTime;\nexport function endOfMonth(\n  input: Temporal.Instant | Temporal.ZonedDateTime | Temporal.PlainDate,\n  timezone?: Timezone\n): Temporal.ZonedDateTime | Temporal.PlainDate {\n  if (isPlainDate(input) && timezone === undefined) {\n    return input.with({ day: input.daysInMonth });\n  }\n\n  const zonedDateTime = normalizeWithPlainDate(input, timezone!);\n  const lastDay = zonedDateTime.with({ day: zonedDateTime.daysInMonth });\n  return getEndOfDay(lastDay);\n}\n"],"mappings":";;;;;;;;;;;AAoDO,SAAS,WACd,OACA,UAC6C;AAC7C,MAAI,YAAY,KAAK,KAAK,aAAa,QAAW;AAChD,WAAO,MAAM,KAAK,EAAE,KAAK,MAAM,YAAY,CAAC;AAAA,EAC9C;AAEA,QAAM,gBAAgB,uBAAuB,OAAO,QAAS;AAC7D,QAAM,UAAU,cAAc,KAAK,EAAE,KAAK,cAAc,YAAY,CAAC;AACrE,SAAO,YAAY,OAAO;AAC5B;","names":[]}

package/dist/chunk-YRCFMGBH.js

@@ -0,0 +1,54 @@
+import {
+  quarterStartMonth
+} from "./chunk-XS2HUADA.js";
+import {
+  normalizeTemporalInput
+} from "./chunk-NTMT5XGC.js";
+import {
+  Temporal,
+  isPlainDate
+} from "./chunk-R7ZCA6AQ.js";
+
+// src/eachQuarterOfInterval.ts
+function eachQuarterOfInterval(interval) {
+  if (isPlainDate(interval.start) && isPlainDate(interval.end)) {
+    return eachQuarterStart(interval.start, interval.end, (ym) => ym.toPlainDate({ day: 1 }));
+  }
+  const startZoned = normalizeTemporalInput(
+    interval.start
+  );
+  const endZoned = normalizeTemporalInput(
+    interval.end
+  );
+  const timezone = startZoned.timeZoneId;
+  return eachQuarterStart(
+    startZoned,
+    endZoned.withTimeZone(timezone),
+    (ym) => ym.toPlainDate({ day: 1 }).toZonedDateTime({
+      timeZone: timezone,
+      plainTime: new Temporal.PlainTime()
+    })
+  );
+}
+function eachQuarterStart(start, end, make) {
+  const startYearMonth = Temporal.PlainYearMonth.from({
+    year: start.year,
+    month: quarterStartMonth(start.month)
+  });
+  const endYearMonth = Temporal.PlainYearMonth.from({
+    year: end.year,
+    month: quarterStartMonth(end.month)
+  });
+  const out = [];
+  let current = startYearMonth;
+  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {
+    out.push(make(current));
+    current = current.add({ months: 3 });
+  }
+  return out;
+}
+
+export {
+  eachQuarterOfInterval
+};
+//# sourceMappingURL=chunk-YRCFMGBH.js.map

package/dist/chunk-YRCFMGBH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eachQuarterOfInterval.ts"],"sourcesContent":["import { Temporal } from \"./shared/temporal\";\nimport { isPlainDate } from \"./shared/temporal\";\nimport { normalizeTemporalInput } from \"./shared/normalizeTemporalInput\";\nimport { quarterStartMonth } from \"./shared/quarter\";\n\n/**\n * Returns an array with the start of each quarter within the interval, inclusive\n * of both the start and end quarters.\n *\n * Quarters: Q1 = Jan–Mar, Q2 = Apr–Jun, Q3 = Jul–Sep, Q4 = Oct–Dec. Each element\n * is the first moment of the quarter (1st day of the quarter's starting month at\n * midnight) for Instant/ZonedDateTime inputs, or the first day as a PlainDate for\n * PlainDate inputs.\n *\n * For Instant inputs, UTC is used. For ZonedDateTime inputs, the timezone of the\n * start date is preserved. PlainDate inputs need no timezone and return PlainDate[].\n *\n * @param interval - The interval with start and end\n * @returns Array of ZonedDateTime (or PlainDate) at the start of each quarter\n *\n * @example\n * ```ts\n * const start = Temporal.ZonedDateTime.from('2025-02-15T10:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-11-20T14:00:00Z[UTC]');\n * eachQuarterOfInterval({ start, end });\n * // [2025-01-01…, 2025-04-01…, 2025-07-01…, 2025-10-01…]\n * ```\n *\n * @example\n * ```ts\n * // PlainDate interval returns PlainDate quarter starts (no timezone)\n * eachQuarterOfInterval({\n *   start: Temporal.PlainDate.from('2025-02-15'),\n *   end: Temporal.PlainDate.from('2025-08-20'),\n * });\n * // [2025-01-01, 2025-04-01, 2025-07-01]\n * ```\n */\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.Instant | Temporal.ZonedDateTime;\n  end: Temporal.Instant | Temporal.ZonedDateTime;\n}): Temporal.ZonedDateTime[];\nexport function eachQuarterOfInterval(interval: {\n  start: Temporal.PlainDate;\n  end: Temporal.PlainDate;\n}): Temporal.PlainDate[];\nexport function eachQuarterOfInterval(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    return eachQuarterStart(interval.start, interval.end, (ym) => ym.toPlainDate({ day: 1 }));\n  }\n\n  const startZoned = normalizeTemporalInput(\n    interval.start as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  const endZoned = normalizeTemporalInput(\n    interval.end as Temporal.Instant | Temporal.ZonedDateTime,\n  );\n  const timezone = startZoned.timeZoneId;\n\n  return eachQuarterStart(startZoned, endZoned.withTimeZone(timezone), (ym) =>\n    ym.toPlainDate({ day: 1 }).toZonedDateTime({\n      timeZone: timezone,\n      plainTime: new Temporal.PlainTime(),\n    }),\n  );\n}\n\n/**\n * Walks quarter-aligned year-months from start to end (inclusive) and maps each\n * to a result. Both bounds are snapped to their quarter's starting month.\n */\nfunction eachQuarterStart<T>(\n  start: { year: number; month: number },\n  end: { year: number; month: number },\n  make: (ym: Temporal.PlainYearMonth) => T,\n): T[] {\n  const startYearMonth = Temporal.PlainYearMonth.from({\n    year: start.year,\n    month: quarterStartMonth(start.month),\n  });\n  const endYearMonth = Temporal.PlainYearMonth.from({\n    year: end.year,\n    month: quarterStartMonth(end.month),\n  });\n\n  const out: T[] = [];\n  let current = startYearMonth;\n  while (Temporal.PlainYearMonth.compare(current, endYearMonth) <= 0) {\n    out.push(make(current));\n    current = current.add({ months: 3 });\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;AA8CO,SAAS,sBAAsB,UAGc;AAClD,MAAI,YAAY,SAAS,KAAK,KAAK,YAAY,SAAS,GAAG,GAAG;AAC5D,WAAO,iBAAiB,SAAS,OAAO,SAAS,KAAK,CAAC,OAAO,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;AAAA,EAC1F;AAEA,QAAM,aAAa;AAAA,IACjB,SAAS;AAAA,EACX;AACA,QAAM,WAAW;AAAA,IACf,SAAS;AAAA,EACX;AACA,QAAM,WAAW,WAAW;AAE5B,SAAO;AAAA,IAAiB;AAAA,IAAY,SAAS,aAAa,QAAQ;AAAA,IAAG,CAAC,OACpE,GAAG,YAAY,EAAE,KAAK,EAAE,CAAC,EAAE,gBAAgB;AAAA,MACzC,UAAU;AAAA,MACV,WAAW,IAAI,SAAS,UAAU;AAAA,IACpC,CAAC;AAAA,EACH;AACF;AAMA,SAAS,iBACP,OACA,KACA,MACK;AACL,QAAM,iBAAiB,SAAS,eAAe,KAAK;AAAA,IAClD,MAAM,MAAM;AAAA,IACZ,OAAO,kBAAkB,MAAM,KAAK;AAAA,EACtC,CAAC;AACD,QAAM,eAAe,SAAS,eAAe,KAAK;AAAA,IAChD,MAAM,IAAI;AAAA,IACV,OAAO,kBAAkB,IAAI,KAAK;AAAA,EACpC,CAAC;AAED,QAAM,MAAW,CAAC;AAClB,MAAI,UAAU;AACd,SAAO,SAAS,eAAe,QAAQ,SAAS,YAAY,KAAK,GAAG;AAClE,QAAI,KAAK,KAAK,OAAO,CAAC;AACtB,cAAU,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC;AAAA,EACrC;AACA,SAAO;AACT;","names":[]}

package/dist/differenceInDays.d.ts

@@ -1,5 +1,5 @@
-import { Temporal } from './shared/temporal';
-import type { DifferenceOptions } from './shared/differenceOptions';
+import { Temporal } from './shared/temporal.js';
+import type { DifferenceOptions } from './shared/differenceOptions.js';
 /**
  * Returns the number of days between two datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.

package/dist/differenceInHours.d.ts

@@ -1,5 +1,5 @@
-import { Temporal } from './shared/temporal';
-import type { DifferenceOptions } from './shared/differenceOptions';
+import { Temporal } from './shared/temporal.js';
+import type { DifferenceOptions } from './shared/differenceOptions.js';
 /**
  * Returns the number of hours between two datetimes.
  * The result is positive if laterDate is after earlierDate, negative if before.