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

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

@@ -1,15 +1,11 @@
-import { describe, expect, it } from "vitest";
-import { parse } from "./index";
+import { describe, expect, it } from 'vitest';
+import { parse } from './index';
 
-describe("parse", () => {
+describe('parse', () => {
   const referenceDate = new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 900);
 
-  it("escapes characters between the single quote characters", () => {
-    const result = parse(
-      "2018 hello world July 2nd",
-      "yyyy 'hello world' MMMM do",
-      referenceDate,
-    );
+  it('escapes characters between the single quote characters', () => {
+    const result = parse('2018 hello world July 2nd', "yyyy 'hello world' MMMM do", referenceDate);
     expect(result).toEqual(new Date(2018, 6 /* Jul */, 2));
   });
 
@@ -18,848 +14,790 @@ describe("parse", () => {
     expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 5));
   });
 
-  it("accepts new line charactor", () => {
-    const result = parse(
-      "2014-04-04\n05:00:00",
-      "yyyy-MM-dd'\n'HH:mm:ss",
-      referenceDate,
-    );
+  it('accepts new line charactor', () => {
+    const result = parse('2014-04-04\n05:00:00', "yyyy-MM-dd'\n'HH:mm:ss", referenceDate);
     expect(result).toEqual(new Date(2014, 3 /* Apr */, 4, 5));
   });
 
-  describe("era", () => {
-    it("abbreviated", () => {
-      const result = parse("10000 BC", "yyyyy G", referenceDate);
+  describe('era', () => {
+    it('abbreviated', () => {
+      const result = parse('10000 BC', 'yyyyy G', referenceDate);
       expect(result).toEqual(new Date(-9999, 0 /* Jan */, 1));
     });
 
-    it("wide", () => {
-      const result = parse("2018 Anno Domini", "yyyy GGGG", referenceDate);
+    it('wide', () => {
+      const result = parse('2018 Anno Domini', 'yyyy GGGG', referenceDate);
       expect(result).toEqual(new Date(2018, 0 /* Jan */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("44 B", "y GGGGG", referenceDate);
+    it('narrow', () => {
+      const result = parse('44 B', 'y GGGGG', referenceDate);
       expect(result).toEqual(new Date(-43, 0 /* Jan */, 1));
     });
 
-    it("with week-numbering year", () => {
-      const result = parse("44 B", "Y GGGGG", referenceDate);
+    it('with week-numbering year', () => {
+      const result = parse('44 B', 'Y GGGGG', referenceDate);
       expect(result).toEqual(new Date(-44, 11 /* Dec */, 30));
     });
 
-    it("parses stand-alone BC", () => {
-      const result = parse("BC", "G", referenceDate);
+    it('parses stand-alone BC', () => {
+      const result = parse('BC', 'G', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(0, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    it("parses stand-alone AD", () => {
-      const result = parse("AD", "G", referenceDate);
+    it('parses stand-alone AD', () => {
+      const result = parse('AD', 'G', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(1, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["G", "BC"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['G', 'BC'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when G is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 420`, `${token} G`, referenceDate);
+          const block = () => parse(`${example} 420`, `${token} G`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`G\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`G\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("calendar year", () => {
-    it("numeric", () => {
-      const result = parse("2017", "y", referenceDate);
+  describe('calendar year', () => {
+    it('numeric', () => {
+      const result = parse('2017', 'y', referenceDate);
       expect(result).toEqual(new Date(2017, 0 /* Jan */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("2017th", "yo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('2017th', 'yo', referenceDate);
       expect(result).toEqual(new Date(2017, 0 /* Jan */, 1));
     });
 
-    describe("two-digit numeric year", () => {
-      it("works as expected", () => {
-        const result = parse("02", "yy", referenceDate);
+    describe('two-digit numeric year', () => {
+      it('works as expected', () => {
+        const result = parse('02', 'yy', referenceDate);
         expect(result).toEqual(new Date(2002, 0 /* Jan */, 1));
       });
 
-      it("gets the 100 year range from `referenceDate`", () => {
-        const result = parse("02", "yy", new Date(1860, 6 /* Jul */, 2));
+      it('gets the 100 year range from `referenceDate`', () => {
+        const result = parse('02', 'yy', new Date(1860, 6 /* Jul */, 2));
         expect(result).toEqual(new Date(1902, 0 /* Jan */, 1));
       });
     });
 
-    it("three-digit zero-padding", () => {
-      const result = parse("123", "yyy", referenceDate);
+    it('three-digit zero-padding', () => {
+      const result = parse('123', 'yyy', referenceDate);
       expect(result).toEqual(new Date(123, 0 /* Jan */, 1));
     });
 
-    it("four-digit zero-padding", () => {
-      const result = parse("0044", "yyyy", referenceDate);
+    it('four-digit zero-padding', () => {
+      const result = parse('0044', 'yyyy', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(44, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("000001", "yyyyyy", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('000001', 'yyyyyy', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(1, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["w", "1"],
-        ["I", "1"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['w', '1'],
+        ['I', '1'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when y is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 2019`, `${token} y`, referenceDate);
+          const block = () => parse(`${example} 2019`, `${token} y`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`y\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`y\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("local week-numbering year", () => {
-    it("numeric", () => {
-      const result = parse("2002", "Y", referenceDate);
+  describe('local week-numbering year', () => {
+    it('numeric', () => {
+      const result = parse('2002', 'Y', referenceDate);
       expect(result).toEqual(new Date(2001, 11 /* Dec */, 30));
     });
 
-    it("ordinal", () => {
-      const result = parse("12345th", "Yo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('12345th', 'Yo', referenceDate);
       expect(result).toEqual(new Date(12344, 11 /* Dec */, 31));
     });
 
-    describe("two-digit numeric year", () => {
-      it("works as expected", () => {
-        const result = parse("02", "YY", referenceDate, {
+    describe('two-digit numeric year', () => {
+      it('works as expected', () => {
+        const result = parse('02', 'YY', referenceDate, {
           useAdditionalWeekYearTokens: true,
         });
         expect(result).toEqual(new Date(2001, 11 /* Dec */, 30));
       });
 
-      it("gets the 100 year range from `referenceDate`", () => {
-        const result = parse("02", "YY", new Date(1860, 6 /* Jul */, 2), {
+      it('gets the 100 year range from `referenceDate`', () => {
+        const result = parse('02', 'YY', new Date(1860, 6 /* Jul */, 2), {
           useAdditionalWeekYearTokens: true,
         });
         expect(result).toEqual(new Date(1901, 11 /* Dec */, 29));
       });
     });
 
-    it("three-digit zero-padding", () => {
-      const result = parse("123", "YYY", referenceDate);
+    it('three-digit zero-padding', () => {
+      const result = parse('123', 'YYY', referenceDate);
       expect(result).toEqual(new Date(122, 11 /* Dec */, 27));
     });
 
-    it("four-digit zero-padding", () => {
-      const result = parse("2018", "YYYY", referenceDate, {
+    it('four-digit zero-padding', () => {
+      const result = parse('2018', 'YYYY', referenceDate, {
         useAdditionalWeekYearTokens: true,
       });
       expect(result).toEqual(new Date(2017, 11 /* Dec */, 31));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("000001", "YYYYYY", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('000001', 'YYYYYY', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(0, 11 /* Dec */, 31);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    it("allows to specify `weekStartsOn` and `firstWeekContainsDate` in options", () => {
-      const result = parse("2018", "Y", referenceDate, {
+    it('allows to specify `weekStartsOn` and `firstWeekContainsDate` in options', () => {
+      const result = parse('2018', 'Y', referenceDate, {
         weekStartsOn: 1 /* Mon */,
         firstWeekContainsDate: 4,
       });
       expect(result).toEqual(new Date(2018, 0 /* Jan */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when Y is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 2019`, `${token} Y`, referenceDate, options);
+          const block = () => parse(`${example} 2019`, `${token} Y`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`Y\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`Y\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("ISO week-numbering year", () => {
-    it("numeric", () => {
-      const result = parse("-1234", "R", referenceDate);
+  describe('ISO week-numbering year', () => {
+    it('numeric', () => {
+      const result = parse('-1234', 'R', referenceDate);
       expect(result).toEqual(new Date(-1234, 0 /* Jan */, 3));
     });
 
-    it("two-digit zero-padding", () => {
-      const result = parse("-02", "RR", referenceDate);
+    it('two-digit zero-padding', () => {
+      const result = parse('-02', 'RR', referenceDate);
       expect(result).toEqual(new Date(-3, 11 /* Dec */, 29));
     });
 
-    it("three-digit zero-padding", () => {
-      const result = parse("123", "RRR", referenceDate);
+    it('three-digit zero-padding', () => {
+      const result = parse('123', 'RRR', referenceDate);
       expect(result).toEqual(new Date(123, 0 /* Jan */, 4));
     });
 
-    it("four-digit zero-padding", () => {
-      const result = parse("2018", "RRRR", referenceDate);
+    it('four-digit zero-padding', () => {
+      const result = parse('2018', 'RRRR', referenceDate);
       expect(result).toEqual(new Date(2018, 0 /* Jan */, 1));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("000001", "RRRRRR", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('000001', 'RRRRRR', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(1, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["G", "AD"],
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['G', 'AD'],
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when R is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 2019`, `${token} R`, referenceDate, options);
+          const block = () => parse(`${example} 2019`, `${token} R`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`R\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`R\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("extended year", () => {
-    it("numeric", () => {
-      const result = parse("-1234", "u", referenceDate);
+  describe('extended year', () => {
+    it('numeric', () => {
+      const result = parse('-1234', 'u', referenceDate);
       expect(result).toEqual(new Date(-1234, 0 /* Jan */, 1));
     });
 
-    it("two-digit zero-padding", () => {
-      const result = parse("-02", "uu", referenceDate);
+    it('two-digit zero-padding', () => {
+      const result = parse('-02', 'uu', referenceDate);
       expect(result).toEqual(new Date(-2, 0 /* Jan */, 1));
     });
 
-    it("three-digit zero-padding", () => {
-      const result = parse("123", "uuu", referenceDate);
+    it('three-digit zero-padding', () => {
+      const result = parse('123', 'uuu', referenceDate);
       expect(result).toEqual(new Date(123, 0 /* Jan */, 1));
     });
 
-    it("four-digit zero-padding", () => {
-      const result = parse("2018", "uuuu", referenceDate);
+    it('four-digit zero-padding', () => {
+      const result = parse('2018', 'uuuu', referenceDate);
       expect(result).toEqual(new Date(2018, 0 /* Jan */, 1));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("000001", "uuuuuu", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('000001', 'uuuuuu', referenceDate);
       const expectedResult = new Date(0);
       expectedResult.setFullYear(1, 0 /* Jan */, 1);
       expectedResult.setHours(0, 0, 0, 0);
       expect(result).toEqual(expectedResult);
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["G", "AD"],
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["w", "1"],
-        ["I", "1"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['G', 'AD'],
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['w', '1'],
+        ['I', '1'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when u is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 2019`, `${token} u`, referenceDate);
+          const block = () => parse(`${example} 2019`, `${token} u`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`u\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`u\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("quarter with following year", () => {
-    it("first quarter", () => {
-      const result = parse("Q1/2020", "QQQ/yyyy", referenceDate);
+  describe('quarter with following year', () => {
+    it('first quarter', () => {
+      const result = parse('Q1/2020', 'QQQ/yyyy', referenceDate);
       expect(result).toEqual(new Date(2020, 0 /* Jan */, 1));
     });
 
-    it("second quarter", () => {
-      const result = parse("Q2/2020", "QQQ/yyyy", referenceDate);
+    it('second quarter', () => {
+      const result = parse('Q2/2020', 'QQQ/yyyy', referenceDate);
       expect(result).toEqual(new Date(2020, 3 /* Apr */, 1));
     });
 
-    it("third quarter", () => {
-      const result = parse("Q3/2020", "QQQ/yyyy", referenceDate);
+    it('third quarter', () => {
+      const result = parse('Q3/2020', 'QQQ/yyyy', referenceDate);
       expect(result).toEqual(new Date(2020, 6 /* Jul */, 1));
     });
 
-    it("fourth quarter", () => {
-      const result = parse("Q4/2020", "QQQ/yyyy", referenceDate);
+    it('fourth quarter', () => {
+      const result = parse('Q4/2020', 'QQQ/yyyy', referenceDate);
       expect(result).toEqual(new Date(2020, 9 /* Oct */, 1));
     });
   });
 
-  describe("quarter (formatting)", () => {
-    it("numeric", () => {
-      const result = parse("1", "Q", referenceDate);
+  describe('quarter (formatting)', () => {
+    it('numeric', () => {
+      const result = parse('1', 'Q', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("1st", "Qo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('1st', 'Qo', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("02", "QQ", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('02', 'QQ', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Q3", "QQQ", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Q3', 'QQQ', referenceDate);
       expect(result).toEqual(new Date(1986, 6 /* Jul */, 1));
     });
 
-    it("wide", () => {
-      const result = parse("4st quarter", "QQQQ", referenceDate);
+    it('wide', () => {
+      const result = parse('4st quarter', 'QQQQ', referenceDate);
       expect(result).toEqual(new Date(1986, 9 /* Oct */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("1", "QQQQQ", referenceDate);
+    it('narrow', () => {
+      const result = parse('1', 'QQQQQ', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when Q is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} Q`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} Q`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`Q\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`Q\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("quarter (stand-alone)", () => {
-    it("numeric", () => {
-      const result = parse("1", "q", referenceDate);
+  describe('quarter (stand-alone)', () => {
+    it('numeric', () => {
+      const result = parse('1', 'q', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("1th", "qo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('1th', 'qo', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("02", "qq", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('02', 'qq', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Q3", "qqq", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Q3', 'qqq', referenceDate);
       expect(result).toEqual(new Date(1986, 6 /* Jul */, 1));
     });
 
-    it("wide", () => {
-      const result = parse("4th quarter", "qqqq", referenceDate);
+    it('wide', () => {
+      const result = parse('4th quarter', 'qqqq', referenceDate);
       expect(result).toEqual(new Date(1986, 9 /* Oct */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("1", "qqqqq", referenceDate);
+    it('narrow', () => {
+      const result = parse('1', 'qqqqq', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when q is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} q`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} q`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`q\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`q\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("month (formatting)", () => {
-    it("numeric", () => {
-      const result = parse("6", "M", referenceDate);
+  describe('month (formatting)', () => {
+    it('numeric', () => {
+      const result = parse('6', 'M', referenceDate);
       expect(result).toEqual(new Date(1986, 5 /* Jun */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("6th", "Mo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('6th', 'Mo', referenceDate);
       expect(result).toEqual(new Date(1986, 5 /* Jun */, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "MM", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'MM', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Nov", "MMM", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Nov', 'MMM', referenceDate);
       expect(result).toEqual(new Date(1986, 10 /* Nov */, 1));
     });
 
-    it("wide", () => {
-      const result = parse("February", "MMMM", referenceDate);
+    it('wide', () => {
+      const result = parse('February', 'MMMM', referenceDate);
       expect(result).toEqual(new Date(1986, 1 /* Feb */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("J", "MMMMM", referenceDate);
+    it('narrow', () => {
+      const result = parse('J', 'MMMMM', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when M is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} M`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} M`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`M\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`M\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("month (stand-alone)", () => {
-    it("numeric", () => {
-      const result = parse("6", "L", referenceDate);
+  describe('month (stand-alone)', () => {
+    it('numeric', () => {
+      const result = parse('6', 'L', referenceDate);
       expect(result).toEqual(new Date(1986, 5 /* Jun */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("6th", "Lo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('6th', 'Lo', referenceDate);
       expect(result).toEqual(new Date(1986, 5 /* Jun */, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "LL", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'LL', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Nov", "LLL", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Nov', 'LLL', referenceDate);
       expect(result).toEqual(new Date(1986, 10 /* Nov */, 1));
     });
 
-    it("wide", () => {
-      const result = parse("February", "LLLL", referenceDate);
+    it('wide', () => {
+      const result = parse('February', 'LLLL', referenceDate);
       expect(result).toEqual(new Date(1986, 1 /* Feb */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("J", "LLLLL", referenceDate);
+    it('narrow', () => {
+      const result = parse('J', 'LLLLL', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when L is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} L`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} L`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`L\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`L\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("local week of year", () => {
-    it("numeric", () => {
-      const result = parse("49", "w", referenceDate);
+  describe('local week of year', () => {
+    it('numeric', () => {
+      const result = parse('49', 'w', referenceDate);
       expect(result).toEqual(new Date(1986, 10 /* Nov */, 30));
     });
 
-    it("ordinal", () => {
-      const result = parse("49th", "wo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('49th', 'wo', referenceDate);
       expect(result).toEqual(new Date(1986, 10 /* Nov */, 30));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "ww", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'ww', referenceDate);
       expect(result).toEqual(new Date(1985, 11 /* Dec */, 29));
     });
 
-    it("allows to specify `weekStartsOn` and `firstWeekContainsDate` in options", () => {
-      const result = parse("49", "w", referenceDate, {
+    it('allows to specify `weekStartsOn` and `firstWeekContainsDate` in options', () => {
+      const result = parse('49', 'w', referenceDate, {
         weekStartsOn: 1 /* Mon */,
         firstWeekContainsDate: 4,
       });
       expect(result).toEqual(new Date(1986, 11 /* Dec */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when w is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} w`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} w`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`w\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`w\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("ISO week of year", () => {
-    it("numeric", () => {
-      const result = parse("49", "I", referenceDate);
+  describe('ISO week of year', () => {
+    it('numeric', () => {
+      const result = parse('49', 'I', referenceDate);
       expect(result).toEqual(new Date(1986, 11 /* Dec */, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("49th", "Io", referenceDate);
+    it('ordinal', () => {
+      const result = parse('49th', 'Io', referenceDate);
       expect(result).toEqual(new Date(1986, 11 /* Dec */, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "II", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'II', referenceDate);
       expect(result).toEqual(new Date(1985, 11 /* Dec */, 30));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when I is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} I`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} I`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`I\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`I\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("day of month", () => {
-    it("numeric", () => {
-      const result = parse("28", "d", referenceDate);
+  describe('day of month', () => {
+    it('numeric', () => {
+      const result = parse('28', 'd', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 28));
     });
 
-    it("ordinal", () => {
-      const result = parse("28th", "do", referenceDate);
+    it('ordinal', () => {
+      const result = parse('28th', 'do', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 28));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "dd", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'dd', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when d is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} d`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} d`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`d\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`d\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("day of year", () => {
-    it("numeric", () => {
-      const result = parse("200", "D", referenceDate, {
+  describe('day of year', () => {
+    it('numeric', () => {
+      const result = parse('200', 'D', referenceDate, {
         useAdditionalDayOfYearTokens: true,
       });
       expect(result).toEqual(new Date(1986, 6 /* Jul */, 19));
     });
 
-    it("ordinal", () => {
-      const result = parse("200th", "Do", referenceDate);
+    it('ordinal', () => {
+      const result = parse('200th', 'Do', referenceDate);
       expect(result).toEqual(new Date(1986, 6 /* Jul */, 19));
     });
 
-    it("two-digit zero-padding", () => {
-      const result = parse("01", "DD", referenceDate, {
+    it('two-digit zero-padding', () => {
+      const result = parse('01', 'DD', referenceDate, {
         useAdditionalDayOfYearTokens: true,
       });
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("three-digit zero-padding", () => {
-      const result = parse("001", "DDD", referenceDate);
+    it('three-digit zero-padding', () => {
+      const result = parse('001', 'DDD', referenceDate);
       expect(result).toEqual(new Date(1986, 0 /* Jan */, 1));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("000200", "DDDDDD", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('000200', 'DDDDDD', referenceDate);
       expect(result).toEqual(new Date(1986, 6 /* Jul */, 19));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["Y", "2019"],
-        ["R", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1"],
-        ["E", "Mon"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['Y', '2019'],
+        ['R', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1'],
+        ['E', 'Mon'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example, _options]) => {
         it(`throws an error when D is used after ${token}`, () => {
           const block = () =>
@@ -868,1324 +806,1134 @@ describe("parse", () => {
             });
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`D\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`D\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("day of week (formatting)", () => {
-    it("abbreviated", () => {
-      const result = parse("Mon", "E", referenceDate);
+  describe('day of week (formatting)', () => {
+    it('abbreviated', () => {
+      const result = parse('Mon', 'E', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("wide", () => {
-      const result = parse("Tuesday", "EEEE", referenceDate);
+    it('wide', () => {
+      const result = parse('Tuesday', 'EEEE', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("narrow", () => {
-      const result = parse("W", "EEEEE", referenceDate);
+    it('narrow', () => {
+      const result = parse('W', 'EEEEE', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 2));
     });
 
-    it("short", () => {
-      const result = parse("Th", "EEEEEE", referenceDate);
+    it('short', () => {
+      const result = parse('Th', 'EEEEEE', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 3));
     });
 
-    it("allows to specify which day is the first day of the week", () => {
-      const result = parse("Thursday", "EEEE", referenceDate, {
+    it('allows to specify which day is the first day of the week', () => {
+      const result = parse('Thursday', 'EEEE', referenceDate, {
         weekStartsOn: /* Fri */ 5,
       });
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 10));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["E", "Mon"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['E', 'Mon'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when E is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} Mon`, `${token} E`, referenceDate, options);
+          const block = () => parse(`${example} Mon`, `${token} E`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`E\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`E\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("ISO day of week (formatting)", () => {
-    it("numeric", () => {
-      const result = parse("1", "i", referenceDate);
+  describe('ISO day of week (formatting)', () => {
+    it('numeric', () => {
+      const result = parse('1', 'i', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("ordinal", () => {
-      const result = parse("1st", "io", referenceDate);
+    it('ordinal', () => {
+      const result = parse('1st', 'io', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("zero-padding", () => {
-      const result = parse("02", "ii", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('02', 'ii', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Wed", "iii", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Wed', 'iii', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 2));
     });
 
-    it("wide", () => {
-      const result = parse("Thursday", "iiii", referenceDate);
+    it('wide', () => {
+      const result = parse('Thursday', 'iiii', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 3));
     });
 
-    it("narrow", () => {
-      const result = parse("S", "iiiii", referenceDate);
+    it('narrow', () => {
+      const result = parse('S', 'iiiii', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 6));
     });
 
-    it("short", () => {
-      const result = parse("Fr", "iiiiii", referenceDate);
+    it('short', () => {
+      const result = parse('Fr', 'iiiiii', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["Y", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["w", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["E", "Mon"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['Y', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['w', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['E', 'Mon'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when i is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} i`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} i`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`i\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`i\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("local day of week (formatting)", () => {
-    it("numeric", () => {
-      const result = parse("2", "e", referenceDate);
+  describe('local day of week (formatting)', () => {
+    it('numeric', () => {
+      const result = parse('2', 'e', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("ordinal", () => {
-      const result = parse("2nd", "eo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('2nd', 'eo', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("zero-padding", () => {
-      const result = parse("03", "ee", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('03', 'ee', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Wed", "eee", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Wed', 'eee', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 2));
     });
 
-    it("wide", () => {
-      const result = parse("Thursday", "eeee", referenceDate);
+    it('wide', () => {
+      const result = parse('Thursday', 'eeee', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 3));
     });
 
-    it("narrow", () => {
-      const result = parse("S", "eeeee", referenceDate);
+    it('narrow', () => {
+      const result = parse('S', 'eeeee', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 30));
     });
 
-    it("short", () => {
-      const result = parse("Fr", "eeeeee", referenceDate);
+    it('short', () => {
+      const result = parse('Fr', 'eeeeee', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4));
     });
 
-    it("allows to specify which day is the first day of the week", () => {
-      const result = parse("7th", "eo", referenceDate, {
+    it('allows to specify which day is the first day of the week', () => {
+      const result = parse('7th', 'eo', referenceDate, {
         weekStartsOn: /* Fri */ 5,
       });
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 10));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["E", "Mon"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['E', 'Mon'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when e is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} e`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} e`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`e\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`e\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("local day of week (stand-alone)", () => {
-    it("numeric", () => {
-      const result = parse("2", "c", referenceDate);
+  describe('local day of week (stand-alone)', () => {
+    it('numeric', () => {
+      const result = parse('2', 'c', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("ordinal", () => {
-      const result = parse("2nd", "co", referenceDate);
+    it('ordinal', () => {
+      const result = parse('2nd', 'co', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 31));
     });
 
-    it("zero-padding", () => {
-      const result = parse("03", "cc", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('03', 'cc', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 1));
     });
 
-    it("abbreviated", () => {
-      const result = parse("Wed", "ccc", referenceDate);
+    it('abbreviated', () => {
+      const result = parse('Wed', 'ccc', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 2));
     });
 
-    it("wide", () => {
-      const result = parse("Thursday", "cccc", referenceDate);
+    it('wide', () => {
+      const result = parse('Thursday', 'cccc', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 3));
     });
 
-    it("narrow", () => {
-      const result = parse("S", "ccccc", referenceDate);
+    it('narrow', () => {
+      const result = parse('S', 'ccccc', referenceDate);
       expect(result).toEqual(new Date(1986, 2 /* Mar */, 30));
     });
 
-    it("short", () => {
-      const result = parse("Fr", "cccccc", referenceDate);
+    it('short', () => {
+      const result = parse('Fr', 'cccccc', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4));
     });
 
-    it("allows to specify which day is the first day of the week", () => {
-      const result = parse("7th", "co", referenceDate, {
+    it('allows to specify which day is the first day of the week', () => {
+      const result = parse('7th', 'co', referenceDate, {
         weekStartsOn: /* Fri */ 5,
       });
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 10));
     });
 
-    describe("validation", () => {
-      const tokensToValidate: Array<
-        [string, string, { useAdditionalDayOfYearTokens: boolean }?]
-      > = [
-        ["y", "2019"],
-        ["R", "2019"],
-        ["u", "2019"],
-        ["Q", "1"],
-        ["q", "1"],
-        ["M", "1"],
-        ["L", "1"],
-        ["I", "1"],
-        ["d", "1"],
-        ["D", "1", { useAdditionalDayOfYearTokens: true }],
-        ["E", "Mon"],
-        ["i", "1"],
-        ["e", "1"],
-        ["c", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+    describe('validation', () => {
+      const tokensToValidate: Array<[string, string, { useAdditionalDayOfYearTokens: boolean }?]> = [
+        ['y', '2019'],
+        ['R', '2019'],
+        ['u', '2019'],
+        ['Q', '1'],
+        ['q', '1'],
+        ['M', '1'],
+        ['L', '1'],
+        ['I', '1'],
+        ['d', '1'],
+        ['D', '1', { useAdditionalDayOfYearTokens: true }],
+        ['E', 'Mon'],
+        ['i', '1'],
+        ['e', '1'],
+        ['c', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ];
       tokensToValidate.forEach(([token, example, options]) => {
         it(`throws an error when c is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} c`, referenceDate, options);
+          const block = () => parse(`${example} 1`, `${token} c`, referenceDate, options);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`c\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`c\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("AM, PM", () => {
-    it("abbreviated", () => {
-      const result = parse("5 AM", "h a", referenceDate);
+  describe('AM, PM', () => {
+    it('abbreviated', () => {
+      const result = parse('5 AM', 'h a', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 5));
     });
 
-    it("12 AM", () => {
-      const result = parse("12 AM", "h aa", referenceDate);
+    it('12 AM', () => {
+      const result = parse('12 AM', 'h aa', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 0));
     });
 
-    it("12 PM", () => {
-      const result = parse("12 PM", "h aaa", referenceDate);
+    it('12 PM', () => {
+      const result = parse('12 PM', 'h aaa', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("wide", () => {
-      const result = parse("5 p.m.", "h aaaa", referenceDate);
+    it('wide', () => {
+      const result = parse('5 p.m.', 'h aaaa', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 17));
     });
 
-    it("narrow", () => {
-      const result = parse("11 a", "h aaaaa", referenceDate);
+    it('narrow', () => {
+      const result = parse('11 a', 'h aaaaa', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 11));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["a", "AM"],
-        ["b", "AM"],
-        ["B", "in the morning"],
-        ["H", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['a', 'AM'],
+        ['b', 'AM'],
+        ['B', 'in the morning'],
+        ['H', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when a is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} AM`, `${token} a`, referenceDate);
+          const block = () => parse(`${example} AM`, `${token} a`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`a\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`a\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("AM, PM, noon, midnight", () => {
-    it("abbreviated", () => {
-      const result = parse("noon", "b", referenceDate);
+  describe('AM, PM, noon, midnight', () => {
+    it('abbreviated', () => {
+      const result = parse('noon', 'b', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("wide", () => {
-      const result = parse("midnight", "bbbb", referenceDate);
+    it('wide', () => {
+      const result = parse('midnight', 'bbbb', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 0));
     });
 
-    it("narrow", () => {
-      const result = parse("mi", "bbbbb", referenceDate);
+    it('narrow', () => {
+      const result = parse('mi', 'bbbbb', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 0));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["a", "AM"],
-        ["b", "AM"],
-        ["B", "in the morning"],
-        ["H", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['a', 'AM'],
+        ['b', 'AM'],
+        ['B', 'in the morning'],
+        ['H', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when b is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} AM`, `${token} b`, referenceDate);
+          const block = () => parse(`${example} AM`, `${token} b`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`b\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`b\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("flexible day period", () => {
-    it("abbreviated", () => {
-      const result = parse("2 at night", "h B", referenceDate);
+  describe('flexible day period', () => {
+    it('abbreviated', () => {
+      const result = parse('2 at night', 'h B', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 2));
     });
 
-    it("wide", () => {
-      const result = parse("12 in the afternoon", "h BBBB", referenceDate);
+    it('wide', () => {
+      const result = parse('12 in the afternoon', 'h BBBB', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("narrow", () => {
-      const result = parse("5 in the evening", "h BBBBB", referenceDate);
+    it('narrow', () => {
+      const result = parse('5 in the evening', 'h BBBBB', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 17));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["a", "AM"],
-        ["b", "AM"],
-        ["B", "in the morning"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['a', 'AM'],
+        ['b', 'AM'],
+        ['B', 'in the morning'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when B is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} in the morning`, `${token} B`, referenceDate);
+          const block = () => parse(`${example} in the morning`, `${token} B`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`B\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`B\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("hour [1-12]", () => {
-    it("numeric", () => {
-      const result = parse("1", "h", referenceDate);
+  describe('hour [1-12]', () => {
+    it('numeric', () => {
+      const result = parse('1', 'h', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("1st", "ho", referenceDate);
+    it('ordinal', () => {
+      const result = parse('1st', 'ho', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("01", "hh", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('01', 'hh', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["h", "1"],
-        ["H", "1"],
-        ["K", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['h', '1'],
+        ['H', '1'],
+        ['K', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when h is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} h`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} h`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`h\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`h\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("hour [0-23]", () => {
-    it("numeric", () => {
-      const result = parse("12", "H", referenceDate);
+  describe('hour [0-23]', () => {
+    it('numeric', () => {
+      const result = parse('12', 'H', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("ordinal", () => {
-      const result = parse("12th", "Ho", referenceDate);
+    it('ordinal', () => {
+      const result = parse('12th', 'Ho', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("zero-padding", () => {
-      const result = parse("00", "HH", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('00', 'HH', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 0));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["a", "AM"],
-        ["b", "AM"],
-        ["h", "1"],
-        ["H", "1"],
-        ["K", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['a', 'AM'],
+        ['b', 'AM'],
+        ['h', '1'],
+        ['H', '1'],
+        ['K', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when H is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} H`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} H`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`H\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`H\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("hour [0-11]", () => {
-    it("numeric", () => {
-      const result = parse("1", "K", referenceDate);
+  describe('hour [0-11]', () => {
+    it('numeric', () => {
+      const result = parse('1', 'K', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    it("ordinal", () => {
-      const result = parse("1st", "Ko", referenceDate);
+    it('ordinal', () => {
+      const result = parse('1st', 'Ko', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    it("zero-padding", () => {
-      const result = parse("1", "KK", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('1', 'KK', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 1));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["h", "1"],
-        ["H", "1"],
-        ["K", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['h', '1'],
+        ['H', '1'],
+        ['K', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when K is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} K`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} K`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`K\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`K\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("hour [1-24]", () => {
-    it("numeric", () => {
-      const result = parse("12", "k", referenceDate);
+  describe('hour [1-24]', () => {
+    it('numeric', () => {
+      const result = parse('12', 'k', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("ordinal", () => {
-      const result = parse("12th", "ko", referenceDate);
+    it('ordinal', () => {
+      const result = parse('12th', 'ko', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 12));
     });
 
-    it("zero-padding", () => {
-      const result = parse("24", "kk", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('24', 'kk', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 0));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["a", "AM"],
-        ["b", "AM"],
-        ["h", "1"],
-        ["H", "1"],
-        ["K", "1"],
-        ["k", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['a', 'AM'],
+        ['b', 'AM'],
+        ['h', '1'],
+        ['H', '1'],
+        ['K', '1'],
+        ['k', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when k is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} k`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} k`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`k\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`k\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("minute", () => {
-    it("numeric", () => {
-      const result = parse("25", "m", referenceDate);
+  describe('minute', () => {
+    it('numeric', () => {
+      const result = parse('25', 'm', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 25));
     });
 
-    it("ordinal", () => {
-      const result = parse("25th", "mo", referenceDate);
+    it('ordinal', () => {
+      const result = parse('25th', 'mo', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 25));
     });
 
-    it("zero-padding", () => {
-      const result = parse("05", "mm", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('05', 'mm', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 5));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["m", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['m', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when m is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} m`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} m`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`m\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`m\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("second", () => {
-    it("numeric", () => {
-      const result = parse("25", "s", referenceDate);
+  describe('second', () => {
+    it('numeric', () => {
+      const result = parse('25', 's', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 25));
     });
 
-    it("ordinal", () => {
-      const result = parse("25th", "so", referenceDate);
+    it('ordinal', () => {
+      const result = parse('25th', 'so', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 25));
     });
 
-    it("zero-padding", () => {
-      const result = parse("05", "ss", referenceDate);
+    it('zero-padding', () => {
+      const result = parse('05', 'ss', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 5));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["s", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['s', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when s is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} s`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} s`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`s\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`s\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("fraction of second", () => {
-    it("1/10 of second", () => {
-      const result = parse("1", "S", referenceDate);
+  describe('fraction of second', () => {
+    it('1/10 of second', () => {
+      const result = parse('1', 'S', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 100));
     });
 
-    it("1/100 of second", () => {
-      const result = parse("12", "SS", referenceDate);
+    it('1/100 of second', () => {
+      const result = parse('12', 'SS', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 120));
     });
 
-    it("millisecond", () => {
-      const result = parse("123", "SSS", referenceDate);
+    it('millisecond', () => {
+      const result = parse('123', 'SSS', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 123));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse("567890", "SSSSSS", referenceDate);
+    it('specified amount of digits', () => {
+      const result = parse('567890', 'SSSSSS', referenceDate);
       expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 567));
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["S", "1"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['S', '1'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when S is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} 1`, `${token} S`, referenceDate);
+          const block = () => parse(`${example} 1`, `${token} S`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`S\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`S\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("timezone (ISO-8601 w/ Z)", () => {
-    describe("X", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+  describe('timezone (ISO-8601 w/ Z)', () => {
+    describe('X', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
+      });
+
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123Z', "yyyy-MM-dd'T'HH:mm:ss.SSSX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
-
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123Z",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
-      });
-
-      it("hours", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+05",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123+05:00"));
+
+      it('hours', () => {
+        const result = parse('2016-11-25T16:38:38.123+05', "yyyy-MM-dd'T'HH:mm:ss.SSSX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123+05:00'));
       });
     });
 
-    describe("XX", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('XX', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123Z",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123Z', "yyyy-MM-dd'T'HH:mm:ss.SSSXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
     });
 
-    describe("XXX", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-05:30",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('XXX', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-05:30', "yyyy-MM-dd'T'HH:mm:ss.SSSXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123Z",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123Z', "yyyy-MM-dd'T'HH:mm:ss.SSSXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
     });
 
-    describe("XXXX", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('XXXX', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123Z",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123Z', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
 
-      it("hours, minutes and seconds", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+053045",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:37:53.123+05:30"));
+      it('hours, minutes and seconds', () => {
+        const result = parse('2016-11-25T16:38:38.123+053045', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:37:53.123+05:30'));
       });
     });
 
-    describe("XXXXX", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-05:30",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('XXXXX', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-05:30', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123Z",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123Z', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
 
-      it("hours, minutes and seconds", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+05:30:45",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:37:53.123+05:30"));
+      it('hours, minutes and seconds', () => {
+        const result = parse('2016-11-25T16:38:38.123+05:30:45', "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:37:53.123+05:30'));
       });
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["X", "-0530"],
-        ["x", "-0530"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['X', '-0530'],
+        ['x', '-0530'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when X is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} -0530`, `${token} X`, referenceDate);
+          const block = () => parse(`${example} -0530`, `${token} X`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`X\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`X\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("timezone (ISO-8601 w/o Z)", () => {
-    describe("x", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+  describe('timezone (ISO-8601 w/o Z)', () => {
+    describe('x', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
-
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+0000",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
-      });
-
-      it("hours", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+05",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123+05:00"));
+
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123+0000', "yyyy-MM-dd'T'HH:mm:ss.SSSx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
+      });
+
+      it('hours', () => {
+        const result = parse('2016-11-25T16:38:38.123+05', "yyyy-MM-dd'T'HH:mm:ss.SSSx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123+05:00'));
       });
     });
 
-    describe("xx", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('xx', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+0000",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123+0000', "yyyy-MM-dd'T'HH:mm:ss.SSSxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
     });
 
-    describe("xxx", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-05:30",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('xxx', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-05:30', "yyyy-MM-dd'T'HH:mm:ss.SSSxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+00:00",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123+00:00', "yyyy-MM-dd'T'HH:mm:ss.SSSxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
     });
 
-    describe("xxxx", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-0530",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('xxxx', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-0530', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+0000",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123+0000', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
 
-      it("hours, minutes and seconds", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+053045",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:37:53.123+05:30"));
+      it('hours, minutes and seconds', () => {
+        const result = parse('2016-11-25T16:38:38.123+053045', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:37:53.123+05:30'));
       });
     });
 
-    describe("xxxxx", () => {
-      it("hours and minutes", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123-05:30",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123-05:30"));
+    describe('xxxxx', () => {
+      it('hours and minutes', () => {
+        const result = parse('2016-11-25T16:38:38.123-05:30', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123-05:30'));
       });
 
-      it("GMT", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+00:00",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:38:38.123Z"));
+      it('GMT', () => {
+        const result = parse('2016-11-25T16:38:38.123+00:00', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:38:38.123Z'));
       });
 
-      it("hours, minutes and seconds", () => {
-        const result = parse(
-          "2016-11-25T16:38:38.123+05:30:45",
-          "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx",
-          referenceDate,
-        );
-        expect(result).toEqual(new Date("2016-11-25T16:37:53.123+05:30"));
+      it('hours, minutes and seconds', () => {
+        const result = parse('2016-11-25T16:38:38.123+05:30:45', "yyyy-MM-dd'T'HH:mm:ss.SSSxxxxx", referenceDate);
+        expect(result).toEqual(new Date('2016-11-25T16:37:53.123+05:30'));
       });
     });
 
-    describe("validation", () => {
+    describe('validation', () => {
       [
-        ["X", "-0530"],
-        ["x", "-0530"],
-        ["t", "512969520"],
-        ["T", "512969520900"],
+        ['X', '-0530'],
+        ['x', '-0530'],
+        ['t', '512969520'],
+        ['T', '512969520900'],
       ].forEach(([token, example]) => {
         it(`throws an error when x is used after ${token}`, () => {
-          const block = () =>
-            parse(`${example} -0530`, `${token} x`, referenceDate);
+          const block = () => parse(`${example} -0530`, `${token} x`, referenceDate);
           expect(block).toThrow(RangeError);
           expect(block).toThrow(
-            new RegExp(
-              `The format string mustn't contain \`${token}\` and \`x\` at the same time`,
-            ),
+            new RegExp(`The format string mustn't contain \`${token}\` and \`x\` at the same time`),
           );
         });
       });
     });
   });
 
-  describe("seconds timestamp", () => {
-    it("numeric", () => {
-      const result = parse("512969520", "t", referenceDate);
+  describe('seconds timestamp', () => {
+    it('numeric', () => {
+      const result = parse('512969520', 't', referenceDate);
       expect(result).toEqual(new Date(512969520000));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse(
-        "00000000000512969520",
-        "tttttttttttttttttttt",
-        referenceDate,
-      );
+    it('specified amount of digits', () => {
+      const result = parse('00000000000512969520', 'tttttttttttttttttttt', referenceDate);
       expect(result).toEqual(new Date(512969520000));
     });
 
     it(`throws an error when it is used after any token`, () => {
       const block = () => parse(`1 512969520`, `h t`, referenceDate);
       expect(block).toThrow(RangeError);
-      expect(block).toThrow(
-        new RegExp(
-          `The format string mustn't contain \`t\` and any other token at the same time`,
-        ),
-      );
+      expect(block).toThrow(new RegExp(`The format string mustn't contain \`t\` and any other token at the same time`));
     });
   });
 
-  describe("milliseconds timestamp", () => {
-    it("numeric", () => {
-      const result = parse("512969520900", "T", referenceDate);
+  describe('milliseconds timestamp', () => {
+    it('numeric', () => {
+      const result = parse('512969520900', 'T', referenceDate);
       expect(result).toEqual(new Date(512969520900));
     });
 
-    it("specified amount of digits", () => {
-      const result = parse(
-        "00000000512969520900",
-        "TTTTTTTTTTTTTTTTTTTT",
-        referenceDate,
-      );
+    it('specified amount of digits', () => {
+      const result = parse('00000000512969520900', 'TTTTTTTTTTTTTTTTTTTT', referenceDate);
       expect(result).toEqual(new Date(512969520900));
     });
 
     it(`throws an error when it is used after any token`, () => {
       const block = () => parse(`1 512969520900`, `h T`, referenceDate);
       expect(block).toThrow(RangeError);
-      expect(block).toThrow(
-        new RegExp(
-          `The format string mustn't contain \`T\` and any other token at the same time`,
-        ),
-      );
+      expect(block).toThrow(new RegExp(`The format string mustn't contain \`T\` and any other token at the same time`));
     });
   });
 
-  describe("common formats", () => {
-    it("ISO-8601", () => {
-      const result = parse(
-        "20161105T040404",
-        "yyyyMMdd'T'HHmmss",
-        referenceDate,
-      );
+  describe('common formats', () => {
+    it('ISO-8601', () => {
+      const result = parse('20161105T040404', "yyyyMMdd'T'HHmmss", referenceDate);
       expect(result).toEqual(new Date(2016, 10 /* Nov */, 5, 4, 4, 4, 0));
     });
 
-    it("ISO week-numbering date", () => {
-      const result = parse(
-        "2016W474T153005",
-        "RRRR'W'IIi'T'HHmmss",
-        referenceDate,
-      );
+    it('ISO week-numbering date', () => {
+      const result = parse('2016W474T153005', "RRRR'W'IIi'T'HHmmss", referenceDate);
       expect(result).toEqual(new Date(2016, 10 /* Nov */, 24, 15, 30, 5, 0));
     });
 
-    it("ISO day of year date", () => {
-      const result = parse("2010123T235959", "yyyyDDD'T'HHmmss", referenceDate);
+    it('ISO day of year date', () => {
+      const result = parse('2010123T235959', "yyyyDDD'T'HHmmss", referenceDate);
       expect(result).toEqual(new Date(2010, 4 /* May */, 3, 23, 59, 59, 0));
     });
 
-    it("Date.prototype.toString()", () => {
-      const dateString = "Wed Jul 02 2014 05:30:15 GMT+0600";
+    it('Date.prototype.toString()', () => {
+      const dateString = 'Wed Jul 02 2014 05:30:15 GMT+0600';
       const formatString = "EEE MMM dd yyyy HH:mm:ss 'GMT'xx";
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(new Date(dateString));
     });
 
-    it("Date.prototype.toISOString()", () => {
-      const dateString = "2014-07-02T05:30:15.123+06:00";
+    it('Date.prototype.toISOString()', () => {
+      const dateString = '2014-07-02T05:30:15.123+06:00';
       const formatString = "yyyy-MM-dd'T'HH:mm:ss.SSSxxx";
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(new Date(dateString));
     });
 
-    it("middle-endian", () => {
-      const result = parse(
-        "5 a.m. 07/02/2016",
-        "h aaaa MM/dd/yyyy",
-        referenceDate,
-      );
+    it('middle-endian', () => {
+      const result = parse('5 a.m. 07/02/2016', 'h aaaa MM/dd/yyyy', referenceDate);
       expect(result).toEqual(new Date(2016, 6 /* Jul */, 2, 5, 0, 0, 0));
     });
 
-    it("little-endian", () => {
-      const result = parse("02.07.1995", "dd.MM.yyyy", referenceDate);
+    it('little-endian', () => {
+      const result = parse('02.07.1995', 'dd.MM.yyyy', referenceDate);
       expect(result).toEqual(new Date(1995, 6 /* Jul */, 2, 0, 0, 0, 0));
     });
   });
 
-  describe("priority", () => {
+  describe('priority', () => {
     it("units of lower priority don't overwrite values of higher priority", () => {
-      const dateString = "+06:00 123 15 30 05 02 07 2014";
-      const formatString = "xxx SSS ss mm HH dd MM yyyy";
+      const dateString = '+06:00 123 15 30 05 02 07 2014';
+      const formatString = 'xxx SSS ss mm HH dd MM yyyy';
       const result = parse(dateString, formatString, referenceDate);
-      expect(result).toEqual(new Date("2014-07-02T05:30:15.123+06:00"));
+      expect(result).toEqual(new Date('2014-07-02T05:30:15.123+06:00'));
     });
   });
 
-  describe("with `options.strictValidation` = true", () => {
-    describe("calendar year", () => {
-      it("returns `Invalid Date` for year zero", () => {
-        const result = parse("0", "y", referenceDate);
+  describe('with `options.strictValidation` = true', () => {
+    describe('calendar year', () => {
+      it('returns `Invalid Date` for year zero', () => {
+        const result = parse('0', 'y', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("works correctly for two-digit year zero", () => {
-        const result = parse("00", "yy", referenceDate);
+      it('works correctly for two-digit year zero', () => {
+        const result = parse('00', 'yy', referenceDate);
         expect(result).toEqual(new Date(2000, 0 /* Jan */, 1));
       });
     });
 
-    describe("local week-numbering year", () => {
-      it("returns `Invalid Date` for year zero", () => {
-        const result = parse("0", "Y", referenceDate);
+    describe('local week-numbering year', () => {
+      it('returns `Invalid Date` for year zero', () => {
+        const result = parse('0', 'Y', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("works correctly for two-digit year zero", () => {
-        const result = parse("00", "YY", referenceDate, {
+      it('works correctly for two-digit year zero', () => {
+        const result = parse('00', 'YY', referenceDate, {
           useAdditionalWeekYearTokens: true,
         });
         expect(result).toEqual(new Date(1999, 11 /* Dec */, 26));
       });
     });
 
-    describe("quarter (formatting)", () => {
-      it("returns `Invalid Date` for invalid quarter", () => {
-        const result = parse("0", "Q", referenceDate);
+    describe('quarter (formatting)', () => {
+      it('returns `Invalid Date` for invalid quarter', () => {
+        const result = parse('0', 'Q', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("quarter (stand-alone)", () => {
-      it("returns `Invalid Date` for invalid quarter", () => {
-        const result = parse("5", "q", referenceDate);
+    describe('quarter (stand-alone)', () => {
+      it('returns `Invalid Date` for invalid quarter', () => {
+        const result = parse('5', 'q', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("month (formatting)", () => {
-      it("returns `Invalid Date` for invalid month", () => {
-        const result = parse("00", "MM", referenceDate);
+    describe('month (formatting)', () => {
+      it('returns `Invalid Date` for invalid month', () => {
+        const result = parse('00', 'MM', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("month (stand-alone)", () => {
-      it("returns `Invalid Date` for invalid month", () => {
-        const result = parse("13", "LL", referenceDate);
+    describe('month (stand-alone)', () => {
+      it('returns `Invalid Date` for invalid month', () => {
+        const result = parse('13', 'LL', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("local week of year", () => {
-      it("returns `Invalid Date` for invalid week", () => {
-        const result = parse("0", "w", referenceDate);
+    describe('local week of year', () => {
+      it('returns `Invalid Date` for invalid week', () => {
+        const result = parse('0', 'w', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("ISO week of year", () => {
-      it("returns `Invalid Date` for invalid week", () => {
-        const result = parse("54", "II", referenceDate);
+    describe('ISO week of year', () => {
+      it('returns `Invalid Date` for invalid week', () => {
+        const result = parse('54', 'II', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("day of month", () => {
-      it("returns `Invalid Date` for invalid day of the month", () => {
-        const result = parse("30", "d", new Date(2012, 1 /* Feb */, 1));
+    describe('day of month', () => {
+      it('returns `Invalid Date` for invalid day of the month', () => {
+        const result = parse('30', 'd', new Date(2012, 1 /* Feb */, 1));
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for 29th of February of non-leap year", () => {
-        const result = parse("29", "d", new Date(2014, 1 /* Feb */, 1));
+      it('returns `Invalid Date` for 29th of February of non-leap year', () => {
+        const result = parse('29', 'd', new Date(2014, 1 /* Feb */, 1));
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("parses 29th of February of leap year", () => {
-        const result = parse("29", "d", new Date(2012, 1 /* Feb */, 1));
+      it('parses 29th of February of leap year', () => {
+        const result = parse('29', 'd', new Date(2012, 1 /* Feb */, 1));
         expect(result).toEqual(new Date(2012, 1 /* Feb */, 29));
       });
     });
 
-    describe("day of year", () => {
-      it("returns `Invalid Date` for invalid day of the year", () => {
-        const result = parse("0", "D", referenceDate, {
+    describe('day of year', () => {
+      it('returns `Invalid Date` for invalid day of the year', () => {
+        const result = parse('0', 'D', referenceDate, {
           useAdditionalDayOfYearTokens: true,
         });
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for 366th day of non-leap year", () => {
-        const result = parse("366", "D", new Date(2014, 1 /* Feb */, 1), {
+      it('returns `Invalid Date` for 366th day of non-leap year', () => {
+        const result = parse('366', 'D', new Date(2014, 1 /* Feb */, 1), {
           useAdditionalDayOfYearTokens: true,
         });
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("parses 366th day of leap year", () => {
-        const result = parse("366", "D", new Date(2012, 1 /* Feb */, 1), {
+      it('parses 366th day of leap year', () => {
+        const result = parse('366', 'D', new Date(2012, 1 /* Feb */, 1), {
           useAdditionalDayOfYearTokens: true,
         });
         expect(result).toEqual(new Date(2012, 11 /* Dec */, 31));
       });
     });
 
-    describe("ISO day of week (formatting)", () => {
-      it("returns `Invalid Date` for day zero", () => {
-        const result = parse("0", "i", referenceDate);
+    describe('ISO day of week (formatting)', () => {
+      it('returns `Invalid Date` for day zero', () => {
+        const result = parse('0', 'i', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for eight day of week", () => {
-        const result = parse("8", "i", referenceDate);
+      it('returns `Invalid Date` for eight day of week', () => {
+        const result = parse('8', 'i', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("local day of week (formatting)", () => {
-      it("returns `Invalid Date` for day zero", () => {
-        const result = parse("0", "e", referenceDate);
+    describe('local day of week (formatting)', () => {
+      it('returns `Invalid Date` for day zero', () => {
+        const result = parse('0', 'e', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for eight day of week", () => {
-        const result = parse("8", "e", referenceDate);
+      it('returns `Invalid Date` for eight day of week', () => {
+        const result = parse('8', 'e', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("local day of week (stand-alone)", () => {
-      it("returns `Invalid Date` for day zero", () => {
-        const result = parse("0", "c", referenceDate);
+    describe('local day of week (stand-alone)', () => {
+      it('returns `Invalid Date` for day zero', () => {
+        const result = parse('0', 'c', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for eight day of week", () => {
-        const result = parse("8", "c", referenceDate);
+      it('returns `Invalid Date` for eight day of week', () => {
+        const result = parse('8', 'c', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("hour [1-12]", () => {
-      it("returns `Invalid Date` for hour zero", () => {
-        const result = parse("00", "hh", referenceDate);
+    describe('hour [1-12]', () => {
+      it('returns `Invalid Date` for hour zero', () => {
+        const result = parse('00', 'hh', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for invalid hour", () => {
-        const result = parse("13", "hh", referenceDate);
+      it('returns `Invalid Date` for invalid hour', () => {
+        const result = parse('13', 'hh', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("hour [0-23]", () => {
-      it("returns `Invalid Date` for invalid hour", () => {
-        const result = parse("24", "HH", referenceDate);
+    describe('hour [0-23]', () => {
+      it('returns `Invalid Date` for invalid hour', () => {
+        const result = parse('24', 'HH', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("hour [0-11]", () => {
-      it("returns `Invalid Date` for invalid hour", () => {
-        const result = parse("12", "KK", referenceDate);
+    describe('hour [0-11]', () => {
+      it('returns `Invalid Date` for invalid hour', () => {
+        const result = parse('12', 'KK', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("hour [1-24]", () => {
-      it("returns `Invalid Date` for hour zero", () => {
-        const result = parse("00", "kk", referenceDate);
+    describe('hour [1-24]', () => {
+      it('returns `Invalid Date` for hour zero', () => {
+        const result = parse('00', 'kk', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
 
-      it("returns `Invalid Date` for invalid hour", () => {
-        const result = parse("25", "kk", referenceDate);
+      it('returns `Invalid Date` for invalid hour', () => {
+        const result = parse('25', 'kk', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("minute", () => {
-      it("returns `Invalid Date` for invalid minute", () => {
-        const result = parse("60", "mm", referenceDate);
+    describe('minute', () => {
+      it('returns `Invalid Date` for invalid minute', () => {
+        const result = parse('60', 'mm', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
 
-    describe("second", () => {
-      it("returns `Invalid Date` for invalid second", () => {
-        const result = parse("60", "ss", referenceDate);
+    describe('second', () => {
+      it('returns `Invalid Date` for invalid second', () => {
+        const result = parse('60', 'ss', referenceDate);
         expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
       });
     });
   });
 
-  describe("custom locale", () => {
-    it("allows to pass a custom locale", () => {
+  describe('custom locale', () => {
+    it('allows to pass a custom locale', () => {
       const customLocale = {
         match: {
           era: () => {
             return {
               value: 0,
-              rest: " it works!",
+              rest: ' it works!',
             };
           },
         },
       };
-      const result = parse("2018 foobar", "y G 'it works!'", referenceDate, {
+      const result = parse('2018 foobar', "y G 'it works!'", referenceDate, {
         // @ts-expect-error - It's oke to have incomplete locale
         locale: customLocale,
       });
@@ -2193,206 +1941,186 @@ describe("parse", () => {
     });
   });
 
-  it("accepts a timestamp as `referenceDate`", () => {
-    const dateString = "6 p.m.";
-    const formatString = "h aaaa";
+  it('accepts a timestamp as `referenceDate`', () => {
+    const dateString = '6 p.m.';
+    const formatString = 'h aaaa';
     const result = parse(dateString, formatString, referenceDate.getTime());
     expect(result).toEqual(new Date(1986, 3 /* Apr */, 4, 18));
   });
 
-  it("does not mutate `referenceDate`", () => {
+  it('does not mutate `referenceDate`', () => {
     const referenceDateClone1 = new Date(referenceDate.getTime());
     const referenceDateClone2 = new Date(referenceDate.getTime());
-    const dateString = "6 p.m.";
-    const formatString = "h aaaa";
+    const dateString = '6 p.m.';
+    const formatString = 'h aaaa';
     parse(dateString, formatString, referenceDateClone1);
     expect(referenceDateClone1).toEqual(referenceDateClone2);
   });
 
-  describe("failure", () => {
-    it("returns `referenceDate` if `dateString` and `formatString` are empty strings", () => {
-      const dateString = "";
-      const formatString = "";
+  describe('failure', () => {
+    it('returns `referenceDate` if `dateString` and `formatString` are empty strings', () => {
+      const dateString = '';
+      const formatString = '';
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(referenceDate);
     });
 
-    it("returns `referenceDate` if no tokens in `formatString` are provided", () => {
-      const dateString = "not a token";
+    it('returns `referenceDate` if no tokens in `formatString` are provided', () => {
+      const dateString = 'not a token';
       const formatString = "'not a token'";
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(referenceDate);
     });
 
     it("returns `Invalid Date`  if `formatString` doesn't match `dateString`", () => {
-      const dateString = "2017-01-01";
-      const formatString = "yyyy/MM/dd";
+      const dateString = '2017-01-01';
+      const formatString = 'yyyy/MM/dd';
       const result = parse(dateString, formatString, referenceDate);
       expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
     });
 
-    it("returns `Invalid Date`  if `formatString` tokens failed to parse a value", () => {
-      const dateString = "2017-01-01";
-      const formatString = "MMMM do yyyy";
+    it('returns `Invalid Date`  if `formatString` tokens failed to parse a value', () => {
+      const dateString = '2017-01-01';
+      const formatString = 'MMMM do yyyy';
       const result = parse(dateString, formatString, referenceDate);
       expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
     });
 
-    it("returns `Invalid Date` if `formatString` is empty string but `dateString` is not", () => {
-      const dateString = "2017-01-01";
-      const formatString = "";
+    it('returns `Invalid Date` if `formatString` is empty string but `dateString` is not', () => {
+      const dateString = '2017-01-01';
+      const formatString = '';
       const result = parse(dateString, formatString, referenceDate);
       expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
     });
 
-    it("returns `Invalid Date` if `referenceDate` is `Invalid Date`", () => {
-      const dateString = "2014-07-02T05:30:15.123+06:00";
+    it('returns `Invalid Date` if `referenceDate` is `Invalid Date`', () => {
+      const dateString = '2014-07-02T05:30:15.123+06:00';
       const formatString = "yyyy-MM-dd'T'HH:mm:ss.SSSxxx";
       const result = parse(dateString, formatString, new Date(NaN));
       expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
     });
   });
 
-  describe("edge cases", () => {
-    it("returns Invalid Date if the string contains some remaining input after parsing", () => {
-      const result = parse("2016-11-05T040404", "yyyy-MM-dd", referenceDate);
+  describe('edge cases', () => {
+    it('returns Invalid Date if the string contains some remaining input after parsing', () => {
+      const result = parse('2016-11-05T040404', 'yyyy-MM-dd', referenceDate);
       expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
     });
 
-    it("parses normally if the remaining input is just whitespace", () => {
-      const result = parse("2016-11-05   \n", "yyyy-MM-dd", referenceDate);
+    it('parses normally if the remaining input is just whitespace', () => {
+      const result = parse('2016-11-05   \n', 'yyyy-MM-dd', referenceDate);
       expect(result).toEqual(new Date(2016, 10 /* Nov */, 5));
     });
 
-    it("throws RangeError exception if the format string contains an unescaped latin alphabet character", () => {
-      expect(() =>
-        parse("2016-11-05-nnnn", "yyyy-MM-dd-nnnn", referenceDate),
-      ).toThrow(RangeError);
+    it('throws RangeError exception if the format string contains an unescaped latin alphabet character', () => {
+      expect(() => parse('2016-11-05-nnnn', 'yyyy-MM-dd-nnnn', referenceDate)).toThrow(RangeError);
     });
   });
 
-  describe("useAdditionalWeekYearTokens and useAdditionalDayOfYearTokens options", () => {
-    it("throws an error if D token is used", () => {
+  describe('useAdditionalWeekYearTokens and useAdditionalDayOfYearTokens options', () => {
+    it('throws an error if D token is used', () => {
       try {
-        parse("2016 5", "yyyy D", referenceDate);
+        parse('2016 5', 'yyyy D', referenceDate);
       } catch (e) {
-        expect(
-          e instanceof RangeError &&
-            e.message.startsWith("Use `d` instead of `D`"),
-        ).toBe(true);
+        expect(e instanceof RangeError && e.message.startsWith('Use `d` instead of `D`')).toBe(true);
       }
     });
 
-    it("allows D token if useAdditionalDayOfYearTokens is set to true", () => {
-      const result = parse("2016 5", "yyyy D", referenceDate, {
+    it('allows D token if useAdditionalDayOfYearTokens is set to true', () => {
+      const result = parse('2016 5', 'yyyy D', referenceDate, {
         useAdditionalDayOfYearTokens: true,
       });
       expect(result).toEqual(new Date(2016, 0, 5));
     });
 
-    it("throws an error if DD token is used", () => {
+    it('throws an error if DD token is used', () => {
       try {
-        parse("2016 05", "yyyy DD", referenceDate);
+        parse('2016 05', 'yyyy DD', referenceDate);
       } catch (e) {
-        expect(
-          e instanceof RangeError &&
-            e.message.startsWith("Use `dd` instead of `DD`"),
-        ).toBe(true);
+        expect(e instanceof RangeError && e.message.startsWith('Use `dd` instead of `DD`')).toBe(true);
       }
     });
 
-    it("allows DD token if useAdditionalDayOfYearTokens is set to true", () => {
-      const result = parse("2016 05", "yyyy DD", referenceDate, {
+    it('allows DD token if useAdditionalDayOfYearTokens is set to true', () => {
+      const result = parse('2016 05', 'yyyy DD', referenceDate, {
         useAdditionalDayOfYearTokens: true,
       });
       expect(result).toEqual(new Date(2016, 0, 5));
     });
 
-    it("throws an error if YY token is used", () => {
+    it('throws an error if YY token is used', () => {
       try {
-        parse("16 1", "YY w", referenceDate);
+        parse('16 1', 'YY w', referenceDate);
       } catch (e) {
-        expect(
-          e instanceof RangeError &&
-            e.message.startsWith("Use `yy` instead of `YY`"),
-        ).toBe(true);
+        expect(e instanceof RangeError && e.message.startsWith('Use `yy` instead of `YY`')).toBe(true);
       }
     });
 
-    it("allows YY token if useAdditionalWeekYearTokens is set to true", () => {
-      const result = parse("16 1", "YY w", referenceDate, {
+    it('allows YY token if useAdditionalWeekYearTokens is set to true', () => {
+      const result = parse('16 1', 'YY w', referenceDate, {
         useAdditionalWeekYearTokens: true,
       });
       expect(result).toEqual(new Date(2015, 11, 27));
     });
 
-    it("throws an error if YYYY token is used", () => {
+    it('throws an error if YYYY token is used', () => {
       try {
-        parse("2016 1", "YYYY w", referenceDate);
+        parse('2016 1', 'YYYY w', referenceDate);
       } catch (e) {
-        expect(
-          e instanceof RangeError &&
-            e.message.startsWith("Use `yyyy` instead of `YYYY`"),
-        ).toBe(true);
+        expect(e instanceof RangeError && e.message.startsWith('Use `yyyy` instead of `YYYY`')).toBe(true);
       }
     });
 
-    it("allows YYYY token if useAdditionalWeekYearTokens is set to true", () => {
-      const result = parse("2016 1", "YYYY w", referenceDate, {
+    it('allows YYYY token if useAdditionalWeekYearTokens is set to true', () => {
+      const result = parse('2016 1', 'YYYY w', referenceDate, {
         useAdditionalWeekYearTokens: true,
       });
       expect(result).toEqual(new Date(2015, 11, 27));
     });
   });
 
-  describe("long format", () => {
-    it("short date", () => {
+  describe('long format', () => {
+    it('short date', () => {
       const expected = new Date(1995, 4 /* May */, 26);
-      const dateString = "05/26/1995";
-      const formatString = "P";
+      const dateString = '05/26/1995';
+      const formatString = 'P';
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("medium date", () => {
+    it('medium date', () => {
       const expected = new Date(1995, 4 /* May */, 26);
-      const dateString = "May 26, 1995";
-      const formatString = "PP";
+      const dateString = 'May 26, 1995';
+      const formatString = 'PP';
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("long date", () => {
+    it('long date', () => {
       const expected = new Date(1995, 4 /* May */, 26);
-      const dateString = "May 26th, 1995";
-      const formatString = "PPP";
+      const dateString = 'May 26th, 1995';
+      const formatString = 'PPP';
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("full date", () => {
+    it('full date', () => {
       const expected = new Date(1995, 4 /* May */, 26);
-      const dateString = "Friday, May 26th, 1995";
-      const formatString = "PPPP";
+      const dateString = 'Friday, May 26th, 1995';
+      const formatString = 'PPPP';
       const result = parse(dateString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("short time", () => {
-      const expected = new Date(
-        referenceDate.getFullYear(),
-        referenceDate.getMonth(),
-        referenceDate.getDate(),
-        10,
-        32,
-      );
-      const timeString = "10:32 AM";
-      const formatString = "p";
+    it('short time', () => {
+      const expected = new Date(referenceDate.getFullYear(), referenceDate.getMonth(), referenceDate.getDate(), 10, 32);
+      const timeString = '10:32 AM';
+      const formatString = 'p';
       const result = parse(timeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("medium time", () => {
+    it('medium time', () => {
       const expected = new Date(
         referenceDate.getFullYear(),
         referenceDate.getMonth(),
@@ -2401,72 +2129,72 @@ describe("parse", () => {
         32,
         55,
       );
-      const timeString = "10:32:55 AM";
-      const formatString = "pp";
+      const timeString = '10:32:55 AM';
+      const formatString = 'pp';
       const result = parse(timeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("short date + short time", () => {
+    it('short date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32);
-      const dateTimeString = "05/26/1995, 10:32 AM";
-      const formatString = "Pp";
+      const dateTimeString = '05/26/1995, 10:32 AM';
+      const formatString = 'Pp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("medium date + short time", () => {
+    it('medium date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32);
-      const dateTimeString = "May 26, 1995, 10:32 AM";
-      const formatString = "PPp";
+      const dateTimeString = 'May 26, 1995, 10:32 AM';
+      const formatString = 'PPp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("long date + short time", () => {
+    it('long date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32);
-      const dateTimeString = "May 26th, 1995 at 10:32 AM";
-      const formatString = "PPPp";
+      const dateTimeString = 'May 26th, 1995 at 10:32 AM';
+      const formatString = 'PPPp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("full date + short time", () => {
+    it('full date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32);
-      const dateTimeString = "Friday, May 26th, 1995 at 10:32 AM";
-      const formatString = "PPPPp";
+      const dateTimeString = 'Friday, May 26th, 1995 at 10:32 AM';
+      const formatString = 'PPPPp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("short date + short time", () => {
+    it('short date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32, 55);
-      const dateTimeString = "05/26/1995, 10:32:55 AM";
-      const formatString = "Ppp";
+      const dateTimeString = '05/26/1995, 10:32:55 AM';
+      const formatString = 'Ppp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("medium date + short time", () => {
+    it('medium date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32, 55);
-      const dateTimeString = "May 26, 1995, 10:32:55 AM";
-      const formatString = "PPpp";
+      const dateTimeString = 'May 26, 1995, 10:32:55 AM';
+      const formatString = 'PPpp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("long date + short time", () => {
+    it('long date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32, 55);
-      const dateTimeString = "May 26th, 1995 at 10:32:55 AM";
-      const formatString = "PPPpp";
+      const dateTimeString = 'May 26th, 1995 at 10:32:55 AM';
+      const formatString = 'PPPpp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });
 
-    it("full date + short time", () => {
+    it('full date + short time', () => {
       const expected = new Date(1995, 4 /* May */, 26, 10, 32, 55);
-      const dateTimeString = "Friday, May 26th, 1995 at 10:32:55 AM";
-      const formatString = "PPPPpp";
+      const dateTimeString = 'Friday, May 26th, 1995 at 10:32:55 AM';
+      const formatString = 'PPPPpp';
       const result = parse(dateTimeString, formatString, referenceDate);
       expect(result).toEqual(expected);
     });