@jsenv/test 1.1.2 → 1.1.4

package/dist/jsenv_test.js

@@ -2734,8 +2734,9 @@ const composeV8AndIstanbul = (v8FileByFileCoverage, istanbulFileByFileCoverage,
     if (v8Coverage) {
       if (coverageV8ConflictWarning) {
         console.warn(createDetailedMessage(`Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`, {
-          details: `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
-          suggestion: "You can disable this warning with coverageV8ConflictWarning: false"
+          "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
+          "suggestion": "disable this warning with coverageV8ConflictWarning: false",
+          "suggestion 2": `force coverage using istanbul with coverageMethodForBrowsers: "istanbul"`
         }));
       }
       fileByFileCoverage[key] = v8Coverage;
@@ -4025,6 +4026,7 @@ const executeTestPlan = async ({
     "./**/src/**/*.tsx": true,
     "./**/tests/": false,
     "./**/*.test.html": false,
+    "./**/*.test.html@*.js": false,
     "./**/*.test.js": false,
     "./**/*.test.mjs": false
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,9 +33,9 @@
     "playwright": "1.x"
   },
   "dependencies": {
-    "@jsenv/core": "35.0.3",
+    "@jsenv/core": "35.0.5",
     "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "3.0.7",
+    "@jsenv/ast": "3.0.8",
     "@jsenv/filesystem": "4.2.3",
     "@jsenv/log": "3.3.4",
     "@jsenv/urls": "2.0.0",

package/src/coverage/babel_plugin_instrument.js

@@ -1,27 +1,27 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 // https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
 
 export const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
-  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument")
-  const { types } = api
+  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument");
+  const { types } = api;
 
   return {
     name: "transform-instrument",
     visitor: {
       Program: {
         enter(path) {
-          const { file } = this
-          const { opts } = file
-          let inputSourceMap
+          const { file } = this;
+          const { opts } = file;
+          let inputSourceMap;
           if (useInlineSourceMaps) {
             // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
             inputSourceMap =
               opts.inputSourceMap || file.inputMap
                 ? file.inputMap.sourcemap
-                : null
+                : null;
           } else {
-            inputSourceMap = opts.inputSourceMap
+            inputSourceMap = opts.inputSourceMap;
           }
           this.__dv__ = programVisitor(
             types,
@@ -30,19 +30,19 @@ export const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
               coverageVariable: "__coverage__",
               inputSourceMap,
             },
-          )
-          this.__dv__.enter(path)
+          );
+          this.__dv__.enter(path);
         },
 
         exit(path) {
           if (!this.__dv__) {
-            return
+            return;
           }
-          const object = this.__dv__.exit(path)
+          const object = this.__dv__.exit(path);
           // object got two properties: fileCoverage and sourceMappingURL
-          this.file.metadata.coverage = object.fileCoverage
+          this.file.metadata.coverage = object.fileCoverage;
         },
       },
     },
-  }
-}
+  };
+};

package/src/coverage/coverage_reporter_html_directory.js

@@ -1,8 +1,8 @@
-import { fileURLToPath } from "node:url"
-import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js";
 
 export const generateCoverageHtmlDirectory = async (
   coverage,
@@ -13,20 +13,20 @@ export const generateCoverageHtmlDirectory = async (
     coverageReportSkipFull,
   },
 ) => {
-  const libReport = requireFromJsenv("istanbul-lib-report")
-  const reports = requireFromJsenv("istanbul-reports")
+  const libReport = requireFromJsenv("istanbul-lib-report");
+  const reports = requireFromJsenv("istanbul-reports");
 
   const context = libReport.createContext({
     dir: fileURLToPath(rootDirectoryUrl),
     coverageMap: istanbulCoverageMapFromCoverage(coverage),
     sourceFinder: (path) =>
       readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
-  })
+  });
 
   const report = reports.create("html", {
     skipEmpty: coverageReportSkipEmpty,
     skipFull: coverageReportSkipFull,
     subdir: coverageHtmlDirectoryRelativeUrl,
-  })
-  report.execute(context)
-}
+  });
+  report.execute(context);
+};

package/src/coverage/coverage_reporter_json_file.js

@@ -1,17 +1,17 @@
-import { writeFile } from "@jsenv/filesystem"
-import { urlToFileSystemPath } from "@jsenv/urls"
-import { byteAsFileSize } from "@jsenv/log"
+import { writeFile } from "@jsenv/filesystem";
+import { urlToFileSystemPath } from "@jsenv/urls";
+import { byteAsFileSize } from "@jsenv/log";
 
 export const generateCoverageJsonFile = async ({
   coverage,
   coverageJsonFileUrl,
   logger,
 }) => {
-  const coverageAsText = JSON.stringify(coverage, null, "  ")
+  const coverageAsText = JSON.stringify(coverage, null, "  ");
   logger.info(
     `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
       Buffer.byteLength(coverageAsText),
     )})`,
-  )
-  await writeFile(coverageJsonFileUrl, coverageAsText)
-}
+  );
+  await writeFile(coverageJsonFileUrl, coverageAsText);
+};

package/src/coverage/coverage_reporter_text_log.js

@@ -1,19 +1,19 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js";
 
 export const generateCoverageTextLog = (
   coverage,
   { coverageReportSkipEmpty, coverageReportSkipFull },
 ) => {
-  const libReport = requireFromJsenv("istanbul-lib-report")
-  const reports = requireFromJsenv("istanbul-reports")
+  const libReport = requireFromJsenv("istanbul-lib-report");
+  const reports = requireFromJsenv("istanbul-reports");
 
   const context = libReport.createContext({
     coverageMap: istanbulCoverageMapFromCoverage(coverage),
-  })
+  });
   const report = reports.create("text", {
     skipEmpty: coverageReportSkipEmpty,
     skipFull: coverageReportSkipFull,
-  })
-  report.execute(context)
-}
+  });
+  report.execute(context);
+};

package/src/coverage/empty_coverage_factory.js

@@ -1,52 +1,52 @@
-import { readFile } from "@jsenv/filesystem"
-import { resolveUrl } from "@jsenv/urls"
-import { Abort } from "@jsenv/abort"
-import { applyBabelPlugins } from "@jsenv/ast"
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { readFile } from "@jsenv/filesystem";
+import { resolveUrl } from "@jsenv/urls";
+import { Abort } from "@jsenv/abort";
+import { applyBabelPlugins } from "@jsenv/ast";
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
-import { babelPluginInstrument } from "./babel_plugin_instrument.js"
+import { babelPluginInstrument } from "./babel_plugin_instrument.js";
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
   { signal, rootDirectoryUrl },
 ) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
   try {
-    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl)
-    const content = await readFile(fileUrl, { as: "string" })
+    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl);
+    const content = await readFile(fileUrl, { as: "string" });
 
-    operation.throwIfAborted()
+    operation.throwIfAborted();
     const { metadata } = await applyBabelPlugins({
       babelPlugins: [babelPluginInstrument],
       urlInfo: {
         originalUrl: fileUrl,
         content,
       },
-    })
-    const { coverage } = metadata
+    });
+    const { coverage } = metadata;
     if (!coverage) {
-      throw new Error(`missing coverage for file`)
+      throw new Error(`missing coverage for file`);
     }
     // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
     Object.keys(coverage.s).forEach(function (key) {
-      coverage.s[key] = 0
-    })
-    return coverage
+      coverage.s[key] = 0;
+    });
+    return coverage;
   } catch (e) {
     if (e && e.code === "PARSE_ERROR") {
       // return an empty coverage for that file when
       // it contains a syntax error
-      return createEmptyCoverage(relativeUrl)
+      return createEmptyCoverage(relativeUrl);
     }
-    throw e
+    throw e;
   } finally {
-    await operation.end()
+    await operation.end();
   }
-}
+};
 
 const createEmptyCoverage = (relativeUrl) => {
-  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage")
-  return createFileCoverage(relativeUrl).toJSON()
-}
+  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage");
+  return createFileCoverage(relativeUrl).toJSON();
+};

package/src/coverage/file_by_file_coverage.js

@@ -2,24 +2,24 @@ import {
   urlToRelativeUrl,
   fileSystemPathToUrl,
   isFileSystemPath,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 
 export const normalizeFileByFileCoveragePaths = (
   fileByFileCoverage,
   rootDirectoryUrl,
 ) => {
-  const fileByFileNormalized = {}
+  const fileByFileNormalized = {};
   Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key]
-    const { path } = fileCoverage
+    const fileCoverage = fileByFileCoverage[key];
+    const { path } = fileCoverage;
     const url = isFileSystemPath(path)
       ? fileSystemPathToUrl(path)
-      : new URL(path, rootDirectoryUrl).href
-    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl)
+      : new URL(path, rootDirectoryUrl).href;
+    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
     fileByFileNormalized[`./${relativeUrl}`] = {
       ...fileCoverage,
       path: `./${relativeUrl}`,
-    }
-  })
-  return fileByFileNormalized
-}
+    };
+  });
+  return fileByFileNormalized;
+};

package/src/coverage/istanbul_coverage_composition.js

@@ -1,28 +1,28 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 export const composeTwoFileByFileIstanbulCoverages = (
   firstFileByFileIstanbulCoverage,
   secondFileByFileIstanbulCoverage,
 ) => {
-  const fileByFileIstanbulCoverage = {}
+  const fileByFileIstanbulCoverage = {};
   Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
-    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key]
-  })
+    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key];
+  });
   Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
-    const firstCoverage = firstFileByFileIstanbulCoverage[key]
-    const secondCoverage = secondFileByFileIstanbulCoverage[key]
+    const firstCoverage = firstFileByFileIstanbulCoverage[key];
+    const secondCoverage = secondFileByFileIstanbulCoverage[key];
     fileByFileIstanbulCoverage[key] = firstCoverage
       ? merge(firstCoverage, secondCoverage)
-      : secondCoverage
-  })
+      : secondCoverage;
+  });
 
-  return fileByFileIstanbulCoverage
-}
+  return fileByFileIstanbulCoverage;
+};
 
 const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
-  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage")
-  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
-  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
-  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
-  return istanbulCoverage
-}
+  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage");
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage);
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage);
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON();
+  return istanbulCoverage;
+};

package/src/coverage/istanbul_coverage_map_from_coverage.js

@@ -1,16 +1,16 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 export const istanbulCoverageMapFromCoverage = (coverage) => {
-  const { createCoverageMap } = requireFromJsenv("istanbul-lib-coverage")
+  const { createCoverageMap } = requireFromJsenv("istanbul-lib-coverage");
 
-  const coverageAdjusted = {}
+  const coverageAdjusted = {};
   Object.keys(coverage).forEach((key) => {
     coverageAdjusted[key.slice(2)] = {
       ...coverage[key],
       path: key.slice(2),
-    }
-  })
+    };
+  });
 
-  const coverageMap = createCoverageMap(coverageAdjusted)
-  return coverageMap
-}
+  const coverageMap = createCoverageMap(coverageAdjusted);
+  return coverageMap;
+};

package/src/coverage/list_files_not_covered.js

@@ -1,4 +1,4 @@
-import { collectFiles } from "@jsenv/filesystem"
+import { collectFiles } from "@jsenv/filesystem";
 
 export const listRelativeFileUrlToCover = async ({
   signal,
@@ -10,6 +10,6 @@ export const listRelativeFileUrlToCover = async ({
     directoryUrl: rootDirectoryUrl,
     associations: { cover: coverageConfig },
     predicate: ({ cover }) => cover,
-  })
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
-}
+  });
+  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl);
+};

package/src/coverage/missing_coverage.js

@@ -1,7 +1,7 @@
-import { Abort } from "@jsenv/abort"
+import { Abort } from "@jsenv/abort";
 
-import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.js"
+import { listRelativeFileUrlToCover } from "./list_files_not_covered.js";
+import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.js";
 
 export const getMissingFileByFileCoverage = async ({
   signal,
@@ -13,19 +13,19 @@ export const getMissingFileByFileCoverage = async ({
     signal,
     rootDirectoryUrl,
     coverageConfig,
-  })
+  });
   const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
     Object.keys(fileByFileCoverage).every((key) => {
-      return key !== `./${relativeUrlToCover}`
+      return key !== `./${relativeUrlToCover}`;
     }),
-  )
+  );
 
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-  const missingFileByFileCoverage = {}
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+  const missingFileByFileCoverage = {};
   await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
-    operation.throwIfAborted()
-    await previous
+    operation.throwIfAborted();
+    await previous;
     await operation.withSignal(async (signal) => {
       const emptyCoverage = await relativeUrlToEmptyCoverage(
         relativeUrlMissing,
@@ -33,9 +33,9 @@ export const getMissingFileByFileCoverage = async ({
           signal,
           rootDirectoryUrl,
         },
-      )
-      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
-    })
-  }, Promise.resolve())
-  return missingFileByFileCoverage
-}
+      );
+      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage;
+    });
+  }, Promise.resolve());
+  return missingFileByFileCoverage;
+};

package/src/coverage/report_to_coverage.js

@@ -1,14 +1,14 @@
-import { readFileSync } from "node:fs"
-import { Abort } from "@jsenv/abort"
-
-import { filterV8Coverage } from "./v8_coverage.js"
-import { readNodeV8CoverageDirectory } from "./v8_coverage_node_directory.js"
-import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
-import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
-import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
-import { composeV8AndIstanbul } from "./v8_and_istanbul.js"
-import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js"
-import { getMissingFileByFileCoverage } from "./missing_coverage.js"
+import { readFileSync } from "node:fs";
+import { Abort } from "@jsenv/abort";
+
+import { filterV8Coverage } from "./v8_coverage.js";
+import { readNodeV8CoverageDirectory } from "./v8_coverage_node_directory.js";
+import { composeTwoV8Coverages } from "./v8_coverage_composition.js";
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js";
+import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js";
+import { composeV8AndIstanbul } from "./v8_and_istanbul.js";
+import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js";
+import { getMissingFileByFileCoverage } from "./missing_coverage.js";
 
 export const reportToCoverage = async (
   report,
@@ -51,10 +51,10 @@ export const reportToCoverage = async (
       ) {
         logger.warn(
           `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
-        )
+        );
       }
     },
-  })
+  });
 
   if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
     await readNodeV8CoverageDirectory({
@@ -64,38 +64,38 @@ export const reportToCoverage = async (
         const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
           rootDirectoryUrl,
           coverageConfig,
-        })
+        });
         v8Coverage = v8Coverage
           ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
-          : nodeV8CoverageLight
+          : nodeV8CoverageLight;
       },
-    })
+    });
   }
 
   // try to merge v8 with istanbul, if any
-  let fileByFileCoverage
+  let fileByFileCoverage;
   if (v8Coverage) {
     let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
       signal,
-    })
+    });
 
     v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
       v8FileByFileCoverage,
       rootDirectoryUrl,
-    )
+    );
 
     if (fileByFileIstanbulCoverage) {
       fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
         fileByFileIstanbulCoverage,
         rootDirectoryUrl,
-      )
+      );
       fileByFileCoverage = composeV8AndIstanbul(
         v8FileByFileCoverage,
         fileByFileIstanbulCoverage,
         { coverageV8ConflictWarning },
-      )
+      );
     } else {
-      fileByFileCoverage = v8FileByFileCoverage
+      fileByFileCoverage = v8FileByFileCoverage;
     }
   }
   // get istanbul only
@@ -103,11 +103,11 @@ export const reportToCoverage = async (
     fileByFileCoverage = normalizeFileByFileCoveragePaths(
       fileByFileIstanbulCoverage,
       rootDirectoryUrl,
-    )
+    );
   }
   // no coverage found in execution (or zero file where executed)
   else {
-    fileByFileCoverage = {}
+    fileByFileCoverage = {};
   }
 
   // now add coverage for file not covered
@@ -117,82 +117,82 @@ export const reportToCoverage = async (
       rootDirectoryUrl,
       coverageConfig,
       fileByFileCoverage,
-    })
+    });
     Object.assign(
       fileByFileCoverage,
       normalizeFileByFileCoveragePaths(
         missingFileByFileCoverage,
         rootDirectoryUrl,
       ),
-    )
+    );
   }
 
-  return fileByFileCoverage
-}
+  return fileByFileCoverage;
+};
 
 const getCoverageFromReport = async ({ signal, report, onMissing }) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
   try {
-    let v8Coverage
-    let fileByFileIstanbulCoverage
+    let v8Coverage;
+    let fileByFileIstanbulCoverage;
 
     // collect v8 and istanbul coverage from executions
     await Object.keys(report).reduce(async (previous, file) => {
-      operation.throwIfAborted()
-      await previous
+      operation.throwIfAborted();
+      await previous;
 
-      const executionResultForFile = report[file]
+      const executionResultForFile = report[file];
       await Object.keys(executionResultForFile).reduce(
         async (previous, executionName) => {
-          operation.throwIfAborted()
-          await previous
+          operation.throwIfAborted();
+          await previous;
 
           const executionResultForFileOnRuntime =
-            executionResultForFile[executionName]
-          const { coverageFileUrl } = executionResultForFileOnRuntime
-          let executionCoverage
+            executionResultForFile[executionName];
+          const { coverageFileUrl } = executionResultForFileOnRuntime;
+          let executionCoverage;
           try {
             executionCoverage = JSON.parse(
               String(readFileSync(new URL(coverageFileUrl))),
-            )
+            );
           } catch (e) {
             if (e.code === "ENOENT" || e.name === "SyntaxError") {
               onMissing({
                 executionName,
                 file,
                 executionResult: executionResultForFileOnRuntime,
-              })
-              return
+              });
+              return;
             }
-            throw e
+            throw e;
           }
 
           if (isV8Coverage(executionCoverage)) {
             v8Coverage = v8Coverage
               ? composeTwoV8Coverages(v8Coverage, executionCoverage)
-              : executionCoverage
+              : executionCoverage;
           } else {
             fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
               ? composeTwoFileByFileIstanbulCoverages(
                   fileByFileIstanbulCoverage,
                   executionCoverage,
                 )
-              : executionCoverage
+              : executionCoverage;
           }
         },
         Promise.resolve(),
-      )
-    }, Promise.resolve())
+      );
+    }, Promise.resolve());
 
     return {
       v8Coverage,
       fileByFileIstanbulCoverage,
-    }
+    };
   } finally {
-    await operation.end()
+    await operation.end();
   }
-}
+};
 
-const isV8Coverage = (coverage) => Boolean(coverage.result)
+const isV8Coverage = (coverage) => Boolean(coverage.result);