@internationalized/date 3.12.0 → 3.12.2

package/src/manipulation.ts

@@ -10,9 +10,29 @@
  * governing permissions and limitations under the License.
  */
 
-import {AnyCalendarDate, AnyDateTime, AnyTime, CycleOptions, CycleTimeOptions, DateDuration, DateField, DateFields, DateTimeDuration, Disambiguation, TimeDuration, TimeField, TimeFields} from './types';
+import {
+  AnyCalendarDate,
+  AnyDateTime,
+  AnyTime,
+  CycleOptions,
+  CycleTimeOptions,
+  DateDuration,
+  DateField,
+  DateFields,
+  DateTimeDuration,
+  Disambiguation,
+  TimeDuration,
+  TimeField,
+  TimeFields
+} from './types';
 import {CalendarDate, CalendarDateTime, Time, ZonedDateTime} from './CalendarDate';
-import {epochFromDate, fromAbsolute, toAbsolute, toCalendar, toCalendarDateTime} from './conversion';
+import {
+  epochFromDate,
+  fromAbsolute,
+  toAbsolute,
+  toCalendar,
+  toCalendarDateTime
+} from './conversion';
 import {GregorianCalendar} from './calendars/GregorianCalendar';
 import {Mutable} from './utils';
 
@@ -20,8 +40,14 @@ const ONE_HOUR = 3600000;
 
 export function add(date: CalendarDateTime, duration: DateTimeDuration): CalendarDateTime;
 export function add(date: CalendarDate, duration: DateDuration): CalendarDate;
-export function add(date: CalendarDate | CalendarDateTime, duration: DateTimeDuration): CalendarDate | CalendarDateTime;
-export function add(date: CalendarDate | CalendarDateTime, duration: DateTimeDuration): Mutable<AnyCalendarDate | AnyDateTime> {
+export function add(
+  date: CalendarDate | CalendarDateTime,
+  duration: DateTimeDuration
+): CalendarDate | CalendarDateTime;
+export function add(
+  date: CalendarDate | CalendarDateTime,
+  duration: DateTimeDuration
+): Mutable<AnyCalendarDate | AnyDateTime> {
   let mutableDate: Mutable<AnyCalendarDate | AnyDateTime> = date.copy();
   let days = 'hour' in mutableDate ? addTimeFields(mutableDate, duration) : 0;
 
@@ -74,7 +100,10 @@ export function add(date: CalendarDate | CalendarDateTime, duration: DateTimeDur
     mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
   }
 
-  mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+  mutableDate.day = Math.max(
+    1,
+    Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day)
+  );
   return mutableDate;
 }
 
@@ -140,13 +169,19 @@ export function invertDuration(duration: DateTimeDuration): DateTimeDuration {
 
 export function subtract(date: CalendarDateTime, duration: DateTimeDuration): CalendarDateTime;
 export function subtract(date: CalendarDate, duration: DateDuration): CalendarDate;
-export function subtract(date: CalendarDate | CalendarDateTime, duration: DateTimeDuration): CalendarDate | CalendarDateTime {
+export function subtract(
+  date: CalendarDate | CalendarDateTime,
+  duration: DateTimeDuration
+): CalendarDate | CalendarDateTime {
   return add(date, invertDuration(duration));
 }
 
 export function set(date: CalendarDateTime, fields: DateFields): CalendarDateTime;
 export function set(date: CalendarDate, fields: DateFields): CalendarDate;
-export function set(date: CalendarDate | CalendarDateTime, fields: DateFields): Mutable<AnyCalendarDate> {
+export function set(
+  date: CalendarDate | CalendarDateTime,
+  fields: DateFields
+): Mutable<AnyCalendarDate> {
   let mutableDate: Mutable<AnyCalendarDate> = date.copy();
 
   if (fields.era != null) {
@@ -171,7 +206,10 @@ export function set(date: CalendarDate | CalendarDateTime, fields: DateFields):
 
 export function setTime(value: CalendarDateTime, fields: TimeFields): CalendarDateTime;
 export function setTime(value: Time, fields: TimeFields): Time;
-export function setTime(value: Time | CalendarDateTime, fields: TimeFields): Mutable<Time | CalendarDateTime> {
+export function setTime(
+  value: Time | CalendarDateTime,
+  fields: TimeFields
+): Mutable<Time | CalendarDateTime> {
   let mutableValue: Mutable<Time | CalendarDateTime> = value.copy();
 
   if (fields.hour != null) {
@@ -243,9 +281,24 @@ export function subtractTime(time: Time, duration: TimeDuration): Time {
   return addTime(time, invertDuration(duration));
 }
 
-export function cycleDate(value: CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): CalendarDateTime;
-export function cycleDate(value: CalendarDate, field: DateField, amount: number, options?: CycleOptions): CalendarDate;
-export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): Mutable<CalendarDate | CalendarDateTime> {
+export function cycleDate(
+  value: CalendarDateTime,
+  field: DateField,
+  amount: number,
+  options?: CycleOptions
+): CalendarDateTime;
+export function cycleDate(
+  value: CalendarDate,
+  field: DateField,
+  amount: number,
+  options?: CycleOptions
+): CalendarDate;
+export function cycleDate(
+  value: CalendarDate | CalendarDateTime,
+  field: DateField,
+  amount: number,
+  options?: CycleOptions
+): Mutable<CalendarDate | CalendarDateTime> {
   let mutable: Mutable<CalendarDate | CalendarDateTime> = value.copy();
 
   switch (field) {
@@ -281,10 +334,22 @@ export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateFie
       break;
     }
     case 'month':
-      mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
+      mutable.month = cycleValue(
+        value.month,
+        amount,
+        1,
+        value.calendar.getMonthsInYear(value),
+        options?.round
+      );
       break;
     case 'day':
-      mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+      mutable.day = cycleValue(
+        value.day,
+        amount,
+        1,
+        value.calendar.getDaysInMonth(value),
+        options?.round
+      );
       break;
     default:
       throw new Error('Unsupported field ' + field);
@@ -298,9 +363,24 @@ export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateFie
   return mutable;
 }
 
-export function cycleTime(value: CalendarDateTime, field: TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime;
-export function cycleTime(value: Time, field: TimeField, amount: number, options?: CycleTimeOptions): Time;
-export function cycleTime(value: Time | CalendarDateTime, field: TimeField, amount: number, options?: CycleTimeOptions): Mutable<Time | CalendarDateTime> {
+export function cycleTime(
+  value: CalendarDateTime,
+  field: TimeField,
+  amount: number,
+  options?: CycleTimeOptions
+): CalendarDateTime;
+export function cycleTime(
+  value: Time,
+  field: TimeField,
+  amount: number,
+  options?: CycleTimeOptions
+): Time;
+export function cycleTime(
+  value: Time | CalendarDateTime,
+  field: TimeField,
+  amount: number,
+  options?: CycleTimeOptions
+): Mutable<Time | CalendarDateTime> {
   let mutable: Mutable<Time | CalendarDateTime> = value.copy();
 
   switch (field) {
@@ -364,7 +444,12 @@ function cycleValue(value: number, amount: number, min: number, max: number, rou
 
 export function addZoned(dateTime: ZonedDateTime, duration: DateTimeDuration): ZonedDateTime {
   let ms: number;
-  if ((duration.years != null && duration.years !== 0) || (duration.months != null && duration.months !== 0) || (duration.weeks != null && duration.weeks !== 0) || (duration.days != null && duration.days !== 0)) {
+  if (
+    (duration.years != null && duration.years !== 0) ||
+    (duration.months != null && duration.months !== 0) ||
+    (duration.weeks != null && duration.weeks !== 0) ||
+    (duration.days != null && duration.days !== 0)
+  ) {
     let res = add(toCalendarDateTime(dateTime), {
       years: duration.years,
       months: duration.months,
@@ -396,7 +481,12 @@ export function subtractZoned(dateTime: ZonedDateTime, duration: DateTimeDuratio
   return addZoned(dateTime, invertDuration(duration));
 }
 
-export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
+export function cycleZoned(
+  dateTime: ZonedDateTime,
+  field: DateField | TimeField,
+  amount: number,
+  options?: CycleTimeOptions
+): ZonedDateTime {
   // For date fields, we want the time to remain consistent and the UTC offset to potentially change to account for DST changes.
   // For time fields, we want the time to change by the amount given. This may result in the hour field staying the same, but the UTC
   // offset changing in the case of a backward DST transition, or skipping an hour in the case of a forward DST transition.
@@ -417,12 +507,18 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
       // that is within the current day.
       let plainDateTime = toCalendarDateTime(dateTime);
       let minDate = toCalendar(setTime(plainDateTime, {hour: min}), new GregorianCalendar());
-      let minAbsolute = [toAbsolute(minDate, dateTime.timeZone, 'earlier'), toAbsolute(minDate, dateTime.timeZone, 'later')]
-        .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === minDate.day)[0];
+      let minAbsolute = [
+        toAbsolute(minDate, dateTime.timeZone, 'earlier'),
+        toAbsolute(minDate, dateTime.timeZone, 'later')
+      ].filter(ms => fromAbsolute(ms, dateTime.timeZone).day === minDate.day)[0];
 
       let maxDate = toCalendar(setTime(plainDateTime, {hour: max}), new GregorianCalendar());
-      let maxAbsolute = [toAbsolute(maxDate, dateTime.timeZone, 'earlier'), toAbsolute(maxDate, dateTime.timeZone, 'later')]
-        .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === maxDate.day).pop()!;
+      let maxAbsolute = [
+        toAbsolute(maxDate, dateTime.timeZone, 'earlier'),
+        toAbsolute(maxDate, dateTime.timeZone, 'later')
+      ]
+        .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === maxDate.day)
+        .pop()!;
 
       // Since hours may repeat, we need to operate on the absolute time in milliseconds.
       // This is done in hours from the Unix epoch so that cycleValue works correctly,
@@ -430,13 +526,16 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
       let ms = epochFromDate(dateTime) - dateTime.offset;
       let hours = Math.floor(ms / ONE_HOUR);
       let remainder = ms % ONE_HOUR;
-      ms = cycleValue(
-        hours,
-        amount,
-        Math.floor(minAbsolute / ONE_HOUR),
-        Math.floor(maxAbsolute / ONE_HOUR),
-        options?.round
-      ) * ONE_HOUR + remainder;
+      ms =
+        cycleValue(
+          hours,
+          amount,
+          Math.floor(minAbsolute / ONE_HOUR),
+          Math.floor(maxAbsolute / ONE_HOUR),
+          options?.round
+        ) *
+          ONE_HOUR +
+        remainder;
 
       // Now compute the new timezone offset, and convert the absolute time back to local time.
       return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
@@ -459,7 +558,11 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
   }
 }
 
-export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
+export function setZoned(
+  dateTime: ZonedDateTime,
+  fields: DateFields & TimeFields,
+  disambiguation?: Disambiguation
+): ZonedDateTime {
   // Set the date/time fields, and recompute the UTC offset to account for DST changes.
   // We also need to validate by converting back to a local time in case hours are skipped during forward DST transitions.
   let plainDateTime = toCalendarDateTime(dateTime);

package/src/queries.ts

@@ -11,19 +11,20 @@
  */
 
 import {AnyCalendarDate, AnyTime, Calendar} from './types';
-import {CalendarDate, CalendarDateTime, ZonedDateTime} from './CalendarDate';
+import {CalendarDate, CalendarDateTime, DateValue, ZonedDateTime} from './CalendarDate';
 import {fromAbsolute, toAbsolute, toCalendar, toCalendarDate} from './conversion';
 import {weekStartData} from './weekStartData';
 
-type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
-
 /** Returns whether the given dates occur on the same day, regardless of the time or calendar system. */
 export function isSameDay(a: DateValue, b: DateValue): boolean {
   b = toCalendar(b, a.calendar);
   return a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
 }
 
-/** Returns whether the given dates occur in the same month, using the calendar system of the first date. */
+/**
+ * Returns whether the given dates occur in the same month, using the calendar system of the first
+ * date.
+ */
 export function isSameMonth(a: DateValue, b: DateValue): boolean {
   b = toCalendar(b, a.calendar);
   // In the Japanese calendar, months can span multiple eras/years, so only compare the first of the month.
@@ -32,7 +33,10 @@ export function isSameMonth(a: DateValue, b: DateValue): boolean {
   return a.era === b.era && a.year === b.year && a.month === b.month;
 }
 
-/** Returns whether the given dates occur in the same year, using the calendar system of the first date. */
+/**
+ * Returns whether the given dates occur in the same year, using the calendar system of the first
+ * date.
+ */
 export function isSameYear(a: DateValue, b: DateValue): boolean {
   b = toCalendar(b, a.calendar);
   a = startOfYear(a);
@@ -212,19 +216,47 @@ export function getMinimumDayInMonth(date: AnyCalendarDate): number {
 }
 
 /** Returns the first date of the week for the given date and locale. */
-export function startOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
-export function startOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
-export function startOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+export function startOfWeek(
+  date: ZonedDateTime,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): ZonedDateTime;
+export function startOfWeek(
+  date: CalendarDateTime,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): CalendarDateTime;
+export function startOfWeek(
+  date: CalendarDate,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): CalendarDate;
 export function startOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
-export function startOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue {
+export function startOfWeek(
+  date: DateValue,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): DateValue {
   let dayOfWeek = getDayOfWeek(date, locale, firstDayOfWeek);
   return date.subtract({days: dayOfWeek});
 }
 
 /** Returns the last date of the week for the given date and locale. */
-export function endOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
-export function endOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
-export function endOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+export function endOfWeek(
+  date: ZonedDateTime,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): ZonedDateTime;
+export function endOfWeek(
+  date: CalendarDateTime,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): CalendarDateTime;
+export function endOfWeek(
+  date: CalendarDate,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): CalendarDate;
 export function endOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
 export function endOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue {
   return startOfWeek(date, locale, firstDayOfWeek).add({days: 6});
@@ -306,13 +338,20 @@ function getWeekStart(locale: string): number {
 }
 
 /** Returns the number of weeks in the given month and locale. */
-export function getWeeksInMonth(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): number {
+export function getWeeksInMonth(
+  date: DateValue,
+  locale: string,
+  firstDayOfWeek?: DayOfWeek
+): number {
   let days = date.calendar.getDaysInMonth(date);
   return Math.ceil((getDayOfWeek(startOfMonth(date), locale, firstDayOfWeek) + days) / 7);
 }
 
 /** Returns the lesser of the two provider dates. */
-export function minDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined {
+export function minDate<A extends DateValue, B extends DateValue>(
+  a?: A | null,
+  b?: B | null
+): A | B | null | undefined {
   if (a && b) {
     return a.compare(b) <= 0 ? a : b;
   }
@@ -321,7 +360,10 @@ export function minDate<A extends DateValue, B extends DateValue>(a?: A | null,
 }
 
 /** Returns the greater of the two provider dates. */
-export function maxDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined {
+export function maxDate<A extends DateValue, B extends DateValue>(
+  a?: A | null,
+  b?: B | null
+): A | B | null | undefined {
   if (a && b) {
     return a.compare(b) >= 0 ? a : b;
   }

package/src/string.ts

@@ -12,18 +12,29 @@
 
 import {AnyDateTime, DateTimeDuration, Disambiguation} from './types';
 import {CalendarDate, CalendarDateTime, Time, ZonedDateTime} from './CalendarDate';
-import {epochFromDate, fromAbsolute, possibleAbsolutes, toAbsolute, toCalendar, toCalendarDateTime, toTimeZone} from './conversion';
+import {
+  epochFromDate,
+  fromAbsolute,
+  possibleAbsolutes,
+  toAbsolute,
+  toCalendar,
+  toCalendarDateTime,
+  toTimeZone
+} from './conversion';
 import {getLocalTimeZone} from './queries';
 import {GregorianCalendar} from './calendars/GregorianCalendar';
 import {Mutable} from './utils';
 
 const TIME_RE = /^(\d{2})(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
 const DATE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})$/;
-const DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
-const ZONED_DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:([+-]\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?\[(.*?)\]$/;
-const ABSOLUTE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:(?:([+-]\d{2})(?::?(\d{2}))?)|Z)$/;
+const DATE_TIME_RE =
+  /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
+const ZONED_DATE_TIME_RE =
+  /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:([+-]\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?\[(.*?)\]$/;
+const ABSOLUTE_RE =
+  /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:(?:([+-]\d{2})(?::?(\d{2}))?)|Z)$/;
 const DATE_TIME_DURATION_RE =
-    /^((?<negative>-)|\+)?P((?<years>\d*)Y)?((?<months>\d*)M)?((?<weeks>\d*)W)?((?<days>\d*)D)?((?<time>T)((?<hours>\d*[.,]?\d{1,9})H)?((?<minutes>\d*[.,]?\d{1,9})M)?((?<seconds>\d*[.,]?\d{1,9})S)?)?$/;
+  /^((?<negative>-)|\+)?P((?<years>\d*)Y)?((?<months>\d*)M)?((?<weeks>\d*)W)?((?<days>\d*)D)?((?<time>T)((?<hours>\d*[.,]?\d{1,9})H)?((?<minutes>\d*[.,]?\d{1,9})M)?((?<seconds>\d*[.,]?\d{1,9})S)?)?$/;
 const requiredDurationTimeGroups = ['hours', 'minutes', 'seconds'];
 const requiredDurationGroups = ['years', 'months', 'weeks', 'days', ...requiredDurationTimeGroups];
 
@@ -91,10 +102,10 @@ export function parseDateTime(value: string): CalendarDateTime {
 }
 
 /**
- * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset
- * (e.g. "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
- * Ambiguous times due to daylight saving time transitions are resolved according to the `disambiguation`
- * parameter.
+ * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
+ * "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
+ * Ambiguous times due to daylight saving time transitions are resolved according to the
+ * `disambiguation` parameter.
  */
 export function parseZonedDateTime(value: string, disambiguation?: Disambiguation): ZonedDateTime {
   let m = value.match(ZONED_DATE_TIME_RE);
@@ -125,13 +136,19 @@ export function parseZonedDateTime(value: string, disambiguation?: Disambiguatio
   let ms: number;
   if (m[8]) {
     let hourOffset = parseNumber(m[8], -23, 23);
-    date.offset = Math.sign(hourOffset) * (Math.abs(hourOffset) * 60 * 60 * 1000 + parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000 + parseNumber(m[10] ?? '0', 0, 59) * 1000);
+    date.offset =
+      Math.sign(hourOffset) *
+      (Math.abs(hourOffset) * 60 * 60 * 1000 +
+        parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000 +
+        parseNumber(m[10] ?? '0', 0, 59) * 1000);
     ms = epochFromDate(date as ZonedDateTime) - date.offset;
 
     // Validate offset against parsed date.
     let absolutes = possibleAbsolutes(plainDateTime, date.timeZone);
     if (!absolutes.includes(ms)) {
-      throw new Error(`Offset ${offsetToString(date.offset)} is invalid for ${dateTimeToString(date)} in ${date.timeZone}`);
+      throw new Error(
+        `Offset ${offsetToString(date.offset)} is invalid for ${dateTimeToString(date)} in ${date.timeZone}`
+      );
     }
   } else {
     // Convert to absolute and back to fix invalid times due to DST.
@@ -170,7 +187,8 @@ export function parseAbsolute(value: string, timeZone: string): ZonedDateTime {
   date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
 
   if (m[8]) {
-    date.offset = parseNumber(m[8], -23, 23) * 60 * 60 * 1000 + parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000;
+    date.offset =
+      parseNumber(m[8], -23, 23) * 60 * 60 * 1000 + parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000;
   }
 
   return toTimeZone(date as ZonedDateTime, timeZone);
@@ -201,9 +219,10 @@ export function dateToString(date: CalendarDate): string {
   let gregorianDate = toCalendar(date, new GregorianCalendar());
   let year: string;
   if (gregorianDate.era === 'BC') {
-    year = gregorianDate.year === 1
-      ? '0000'
-      : '-' + String(Math.abs(1 - gregorianDate.year)).padStart(6, '00');
+    year =
+      gregorianDate.year === 1
+        ? '0000'
+        : '-' + String(Math.abs(1 - gregorianDate.year)).padStart(6, '00');
   } else {
     year = String(gregorianDate.year).padStart(4, '0');
   }
@@ -220,7 +239,7 @@ function offsetToString(offset: number) {
   offset = Math.abs(offset);
   let offsetHours = Math.floor(offset / (60 * 60 * 1000));
   let offsetMinutes = Math.floor((offset % (60 * 60 * 1000)) / (60 * 1000));
-  let offsetSeconds = Math.floor((offset % (60 * 60 * 1000)) % (60 * 1000) / 1000);
+  let offsetSeconds = Math.floor(((offset % (60 * 60 * 1000)) % (60 * 1000)) / 1000);
   let stringOffset = `${sign}${String(offsetHours).padStart(2, '0')}:${String(offsetMinutes).padStart(2, '0')}`;
   if (offsetSeconds !== 0) {
     stringOffset += `:${String(offsetSeconds).padStart(2, '0')}`;
@@ -235,6 +254,7 @@ export function zonedDateTimeToString(date: ZonedDateTime): string {
 
 /**
  * Parses an ISO 8601 duration string (e.g. "P3Y6M6W4DT12H30M5S").
+ *
  * @param value An ISO 8601 duration string.
  * @returns A DateTimeDuration object.
  */
@@ -245,10 +265,7 @@ export function parseDuration(value: string): Required<DateTimeDuration> {
     throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
   }
 
-  const parseDurationGroup = (
-    group: string | undefined,
-    isNegative: boolean
-  ): number => {
+  const parseDurationGroup = (group: string | undefined, isNegative: boolean): number => {
     if (!group) {
       return 0;
     }
@@ -271,7 +288,9 @@ export function parseDuration(value: string): Required<DateTimeDuration> {
   const durationStringIncludesTime = match.groups?.time;
 
   if (durationStringIncludesTime) {
-    const hasRequiredDurationTimeGroups = requiredDurationTimeGroups.some(group => match.groups?.[group]);
+    const hasRequiredDurationTimeGroups = requiredDurationTimeGroups.some(
+      group => match.groups?.[group]
+    );
     if (!hasRequiredDurationTimeGroups) {
       throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
     }
@@ -287,12 +306,20 @@ export function parseDuration(value: string): Required<DateTimeDuration> {
     seconds: parseDurationGroup(match.groups?.seconds, isNegative)
   };
 
-  if (duration.hours !== undefined && ((duration.hours % 1) !== 0) && (duration.minutes || duration.seconds)) {
-    throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+  if (
+    duration.hours !== undefined &&
+    duration.hours % 1 !== 0 &&
+    (duration.minutes || duration.seconds)
+  ) {
+    throw new Error(
+      `Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`
+    );
   }
 
-  if (duration.minutes !== undefined && ((duration.minutes % 1) !== 0) && duration.seconds) {
-    throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+  if (duration.minutes !== undefined && duration.minutes % 1 !== 0 && duration.seconds) {
+    throw new Error(
+      `Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`
+    );
   }
 
   return duration as Required<DateTimeDuration>;