@checkdigit/time 4.0.0 → 5.0.0-PR.21-7813

package/src/date-fns/differenceInCalendarISOWeeks/index.ts

@@ -1,6 +1,17 @@
-import { millisecondsInWeek } from '../constants/index';
-import { startOfISOWeek } from '../startOfISOWeek/index';
-import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index.ts';
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { millisecondsInWeek } from '../constants/index.ts';
+import { startOfISOWeek } from '../startOfISOWeek/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInCalendarISOWeeks} function options.
+ */
+export interface DifferenceInCalendarISOWeeksOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInCalendarISOWeeks
@@ -12,10 +23,9 @@ import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMill
  *
  * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of calendar ISO weeks
  *
@@ -23,16 +33,19 @@ import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMill
  * // How many calendar ISO weeks are between 6 July 2014 and 21 July 2014?
  * const result = differenceInCalendarISOWeeks(
  *   new Date(2014, 6, 21),
- *   new Date(2014, 6, 6)
- * )
+ *   new Date(2014, 6, 6),
+ * );
  * //=> 3
  */
-export function differenceInCalendarISOWeeks<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInCalendarISOWeeks(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInCalendarISOWeeksOptions | undefined,
 ): number {
-  const startOfISOWeekLeft = startOfISOWeek(dateLeft);
-  const startOfISOWeekRight = startOfISOWeek(dateRight);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+
+  const startOfISOWeekLeft = startOfISOWeek(laterDate_);
+  const startOfISOWeekRight = startOfISOWeek(earlierDate_);
 
   const timestampLeft = +startOfISOWeekLeft - getTimezoneOffsetInMilliseconds(startOfISOWeekLeft);
   const timestampRight = +startOfISOWeekRight - getTimezoneOffsetInMilliseconds(startOfISOWeekRight);
@@ -42,3 +55,5 @@ export function differenceInCalendarISOWeeks<DateType extends Date>(
   // the daylight saving time clock shift).
   return Math.round((timestampLeft - timestampRight) / millisecondsInWeek);
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInCalendarMonths/index.ts

@@ -1,4 +1,14 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInCalendarMonths} function options.
+ */
+export interface DifferenceInCalendarMonthsOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInCalendarMonths
@@ -8,10 +18,9 @@ import { toDate } from '../toDate/index';
  * @description
  * Get the number of calendar months between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of calendar months
  *
@@ -23,15 +32,17 @@ import { toDate } from '../toDate/index';
  * )
  * //=> 8
  */
-export function differenceInCalendarMonths<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInCalendarMonths(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInCalendarMonthsOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
 
-  const yearDiff = _dateLeft.getFullYear() - _dateRight.getFullYear();
-  const monthDiff = _dateLeft.getMonth() - _dateRight.getMonth();
+  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
+  const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
 
-  return yearDiff * 12 + monthDiff;
+  return yearsDiff * 12 + monthsDiff;
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInCalendarQuarters/index.ts

@@ -1,5 +1,15 @@
-import { getQuarter } from '../getQuarter/index';
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { getQuarter } from '../getQuarter/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInCalendarQuarters} function options.
+ */
+export interface DifferenceInCalendarQuartersOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInCalendarQuarters
@@ -9,11 +19,10 @@ import { toDate } from '../toDate/index';
  * @description
  * Get the number of calendar quarters between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
-
  * @returns The number of calendar quarters
  *
  * @example
@@ -24,15 +33,17 @@ import { toDate } from '../toDate/index';
  * )
  * //=> 3
  */
-export function differenceInCalendarQuarters<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInCalendarQuarters(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInCalendarQuartersOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
 
-  const yearDiff = _dateLeft.getFullYear() - _dateRight.getFullYear();
-  const quarterDiff = getQuarter(_dateLeft) - getQuarter(_dateRight);
+  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
+  const quartersDiff = getQuarter(laterDate_) - getQuarter(earlierDate_);
 
-  return yearDiff * 4 + quarterDiff;
+  return yearsDiff * 4 + quartersDiff;
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInCalendarWeeks/index.ts

@@ -1,12 +1,20 @@
-import { millisecondsInWeek } from '../constants/index';
-import { startOfWeek } from '../startOfWeek/index';
-import type { LocalizedOptions, WeekOptions } from '../types';
-import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index.ts';
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { millisecondsInWeek } from '../constants/index.ts';
+import { startOfWeek } from '../startOfWeek/index.ts';
+import type { ContextOptions, DateArg, LocalizedOptions, WeekOptions } from '../types.ts';
 
 /**
  * The {@link differenceInCalendarWeeks} function options.
  */
-export interface DifferenceInCalendarWeeksOptions extends LocalizedOptions<'options'>, WeekOptions {}
+export interface DifferenceInCalendarWeeksOptions
+  extends LocalizedOptions<'options'>,
+    WeekOptions,
+    ContextOptions<Date> {}
 
 /**
  * @name differenceInCalendarWeeks
@@ -16,10 +24,8 @@ export interface DifferenceInCalendarWeeksOptions extends LocalizedOptions<'opti
  * @description
  * Get the number of calendar weeks between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of calendar weeks
@@ -42,19 +48,20 @@ export interface DifferenceInCalendarWeeksOptions extends LocalizedOptions<'opti
  * )
  * //=> 2
  */
-export function differenceInCalendarWeeks<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
-  options?: DifferenceInCalendarWeeksOptions,
+export function differenceInCalendarWeeks(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInCalendarWeeksOptions | undefined,
 ): number {
-  const startOfWeekLeft = startOfWeek(dateLeft, options);
-  const startOfWeekRight = startOfWeek(dateRight, options);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
 
-  const timestampLeft = +startOfWeekLeft - getTimezoneOffsetInMilliseconds(startOfWeekLeft);
-  const timestampRight = +startOfWeekRight - getTimezoneOffsetInMilliseconds(startOfWeekRight);
+  const laterStartOfWeek = startOfWeek(laterDate_, options);
+  const earlierStartOfWeek = startOfWeek(earlierDate_, options);
 
-  // Round the number of days to the nearest integer because the number of
-  // milliseconds in a days is not constant (e.g. it's different in the week of
-  // the daylight saving time clock shift).
-  return Math.round((timestampLeft - timestampRight) / millisecondsInWeek);
+  const laterTimestamp = +laterStartOfWeek - getTimezoneOffsetInMilliseconds(laterStartOfWeek);
+  const earlierTimestamp = +earlierStartOfWeek - getTimezoneOffsetInMilliseconds(earlierStartOfWeek);
+
+  return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInWeek);
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInCalendarYears/index.ts

@@ -1,4 +1,14 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInCalendarYears} function options.
+ */
+export interface DifferenceInCalendarYearsOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInCalendarYears
@@ -8,10 +18,9 @@ import { toDate } from '../toDate/index';
  * @description
  * Get the number of calendar years between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
 
  * @returns The number of calendar years
  *
@@ -20,15 +29,16 @@ import { toDate } from '../toDate/index';
  * const result = differenceInCalendarYears(
  *   new Date(2015, 1, 11),
  *   new Date(2013, 11, 31)
- * )
+ * );
  * //=> 2
  */
-export function differenceInCalendarYears<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInCalendarYears(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInCalendarYearsOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
-
-  return _dateLeft.getFullYear() - _dateRight.getFullYear();
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+  return laterDate_.getFullYear() - earlierDate_.getFullYear();
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInDays/index.ts

@@ -1,5 +1,15 @@
-import { differenceInCalendarDays } from '../differenceInCalendarDays/index';
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { differenceInCalendarDays } from '../differenceInCalendarDays/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInDays} function options.
+ */
+export interface DifferenceInDaysOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInDays
@@ -17,10 +27,9 @@ import { toDate } from '../toDate/index';
  * To ignore DST and only measure exact 24-hour periods, use this instead:
  * `Math.trunc(differenceInHours(dateLeft, dateRight)/24)|0`.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full days according to the local timezone
  *
@@ -55,21 +64,22 @@ import { toDate } from '../toDate/index';
  * )
  * //=> 92
  */
-export function differenceInDays<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInDays(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInDaysOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
 
-  const sign = compareLocalAsc(_dateLeft, _dateRight);
-  const difference = Math.abs(differenceInCalendarDays(_dateLeft, _dateRight));
+  const sign = compareLocalAsc(laterDate_, earlierDate_);
+  const difference = Math.abs(differenceInCalendarDays(laterDate_, earlierDate_));
 
-  _dateLeft.setDate(_dateLeft.getDate() - sign * difference);
+  laterDate_.setDate(laterDate_.getDate() - sign * difference);
 
   // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full
   // If so, result must be decreased by 1 in absolute value
-  const isLastDayNotFull = Number(compareLocalAsc(_dateLeft, _dateRight) === -sign);
+  const isLastDayNotFull = Number(compareLocalAsc(laterDate_, earlierDate_) === -sign);
+
   const result = sign * (difference - isLastDayNotFull);
   // Prevent negative zero
   return result === 0 ? 0 : result;
@@ -79,22 +89,21 @@ export function differenceInDays<DateType extends Date>(
 // for accurate equality comparisons of UTC timestamps that end up
 // having the same representation in local time, e.g. one hour before
 // DST ends vs. the instant that DST ends.
-function compareLocalAsc<DateType extends Date>(dateLeft: DateType, dateRight: DateType): number {
+function compareLocalAsc(laterDate: Date, earlierDate: Date): number {
   const diff =
-    dateLeft.getFullYear() - dateRight.getFullYear() ||
-    dateLeft.getMonth() - dateRight.getMonth() ||
-    dateLeft.getDate() - dateRight.getDate() ||
-    dateLeft.getHours() - dateRight.getHours() ||
-    dateLeft.getMinutes() - dateRight.getMinutes() ||
-    dateLeft.getSeconds() - dateRight.getSeconds() ||
-    dateLeft.getMilliseconds() - dateRight.getMilliseconds();
+    laterDate.getFullYear() - earlierDate.getFullYear() ||
+    laterDate.getMonth() - earlierDate.getMonth() ||
+    laterDate.getDate() - earlierDate.getDate() ||
+    laterDate.getHours() - earlierDate.getHours() ||
+    laterDate.getMinutes() - earlierDate.getMinutes() ||
+    laterDate.getSeconds() - earlierDate.getSeconds() ||
+    laterDate.getMilliseconds() - earlierDate.getMilliseconds();
 
-  if (diff < 0) {
-    return -1;
-  } else if (diff > 0) {
-    return 1;
-    // Return 0 if diff is 0; return NaN if diff is NaN
-  } else {
-    return diff;
-  }
+  if (diff < 0) return -1;
+  if (diff > 0) return 1;
+
+  // Return 0 if diff is 0; return NaN if diff is NaN
+  return diff;
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInHours/index.ts

@@ -1,12 +1,16 @@
-import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
-import { millisecondsInHour } from '../constants/index';
-import { differenceInMilliseconds } from '../differenceInMilliseconds/index';
-import type { RoundingOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index.ts';
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { millisecondsInHour } from '../constants/index.ts';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 
 /**
  * The {@link differenceInHours} function options.
  */
-export interface DifferenceInHoursOptions extends RoundingOptions {}
+export interface DifferenceInHoursOptions extends RoundingOptions, ContextOptions<Date> {}
 
 /**
  * @name differenceInHours
@@ -16,10 +20,8 @@ export interface DifferenceInHoursOptions extends RoundingOptions {}
  * @description
  * Get the number of hours between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of hours
@@ -32,11 +34,14 @@ export interface DifferenceInHoursOptions extends RoundingOptions {}
  * )
  * //=> 12
  */
-export function differenceInHours<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInHours(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
   options?: DifferenceInHoursOptions,
 ): number {
-  const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInHour;
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+  const diff = (+laterDate_ - +earlierDate_) / millisecondsInHour;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInISOWeekYears/index.ts

@@ -1,7 +1,17 @@
-import { compareAsc } from '../compareAsc/index';
-import { differenceInCalendarISOWeekYears } from '../differenceInCalendarISOWeekYears/index';
-import { subISOWeekYears } from '../subISOWeekYears/index';
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { compareAsc } from '../compareAsc/index.ts';
+import { differenceInCalendarISOWeekYears } from '../differenceInCalendarISOWeekYears/index.ts';
+import { subISOWeekYears } from '../subISOWeekYears/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInISOWeekYears} function options.
+ */
+export interface DifferenceInISOWeekYearsOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInISOWeekYears
@@ -13,10 +23,9 @@ import { toDate } from '../toDate/index';
  *
  * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - The options
  *
  * @returns The number of full ISO week-numbering years
  *
@@ -26,24 +35,25 @@ import { toDate } from '../toDate/index';
  *   new Date(2012, 0, 1),
  *   new Date(2010, 0, 1)
  * )
- * //=> 1
+ * // => 1
  */
-export function differenceInISOWeekYears<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInISOWeekYears(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInISOWeekYearsOptions | undefined,
 ): number {
-  let _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
-
-  const sign = compareAsc(_dateLeft, _dateRight);
-  const difference = Math.abs(differenceInCalendarISOWeekYears(_dateLeft, _dateRight));
-  _dateLeft = subISOWeekYears(_dateLeft, sign * difference);
-
-  // Math.abs(diff in full ISO years - diff in calendar ISO years) === 1
-  // if last calendar ISO year is not full
-  // If so, result must be decreased by 1 in absolute value
-  const isLastISOWeekYearNotFull = Number(compareAsc(_dateLeft, _dateRight) === -sign);
-  const result = sign * (difference - isLastISOWeekYearNotFull);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+
+  const sign = compareAsc(laterDate_, earlierDate_);
+  const diff = Math.abs(differenceInCalendarISOWeekYears(laterDate_, earlierDate_, options));
+
+  const adjustedDate = subISOWeekYears(laterDate_, sign * diff, options);
+
+  const isLastISOWeekYearNotFull = Number(compareAsc(adjustedDate, earlierDate_) === -sign);
+  const result = sign * (diff - isLastISOWeekYearNotFull);
+
   // Prevent negative zero
   return result === 0 ? 0 : result;
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInMilliseconds/index.ts

@@ -1,4 +1,9 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { DateArg } from '../types.ts';
 
 /**
  * @name differenceInMilliseconds
@@ -8,10 +13,8 @@ import { toDate } from '../toDate/index';
  * @description
  * Get the number of milliseconds between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  *
  * @returns The number of milliseconds
  *
@@ -24,9 +27,8 @@ import { toDate } from '../toDate/index';
  * )
  * //=> 1100
  */
-export function differenceInMilliseconds<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
-): number {
-  return +toDate(dateLeft) - +toDate(dateRight);
+export function differenceInMilliseconds(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}): number {
+  return +toDate(laterDate) - +toDate(earlierDate);
 }
+
+/* eslint-enable */

package/src/date-fns/differenceInMinutes/index.ts

@@ -1,7 +1,11 @@
-import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
-import { millisecondsInMinute } from '../constants/index';
-import { differenceInMilliseconds } from '../differenceInMilliseconds/index';
-import type { RoundingOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index.ts';
+import { millisecondsInMinute } from '../constants/index.ts';
+import { differenceInMilliseconds } from '../differenceInMilliseconds/index.ts';
+import type { DateArg, RoundingOptions } from '../types.ts';
 
 /**
  * The {@link differenceInMinutes} function options.
@@ -16,8 +20,6 @@ export interface DifferenceInMinutesOptions extends RoundingOptions {}
  * @description
  * Get the signed number of full (rounded towards 0) minutes between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
  * @param dateLeft - The later date
  * @param dateRight - The earlier date
  * @param options - An object with options.
@@ -40,11 +42,13 @@ export interface DifferenceInMinutesOptions extends RoundingOptions {}
  * )
  * //=> -1
  */
-export function differenceInMinutes<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInMinutes(
+  dateLeft: DateArg<Date> & {},
+  dateRight: DateArg<Date> & {},
   options?: DifferenceInMinutesOptions,
 ): number {
   const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }
+
+/* eslint-enable */