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

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isAfter

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

@@ -1,50 +1,38 @@
-import { describe, expect, it } from "vitest";
-import { isAfter } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isAfter } from './index';
 
-describe("isAfter", () => {
-  it("returns true if the first date is after the second one", () => {
-    const result = isAfter(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    );
+describe('isAfter', () => {
+  it('returns true if the first date is after the second one', () => {
+    const result = isAfter(new Date(1989, 6 /* Jul */, 10), new Date(1987, 1 /* Feb */, 11));
     expect(result).toBe(true);
   });
 
-  it("returns false if the first date is before the second one", () => {
-    const result = isAfter(
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    );
+  it('returns false if the first date is before the second one', () => {
+    const result = isAfter(new Date(1987, 1 /* Feb */, 11), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("returns false if the first date is equal to the second one", () => {
-    const result = isAfter(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1989, 6 /* Jul */, 10),
-    );
+  it('returns false if the first date is equal to the second one', () => {
+    const result = isAfter(new Date(1989, 6 /* Jul */, 10), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
-    const result = isAfter(
-      new Date(1989, 6 /* Jul */, 10).getTime(),
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-    );
+  it('accepts a timestamp', () => {
+    const result = isAfter(new Date(1989, 6 /* Jul */, 10).getTime(), new Date(1987, 1 /* Feb */, 11).getTime());
     expect(result).toBe(true);
   });
 
-  it("returns false if the first date is `Invalid Date`", () => {
+  it('returns false if the first date is `Invalid Date`', () => {
     const result = isAfter(new Date(NaN), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("returns false if the second date is `Invalid Date`", () => {
+  it('returns false if the second date is `Invalid Date`', () => {
     const result = isAfter(new Date(1987, 1 /* Feb */, 11), new Date(NaN));
     expect(result).toBe(false);
   });
 
-  it("returns false if the both dates are `Invalid Date`", () => {
+  it('returns false if the both dates are `Invalid Date`', () => {
     const result = isAfter(new Date(NaN), new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isBefore

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

@@ -1,50 +1,38 @@
-import { describe, expect, it } from "vitest";
-import { isBefore } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isBefore } from './index';
 
-describe("isBefore", () => {
-  it("returns true if the first date is before the second one", () => {
-    const result = isBefore(
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    );
+describe('isBefore', () => {
+  it('returns true if the first date is before the second one', () => {
+    const result = isBefore(new Date(1987, 1 /* Feb */, 11), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(true);
   });
 
-  it("returns false if the first date is after the second one", () => {
-    const result = isBefore(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    );
+  it('returns false if the first date is after the second one', () => {
+    const result = isBefore(new Date(1989, 6 /* Jul */, 10), new Date(1987, 1 /* Feb */, 11));
     expect(result).toBe(false);
   });
 
-  it("returns false if the first date is equal to the second one", () => {
-    const result = isBefore(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1989, 6 /* Jul */, 10),
-    );
+  it('returns false if the first date is equal to the second one', () => {
+    const result = isBefore(new Date(1989, 6 /* Jul */, 10), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
-    const result = isBefore(
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-      new Date(1989, 6 /* Jul */, 10).getTime(),
-    );
+  it('accepts a timestamp', () => {
+    const result = isBefore(new Date(1987, 1 /* Feb */, 11).getTime(), new Date(1989, 6 /* Jul */, 10).getTime());
     expect(result).toBe(true);
   });
 
-  it("returns false if the first date is `Invalid Date`", () => {
+  it('returns false if the first date is `Invalid Date`', () => {
     const result = isBefore(new Date(NaN), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("returns false if the second date is `Invalid Date`", () => {
+  it('returns false if the second date is `Invalid Date`', () => {
     const result = isBefore(new Date(1987, 1 /* Feb */, 11), new Date(NaN));
     expect(result).toBe(false);
   });
 
-  it("returns false if the both dates are `Invalid Date`", () => {
+  it('returns false if the both dates are `Invalid Date`', () => {
     const result = isBefore(new Date(NaN), new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -32,8 +32,6 @@
  */
 export function isDate(value: unknown): value is Date {
   return (
-    value instanceof Date ||
-    (typeof value === "object" &&
-      Object.prototype.toString.call(value) === "[object Date]")
+    value instanceof Date || (typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]')
   );
 }

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

@@ -1,17 +1,17 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { assertType } from "../_lib/test/index";
-import { isDate } from "./index";
+import { afterEach, describe, expect, it } from 'vitest';
+import { assertType } from '../_lib/test/index';
+import { isDate } from './index';
 
-describe("isDate", () => {
-  it("returns true if the given value is a date object", () => {
+describe('isDate', () => {
+  it('returns true if the given value is a date object', () => {
     expect(isDate(new Date())).toBe(true);
   });
 
-  it("returns true if the given value is an Invalid Date", () => {
+  it('returns true if the given value is an Invalid Date', () => {
     expect(isDate(new Date(NaN))).toBe(true);
   });
 
-  it("ensures that the passed argument is an instance of Date", () => {
+  it('ensures that the passed argument is an instance of Date', () => {
     const date: unknown = new Date();
 
     if (isDate(date)) {
@@ -21,50 +21,48 @@ describe("isDate", () => {
     }
   });
 
-  describe("with date passed from another iframe", () => {
+  describe('with date passed from another iframe', () => {
     // If in the browser, run the test in an iframe
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
       afterEach(() => {
-        const iframe = document.getElementById("iframe");
+        const iframe = document.getElementById('iframe');
         iframe && iframe.remove();
       });
 
-      it("returns true for a date passed from another iframe", () =>
+      it('returns true for a date passed from another iframe', () =>
         new Promise((resolve) => {
-          const iframe = document.createElement("iframe");
-          iframe.id = "iframe";
-          iframe.addEventListener("load", () => {
-            execScript("window.date = new Date()");
+          const iframe = document.createElement('iframe');
+          iframe.id = 'iframe';
+          iframe.addEventListener('load', () => {
+            execScript('window.date = new Date()');
             // eslint-disable-next-line @typescript-eslint/no-explicit-any -- It's ok we're messing with iframes
             expect(isDate((iframe.contentWindow as any).date)).toBe(true);
             resolve(void 0);
           });
-          if (!document.body) throw new Error("document.body is not defined");
+          if (!document.body) throw new Error('document.body is not defined');
           document.body.appendChild(iframe);
         }));
     } else {
-      it.skip("returns true for a date passed from another iframe");
+      it.skip('returns true for a date passed from another iframe');
     }
 
     function execScript(scriptText: string) {
-      const iframe = document.querySelector("iframe#iframe");
+      const iframe = document.querySelector('iframe#iframe');
       if (!iframe || !(iframe instanceof HTMLIFrameElement)) {
         throw new Error("Can't execute the script because iframe isn't found");
       }
       const doc = iframe.contentDocument!;
-      const script = doc.createElement("script");
+      const script = doc.createElement('script');
       script.innerText = scriptText;
       // @ts-expect-error - We're messing with iframes
       if (!(doc.body instanceof iframe.contentWindow.HTMLBodyElement)) {
-        throw new Error(
-          "Can't execute the script because iframe does not have body",
-        );
+        throw new Error("Can't execute the script because iframe does not have body");
       }
       doc.body.append(script);
     }
   });
 
-  it("returns false if the given value is not a date object", () => {
+  it('returns false if the given value is not a date object', () => {
     expect(!isDate(new Date().getTime())).toBe(true);
     expect(!isDate(new Date().toISOString())).toBe(true);
     expect(!isDate({})).toBe(true);

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isEqual

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

@@ -1,42 +1,33 @@
-import { describe, expect, it } from "vitest";
-import { isEqual } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isEqual } from './index';
 
-describe("isEqual", () => {
-  it("returns true if the given dates are equal", () => {
-    const result = isEqual(
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1987, 1 /* Feb */, 11),
-    );
+describe('isEqual', () => {
+  it('returns true if the given dates are equal', () => {
+    const result = isEqual(new Date(1987, 1 /* Feb */, 11), new Date(1987, 1 /* Feb */, 11));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given dates are not equal", () => {
-    const result = isEqual(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    );
+  it('returns false if the given dates are not equal', () => {
+    const result = isEqual(new Date(1989, 6 /* Jul */, 10), new Date(1987, 1 /* Feb */, 11));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
-    const result = isEqual(
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-    );
+  it('accepts a timestamp', () => {
+    const result = isEqual(new Date(1987, 1 /* Feb */, 11).getTime(), new Date(1987, 1 /* Feb */, 11).getTime());
     expect(result).toBe(true);
   });
 
-  it("returns false if the first date is `Invalid Date`", () => {
+  it('returns false if the first date is `Invalid Date`', () => {
     const result = isEqual(new Date(NaN), new Date(1989, 6 /* Jul */, 10));
     expect(result).toBe(false);
   });
 
-  it("returns false if the second date is `Invalid Date`", () => {
+  it('returns false if the second date is `Invalid Date`', () => {
     const result = isEqual(new Date(1987, 1 /* Feb */, 11), new Date(NaN));
     expect(result).toBe(false);
   });
 
-  it("returns false if the both dates are `Invalid Date`", () => {
+  it('returns false if the both dates are `Invalid Date`', () => {
     const result = isEqual(new Date(NaN), new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -24,9 +24,5 @@
  */
 export function isExists(year: number, month: number, day: number): boolean {
   const date = new Date(year, month, day);
-  return (
-    date.getFullYear() === year &&
-    date.getMonth() === month &&
-    date.getDate() === day
-  );
+  return date.getFullYear() === year && date.getMonth() === month && date.getDate() === day;
 }

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

@@ -1,13 +1,13 @@
-import { describe, expect, it } from "vitest";
-import { isExists } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isExists } from './index';
 
-describe("isValid", () => {
-  it("returns true if the given date is valid", () => {
+describe('isValid', () => {
+  it('returns true if the given date is valid', () => {
     const result = isExists(2018, 0, 31);
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is invalid", () => {
+  it('returns false if the given date is invalid', () => {
     const result = isExists(2018, 1 /* Feb */, 31);
     expect(result).toBe(false);
   });

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isFirstDayOfMonth
@@ -19,8 +19,6 @@ import { toDate } from "../toDate/index";
  * const result = isFirstDayOfMonth(new Date(2014, 8, 1))
  * //=> true
  */
-export function isFirstDayOfMonth<DateType extends Date>(
-  date: DateType | number | string,
-): boolean {
+export function isFirstDayOfMonth<DateType extends Date>(date: DateType | number | string): boolean {
   return toDate(date).getDate() === 1;
 }

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

@@ -1,24 +1,24 @@
-import { describe, expect, it } from "vitest";
-import { isFirstDayOfMonth } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isFirstDayOfMonth } from './index';
 
-describe("isFirstDayOfMonth", () => {
-  it("returns true if the given date is in the last day of month", () => {
+describe('isFirstDayOfMonth', () => {
+  it('returns true if the given date is in the last day of month', () => {
     const result = isFirstDayOfMonth(new Date(2014, 9 /* Oct */, 1));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is not in the last day of month", () => {
+  it('returns false if the given date is not in the last day of month', () => {
     const result = isFirstDayOfMonth(new Date(2014, 9 /* Oct */, 2));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
+  it('accepts a timestamp', () => {
     const date = new Date(2014, 9 /* Oct */, 1).getTime();
     const result = isFirstDayOfMonth(date);
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is `Invalid Date`", () => {
+  it('returns false if the given date is `Invalid Date`', () => {
     const result = isFirstDayOfMonth(new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isFriday
@@ -19,8 +19,6 @@ import { toDate } from "../toDate/index";
  * const result = isFriday(new Date(2014, 8, 26))
  * //=> true
  */
-export function isFriday<DateType extends Date>(
-  date: DateType | number | string,
-): boolean {
+export function isFriday<DateType extends Date>(date: DateType | number | string): boolean {
   return toDate(date).getDay() === 5;
 }

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

@@ -1,23 +1,23 @@
-import { describe, expect, it } from "vitest";
-import { isFriday } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isFriday } from './index';
 
-describe("isFriday", () => {
-  it("returns true if the given date is Friday", () => {
+describe('isFriday', () => {
+  it('returns true if the given date is Friday', () => {
     const result = isFriday(new Date(2014, 8 /* Sep */, 26));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is not Friday", () => {
+  it('returns false if the given date is not Friday', () => {
     const result = isFriday(new Date(2014, 8 /* Sep */, 25));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
+  it('accepts a timestamp', () => {
     const result = isFriday(new Date(2014, 1 /* Feb */, 14).getTime());
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is `Invalid Date`", () => {
+  it('returns false if the given date is `Invalid Date`', () => {
     const result = isFriday(new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isFuture
@@ -20,8 +20,6 @@ import { toDate } from "../toDate/index";
  * const result = isFuture(new Date(2014, 11, 31))
  * //=> true
  */
-export function isFuture<DateType extends Date>(
-  date: DateType | number | string,
-): boolean {
+export function isFuture<DateType extends Date>(date: DateType | number | string): boolean {
   return +toDate(date) > Date.now();
 }

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

@@ -1,8 +1,8 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import sinon from "sinon";
-import { isFuture } from "./index";
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import sinon from 'sinon';
+import { isFuture } from './index';
 
-describe("isFuture", () => {
+describe('isFuture', () => {
   let clock: sinon.SinonFakeTimers;
   beforeEach(() => {
     clock = sinon.useFakeTimers(new Date(2014, 8 /* Sep */, 25).getTime());
@@ -12,22 +12,22 @@ describe("isFuture", () => {
     clock.restore();
   });
 
-  it("returns true if the given date is in the future", () => {
+  it('returns true if the given date is in the future', () => {
     const result = isFuture(new Date(2014, 9 /* Oct */, 31));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is in the past", () => {
+  it('returns false if the given date is in the past', () => {
     const result = isFuture(new Date(2014, 8 /* Sep */, 1));
     expect(result).toBe(false);
   });
 
-  it("returns false if the given date is now", () => {
+  it('returns false if the given date is now', () => {
     const result = isFuture(new Date(2014, 8 /* Sep */, 25));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
+  it('accepts a timestamp', () => {
     const result = isFuture(new Date(2014, 9 /* Oct */, 31).getTime());
     expect(result).toBe(true);
   });

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

@@ -1,6 +1,6 @@
-import { endOfDay } from "../endOfDay/index";
-import { endOfMonth } from "../endOfMonth/index";
-import { toDate } from "../toDate/index";
+import { endOfDay } from '../endOfDay/index';
+import { endOfMonth } from '../endOfMonth/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name isLastDayOfMonth
@@ -21,9 +21,7 @@ import { toDate } from "../toDate/index";
  * const result = isLastDayOfMonth(new Date(2014, 1, 28))
  * //=> true
  */
-export function isLastDayOfMonth<DateType extends Date>(
-  date: DateType | number | string,
-): boolean {
+export function isLastDayOfMonth<DateType extends Date>(date: DateType | number | string): boolean {
   const _date = toDate(date);
   return +endOfDay(_date) === +endOfMonth(_date);
 }

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

@@ -1,24 +1,24 @@
-import { describe, expect, it } from "vitest";
-import { isLastDayOfMonth } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isLastDayOfMonth } from './index';
 
-describe("isLastDayOfMonth", () => {
-  it("returns true if the given date is in the last day of month", () => {
+describe('isLastDayOfMonth', () => {
+  it('returns true if the given date is in the last day of month', () => {
     const result = isLastDayOfMonth(new Date(2014, 9 /* Oct */, 31));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is not in the last day of month", () => {
+  it('returns false if the given date is not in the last day of month', () => {
     const result = isLastDayOfMonth(new Date(2014, 9 /* Oct */, 30));
     expect(result).toBe(false);
   });
 
-  it("accepts a timestamp", () => {
+  it('accepts a timestamp', () => {
     const date = new Date(2014, 9 /* Oct */, 31).getTime();
     const result = isLastDayOfMonth(date);
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is `Invalid Date`", () => {
+  it('returns false if the given date is `Invalid Date`', () => {
     const result = isLastDayOfMonth(new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name isLeapYear
@@ -19,9 +19,7 @@ import { toDate } from "../toDate/index";
  * const result = isLeapYear(new Date(2012, 8, 1))
  * //=> true
  */
-export function isLeapYear<DateType extends Date>(
-  date: DateType | number | string,
-): boolean {
+export function isLeapYear<DateType extends Date>(date: DateType | number | string): boolean {
   const _date = toDate(date);
   const year = _date.getFullYear();
   return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);

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

@@ -1,34 +1,34 @@
-import { describe, expect, it } from "vitest";
-import { isLeapYear } from "./index";
+import { describe, expect, it } from 'vitest';
+import { isLeapYear } from './index';
 
-describe("isLeapYear", () => {
-  it("returns true if the given date is in the leap year", () => {
+describe('isLeapYear', () => {
+  it('returns true if the given date is in the leap year', () => {
     const result = isLeapYear(new Date(2012, 6 /* Jul */, 2));
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is not in the leap year", () => {
+  it('returns false if the given date is not in the leap year', () => {
     const result = isLeapYear(new Date(2014, 6 /* Jul */, 2));
     expect(result).toBe(false);
   });
 
-  it("works for the years divisible by 100 but not by 400", () => {
+  it('works for the years divisible by 100 but not by 400', () => {
     const result = isLeapYear(new Date(2100, 6 /* Jul */, 2));
     expect(result).toBe(false);
   });
 
-  it("works for the years divisible by 400", () => {
+  it('works for the years divisible by 400', () => {
     const result = isLeapYear(new Date(2000, 6 /* Jul */, 2));
     expect(result).toBe(true);
   });
 
-  it("accepts a timestamp", () => {
+  it('accepts a timestamp', () => {
     const date = new Date(2012, 6 /* Jul */, 2).getTime();
     const result = isLeapYear(date);
     expect(result).toBe(true);
   });
 
-  it("returns false if the given date is `Invalid Date`", () => {
+  it('returns false if the given date is `Invalid Date`', () => {
     const result = isLeapYear(new Date(NaN));
     expect(result).toBe(false);
   });

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

@@ -1,17 +1,12 @@
-import { isValid } from "../isValid/index";
-import { parse } from "../parse/index";
-import type {
-  AdditionalTokensOptions,
-  FirstWeekContainsDateOptions,
-  LocalizedOptions,
-  WeekOptions,
-} from "../types";
+import { isValid } from '../isValid/index';
+import { parse } from '../parse/index';
+import type { AdditionalTokensOptions, FirstWeekContainsDateOptions, LocalizedOptions, WeekOptions } from '../types';
 
 /**
  * The {@link isMatch} function options.
  */
 export interface IsMatchOptions
-  extends LocalizedOptions<"options" | "match" | "formatLong">,
+  extends LocalizedOptions<'options' | 'match' | 'formatLong'>,
     WeekOptions,
     FirstWeekContainsDateOptions,
     AdditionalTokensOptions {}
@@ -302,10 +297,6 @@ export interface IsMatchOptions
  * })
  * //=> true
  */
-export function isMatch(
-  dateStr: string,
-  formatStr: string,
-  options?: IsMatchOptions,
-): boolean {
+export function isMatch(dateStr: string, formatStr: string, options?: IsMatchOptions): boolean {
   return isValid(parse(dateStr, formatStr, new Date(), options));
 }