@checkdigit/time 4.0.0-PR.18-9134 → 4.0.0-PR.18-81a3

package/src/date-fns/differenceInDays/test.mts

@@ -1,25 +1,19 @@
-import { describe, expect, it } from "vitest";
-import { differenceInDays } from "./index";
-import { getDstTransitions } from "../_test/dst/tzOffsetTransitions";
+import { describe, expect, it } from 'vitest';
+import { differenceInDays } from './index';
+import { getDstTransitions } from '../_test/dst/tzOffsetTransitions';
 
-describe("differenceInDays", () => {
-  it("returns the number of full days between the given dates", () => {
-    const result = differenceInDays(
-      new Date(2012, 6 /* Jul */, 2, 18, 0),
-      new Date(2011, 6 /* Jul */, 2, 6, 0),
-    );
+describe('differenceInDays', () => {
+  it('returns the number of full days between the given dates', () => {
+    const result = differenceInDays(new Date(2012, 6 /* Jul */, 2, 18, 0), new Date(2011, 6 /* Jul */, 2, 6, 0));
     expect(result).toBe(366);
   });
 
-  it("returns a negative number if the time value of the first date is smaller", () => {
-    const result = differenceInDays(
-      new Date(2011, 6 /* Jul */, 2, 6, 0),
-      new Date(2012, 6 /* Jul */, 2, 18, 0),
-    );
+  it('returns a negative number if the time value of the first date is smaller', () => {
+    const result = differenceInDays(new Date(2011, 6 /* Jul */, 2, 6, 0), new Date(2012, 6 /* Jul */, 2, 18, 0));
     expect(result).toBe(-366);
   });
 
-  it("accepts timestamps", () => {
+  it('accepts timestamps', () => {
     const result = differenceInDays(
       new Date(2014, 8 /* Sep */, 5, 18, 0).getTime(),
       new Date(2014, 8 /* Sep */, 4, 6, 0).getTime(),
@@ -27,180 +21,154 @@ describe("differenceInDays", () => {
     expect(result).toBe(1);
   });
 
-  describe("edge cases", () => {
-    it("the difference is less than a day, but the given dates are in different calendar days", () => {
-      const result = differenceInDays(
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-        new Date(2014, 8 /* Sep */, 4, 23, 59),
-      );
+  describe('edge cases', () => {
+    it('the difference is less than a day, but the given dates are in different calendar days', () => {
+      const result = differenceInDays(new Date(2014, 8 /* Sep */, 5, 0, 0), new Date(2014, 8 /* Sep */, 4, 23, 59));
       expect(result).toBe(0);
     });
 
-    it("the same for the swapped dates", () => {
-      const result = differenceInDays(
-        new Date(2014, 8 /* Sep */, 4, 23, 59),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+    it('the same for the swapped dates', () => {
+      const result = differenceInDays(new Date(2014, 8 /* Sep */, 4, 23, 59), new Date(2014, 8 /* Sep */, 5, 0, 0));
       expect(result).toBe(0);
     });
 
-    it("the time values of the given dates are the same", () => {
-      const result = differenceInDays(
-        new Date(2014, 8 /* Sep */, 6, 0, 0),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+    it('the time values of the given dates are the same', () => {
+      const result = differenceInDays(new Date(2014, 8 /* Sep */, 6, 0, 0), new Date(2014, 8 /* Sep */, 5, 0, 0));
       expect(result).toBe(1);
     });
 
-    it("the given dates are the same", () => {
-      const result = differenceInDays(
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+    it('the given dates are the same', () => {
+      const result = differenceInDays(new Date(2014, 8 /* Sep */, 5, 0, 0), new Date(2014, 8 /* Sep */, 5, 0, 0));
       expect(result).toBe(0);
     });
 
     const dstTransitions = getDstTransitions(2017);
     const dstOnly = dstTransitions.start && dstTransitions.end ? it : it.skip;
-    const tz =
-      Intl.DateTimeFormat().resolvedOptions().timeZone || process.env.tz;
-    dstOnly(
-      `works across DST start & end in local timezone: ${tz || "(unknown)"}`,
-      () => {
-        const { start, end } = dstTransitions;
-        const HOUR = 1000 * 60 * 60;
-        const MINUTE = 1000 * 60;
-        function sameTime(t1: Date, t2: Date): boolean {
-          return (
-            t1.getHours() === t2.getHours() &&
-            t1.getMinutes() === t2.getMinutes() &&
-            t1.getSeconds() === t2.getSeconds() &&
-            t1.getMilliseconds() === t2.getMilliseconds()
-          );
-        }
-
-        expect(start).not.toBe(undefined);
-        expect(end).not.toBe(undefined);
-
-        if (start === undefined || end === undefined) {
-          return;
-        }
-
-        // It's usually 1 hour, but for some timezones, e.g. Australia/Lord_Howe, it is 30 minutes
-        const dstOffset =
-          (end.getTimezoneOffset() - start.getTimezoneOffset()) * MINUTE;
-
-        // TEST DST START (SPRING)
-
-        // anchor to one hour before the boundary
-        {
-          const a = new Date(start.getTime() - HOUR); // 1 hour before DST
-          const b = new Date(a.getTime() + 24 * HOUR - dstOffset); // 1 day later, same local time
-          const c = new Date(a.getTime() + 48 * HOUR - dstOffset); // 2 days later, same local time
-
-          expect(sameTime(a, b)).toBe(true);
-          expect(sameTime(a, c)).toBe(true);
-          expect(sameTime(b, c)).toBe(true);
-          expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(b, a)).toBe(1); // 23 hours -> 1 day
-          expect(differenceInDays(c, a)).toBe(2); // 47 hours -> 2 days
-        }
-        // anchor exactly, the boundary
-        {
-          const a = start; // exactly when DST starts
-          const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
-          const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
-
-          expect(sameTime(a, b)).toBe(true);
-          expect(sameTime(a, c)).toBe(true);
-          expect(sameTime(b, c)).toBe(true);
-          expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
-        }
-
-        // TEST DST END (FALL)
-
-        // make sure that diffs across a "fall back" DST boundary won't report a full day
-        // until 25 hours have elapsed.
-        {
-          const a = new Date(end.getTime() - HOUR / 2); // 1 hour before Standard Time starts
-          const b = new Date(a.getTime() + 24 * HOUR + dstOffset - 15 * MINUTE); // 1 day later, 15 mins earlier local time
-          const c = new Date(a.getTime() + 48 * HOUR + dstOffset - 15 * MINUTE); // 2 days later, 15 mins earlier local time
-
-          expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(b, a)).toBe(0); // 24.75 hours -> 0 full days (because hour lost to DST)
-          expect(differenceInDays(c, a)).toBe(1); // 48.75 hours -> 1 full day (because hour lost to DST)
-        }
-        // anchor to one hour before the boundary
-        {
-          const a = new Date(end.getTime() - HOUR); // 1 hour before Standard Time start
-          const b = new Date(a.getTime() + 24 * HOUR + dstOffset); // 1 day later, same local time
-          const c = new Date(a.getTime() + 48 * HOUR + dstOffset); // 2 days later, same local time
-
-          expect(sameTime(a, b)).toBe(true);
-          expect(sameTime(a, c)).toBe(true);
-          expect(sameTime(b, c)).toBe(true);
-          expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(b, a)).toBe(1); // 25 hours -> 1 day
-          expect(differenceInDays(c, a)).toBe(2); // 49 hours -> 2 days
-        }
-        // anchor to one hour after the boundary
-        {
-          const a = new Date(end.getTime() + HOUR); // 1 hour after Standard Time start
-          const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
-          const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
-
-          expect(sameTime(a, b)).toBe(true);
-          expect(sameTime(a, c)).toBe(true);
-          expect(sameTime(b, c)).toBe(true);
-          expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
-        }
-        // anchor exactly at the boundary
-        {
-          const a = end; // exactly when Standard Time starts
-          const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
-          const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
-          expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
-          expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
-        }
-      },
-    );
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone || process.env.tz;
+    dstOnly(`works across DST start & end in local timezone: ${tz || '(unknown)'}`, () => {
+      const { start, end } = dstTransitions;
+      const HOUR = 1000 * 60 * 60;
+      const MINUTE = 1000 * 60;
+      function sameTime(t1: Date, t2: Date): boolean {
+        return (
+          t1.getHours() === t2.getHours() &&
+          t1.getMinutes() === t2.getMinutes() &&
+          t1.getSeconds() === t2.getSeconds() &&
+          t1.getMilliseconds() === t2.getMilliseconds()
+        );
+      }
+
+      expect(start).not.toBe(undefined);
+      expect(end).not.toBe(undefined);
 
-    it("does not return -0 when the given dates are the same", () => {
+      if (start === undefined || end === undefined) {
+        return;
+      }
+
+      // It's usually 1 hour, but for some timezones, e.g. Australia/Lord_Howe, it is 30 minutes
+      const dstOffset = (end.getTimezoneOffset() - start.getTimezoneOffset()) * MINUTE;
+
+      // TEST DST START (SPRING)
+
+      // anchor to one hour before the boundary
+      {
+        const a = new Date(start.getTime() - HOUR); // 1 hour before DST
+        const b = new Date(a.getTime() + 24 * HOUR - dstOffset); // 1 day later, same local time
+        const c = new Date(a.getTime() + 48 * HOUR - dstOffset); // 2 days later, same local time
+
+        expect(sameTime(a, b)).toBe(true);
+        expect(sameTime(a, c)).toBe(true);
+        expect(sameTime(b, c)).toBe(true);
+        expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(b, a)).toBe(1); // 23 hours -> 1 day
+        expect(differenceInDays(c, a)).toBe(2); // 47 hours -> 2 days
+      }
+      // anchor exactly, the boundary
+      {
+        const a = start; // exactly when DST starts
+        const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
+        const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
+
+        expect(sameTime(a, b)).toBe(true);
+        expect(sameTime(a, c)).toBe(true);
+        expect(sameTime(b, c)).toBe(true);
+        expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
+      }
+
+      // TEST DST END (FALL)
+
+      // make sure that diffs across a "fall back" DST boundary won't report a full day
+      // until 25 hours have elapsed.
+      {
+        const a = new Date(end.getTime() - HOUR / 2); // 1 hour before Standard Time starts
+        const b = new Date(a.getTime() + 24 * HOUR + dstOffset - 15 * MINUTE); // 1 day later, 15 mins earlier local time
+        const c = new Date(a.getTime() + 48 * HOUR + dstOffset - 15 * MINUTE); // 2 days later, 15 mins earlier local time
+
+        expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(b, a)).toBe(0); // 24.75 hours -> 0 full days (because hour lost to DST)
+        expect(differenceInDays(c, a)).toBe(1); // 48.75 hours -> 1 full day (because hour lost to DST)
+      }
+      // anchor to one hour before the boundary
+      {
+        const a = new Date(end.getTime() - HOUR); // 1 hour before Standard Time start
+        const b = new Date(a.getTime() + 24 * HOUR + dstOffset); // 1 day later, same local time
+        const c = new Date(a.getTime() + 48 * HOUR + dstOffset); // 2 days later, same local time
+
+        expect(sameTime(a, b)).toBe(true);
+        expect(sameTime(a, c)).toBe(true);
+        expect(sameTime(b, c)).toBe(true);
+        expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(b, a)).toBe(1); // 25 hours -> 1 day
+        expect(differenceInDays(c, a)).toBe(2); // 49 hours -> 2 days
+      }
+      // anchor to one hour after the boundary
+      {
+        const a = new Date(end.getTime() + HOUR); // 1 hour after Standard Time start
+        const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
+        const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
+
+        expect(sameTime(a, b)).toBe(true);
+        expect(sameTime(a, c)).toBe(true);
+        expect(sameTime(b, c)).toBe(true);
+        expect(differenceInDays(c, b)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
+      }
+      // anchor exactly at the boundary
+      {
+        const a = end; // exactly when Standard Time starts
+        const b = new Date(a.getTime() + 24 * HOUR); // 1 day later, same local time
+        const c = new Date(a.getTime() + 48 * HOUR); // 2 days later, same local time
+        expect(differenceInDays(b, a)).toBe(1); // normal 24-hour day
+        expect(differenceInDays(c, a)).toBe(2); // 2 normal 24-hour days
+      }
+    });
+
+    it('does not return -0 when the given dates are the same', () => {
       function isNegativeZero(x: number): boolean {
         return x === 0 && 1 / x < 0;
       }
 
-      const result = differenceInDays(
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+      const result = differenceInDays(new Date(2014, 8 /* Sep */, 5, 0, 0), new Date(2014, 8 /* Sep */, 5, 0, 0));
 
       const resultIsNegative = isNegativeZero(result);
       expect(resultIsNegative).toBe(false);
     });
   });
 
-  it("returns NaN if the first date is `Invalid Date`", () => {
-    const result = differenceInDays(
-      new Date(NaN),
-      new Date(2017, 0 /* Jan */, 1),
-    );
+  it('returns NaN if the first date is `Invalid Date`', () => {
+    const result = differenceInDays(new Date(NaN), new Date(2017, 0 /* Jan */, 1));
     expect(isNaN(result)).toBe(true);
   });
 
-  it("returns NaN if the second date is `Invalid Date`", () => {
-    const result = differenceInDays(
-      new Date(2017, 0 /* Jan */, 1),
-      new Date(NaN),
-    );
+  it('returns NaN if the second date is `Invalid Date`', () => {
+    const result = differenceInDays(new Date(2017, 0 /* Jan */, 1), new Date(NaN));
     expect(isNaN(result)).toBe(true);
   });
 
-  it("returns NaN if the both dates are `Invalid Date`", () => {
+  it('returns NaN if the both dates are `Invalid Date`', () => {
     const result = differenceInDays(new Date(NaN), new Date(NaN));
     expect(isNaN(result)).toBe(true);
   });

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

@@ -1,7 +1,7 @@
-import { getRoundingMethod } from "../_lib/getRoundingMethod/index";
-import { millisecondsInHour } from "../constants/index";
-import { differenceInMilliseconds } from "../differenceInMilliseconds/index";
-import type { RoundingOptions } from "../types";
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
+import { millisecondsInHour } from '../constants/index';
+import { differenceInMilliseconds } from '../differenceInMilliseconds/index';
+import type { RoundingOptions } from '../types';
 
 /**
  * The {@link differenceInHours} function options.
@@ -37,7 +37,6 @@ export function differenceInHours<DateType extends Date>(
   dateRight: DateType | number | string,
   options?: DifferenceInHoursOptions,
 ): number {
-  const diff =
-    differenceInMilliseconds(dateLeft, dateRight) / millisecondsInHour;
+  const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInHour;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }

package/src/date-fns/differenceInHours/test.mts

@@ -1,8 +1,8 @@
-import { describe, expect, it } from "vitest";
-import { differenceInHours } from "./index";
+import { describe, expect, it } from 'vitest';
+import { differenceInHours } from './index';
 
-describe("differenceInHours", () => {
-  it("returns the number of hours between the given dates with `trunc` as a default rounding method", () => {
+describe('differenceInHours', () => {
+  it('returns the number of hours between the given dates with `trunc` as a default rounding method', () => {
     const result = differenceInHours(
       new Date(2014, 6 /* Jul */, 2, 6, 0, 29),
       new Date(2014, 6 /* Jul */, 2, 20, 0, 28.973),
@@ -10,23 +10,17 @@ describe("differenceInHours", () => {
     expect(result).toBe(-13);
   });
 
-  it("returns the number of hours between the given dates", () => {
-    const result = differenceInHours(
-      new Date(2014, 6 /* Jul */, 2, 20, 0),
-      new Date(2014, 6 /* Jul */, 2, 6, 0),
-    );
+  it('returns the number of hours between the given dates', () => {
+    const result = differenceInHours(new Date(2014, 6 /* Jul */, 2, 20, 0), new Date(2014, 6 /* Jul */, 2, 6, 0));
     expect(result).toBe(14);
   });
 
-  it("returns a negative number if the time value of the first date is smaller", () => {
-    const result = differenceInHours(
-      new Date(2014, 6 /* Jul */, 2, 6, 0),
-      new Date(2014, 6 /* Jul */, 2, 20, 0),
-    );
+  it('returns a negative number if the time value of the first date is smaller', () => {
+    const result = differenceInHours(new Date(2014, 6 /* Jul */, 2, 6, 0), new Date(2014, 6 /* Jul */, 2, 20, 0));
     expect(result).toBe(-14);
   });
 
-  it("returns a 0, not a negative 0 - issue #2555 ", () => {
+  it('returns a 0, not a negative 0 - issue #2555 ', () => {
     const result = differenceInHours(
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28.973),
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28.976),
@@ -34,43 +28,43 @@ describe("differenceInHours", () => {
     expect(result).toBe(0);
   });
 
-  it("returns 2 with a rounding method of `ceil`, not a negative 0 - issue #2555 ", () => {
+  it('returns 2 with a rounding method of `ceil`, not a negative 0 - issue #2555 ', () => {
     const result = differenceInHours(
       new Date(2021, 6 /* Jul */, 22, 7, 1, 29, 976),
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28, 173),
-      { roundingMethod: "ceil" },
+      { roundingMethod: 'ceil' },
     );
     expect(result).toBe(2);
   });
 
-  it("returns 1 with a rounding method of `floor`, not a negative 0 - issue #2555 ", () => {
+  it('returns 1 with a rounding method of `floor`, not a negative 0 - issue #2555 ', () => {
     const result = differenceInHours(
       new Date(2021, 6 /* Jul */, 22, 7, 1, 29, 976),
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28, 173),
-      { roundingMethod: "floor" },
+      { roundingMethod: 'floor' },
     );
     expect(result).toBe(1);
   });
 
-  it("returns 1 with a rounding method of `round`, not a negative 0 - issue #2555 ", () => {
+  it('returns 1 with a rounding method of `round`, not a negative 0 - issue #2555 ', () => {
     const result = differenceInHours(
       new Date(2021, 6 /* Jul */, 22, 7, 1, 29, 976),
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28, 173),
-      { roundingMethod: "round" },
+      { roundingMethod: 'round' },
     );
     expect(result).toBe(1);
   });
 
-  it("returns 1 with a rounding method of `trunc`, not a negative 0 - issue #2555 ", () => {
+  it('returns 1 with a rounding method of `trunc`, not a negative 0 - issue #2555 ', () => {
     const result = differenceInHours(
       new Date(2021, 6 /* Jul */, 22, 7, 1, 29, 976),
       new Date(2021, 6 /* Jul */, 22, 6, 1, 28, 173),
-      { roundingMethod: "trunc" },
+      { roundingMethod: 'trunc' },
     );
     expect(result).toBe(1);
   });
 
-  it("accepts timestamps", () => {
+  it('accepts timestamps', () => {
     const result = differenceInHours(
       new Date(2014, 8 /* Sep */, 5, 18, 0).getTime(),
       new Date(2014, 8 /* Sep */, 5, 6, 0).getTime(),
@@ -78,71 +72,50 @@ describe("differenceInHours", () => {
     expect(result).toBe(12);
   });
 
-  describe("edge cases", () => {
-    it("the difference is less than an hour, but the given dates are in different calendar hours", () => {
-      const result = differenceInHours(
-        new Date(2014, 8 /* Sep */, 5, 12),
-        new Date(2014, 8 /* Sep */, 5, 11, 59),
-      );
+  describe('edge cases', () => {
+    it('the difference is less than an hour, but the given dates are in different calendar hours', () => {
+      const result = differenceInHours(new Date(2014, 8 /* Sep */, 5, 12), new Date(2014, 8 /* Sep */, 5, 11, 59));
       expect(result).toBe(0);
     });
 
-    it("the same for the swapped dates", () => {
-      const result = differenceInHours(
-        new Date(2014, 8 /* Sep */, 5, 11, 59),
-        new Date(2014, 8 /* Sep */, 5, 12),
-      );
+    it('the same for the swapped dates', () => {
+      const result = differenceInHours(new Date(2014, 8 /* Sep */, 5, 11, 59), new Date(2014, 8 /* Sep */, 5, 12));
       expect(result).toBe(0);
     });
 
-    it("the difference is an integral number of hours", () => {
-      const result = differenceInHours(
-        new Date(2014, 8 /* Sep */, 5, 13, 0),
-        new Date(2014, 8 /* Sep */, 5, 12, 0),
-      );
+    it('the difference is an integral number of hours', () => {
+      const result = differenceInHours(new Date(2014, 8 /* Sep */, 5, 13, 0), new Date(2014, 8 /* Sep */, 5, 12, 0));
       expect(result).toBe(1);
     });
 
-    it("the given dates are the same", () => {
-      const result = differenceInHours(
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+    it('the given dates are the same', () => {
+      const result = differenceInHours(new Date(2014, 8 /* Sep */, 5, 0, 0), new Date(2014, 8 /* Sep */, 5, 0, 0));
       expect(result).toBe(0);
     });
 
-    it("does not return -0 when the given dates are the same", () => {
+    it('does not return -0 when the given dates are the same', () => {
       function isNegativeZero(x: number): boolean {
         return x === 0 && 1 / x < 0;
       }
 
-      const result = differenceInHours(
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-        new Date(2014, 8 /* Sep */, 5, 0, 0),
-      );
+      const result = differenceInHours(new Date(2014, 8 /* Sep */, 5, 0, 0), new Date(2014, 8 /* Sep */, 5, 0, 0));
 
       const resultIsNegative = isNegativeZero(result);
       expect(resultIsNegative).toBe(false);
     });
   });
 
-  it("returns NaN if the first date is `Invalid Date`", () => {
-    const result = differenceInHours(
-      new Date(NaN),
-      new Date(2017, 0 /* Jan */, 1),
-    );
+  it('returns NaN if the first date is `Invalid Date`', () => {
+    const result = differenceInHours(new Date(NaN), new Date(2017, 0 /* Jan */, 1));
     expect(isNaN(result)).toBe(true);
   });
 
-  it("returns NaN if the second date is `Invalid Date`", () => {
-    const result = differenceInHours(
-      new Date(2017, 0 /* Jan */, 1),
-      new Date(NaN),
-    );
+  it('returns NaN if the second date is `Invalid Date`', () => {
+    const result = differenceInHours(new Date(2017, 0 /* Jan */, 1), new Date(NaN));
     expect(isNaN(result)).toBe(true);
   });
 
-  it("returns NaN if the both dates are `Invalid Date`", () => {
+  it('returns NaN if the both dates are `Invalid Date`', () => {
     const result = differenceInHours(new Date(NaN), new Date(NaN));
     expect(isNaN(result)).toBe(true);
   });

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

@@ -1,7 +1,7 @@
-import { compareAsc } from "../compareAsc/index";
-import { differenceInCalendarISOWeekYears } from "../differenceInCalendarISOWeekYears/index";
-import { subISOWeekYears } from "../subISOWeekYears/index";
-import { toDate } from "../toDate/index";
+import { compareAsc } from '../compareAsc/index';
+import { differenceInCalendarISOWeekYears } from '../differenceInCalendarISOWeekYears/index';
+import { subISOWeekYears } from '../subISOWeekYears/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name differenceInISOWeekYears
@@ -36,17 +36,13 @@ export function differenceInISOWeekYears<DateType extends Date>(
   const _dateRight = toDate(dateRight);
 
   const sign = compareAsc(_dateLeft, _dateRight);
-  const difference = Math.abs(
-    differenceInCalendarISOWeekYears(_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 isLastISOWeekYearNotFull = Number(compareAsc(_dateLeft, _dateRight) === -sign);
   const result = sign * (difference - isLastISOWeekYearNotFull);
   // Prevent negative zero
   return result === 0 ? 0 : result;