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

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

@@ -1,4 +1,4 @@
-import { toDate } from "../toDate/index";
+import { toDate } from '../toDate/index';
 
 /**
  * @name endOfYear
@@ -20,9 +20,7 @@ import { toDate } from "../toDate/index";
  * const result = endOfYear(new Date(2014, 8, 2, 11, 55, 00))
  * //=> Wed Dec 31 2014 23:59:59.999
  */
-export function endOfYear<DateType extends Date>(
-  date: DateType | number | string,
-): DateType {
+export function endOfYear<DateType extends Date>(date: DateType | number | string): DateType {
   const _date = toDate(date);
   const year = _date.getFullYear();
   _date.setFullYear(year + 1, 0, 0);

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

@@ -1,21 +1,21 @@
-import { defaultLocale } from "../_lib/defaultLocale/index";
-import { getDefaultOptions } from "../_lib/defaultOptions/index";
-import { formatters } from "../_lib/format/formatters/index";
-import { longFormatters } from "../_lib/format/longFormatters/index";
+import { defaultLocale } from '../_lib/defaultLocale/index';
+import { getDefaultOptions } from '../_lib/defaultOptions/index';
+import { formatters } from '../_lib/format/formatters/index';
+import { longFormatters } from '../_lib/format/longFormatters/index';
 import {
   isProtectedDayOfYearToken,
   isProtectedWeekYearToken,
   warnOrThrowProtectedError,
-} from "../_lib/protectedTokens/index";
-import { isValid } from "../isValid/index";
-import { toDate } from "../toDate/index";
+} from '../_lib/protectedTokens/index';
+import { isValid } from '../isValid/index';
+import { toDate } from '../toDate/index';
 import type {
   AdditionalTokensOptions,
   FirstWeekContainsDateOptions,
   FormatPart,
   LocalizedOptions,
   WeekOptions,
-} from "../types";
+} from '../types';
 
 // Rexports of internal for libraries to use.
 // See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
@@ -32,8 +32,7 @@ export { formatters, longFormatters };
 //   If there is no matching single quote
 //   then the sequence will continue until the end of the string.
 // - . matches any single character unmatched by previous parts of the RegExps
-const formattingTokensRegExp =
-  /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+const formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
 
 // This RegExp catches symbols escaped by quotes, and also
 // sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
@@ -50,7 +49,7 @@ export type { FormatOptions as FormatDateOptions };
  * The {@link format} function options.
  */
 export interface FormatOptions
-  extends LocalizedOptions<"options" | "localize" | "formatLong">,
+  extends LocalizedOptions<'options' | 'localize' | 'formatLong'>,
     WeekOptions,
     FirstWeekContainsDateOptions,
     AdditionalTokensOptions {}
@@ -366,20 +365,20 @@ export function format<DateType extends Date>(
   const originalDate = toDate(date);
 
   if (!isValid(originalDate)) {
-    throw new RangeError("Invalid time value");
+    throw new RangeError('Invalid time value');
   }
 
   let parts: FormatPart[] = formatStr
     .match(longFormattingTokensRegExp)!
     .map((substring) => {
       const firstCharacter = substring[0];
-      if (firstCharacter === "p" || firstCharacter === "P") {
+      if (firstCharacter === 'p' || firstCharacter === 'P') {
         const longFormatter = longFormatters[firstCharacter];
         return longFormatter!(substring, locale.formatLong);
       }
       return substring;
     })
-    .join("")
+    .join('')
     .match(formattingTokensRegExp)!
     .map((substring) => {
       // Replace two single quote characters with one single quote character
@@ -397,11 +396,7 @@ export function format<DateType extends Date>(
       }
 
       if (firstCharacter!.match(unescapedLatinCharacterRegExp)) {
-        throw new RangeError(
-          "Format string contains an unescaped latin alphabet character `" +
-            firstCharacter +
-            "`",
-        );
+        throw new RangeError('Format string contains an unescaped latin alphabet character `' + firstCharacter + '`');
       }
 
       return { isToken: false, value: substring };
@@ -425,10 +420,8 @@ export function format<DateType extends Date>(
       const token = part.value;
 
       if (
-        (!options?.useAdditionalWeekYearTokens &&
-          isProtectedWeekYearToken(token)) ||
-        (!options?.useAdditionalDayOfYearTokens &&
-          isProtectedDayOfYearToken(token))
+        (!options?.useAdditionalWeekYearTokens && isProtectedWeekYearToken(token)) ||
+        (!options?.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(token))
       ) {
         warnOrThrowProtectedError(token, formatStr, String(date));
       }
@@ -436,7 +429,7 @@ export function format<DateType extends Date>(
       const formatter = formatters[token[0]!];
       return formatter!(originalDate, token, locale.localize, formatterOptions);
     })
-    .join("");
+    .join('');
 }
 
 function cleanEscapedString(input: string): string {

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

@@ -1,18 +1,17 @@
-import { compareAsc } from "../compareAsc/index";
-import { minutesInDay, minutesInMonth } from "../constants/index";
-import { differenceInMonths } from "../differenceInMonths/index";
-import { differenceInSeconds } from "../differenceInSeconds/index";
-import { toDate } from "../toDate/index";
-import type { LocalizedOptions } from "../types";
-import { defaultLocale } from "../_lib/defaultLocale/index";
-import { getDefaultOptions } from "../_lib/defaultOptions/index";
-import { getTimezoneOffsetInMilliseconds } from "../_lib/getTimezoneOffsetInMilliseconds/index";
+import { compareAsc } from '../compareAsc/index';
+import { minutesInDay, minutesInMonth } from '../constants/index';
+import { differenceInMonths } from '../differenceInMonths/index';
+import { differenceInSeconds } from '../differenceInSeconds/index';
+import { toDate } from '../toDate/index';
+import type { LocalizedOptions } from '../types';
+import { defaultLocale } from '../_lib/defaultLocale/index';
+import { getDefaultOptions } from '../_lib/defaultOptions/index';
+import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index';
 
 /**
  * The {@link formatDistance} function options.
  */
-export interface FormatDistanceOptions
-  extends LocalizedOptions<"formatDistance"> {
+export interface FormatDistanceOptions extends LocalizedOptions<'formatDistance'> {
   /** Distances less than a minute are more detailed */
   includeSeconds?: boolean;
   /** Add "X ago"/"in X" in the locale language */
@@ -112,7 +111,7 @@ export function formatDistance<DateType extends Date>(
   const comparison = compareAsc(date, baseDate);
 
   if (isNaN(comparison)) {
-    throw new RangeError("Invalid time value");
+    throw new RangeError('Invalid time value');
   }
 
   const localizeOptions = Object.assign({}, options, {
@@ -132,9 +131,7 @@ export function formatDistance<DateType extends Date>(
 
   const seconds = differenceInSeconds(dateRight, dateLeft);
   const offsetInSeconds =
-    (getTimezoneOffsetInMilliseconds(dateRight) -
-      getTimezoneOffsetInMilliseconds(dateLeft)) /
-    1000;
+    (getTimezoneOffsetInMilliseconds(dateRight) - getTimezoneOffsetInMilliseconds(dateLeft)) / 1000;
   const minutes = Math.round((seconds - offsetInSeconds) / 60);
   let months;
 
@@ -142,52 +139,52 @@ export function formatDistance<DateType extends Date>(
   if (minutes < 2) {
     if (options?.includeSeconds) {
       if (seconds < 5) {
-        return locale.formatDistance("lessThanXSeconds", 5, localizeOptions);
+        return locale.formatDistance('lessThanXSeconds', 5, localizeOptions);
       } else if (seconds < 10) {
-        return locale.formatDistance("lessThanXSeconds", 10, localizeOptions);
+        return locale.formatDistance('lessThanXSeconds', 10, localizeOptions);
       } else if (seconds < 20) {
-        return locale.formatDistance("lessThanXSeconds", 20, localizeOptions);
+        return locale.formatDistance('lessThanXSeconds', 20, localizeOptions);
       } else if (seconds < 40) {
-        return locale.formatDistance("halfAMinute", 0, localizeOptions);
+        return locale.formatDistance('halfAMinute', 0, localizeOptions);
       } else if (seconds < 60) {
-        return locale.formatDistance("lessThanXMinutes", 1, localizeOptions);
+        return locale.formatDistance('lessThanXMinutes', 1, localizeOptions);
       } else {
-        return locale.formatDistance("xMinutes", 1, localizeOptions);
+        return locale.formatDistance('xMinutes', 1, localizeOptions);
       }
     } else {
       if (minutes === 0) {
-        return locale.formatDistance("lessThanXMinutes", 1, localizeOptions);
+        return locale.formatDistance('lessThanXMinutes', 1, localizeOptions);
       } else {
-        return locale.formatDistance("xMinutes", minutes, localizeOptions);
+        return locale.formatDistance('xMinutes', minutes, localizeOptions);
       }
     }
 
     // 2 mins up to 0.75 hrs
   } else if (minutes < 45) {
-    return locale.formatDistance("xMinutes", minutes, localizeOptions);
+    return locale.formatDistance('xMinutes', minutes, localizeOptions);
 
     // 0.75 hrs up to 1.5 hrs
   } else if (minutes < 90) {
-    return locale.formatDistance("aboutXHours", 1, localizeOptions);
+    return locale.formatDistance('aboutXHours', 1, localizeOptions);
 
     // 1.5 hrs up to 24 hrs
   } else if (minutes < minutesInDay) {
     const hours = Math.round(minutes / 60);
-    return locale.formatDistance("aboutXHours", hours, localizeOptions);
+    return locale.formatDistance('aboutXHours', hours, localizeOptions);
 
     // 1 day up to 1.75 days
   } else if (minutes < minutesInAlmostTwoDays) {
-    return locale.formatDistance("xDays", 1, localizeOptions);
+    return locale.formatDistance('xDays', 1, localizeOptions);
 
     // 1.75 days up to 30 days
   } else if (minutes < minutesInMonth) {
     const days = Math.round(minutes / minutesInDay);
-    return locale.formatDistance("xDays", days, localizeOptions);
+    return locale.formatDistance('xDays', days, localizeOptions);
 
     // 1 month up to 2 months
   } else if (minutes < minutesInMonth * 2) {
     months = Math.round(minutes / minutesInMonth);
-    return locale.formatDistance("aboutXMonths", months, localizeOptions);
+    return locale.formatDistance('aboutXMonths', months, localizeOptions);
   }
 
   months = differenceInMonths(dateRight, dateLeft);
@@ -195,7 +192,7 @@ export function formatDistance<DateType extends Date>(
   // 2 months up to 12 months
   if (months < 12) {
     const nearestMonth = Math.round(minutes / minutesInMonth);
-    return locale.formatDistance("xMonths", nearestMonth, localizeOptions);
+    return locale.formatDistance('xMonths', nearestMonth, localizeOptions);
 
     // 1 year up to max Date
   } else {
@@ -204,15 +201,15 @@ export function formatDistance<DateType extends Date>(
 
     // N years up to 1 years 3 months
     if (monthsSinceStartOfYear < 3) {
-      return locale.formatDistance("aboutXYears", years, localizeOptions);
+      return locale.formatDistance('aboutXYears', years, localizeOptions);
 
       // N years 3 months up to N years 9 months
     } else if (monthsSinceStartOfYear < 9) {
-      return locale.formatDistance("overXYears", years, localizeOptions);
+      return locale.formatDistance('overXYears', years, localizeOptions);
 
       // N years 9 months up to N year 12 months
     } else {
-      return locale.formatDistance("almostXYears", years + 1, localizeOptions);
+      return locale.formatDistance('almostXYears', years + 1, localizeOptions);
     }
   }
 }

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

@@ -1,23 +1,16 @@
-import { defaultLocale } from "../_lib/defaultLocale/index";
-import { getDefaultOptions } from "../_lib/defaultOptions/index";
-import { getRoundingMethod } from "../_lib/getRoundingMethod/index";
-import { getTimezoneOffsetInMilliseconds } from "../_lib/getTimezoneOffsetInMilliseconds/index";
-import { compareAsc } from "../compareAsc/index";
-import {
-  millisecondsInMinute,
-  minutesInDay,
-  minutesInMonth,
-  minutesInYear,
-} from "../constants/index";
-import { toDate } from "../toDate/index";
-import type { LocalizedOptions, RoundingOptions } from "../types";
+import { defaultLocale } from '../_lib/defaultLocale/index';
+import { getDefaultOptions } from '../_lib/defaultOptions/index';
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
+import { getTimezoneOffsetInMilliseconds } from '../_lib/getTimezoneOffsetInMilliseconds/index';
+import { compareAsc } from '../compareAsc/index';
+import { millisecondsInMinute, minutesInDay, minutesInMonth, minutesInYear } from '../constants/index';
+import { toDate } from '../toDate/index';
+import type { LocalizedOptions, RoundingOptions } from '../types';
 
 /**
  * The {@link formatDistanceStrict} function options.
  */
-export interface FormatDistanceStrictOptions
-  extends LocalizedOptions<"formatDistance">,
-    RoundingOptions {
+export interface FormatDistanceStrictOptions extends LocalizedOptions<'formatDistance'>, RoundingOptions {
   /** Add "X ago"/"in X" in the locale language */
   addSuffix?: boolean;
   /** If specified, will force the unit */
@@ -27,13 +20,7 @@ export interface FormatDistanceStrictOptions
 /**
  * The unit used to format the distance in {@link formatDistanceStrict}.
  */
-export type FormatDistanceStrictUnit =
-  | "second"
-  | "minute"
-  | "hour"
-  | "day"
-  | "month"
-  | "year";
+export type FormatDistanceStrictUnit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
 
 /**
  * @name formatDistanceStrict
@@ -126,7 +113,7 @@ export function formatDistanceStrict<DateType extends Date>(
   const comparison = compareAsc(date, baseDate);
 
   if (isNaN(comparison)) {
-    throw new RangeError("Invalid time value");
+    throw new RangeError('Invalid time value');
   }
 
   const localizeOptions = Object.assign({}, options, {
@@ -144,70 +131,67 @@ export function formatDistanceStrict<DateType extends Date>(
     dateRight = toDate(baseDate);
   }
 
-  const roundingMethod = getRoundingMethod(options?.roundingMethod ?? "round");
+  const roundingMethod = getRoundingMethod(options?.roundingMethod ?? 'round');
 
   const milliseconds = dateRight.getTime() - dateLeft.getTime();
   const minutes = milliseconds / millisecondsInMinute;
 
-  const timezoneOffset =
-    getTimezoneOffsetInMilliseconds(dateRight) -
-    getTimezoneOffsetInMilliseconds(dateLeft);
+  const timezoneOffset = getTimezoneOffsetInMilliseconds(dateRight) - getTimezoneOffsetInMilliseconds(dateLeft);
 
   // Use DST-normalized difference in minutes for years, months and days;
   // use regular difference in minutes for hours, minutes and seconds.
-  const dstNormalizedMinutes =
-    (milliseconds - timezoneOffset) / millisecondsInMinute;
+  const dstNormalizedMinutes = (milliseconds - timezoneOffset) / millisecondsInMinute;
 
   const defaultUnit = options?.unit;
   let unit: FormatDistanceStrictUnit;
   if (!defaultUnit) {
     if (minutes < 1) {
-      unit = "second";
+      unit = 'second';
     } else if (minutes < 60) {
-      unit = "minute";
+      unit = 'minute';
     } else if (minutes < minutesInDay) {
-      unit = "hour";
+      unit = 'hour';
     } else if (dstNormalizedMinutes < minutesInMonth) {
-      unit = "day";
+      unit = 'day';
     } else if (dstNormalizedMinutes < minutesInYear) {
-      unit = "month";
+      unit = 'month';
     } else {
-      unit = "year";
+      unit = 'year';
     }
   } else {
     unit = defaultUnit;
   }
 
   // 0 up to 60 seconds
-  if (unit === "second") {
+  if (unit === 'second') {
     const seconds = roundingMethod(milliseconds / 1000);
-    return locale.formatDistance("xSeconds", seconds, localizeOptions);
+    return locale.formatDistance('xSeconds', seconds, localizeOptions);
 
     // 1 up to 60 mins
-  } else if (unit === "minute") {
+  } else if (unit === 'minute') {
     const roundedMinutes = roundingMethod(minutes);
-    return locale.formatDistance("xMinutes", roundedMinutes, localizeOptions);
+    return locale.formatDistance('xMinutes', roundedMinutes, localizeOptions);
 
     // 1 up to 24 hours
-  } else if (unit === "hour") {
+  } else if (unit === 'hour') {
     const hours = roundingMethod(minutes / 60);
-    return locale.formatDistance("xHours", hours, localizeOptions);
+    return locale.formatDistance('xHours', hours, localizeOptions);
 
     // 1 up to 30 days
-  } else if (unit === "day") {
+  } else if (unit === 'day') {
     const days = roundingMethod(dstNormalizedMinutes / minutesInDay);
-    return locale.formatDistance("xDays", days, localizeOptions);
+    return locale.formatDistance('xDays', days, localizeOptions);
 
     // 1 up to 12 months
-  } else if (unit === "month") {
+  } else if (unit === 'month') {
     const months = roundingMethod(dstNormalizedMinutes / minutesInMonth);
-    return months === 12 && defaultUnit !== "month"
-      ? locale.formatDistance("xYears", 1, localizeOptions)
-      : locale.formatDistance("xMonths", months, localizeOptions);
+    return months === 12 && defaultUnit !== 'month'
+      ? locale.formatDistance('xYears', 1, localizeOptions)
+      : locale.formatDistance('xMonths', months, localizeOptions);
 
     // 1 year up to max Date
   } else {
     const years = roundingMethod(dstNormalizedMinutes / minutesInYear);
-    return locale.formatDistance("xYears", years, localizeOptions);
+    return locale.formatDistance('xYears', years, localizeOptions);
   }
 }

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

@@ -1,6 +1,6 @@
-import { constructNow } from "../constructNow/index";
-import type { FormatDistanceOptions } from "../formatDistance/index";
-import { formatDistance } from "../formatDistance/index";
+import { constructNow } from '../constructNow/index';
+import type { FormatDistanceOptions } from '../formatDistance/index';
+import { formatDistance } from '../formatDistance/index';
 
 /**
  * The {@link formatDistanceToNow} function options.

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

@@ -1,12 +1,11 @@
-import type { FormatDistanceStrictOptions } from "../formatDistanceStrict/index";
-import { formatDistanceStrict } from "../formatDistanceStrict/index";
-import { constructNow } from "../constructNow/index";
+import type { FormatDistanceStrictOptions } from '../formatDistanceStrict/index';
+import { formatDistanceStrict } from '../formatDistanceStrict/index';
+import { constructNow } from '../constructNow/index';
 
 /**
  * The {@link formatDistanceToNowStrict} function options.
  */
-export interface FormatDistanceToNowStrictOptions
-  extends FormatDistanceStrictOptions {}
+export interface FormatDistanceToNowStrictOptions extends FormatDistanceStrictOptions {}
 
 /**
  * @name formatDistanceToNowStrict

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

@@ -1,13 +1,12 @@
-import type { FormatDistanceToken } from "../locale/types";
-import type { Duration, DurationUnit, LocalizedOptions } from "../types";
-import { defaultLocale } from "../_lib/defaultLocale/index";
-import { getDefaultOptions } from "../_lib/defaultOptions/index";
+import type { FormatDistanceToken } from '../locale/types';
+import type { Duration, DurationUnit, LocalizedOptions } from '../types';
+import { defaultLocale } from '../_lib/defaultLocale/index';
+import { getDefaultOptions } from '../_lib/defaultOptions/index';
 
 /**
  * The {@link formatDuration} function options.
  */
-export interface FormatDurationOptions
-  extends LocalizedOptions<"formatDistance"> {
+export interface FormatDurationOptions extends LocalizedOptions<'formatDistance'> {
   /** The array of units to format */
   format?: DurationUnit[];
   /** Should be zeros be included in the output? */
@@ -16,15 +15,7 @@ export interface FormatDurationOptions
   delimiter?: string;
 }
 
-const defaultFormat: DurationUnit[] = [
-  "years",
-  "months",
-  "weeks",
-  "days",
-  "hours",
-  "minutes",
-  "seconds",
-];
+const defaultFormat: DurationUnit[] = ['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds'];
 
 /**
  * @name formatDuration
@@ -86,25 +77,20 @@ const defaultFormat: DurationUnit[] = [
  * formatDuration({ years: 2, months: 9, weeks: 3 }, { delimiter: ', ' })
  * //=> '2 years, 9 months, 3 weeks'
  */
-export function formatDuration(
-  duration: Duration,
-  options?: FormatDurationOptions,
-): string {
+export function formatDuration(duration: Duration, options?: FormatDurationOptions): string {
   const defaultOptions = getDefaultOptions();
   const locale = options?.locale ?? defaultOptions.locale ?? defaultLocale;
   const format = options?.format ?? defaultFormat;
   const zero = options?.zero ?? false;
-  const delimiter = options?.delimiter ?? " ";
+  const delimiter = options?.delimiter ?? ' ';
 
   if (!locale.formatDistance) {
-    return "";
+    return '';
   }
 
   const result = format
     .reduce((acc, unit) => {
-      const token = `x${unit.replace(/(^.)/, (m) =>
-        m.toUpperCase(),
-      )}` as FormatDistanceToken;
+      const token = `x${unit.replace(/(^.)/, (m) => m.toUpperCase())}` as FormatDistanceToken;
       const value = duration[unit];
       if (value !== undefined && (zero || duration[unit])) {
         return acc.concat(locale.formatDistance(token, value));

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

@@ -1,6 +1,6 @@
-import { toDate } from "../toDate/index";
-import type { ISOFormatOptions } from "../types";
-import { addLeadingZeros } from "../_lib/addLeadingZeros/index";
+import { toDate } from '../toDate/index';
+import type { ISOFormatOptions } from '../types';
+import { addLeadingZeros } from '../_lib/addLeadingZeros/index';
 
 /**
  * The {@link formatISO} function options.
@@ -44,27 +44,24 @@ export interface FormatISOOptions extends ISOFormatOptions {}
  * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { representation: 'time' })
  * //=> '19:00:52Z'
  */
-export function formatISO<DateType extends Date>(
-  date: DateType | number | string,
-  options?: FormatISOOptions,
-): string {
+export function formatISO<DateType extends Date>(date: DateType | number | string, options?: FormatISOOptions): string {
   const _date = toDate(date);
 
   if (isNaN(_date.getTime())) {
-    throw new RangeError("Invalid time value");
+    throw new RangeError('Invalid time value');
   }
 
-  const format = options?.format ?? "extended";
-  const representation = options?.representation ?? "complete";
+  const format = options?.format ?? 'extended';
+  const representation = options?.representation ?? 'complete';
 
-  let result = "";
-  let tzOffset = "";
+  let result = '';
+  let tzOffset = '';
 
-  const dateDelimiter = format === "extended" ? "-" : "";
-  const timeDelimiter = format === "extended" ? ":" : "";
+  const dateDelimiter = format === 'extended' ? '-' : '';
+  const timeDelimiter = format === 'extended' ? ':' : '';
 
   // Representation is either 'date' or 'complete'
-  if (representation !== "time") {
+  if (representation !== 'time') {
     const day = addLeadingZeros(_date.getDate(), 2);
     const month = addLeadingZeros(_date.getMonth() + 1, 2);
     const year = addLeadingZeros(_date.getFullYear(), 4);
@@ -74,7 +71,7 @@ export function formatISO<DateType extends Date>(
   }
 
   // Representation is either 'time' or 'complete'
-  if (representation !== "date") {
+  if (representation !== 'date') {
     // Add the timezone.
     const offset = _date.getTimezoneOffset();
 
@@ -83,11 +80,11 @@ export function formatISO<DateType extends 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 = offset < 0 ? "+" : "-";
+      const sign = offset < 0 ? '+' : '-';
 
       tzOffset = `${sign}${hourOffset}:${minuteOffset}`;
     } else {
-      tzOffset = "Z";
+      tzOffset = 'Z';
     }
 
     const hour = addLeadingZeros(_date.getHours(), 2);
@@ -95,7 +92,7 @@ export function formatISO<DateType extends Date>(
     const second = addLeadingZeros(_date.getSeconds(), 2);
 
     // If there's also date, separate it with time with 'T'
-    const separator = result === "" ? "" : "T";
+    const separator = result === '' ? '' : 'T';
 
     // Creates a time string consisting of hour, minute, and second, separated by delimiters, if defined.
     const time = [hour, minute, second].join(timeDelimiter);

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

@@ -1,7 +1,7 @@
-import { isValid } from "../isValid/index";
-import { toDate } from "../toDate/index";
-import type { ISOFormatOptions } from "../types";
-import { addLeadingZeros } from "../_lib/addLeadingZeros/index";
+import { isValid } from '../isValid/index';
+import { toDate } from '../toDate/index';
+import type { ISOFormatOptions } from '../types';
+import { addLeadingZeros } from '../_lib/addLeadingZeros/index';
 
 /**
  * The {@link formatISO9075} function options.
@@ -52,19 +52,19 @@ export function formatISO9075<DateType extends Date>(
   const _date = toDate(date);
 
   if (!isValid(_date)) {
-    throw new RangeError("Invalid time value");
+    throw new RangeError('Invalid time value');
   }
 
-  const format = options?.format ?? "extended";
-  const representation = options?.representation ?? "complete";
+  const format = options?.format ?? 'extended';
+  const representation = options?.representation ?? 'complete';
 
-  let result = "";
+  let result = '';
 
-  const dateDelimiter = format === "extended" ? "-" : "";
-  const timeDelimiter = format === "extended" ? ":" : "";
+  const dateDelimiter = format === 'extended' ? '-' : '';
+  const timeDelimiter = format === 'extended' ? ':' : '';
 
   // Representation is either 'date' or 'complete'
-  if (representation !== "time") {
+  if (representation !== 'time') {
     const day = addLeadingZeros(_date.getDate(), 2);
     const month = addLeadingZeros(_date.getMonth() + 1, 2);
     const year = addLeadingZeros(_date.getFullYear(), 4);
@@ -74,13 +74,13 @@ export function formatISO9075<DateType extends Date>(
   }
 
   // Representation is either 'time' or 'complete'
-  if (representation !== "date") {
+  if (representation !== 'date') {
     const hour = addLeadingZeros(_date.getHours(), 2);
     const minute = addLeadingZeros(_date.getMinutes(), 2);
     const second = addLeadingZeros(_date.getSeconds(), 2);
 
     // If there's also date, separate it with time with a space
-    const separator = result === "" ? "" : " ";
+    const separator = result === '' ? '' : ' ';
 
     // HHmmss or HH:mm:ss.
     result = `${result}${separator}${hour}${timeDelimiter}${minute}${timeDelimiter}${second}`;