@checkdigit/time 4.0.0-PR.18-9134 → 4.0.0-PR.18-e0fa

package/src/date-fns/_lib/format/lightFormatters/index.ts

@@ -1,4 +1,4 @@
-import { addLeadingZeros } from "../../addLeadingZeros/index";
+import { addLeadingZeros } from '../../addLeadingZeros/index';
 
 /*
  * |     | Unit                           |     | Unit                           |
@@ -28,13 +28,13 @@ export const lightFormatters = {
     const signedYear = date.getFullYear();
     // Returns 1 for 1 BC (which is year 0 in JavaScript)
     const year = signedYear > 0 ? signedYear : 1 - signedYear;
-    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+    return addLeadingZeros(token === 'yy' ? year % 100 : year, token.length);
   },
 
   // Month
   M(date: Date, token: string): string {
     const month = date.getMonth();
-    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+    return token === 'M' ? String(month + 1) : addLeadingZeros(month + 1, 2);
   },
 
   // Day of the month
@@ -50,16 +50,16 @@ export const lightFormatters = {
     // const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
 
     switch (token) {
-      case "a":
-      case "aa":
+      case 'a':
+      case 'aa':
         return dayPeriodEnumValue.toUpperCase();
-      case "aaa":
+      case 'aaa':
         return dayPeriodEnumValue;
-      case "aaaaa":
+      case 'aaaaa':
         return dayPeriodEnumValue[0]!;
-      case "aaaa":
+      case 'aaaa':
       default:
-        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+        return dayPeriodEnumValue === 'am' ? 'a.m.' : 'p.m.';
     }
   },
 
@@ -93,9 +93,7 @@ export const lightFormatters = {
   S(date: Date, token: string): string {
     const numberOfDigits = token.length;
     const milliseconds = date.getMilliseconds();
-    const fractionalSeconds = Math.trunc(
-      milliseconds * Math.pow(10, numberOfDigits - 3),
-    );
+    const fractionalSeconds = Math.trunc(milliseconds * Math.pow(10, numberOfDigits - 3));
     return addLeadingZeros(fractionalSeconds, token.length);
   },
 };

package/src/date-fns/_lib/format/longFormatters/index.ts

@@ -1,39 +1,36 @@
-import type { FormatLong } from "../../../locale/types";
+import type { FormatLong } from '../../../locale/types';
 
 type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
 
 const dateLongFormatter: LongFormatter = (pattern, formatLong) => {
   switch (pattern) {
-    case "P":
-      return formatLong.date({ width: "short" });
-    case "PP":
-      return formatLong.date({ width: "medium" });
-    case "PPP":
-      return formatLong.date({ width: "long" });
-    case "PPPP":
+    case 'P':
+      return formatLong.date({ width: 'short' });
+    case 'PP':
+      return formatLong.date({ width: 'medium' });
+    case 'PPP':
+      return formatLong.date({ width: 'long' });
+    case 'PPPP':
     default:
-      return formatLong.date({ width: "full" });
+      return formatLong.date({ width: 'full' });
   }
 };
 
 const timeLongFormatter: LongFormatter = (pattern, formatLong) => {
   switch (pattern) {
-    case "p":
-      return formatLong.time({ width: "short" });
-    case "pp":
-      return formatLong.time({ width: "medium" });
-    case "ppp":
-      return formatLong.time({ width: "long" });
-    case "pppp":
+    case 'p':
+      return formatLong.time({ width: 'short' });
+    case 'pp':
+      return formatLong.time({ width: 'medium' });
+    case 'ppp':
+      return formatLong.time({ width: 'long' });
+    case 'pppp':
     default:
-      return formatLong.time({ width: "full" });
+      return formatLong.time({ width: 'full' });
   }
 };
 
-const dateTimeLongFormatter: LongFormatter = (
-  pattern: string,
-  formatLong: FormatLong,
-) => {
+const dateTimeLongFormatter: LongFormatter = (pattern: string, formatLong: FormatLong) => {
   const matchResult = pattern.match(/(P+)(p+)?/) || [];
   const datePattern = matchResult[1];
   const timePattern = matchResult[2];
@@ -45,24 +42,24 @@ const dateTimeLongFormatter: LongFormatter = (
   let dateTimeFormat: string;
 
   switch (datePattern) {
-    case "P":
-      dateTimeFormat = formatLong.dateTime({ width: "short" });
+    case 'P':
+      dateTimeFormat = formatLong.dateTime({ width: 'short' });
       break;
-    case "PP":
-      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+    case 'PP':
+      dateTimeFormat = formatLong.dateTime({ width: 'medium' });
       break;
-    case "PPP":
-      dateTimeFormat = formatLong.dateTime({ width: "long" });
+    case 'PPP':
+      dateTimeFormat = formatLong.dateTime({ width: 'long' });
       break;
-    case "PPPP":
+    case 'PPPP':
     default:
-      dateTimeFormat = formatLong.dateTime({ width: "full" });
+      dateTimeFormat = formatLong.dateTime({ width: 'full' });
       break;
   }
 
   return dateTimeFormat
-    .replace("{{date}}", dateLongFormatter(datePattern!, formatLong))
-    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+    .replace('{{date}}', dateLongFormatter(datePattern!, formatLong))
+    .replace('{{time}}', timeLongFormatter(timePattern, formatLong));
 };
 
 export const longFormatters: Record<string, LongFormatter> = {

package/src/date-fns/_lib/getRoundingMethod/index.ts

@@ -1,4 +1,4 @@
-import type { RoundingMethod } from "../../types";
+import type { RoundingMethod } from '../../types';
 
 export function getRoundingMethod(method: RoundingMethod | undefined) {
   return (number: number) => {

package/src/date-fns/_lib/getTimezoneOffsetInMilliseconds/index.ts

@@ -1,4 +1,4 @@
-import { toDate } from "../../toDate/index";
+import { toDate } from '../../toDate/index';
 
 /**
  * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
@@ -11,9 +11,7 @@ import { toDate } from "../../toDate/index";
  *
  * This function returns the timezone offset in milliseconds that takes seconds in account.
  */
-export function getTimezoneOffsetInMilliseconds(
-  date: Date | number | string,
-): number {
+export function getTimezoneOffsetInMilliseconds(date: Date | number | string): number {
   const _date = toDate(date);
   const utcDate = new Date(
     Date.UTC(

package/src/date-fns/_lib/protectedTokens/index.ts

@@ -1,7 +1,7 @@
 const dayOfYearTokenRE = /^D+$/;
 const weekYearTokenRE = /^Y+$/;
 
-const throwTokens = ["D", "DD", "YY", "YYYY"];
+const throwTokens = ['D', 'DD', 'YY', 'YYYY'];
 
 export function isProtectedDayOfYearToken(token: string) {
   return dayOfYearTokenRE.test(token);
@@ -11,17 +11,13 @@ export function isProtectedWeekYearToken(token: string) {
   return weekYearTokenRE.test(token);
 }
 
-export function warnOrThrowProtectedError(
-  token: string,
-  format: string,
-  input: string,
-): void {
+export function warnOrThrowProtectedError(token: string, format: string, input: string): void {
   const _message = message(token, format, input);
   console.warn(_message);
   if (throwTokens.includes(token)) throw new RangeError(_message);
 }
 
 function message(token: string, format: string, input: string) {
-  const subject = token[0] === "Y" ? "years" : "days of the month";
+  const subject = token[0] === 'Y' ? 'years' : 'days of the month';
   return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
 }

package/src/date-fns/_lib/test/index.ts

@@ -1,5 +1,5 @@
-import { addLeadingZeros } from "../addLeadingZeros/index";
-import { setDefaultOptions } from "../defaultOptions/index";
+import { addLeadingZeros } from '../addLeadingZeros/index';
+import { setDefaultOptions } from '../defaultOptions/index';
 
 export function assertType<T>(_: T): void {}
 
@@ -10,7 +10,7 @@ export function resetDefaultOptions(): void {
 // This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
 export function generateOffset(originalDate: Date) {
   // Add the timezone.
-  let offset = "";
+  let offset = '';
   const tzOffset = originalDate.getTimezoneOffset();
 
   if (tzOffset !== 0) {
@@ -18,11 +18,11 @@ export function generateOffset(originalDate: Date) {
     const hourOffset = addLeadingZeros(Math.trunc(absoluteOffset / 60), 2);
     const minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
     // If less than 0, the sign is +, because it is ahead of time.
-    const sign = tzOffset < 0 ? "+" : "-";
+    const sign = tzOffset < 0 ? '+' : '-';
 
     offset = `${sign}${hourOffset}:${minuteOffset}`;
   } else {
-    offset = "Z";
+    offset = 'Z';
   }
 
   return offset;

package/src/date-fns/_test/dst/addBusinessDays/basic.ts

@@ -1,18 +1,17 @@
 // This is basic DST test for addBusinessDays
 
-import assert from "assert";
-import { addBusinessDays } from "../../../addBusinessDays/index.js";
+import assert from 'assert';
+import { addBusinessDays } from '../../../addBusinessDays/index.js';
 
-if (process.env.TZ !== "America/Santiago")
-  throw new Error("The test must be run with TZ=America/Santiago");
+if (process.env.TZ !== 'America/Santiago') throw new Error('The test must be run with TZ=America/Santiago');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
 console.log(addBusinessDays(new Date(2014, 8 /* Sep */, 1), 10).toString());
 
 assert.deepStrictEqual(
   // new Date(2014, 8, 7) is the DST day
   addBusinessDays(new Date(2014, 8 /* Sep */, 1), 10).toString(),
-  "Mon Sep 15 2014 00:00:00 GMT-0300 (Chile Summer Time)",
+  'Mon Sep 15 2014 00:00:00 GMT-0300 (Chile Summer Time)',
 );

package/src/date-fns/_test/dst/eachDayOfInterval/basic.ts

@@ -1,13 +1,12 @@
 // This is basic DST test for eachDayOfInterval
 
-import { eachDayOfInterval } from "../../../eachDayOfInterval/index.js";
-import assert from "assert";
+import { eachDayOfInterval } from '../../../eachDayOfInterval/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Asia/Damascus")
-  throw new Error("The test must be run with TZ=Asia/Damascus");
+if (process.env.TZ !== 'Asia/Damascus') throw new Error('The test must be run with TZ=Asia/Damascus');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
 assert.deepStrictEqual(
   eachDayOfInterval({
@@ -15,8 +14,8 @@ assert.deepStrictEqual(
     end: new Date(2020, 2, 28),
   }).map((d) => d.toString()),
   [
-    "Thu Mar 26 2020 00:00:00 GMT+0200 (GMT+03:00)",
-    "Fri Mar 27 2020 01:00:00 GMT+0300 (GMT+03:00)",
-    "Sat Mar 28 2020 00:00:00 GMT+0300 (GMT+03:00)",
-  ]
+    'Thu Mar 26 2020 00:00:00 GMT+0200 (GMT+03:00)',
+    'Fri Mar 27 2020 01:00:00 GMT+0300 (GMT+03:00)',
+    'Sat Mar 28 2020 00:00:00 GMT+0300 (GMT+03:00)',
+  ],
 );

package/src/date-fns/_test/dst/formatDistanceStrict/cairo.ts

@@ -1,15 +1,8 @@
 // This is DST test for formatDistanceStrict in the Cairo timezone
 
-import { formatDistanceStrict } from "../../../formatDistanceStrict/index.js";
-import assert from "assert";
+import { formatDistanceStrict } from '../../../formatDistanceStrict/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Africa/Cairo")
-  throw new Error("The test must be run with TZ=Africa/Cairo");
+if (process.env.TZ !== 'Africa/Cairo') throw new Error('The test must be run with TZ=Africa/Cairo');
 
-assert.strictEqual(
-  formatDistanceStrict(
-    new Date(1986, 3, 4, 10, 32, 0),
-    new Date(1986, 4, 4, 10, 32, 0),
-  ),
-  "1 month",
-);
+assert.strictEqual(formatDistanceStrict(new Date(1986, 3, 4, 10, 32, 0), new Date(1986, 4, 4, 10, 32, 0)), '1 month');

package/src/date-fns/_test/dst/formatDistanceStrict/melbourne.ts

@@ -1,16 +1,12 @@
 // This is DST test for formatDistanceStrict in the Melbourne timezone
 
-import { formatDistanceStrict } from "../../../formatDistanceStrict/index.js";
-import { parseISO } from "../../../parseISO/index.js";
-import assert from "assert";
+import { formatDistanceStrict } from '../../../formatDistanceStrict/index.js';
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Australia/Melbourne")
-  throw new Error("The test must be run with TZ=Australia/Melbourne");
+if (process.env.TZ !== 'Australia/Melbourne') throw new Error('The test must be run with TZ=Australia/Melbourne');
 
 assert.strictEqual(
-  formatDistanceStrict(
-    parseISO("2020-04-05T01:00:00+11:00"),
-    parseISO("2020-04-05T03:00:00+10:00"),
-  ),
-  "3 hours",
+  formatDistanceStrict(parseISO('2020-04-05T01:00:00+11:00'), parseISO('2020-04-05T03:00:00+10:00')),
+  '3 hours',
 );

package/src/date-fns/_test/dst/getOverlappingDaysInIntervals/basic.ts

@@ -1,5 +1,5 @@
-import assert from "assert";
-import { getOverlappingDaysInIntervals } from "../../../getOverlappingDaysInIntervals/index.js";
+import assert from 'assert';
+import { getOverlappingDaysInIntervals } from '../../../getOverlappingDaysInIntervals/index.js';
 
 assert.strictEqual(
   getOverlappingDaysInIntervals(

package/src/date-fns/_test/dst/parseISO/basic.ts

@@ -1,30 +1,23 @@
 // This is basic DST test for parseISO
 
-import { parseISO } from "../../../parseISO/index.js";
-import assert from "assert";
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "America/Sao_Paulo")
-  throw new Error("The test must be run with TZ=America/Sao_Paulo");
+if (process.env.TZ !== 'America/Sao_Paulo') throw new Error('The test must be run with TZ=America/Sao_Paulo');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
 // Test DST start edge
-assert.strictEqual(parseISO("2018-11-03").getDate(), 3);
-assert.strictEqual(parseISO("2018-11-04").getDate(), 4); // DST start
-assert.strictEqual(parseISO("2018-11-05").getDate(), 5);
+assert.strictEqual(parseISO('2018-11-03').getDate(), 3);
+assert.strictEqual(parseISO('2018-11-04').getDate(), 4); // DST start
+assert.strictEqual(parseISO('2018-11-05').getDate(), 5);
 
 // Test DST end edge
-assert.strictEqual(parseISO("2019-02-15").getDate(), 15);
-assert.strictEqual(parseISO("2019-02-16").getDate(), 16); // DST end
-assert.strictEqual(parseISO("2019-02-17").getDate(), 17);
+assert.strictEqual(parseISO('2019-02-15').getDate(), 15);
+assert.strictEqual(parseISO('2019-02-16').getDate(), 16); // DST end
+assert.strictEqual(parseISO('2019-02-17').getDate(), 17);
 
 // Test creation of nonexistent time
-assert.strictEqual(
-  parseISO("2018-11-04T00:00").toString(),
-  "Sun Nov 04 2018 01:00:00 GMT-0200 (Brasilia Summer Time)",
-);
-assert.strictEqual(
-  parseISO("2018-11-04T00:30").toString(),
-  "Sun Nov 04 2018 01:30:00 GMT-0200 (Brasilia Summer Time)",
-);
+assert.strictEqual(parseISO('2018-11-04T00:00').toString(), 'Sun Nov 04 2018 01:00:00 GMT-0200 (Brasilia Summer Time)');
+assert.strictEqual(parseISO('2018-11-04T00:30').toString(), 'Sun Nov 04 2018 01:30:00 GMT-0200 (Brasilia Summer Time)');

package/src/date-fns/_test/dst/parseISO/samoa.ts

@@ -1,16 +1,12 @@
 // This is an edge case DST test for parseISO
 
-import { parseISO } from "../../../parseISO/index.js";
-import assert from "assert";
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Pacific/Apia")
-  throw new Error("The test must be run with TZ=Pacific/Apia");
+if (process.env.TZ !== 'Pacific/Apia') throw new Error('The test must be run with TZ=Pacific/Apia');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
-assert.strictEqual(parseISO("2011-12-30").getDate(), 31);
-assert.strictEqual(
-  parseISO("2011-12-30T03:30").toString(),
-  "Sat Dec 31 2011 03:30:00 GMT+1400 (Apia Daylight Time)",
-);
+assert.strictEqual(parseISO('2011-12-30').getDate(), 31);
+assert.strictEqual(parseISO('2011-12-30T03:30').toString(), 'Sat Dec 31 2011 03:30:00 GMT+1400 (Apia Daylight Time)');

package/src/date-fns/_test/dst/parseISO/sydney.ts

@@ -1,58 +1,57 @@
 // This is basic DST test for parseISO
 
-import { parseISO } from "../../../parseISO/index.js";
-import assert from "assert";
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Australia/Sydney")
-  throw new Error("The test must be run with TZ=Australia/Sydney");
+if (process.env.TZ !== 'Australia/Sydney') throw new Error('The test must be run with TZ=Australia/Sydney');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
 // Test DST start edge
-assert.strictEqual(parseISO("2019-10-06").getDate(), 6); // DST start
-assert.strictEqual(parseISO("2019-10-07").getDate(), 7);
+assert.strictEqual(parseISO('2019-10-06').getDate(), 6); // DST start
+assert.strictEqual(parseISO('2019-10-07').getDate(), 7);
 assert.strictEqual(
-  parseISO("2019-10-06T01:00:00").toString(),
-  "Sun Oct 06 2019 01:00:00 GMT+1000 (Australian Eastern Standard Time)",
+  parseISO('2019-10-06T01:00:00').toString(),
+  'Sun Oct 06 2019 01:00:00 GMT+1000 (Australian Eastern Standard Time)',
 );
 assert.strictEqual(
-  parseISO("2019-10-06T02:00:00").toString(),
-  "Sun Oct 06 2019 03:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2019-10-06T02:00:00').toString(),
+  'Sun Oct 06 2019 03:00:00 GMT+1100 (Australian Eastern Daylight Time)',
 );
 
 assert.strictEqual(
-  parseISO("2019-10-06T05:00:00").toString(),
-  "Sun Oct 06 2019 05:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2019-10-06T05:00:00').toString(),
+  'Sun Oct 06 2019 05:00:00 GMT+1100 (Australian Eastern Daylight Time)',
 );
 
 // Test DST end edge
-assert.strictEqual(parseISO("2019-04-06").getDate(), 6);
-assert.strictEqual(parseISO("2019-04-07").getDate(), 7); // DST end
+assert.strictEqual(parseISO('2019-04-06').getDate(), 6);
+assert.strictEqual(parseISO('2019-04-07').getDate(), 7); // DST end
 assert.strictEqual(
-  parseISO("2019-04-06T11:00:00").toString(),
-  "Sat Apr 06 2019 11:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2019-04-06T11:00:00').toString(),
+  'Sat Apr 06 2019 11:00:00 GMT+1100 (Australian Eastern Daylight Time)',
 );
 assert.strictEqual(
-  parseISO("2019-04-07T11:00:00").toString(),
-  "Sun Apr 07 2019 11:00:00 GMT+1000 (Australian Eastern Standard Time)",
+  parseISO('2019-04-07T11:00:00').toString(),
+  'Sun Apr 07 2019 11:00:00 GMT+1000 (Australian Eastern Standard Time)',
 );
 
 assert.strictEqual(
-  parseISO("2019-04-07T00:00:00").toString(),
-  "Sun Apr 07 2019 00:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2019-04-07T00:00:00').toString(),
+  'Sun Apr 07 2019 00:00:00 GMT+1100 (Australian Eastern Daylight Time)',
 );
 
 // test edge cases for months, years
 assert.strictEqual(
-  parseISO("2020-01-01T00:00:00").toString(),
-  "Wed Jan 01 2020 00:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2020-01-01T00:00:00').toString(),
+  'Wed Jan 01 2020 00:00:00 GMT+1100 (Australian Eastern Daylight Time)',
 );
 assert.strictEqual(
-  parseISO("2019-12-31T23:59:59").toString(),
-  "Tue Dec 31 2019 23:59:59 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2019-12-31T23:59:59').toString(),
+  'Tue Dec 31 2019 23:59:59 GMT+1100 (Australian Eastern Daylight Time)',
 );
 assert.strictEqual(
-  parseISO("2020-02-29T23:59:59").toString(),
-  "Sat Feb 29 2020 23:59:59 GMT+1100 (Australian Eastern Daylight Time)",
+  parseISO('2020-02-29T23:59:59').toString(),
+  'Sat Feb 29 2020 23:59:59 GMT+1100 (Australian Eastern Daylight Time)',
 );

package/src/date-fns/_test/dst/tzOffsetTransitions.ts

@@ -28,8 +28,8 @@ export function getDstTransitions(year: number): PartialInterval {
     const t = transitions[i]!;
     const month = t.date.getMonth();
     if (month > 0 && month < 11) {
-      if (t.type === "forward") result.start = t.date;
-      if (t.type === "back" && !result.end) result.end = t.date;
+      if (t.type === 'forward') result.start = t.date;
+      if (t.type === 'back' && !result.end) result.end = t.date;
     }
   }
   return result;
@@ -92,7 +92,7 @@ export function getTzOffsetTransitions(year: number) {
   // start at the end of the previous day
   let date = firstTickInLocalDay(new Date(year, 0, 1));
   if (!isValidDate(date)) {
-    throw new Error("Invalid Date");
+    throw new Error('Invalid Date');
   }
   let baseTzOffset = previousTickTimezoneOffset(date);
   const transitions = [];
@@ -103,7 +103,7 @@ export function getTzOffsetTransitions(year: number) {
         // Transition is the first tick of a local day.
         transitions.push({
           date: date,
-          type: tzOffset < baseTzOffset ? "forward" : "back",
+          type: tzOffset < baseTzOffset ? 'forward' : 'back',
           before: -baseTzOffset,
           after: -tzOffset,
         });
@@ -118,15 +118,12 @@ export function getTzOffsetTransitions(year: number) {
         // TODO: this could be optimized to search hours then minutes or by or
         // by using a binary search.
         const dayNumber = transitionDate.getDate();
-        while (
-          isValidDate(transitionDate) &&
-          transitionDate.getDate() === dayNumber
-        ) {
+        while (isValidDate(transitionDate) && transitionDate.getDate() === dayNumber) {
           tzOffset = transitionDate.getTimezoneOffset();
           if (baseTzOffset !== tzOffset) {
             transitions.push({
               date: transitionDate,
-              type: tzOffset < baseTzOffset ? "forward" : "back",
+              type: tzOffset < baseTzOffset ? 'forward' : 'back',
               before: -baseTzOffset,
               after: -tzOffset,
             });

package/src/date-fns/_test/formatISO/india.ts

@@ -1,13 +1,9 @@
-import { formatISO } from "../../formatISO/index.js";
-import assert from "assert";
+import { formatISO } from '../../formatISO/index.js';
+import assert from 'assert';
 
-if (process.env.TZ !== "Asia/Kolkata")
-  throw new Error("The test must be run with TZ=Asia/Kolkata");
+if (process.env.TZ !== 'Asia/Kolkata') throw new Error('The test must be run with TZ=Asia/Kolkata');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
-assert.strictEqual(
-  formatISO(new Date(1986, 3, 4, 10, 33, 1)),
-  "1986-04-04T10:33:01+05:30",
-);
+assert.strictEqual(formatISO(new Date(1986, 3, 4, 10, 33, 1)), '1986-04-04T10:33:01+05:30');

package/src/date-fns/_test/formatRFC3339/australia.ts

@@ -1,30 +1,20 @@
-import { formatRFC3339 } from "../../formatRFC3339/index.js";
-import assert from "assert";
+import { formatRFC3339 } from '../../formatRFC3339/index.js';
+import assert from 'assert';
 
 /**
  * Australia/Eucla (Australia) is interesting for its positive to UTC time, with 45 minutes offset.
  * It's independent from Standard and Summer time.
  */
-if (process.env.TZ !== "Australia/Eucla")
-  throw new Error("The test must be run with TZ=Australia/Eucla (UTC+08:45)");
+if (process.env.TZ !== 'Australia/Eucla') throw new Error('The test must be run with TZ=Australia/Eucla (UTC+08:45)');
 
-if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || "0") < 10)
-  throw new Error("The test must be run on Node.js version >= 10");
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
 
 // Old date
-assert.strictEqual(
-  formatRFC3339(new Date(1986, 3, 4, 10, 33, 1)),
-  "1986-04-04T10:33:01+08:45",
-);
+assert.strictEqual(formatRFC3339(new Date(1986, 3, 4, 10, 33, 1)), '1986-04-04T10:33:01+08:45');
 
 // Standard time (Eucla have +08:45)
-assert.strictEqual(
-  formatRFC3339(new Date(2020, 0, 23, 5, 0, 54)),
-  "2020-01-23T05:00:54+08:45",
-);
+assert.strictEqual(formatRFC3339(new Date(2020, 0, 23, 5, 0, 54)), '2020-01-23T05:00:54+08:45');
 
 // Summer time (Eucla have +08:45)
-assert.strictEqual(
-  formatRFC3339(new Date(2020, 6, 30, 20, 59, 1)),
-  "2020-07-30T20:59:01+08:45",
-);
+assert.strictEqual(formatRFC3339(new Date(2020, 6, 30, 20, 59, 1)), '2020-07-30T20:59:01+08:45');