@vitest/coverage-v8 2.1.2 → 2.1.4

package/dist/browser.d.ts

@@ -1,8 +1,9 @@
 import { V8CoverageProvider } from './provider.js';
+import 'magicast';
 import 'istanbul-lib-coverage';
-import 'vitest/coverage';
 import 'vitest/node';
-import 'vitest';
+import 'test-exclude';
+import 'vitest/coverage';
 
 declare const _default: {
     startCoverage(): Promise<void>;

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import { Profiler } from 'node:inspector';
 import { V8CoverageProvider } from './provider.js';
+import { Profiler } from 'node:inspector';
+import 'magicast';
 import 'istanbul-lib-coverage';
-import 'vitest/coverage';
 import 'vitest/node';
-import 'vitest';
+import 'test-exclude';
+import 'vitest/coverage';
 
 declare const _default: {
     startCoverage(): void;

package/dist/provider.d.ts

@@ -1,60 +1,18 @@
+import * as magicast from 'magicast';
 import { CoverageMap } from 'istanbul-lib-coverage';
+import { ResolvedCoverageOptions, CoverageProvider, Vitest, ReportContext } from 'vitest/node';
+import TestExclude from 'test-exclude';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import { Vitest } from 'vitest/node';
-import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 
-interface TestExclude {
-    new (opts: {
-        cwd?: string | string[];
-        include?: string | string[];
-        exclude?: string | string[];
-        extension?: string | string[];
-        excludeNodeModules?: boolean;
-        relativePath?: boolean;
-    }): {
-        shouldInstrument: (filePath: string) => boolean;
-        glob: (cwd: string) => Promise<string[]>;
-    };
-}
-type Options = ResolvedCoverageOptions<'v8'>;
-/**
- * Holds info about raw coverage results that are stored on file system:
- *
- * ```json
- * "project-a": {
- *   "web": {
- *     "tests/math.test.ts": "coverage-1.json",
- *     "tests/utils.test.ts": "coverage-2.json",
- * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
- *   },
- *   "ssr": { ... },
- *   "browser": { ... },
- * },
- * "project-b": ...
- * ```
- */
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT, Record<AfterSuiteRunMeta['transformMode'], {
-    [TestFilenames: string]: string;
-}>>;
-declare const DEFAULT_PROJECT: unique symbol;
-declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
-    name: string;
-    ctx: Vitest;
-    options: Options;
-    testExclude: InstanceType<TestExclude>;
-    coverageFiles: CoverageFiles;
-    coverageFilesDirectory: string;
-    pendingPromises: Promise<void>[];
+declare class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOptions<'v8'>> implements CoverageProvider {
+    name: "v8";
+    version: string;
+    testExclude: InstanceType<typeof TestExclude>;
     initialize(ctx: Vitest): void;
-    resolveOptions(): Options;
-    clean(clean?: boolean): Promise<void>;
-    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    createCoverageMap(): CoverageMap;
     generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
-    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
-    private cleanAfterRun;
-    onTestFailure(): Promise<void>;
     generateReports(coverageMap: CoverageMap, allTestsRun?: boolean): Promise<void>;
-    mergeReports(coverageMaps: unknown[]): Promise<void>;
+    parseConfigModule(configFilePath: string): Promise<magicast.ProxifiedModule<any>>;
     private getUntestedFiles;
     private getSources;
     private convertCoverage;

package/dist/provider.js

@@ -1,26 +1,152 @@
-import { existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
+import { promises } from 'node:fs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import require$$0 from 'assert';
-import require$$2 from 'util';
-import require$$3 from 'path';
-import require$$4 from 'url';
-import require$$9 from 'fs';
-import require$$11 from 'module';
+import remapping from '@ampproject/remapping';
 import { mergeProcessCovs } from '@bcoe/v8-coverage';
-import libReport from 'istanbul-lib-report';
-import reports from 'istanbul-reports';
+import createDebug from 'debug';
 import libCoverage from 'istanbul-lib-coverage';
+import libReport from 'istanbul-lib-report';
 import libSourceMaps from 'istanbul-lib-source-maps';
+import reports from 'istanbul-reports';
 import MagicString from 'magic-string';
 import { parseModule } from 'magicast';
-import remapping from '@ampproject/remapping';
-import c from 'tinyrainbow';
 import { provider } from 'std-env';
-import createDebug from 'debug';
+import TestExclude from 'test-exclude';
+import c from 'tinyrainbow';
+import require$$0 from 'assert';
+import require$$2 from 'util';
+import require$$3 from 'path';
+import require$$4 from 'url';
+import require$$9 from 'fs';
+import require$$11 from 'module';
 import { builtinModules } from 'node:module';
-import { coverageConfigDefaults } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import _TestExclude from 'test-exclude';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -2389,133 +2515,6 @@ function requireV8ToIstanbul () {
 var v8ToIstanbulExports = requireV8ToIstanbul();
 var v8ToIstanbul = /*@__PURE__*/getDefaultExportFromCjs(v8ToIstanbulExports);
 
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const normalize = function(path) {
-  if (path.length === 0) {
-    return ".";
-  }
-  path = normalizeWindowsPath(path);
-  const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path[path.length - 1] === "/";
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path += "/";
-  }
-  if (_DRIVE_LETTER_RE.test(path)) {
-    path += "/";
-  }
-  if (isUNCPath) {
-    if (!isPathAbsolute) {
-      return `//./${path}`;
-    }
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-const resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-
 const isWindows = process.platform === "win32";
 const drive = isWindows ? process.cwd()[0] : null;
 drive ? drive === drive.toUpperCase() ? drive.toLowerCase() : drive.toUpperCase() : null;
@@ -2540,57 +2539,20 @@ function cleanUrl(url) {
   "wasi"
 ]);
 
-var version = "2.1.2";
+var version = "2.1.4";
 
 const WRAPPER_LENGTH = 185;
 const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
 const DECORATOR_METADATA_PATTERN = /_ts_metadata\("design:paramtypes", \[[^\]]*\]\),*/g;
-const DEFAULT_PROJECT = Symbol.for("default-project");
 const FILE_PROTOCOL = "file://";
 const debug = createDebug("vitest:coverage");
-let uniqueId = 0;
 class V8CoverageProvider extends BaseCoverageProvider {
   name = "v8";
-  ctx;
-  options;
+  version = version;
   testExclude;
-  coverageFiles = /* @__PURE__ */ new Map();
-  coverageFilesDirectory;
-  pendingPromises = [];
   initialize(ctx) {
-    const config = ctx.config.coverage;
-    if (ctx.version !== version) {
-      ctx.logger.warn(
-        c.yellow(
-          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-v8@${version} `))}.
-Running mixed versions is not supported and may lead into bugs
-Update your dependencies and make sure the versions match.`
-        )
-      );
-    }
-    this.ctx = ctx;
-    this.options = {
-      ...coverageConfigDefaults,
-      // User's options
-      ...config,
-      // Resolved fields
-      provider: "v8",
-      reporter: this.resolveReporters(
-        config.reporter || coverageConfigDefaults.reporter
-      ),
-      reportsDirectory: resolve(
-        ctx.config.root,
-        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
-      ),
-      thresholds: config.thresholds && {
-        ...config.thresholds,
-        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
-        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
-        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
-        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
-      }
-    };
-    this.testExclude = new _TestExclude({
+    this._initialize(ctx);
+    this.testExclude = new TestExclude({
       cwd: ctx.config.root,
       include: this.options.include,
       exclude: this.options.exclude,
@@ -2598,82 +2560,18 @@ Update your dependencies and make sure the versions match.`
       extension: this.options.extension,
       relativePath: !this.options.allowExternal
     });
-    const shard = this.ctx.config.shard;
-    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-    this.coverageFilesDirectory = resolve(
-      this.options.reportsDirectory,
-      tempDirectory
-    );
-  }
-  resolveOptions() {
-    return this.options;
-  }
-  async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory)) {
-      await promises.rm(this.options.reportsDirectory, {
-        recursive: true,
-        force: true,
-        maxRetries: 10
-      });
-    }
-    if (existsSync(this.coverageFilesDirectory)) {
-      await promises.rm(this.coverageFilesDirectory, {
-        recursive: true,
-        force: true,
-        maxRetries: 10
-      });
-    }
-    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
-    this.coverageFiles = /* @__PURE__ */ new Map();
-    this.pendingPromises = [];
   }
-  /*
-   * Coverage and meta information passed from Vitest runners.
-   * Note that adding new entries here and requiring on those without
-   * backwards compatibility is a breaking change.
-   */
-  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
-    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
-      throw new Error(`Invalid transform mode: ${transformMode}`);
-    }
-    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
-    if (!entry) {
-      entry = { web: {}, ssr: {}, browser: {} };
-      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-    }
-    const testFilenames = testFiles.join();
-    const filename = resolve(
-      this.coverageFilesDirectory,
-      `coverage-${uniqueId++}.json`
-    );
-    entry[transformMode][testFilenames] = filename;
-    const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
-    this.pendingPromises.push(promise);
+  createCoverageMap() {
+    return libCoverage.createCoverageMap({});
   }
   async generateCoverage({ allTestsRun }) {
-    const coverageMap = libCoverage.createCoverageMap({});
-    let index = 0;
-    const total = this.pendingPromises.length;
-    await Promise.all(this.pendingPromises);
-    this.pendingPromises = [];
-    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-        let merged = { result: [] };
-        const filenames = Object.values(coverageByTestfiles);
-        const project = this.ctx.projects.find((p) => p.getName() === projectName) || this.ctx.getCoreWorkspaceProject();
-        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
-          if (debug.enabled) {
-            index += chunk.length;
-            debug("Covered files %d/%d", index, total);
-          }
-          await Promise.all(
-            chunk.map(async (filename) => {
-              const contents = await promises.readFile(filename, "utf-8");
-              const coverage = JSON.parse(contents);
-              merged = mergeProcessCovs([merged, coverage]);
-            })
-          );
-        }
+    const coverageMap = this.createCoverageMap();
+    let merged = { result: [] };
+    await this.readCoverageFiles({
+      onFileRead(coverage) {
+        merged = mergeProcessCovs([merged, coverage]);
+      },
+      onFinished: async (project, transformMode) => {
         const converted = await this.convertCoverage(
           merged,
           project,
@@ -2681,8 +2579,10 @@ Update your dependencies and make sure the versions match.`
         );
         const transformedCoverage = await transformCoverage(converted);
         coverageMap.merge(transformedCoverage);
-      }
-    }
+        merged = { result: [] };
+      },
+      onDebug: debug
+    });
     if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
       const coveredFiles = coverageMap.files();
       const untestedCoverage = await this.getUntestedFiles(coveredFiles);
@@ -2694,7 +2594,7 @@ Update your dependencies and make sure the versions match.`
     }
     return coverageMap;
   }
-  async reportCoverage(coverageMap, { allTestsRun }) {
+  async generateReports(coverageMap, allTestsRun) {
     if (provider === "stackblitz") {
       this.ctx.logger.log(
         c.blue(" % ") + c.yellow(
@@ -2702,28 +2602,6 @@ Update your dependencies and make sure the versions match.`
         )
       );
     }
-    await this.generateReports(
-      coverageMap || libCoverage.createCoverageMap({}),
-      allTestsRun
-    );
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-    if (!keepResults) {
-      await this.cleanAfterRun();
-    }
-  }
-  async cleanAfterRun() {
-    this.coverageFiles = /* @__PURE__ */ new Map();
-    await promises.rm(this.coverageFilesDirectory, { recursive: true });
-    if (readdirSync(this.options.reportsDirectory).length === 0) {
-      await promises.rm(this.options.reportsDirectory, { recursive: true });
-    }
-  }
-  async onTestFailure() {
-    if (!this.options.reportOnFailure) {
-      await this.cleanAfterRun();
-    }
-  }
-  async generateReports(coverageMap, allTestsRun) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -2742,46 +2620,13 @@ Update your dependencies and make sure the versions match.`
       }).execute(context);
     }
     if (this.options.thresholds) {
-      const resolvedThresholds = this.resolveThresholds({
-        coverageMap,
-        thresholds: this.options.thresholds,
-        createCoverageMap: () => libCoverage.createCoverageMap({}),
-        root: this.ctx.config.root
-      });
-      this.checkThresholds({
-        thresholds: resolvedThresholds,
-        perFile: this.options.thresholds.perFile,
-        onError: (error) => this.ctx.logger.error(error)
-      });
-      if (this.options.thresholds.autoUpdate && allTestsRun) {
-        if (!this.ctx.server.config.configFile) {
-          throw new Error(
-            'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
-          );
-        }
-        const configFilePath = this.ctx.server.config.configFile;
-        const configModule = parseModule(
-          await promises.readFile(configFilePath, "utf8")
-        );
-        this.updateThresholds({
-          thresholds: resolvedThresholds,
-          perFile: this.options.thresholds.perFile,
-          configurationFile: configModule,
-          onUpdate: () => writeFileSync(
-            configFilePath,
-            configModule.generate().code,
-            "utf-8"
-          )
-        });
-      }
+      await this.reportThresholds(coverageMap, allTestsRun);
     }
   }
-  async mergeReports(coverageMaps) {
-    const coverageMap = libCoverage.createCoverageMap({});
-    for (const coverage of coverageMaps) {
-      coverageMap.merge(coverage);
-    }
-    await this.generateReports(coverageMap, true);
+  async parseConfigModule(configFilePath) {
+    return parseModule(
+      await promises.readFile(configFilePath, "utf8")
+    );
   }
   async getUntestedFiles(testedFiles) {
     const transformResults = normalizeTransformResults(
@@ -2800,10 +2645,7 @@ Update your dependencies and make sure the versions match.`
     const uncoveredFiles = includedFiles.map((file) => pathToFileURL(file)).filter((file) => !testedFiles.includes(file.pathname));
     let merged = { result: [] };
     let index = 0;
-    for (const chunk of this.toSlices(
-      uncoveredFiles,
-      this.options.processingConcurrency
-    )) {
+    for (const chunk of this.toSlices(uncoveredFiles, this.options.processingConcurrency)) {
       if (debug.enabled) {
         index += chunk.length;
         debug("Uncovered files %d/%d", index, uncoveredFiles.length);
@@ -2916,7 +2758,7 @@ Update your dependencies and make sure the versions match.`
         scriptCoverages.push(result);
       }
     }
-    const coverageMap = libCoverage.createCoverageMap({});
+    const coverageMap = this.createCoverageMap();
     let index = 0;
     for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
       if (debug.enabled) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -41,8 +41,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@vitest/browser": "2.1.2",
-    "vitest": "2.1.2"
+    "@vitest/browser": "2.1.4",
+    "vitest": "2.1.4"
   },
   "peerDependenciesMeta": {
     "@vitest/browser": {
@@ -52,13 +52,13 @@
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
     "@bcoe/v8-coverage": "^0.2.3",
-    "debug": "^4.3.6",
+    "debug": "^4.3.7",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-lib-source-maps": "^5.0.6",
     "istanbul-reports": "^3.1.7",
-    "magic-string": "^0.30.11",
-    "magicast": "^0.3.4",
+    "magic-string": "^0.30.12",
+    "magicast": "^0.3.5",
     "std-env": "^3.7.0",
     "test-exclude": "^7.0.1",
     "tinyrainbow": "^1.2.0"
@@ -69,11 +69,12 @@
     "@types/istanbul-lib-report": "^3.0.3",
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
+    "@types/test-exclude": "^6.0.2",
     "pathe": "^1.1.2",
     "v8-to-istanbul": "^9.3.0",
-    "@vitest/browser": "2.1.2",
-    "vite-node": "2.1.2",
-    "vitest": "2.1.2"
+    "vite-node": "2.1.4",
+    "vitest": "2.1.4",
+    "@vitest/browser": "2.1.4"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",