@vitest/coverage-v8 3.1.0-beta.1 → 3.1.0

package/dist/browser.js

@@ -1,59 +1,58 @@
 import { cdp } from '@vitest/browser/context';
-import { l as loadProvider } from './load-provider-Bl5rgjsL.js';
+import { l as loadProvider } from './load-provider-pEnu7lco.js';
 
 const session = cdp();
 let enabled = false;
 const mod = {
-  async startCoverage() {
-    if (enabled) {
-      return;
-    }
-    enabled = true;
-    await session.send("Profiler.enable");
-    await session.send("Profiler.startPreciseCoverage", {
-      callCount: true,
-      detailed: true
-    });
-  },
-  async takeCoverage() {
-    const coverage = await session.send("Profiler.takePreciseCoverage");
-    const result = [];
-    for (const entry of coverage.result) {
-      if (filterResult(entry)) {
-        result.push({
-          ...entry,
-          url: decodeURIComponent(entry.url.replace(window.location.origin, ""))
-        });
-      }
-    }
-    return { result };
-  },
-  stopCoverage() {
-  },
-  async getProvider() {
-    return loadProvider();
-  }
+	async startCoverage() {
+		if (enabled) {
+			return;
+		}
+		enabled = true;
+		await session.send("Profiler.enable");
+		await session.send("Profiler.startPreciseCoverage", {
+			callCount: true,
+			detailed: true
+		});
+	},
+	async takeCoverage() {
+		const coverage = await session.send("Profiler.takePreciseCoverage");
+		const result = [];
+		for (const entry of coverage.result) {
+			if (filterResult(entry)) {
+				result.push({
+					...entry,
+					url: decodeURIComponent(entry.url.replace(window.location.origin, ""))
+				});
+			}
+		}
+		return { result };
+	},
+	stopCoverage() {},
+	async getProvider() {
+		return loadProvider();
+	}
 };
 function filterResult(coverage) {
-  if (!coverage.url.startsWith(window.location.origin)) {
-    return false;
-  }
-  if (coverage.url.includes("/node_modules/")) {
-    return false;
-  }
-  if (coverage.url.includes("__vitest_browser__")) {
-    return false;
-  }
-  if (coverage.url.includes("__vitest__/assets")) {
-    return false;
-  }
-  if (coverage.url === window.location.href) {
-    return false;
-  }
-  if (coverage.url.includes("?browserv=") || coverage.url.includes("&browserv=")) {
-    return false;
-  }
-  return true;
+	if (!coverage.url.startsWith(window.location.origin)) {
+		return false;
+	}
+	if (coverage.url.includes("/node_modules/")) {
+		return false;
+	}
+	if (coverage.url.includes("__vitest_browser__")) {
+		return false;
+	}
+	if (coverage.url.includes("__vitest__/assets")) {
+		return false;
+	}
+	if (coverage.url === window.location.href) {
+		return false;
+	}
+	if (coverage.url.includes("?browserv=") || coverage.url.includes("&browserv=")) {
+		return false;
+	}
+	return true;
 }
 
 export { mod as default };

package/dist/index.js

@@ -1,60 +1,60 @@
 import inspector from 'node:inspector';
 import { fileURLToPath } from 'node:url';
 import { provider } from 'std-env';
-import { l as loadProvider } from './load-provider-Bl5rgjsL.js';
+import { l as loadProvider } from './load-provider-pEnu7lco.js';
 
 const session = new inspector.Session();
 let enabled = false;
 const mod = {
-  startCoverage({ isolate }) {
-    if (isolate === false && enabled) {
-      return;
-    }
-    enabled = true;
-    session.connect();
-    session.post("Profiler.enable");
-    session.post("Profiler.startPreciseCoverage", {
-      callCount: true,
-      detailed: true
-    });
-  },
-  takeCoverage(options) {
-    return new Promise((resolve, reject) => {
-      session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
-        if (error) {
-          return reject(error);
-        }
-        const result = coverage.result.filter(filterResult).map((res) => ({
-          ...res,
-          startOffset: options?.moduleExecutionInfo?.get(fileURLToPath(res.url))?.startOffset || 0
-        }));
-        resolve({ result });
-      });
-      if (provider === "stackblitz") {
-        resolve({ result: [] });
-      }
-    });
-  },
-  stopCoverage({ isolate }) {
-    if (isolate === false) {
-      return;
-    }
-    session.post("Profiler.stopPreciseCoverage");
-    session.post("Profiler.disable");
-    session.disconnect();
-  },
-  async getProvider() {
-    return loadProvider();
-  }
+	startCoverage({ isolate }) {
+		if (isolate === false && enabled) {
+			return;
+		}
+		enabled = true;
+		session.connect();
+		session.post("Profiler.enable");
+		session.post("Profiler.startPreciseCoverage", {
+			callCount: true,
+			detailed: true
+		});
+	},
+	takeCoverage(options) {
+		return new Promise((resolve, reject) => {
+			session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
+				if (error) {
+					return reject(error);
+				}
+				const result = coverage.result.filter(filterResult).map((res) => ({
+					...res,
+					startOffset: options?.moduleExecutionInfo?.get(fileURLToPath(res.url))?.startOffset || 0
+				}));
+				resolve({ result });
+			});
+			if (provider === "stackblitz") {
+				resolve({ result: [] });
+			}
+		});
+	},
+	stopCoverage({ isolate }) {
+		if (isolate === false) {
+			return;
+		}
+		session.post("Profiler.stopPreciseCoverage");
+		session.post("Profiler.disable");
+		session.disconnect();
+	},
+	async getProvider() {
+		return loadProvider();
+	}
 };
 function filterResult(coverage) {
-  if (!coverage.url.startsWith("file://")) {
-    return false;
-  }
-  if (coverage.url.includes("/node_modules/")) {
-    return false;
-  }
-  return true;
+	if (!coverage.url.startsWith("file://")) {
+		return false;
+	}
+	if (coverage.url.includes("/node_modules/")) {
+		return false;
+	}
+	return true;
 }
 
 export { mod as default };

package/dist/load-provider-pEnu7lco.js

@@ -0,0 +1,10 @@
+const name = "./provider.js";
+async function loadProvider() {
+	const { V8CoverageProvider } = await import(
+		/* @vite-ignore */
+		name
+);
+	return new V8CoverageProvider();
+}
+
+export { loadProvider as l };

package/dist/provider.d.ts

@@ -22,4 +22,5 @@ declare class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOp
 	private convertCoverage;
 }
 
-export { type ScriptCoverageWithOffset, V8CoverageProvider };
+export { V8CoverageProvider };
+export type { ScriptCoverageWithOffset };

package/dist/provider.js

@@ -2520,323 +2520,283 @@ const drive = isWindows ? process.cwd()[0] : null;
 drive ? drive === drive.toUpperCase() ? drive.toLowerCase() : drive.toUpperCase() : null;
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
-  return url.replace(postfixRE, "");
+	return url.replace(postfixRE, "");
 }
-/* @__PURE__ */ new Set([
-  ...builtinModules,
-  "assert/strict",
-  "diagnostics_channel",
-  "dns/promises",
-  "fs/promises",
-  "path/posix",
-  "path/win32",
-  "readline/promises",
-  "stream/consumers",
-  "stream/promises",
-  "stream/web",
-  "timers/promises",
-  "util/types",
-  "wasi"
+new Set([
+	...builtinModules,
+	"assert/strict",
+	"diagnostics_channel",
+	"dns/promises",
+	"fs/promises",
+	"path/posix",
+	"path/win32",
+	"readline/promises",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"timers/promises",
+	"util/types",
+	"wasi"
 ]);
 
-var version = "3.1.0-beta.1";
+var version = "3.1.0";
 
 const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
 const DECORATOR_METADATA_PATTERN = /_ts_metadata\("design:paramtypes", \[[^\]]*\]\),*/g;
 const FILE_PROTOCOL = "file://";
 const debug = createDebug("vitest:coverage");
 class V8CoverageProvider extends BaseCoverageProvider {
-  name = "v8";
-  version = version;
-  testExclude;
-  initialize(ctx) {
-    this._initialize(ctx);
-    this.testExclude = new TestExclude({
-      cwd: ctx.config.root,
-      include: this.options.include,
-      exclude: this.options.exclude,
-      excludeNodeModules: true,
-      extension: this.options.extension,
-      relativePath: !this.options.allowExternal
-    });
-  }
-  createCoverageMap() {
-    return libCoverage.createCoverageMap({});
-  }
-  async generateCoverage({ allTestsRun }) {
-    const coverageMap = this.createCoverageMap();
-    let merged = { result: [] };
-    await this.readCoverageFiles({
-      onFileRead(coverage) {
-        merged = mergeProcessCovs([merged, coverage]);
-        merged.result.forEach((result) => {
-          if (!result.startOffset) {
-            const original = coverage.result.find((r) => r.url === result.url);
-            result.startOffset = original?.startOffset || 0;
-          }
-        });
-      },
-      onFinished: async (project, transformMode) => {
-        const converted = await this.convertCoverage(
-          merged,
-          project,
-          transformMode
-        );
-        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);
-      coverageMap.merge(await transformCoverage(untestedCoverage));
-    }
-    if (this.options.excludeAfterRemap) {
-      coverageMap.filter((filename) => this.testExclude.shouldInstrument(filename));
-    }
-    return coverageMap;
-  }
-  async generateReports(coverageMap, allTestsRun) {
-    if (provider === "stackblitz") {
-      this.ctx.logger.log(
-        c.blue(" % ") + c.yellow(
-          "@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."
-        )
-      );
-    }
-    const context = libReport.createContext({
-      dir: this.options.reportsDirectory,
-      coverageMap,
-      watermarks: this.options.watermarks
-    });
-    if (this.hasTerminalReporter(this.options.reporter)) {
-      this.ctx.logger.log(
-        c.blue(" % ") + c.dim("Coverage report from ") + c.yellow(this.name)
-      );
-    }
-    for (const reporter of this.options.reporter) {
-      reports.create(reporter[0], {
-        skipFull: this.options.skipFull,
-        projectRoot: this.ctx.config.root,
-        ...reporter[1]
-      }).execute(context);
-    }
-    if (this.options.thresholds) {
-      await this.reportThresholds(coverageMap, allTestsRun);
-    }
-  }
-  async parseConfigModule(configFilePath) {
-    return parseModule(
-      await promises.readFile(configFilePath, "utf8")
-    );
-  }
-  async getUntestedFiles(testedFiles) {
-    const transformResults = normalizeTransformResults(
-      this.ctx.vitenode.fetchCache
-    );
-    const transform = this.createUncoveredFileTransformer(this.ctx);
-    const allFiles = await this.testExclude.glob(this.ctx.config.root);
-    let includedFiles = allFiles.map(
-      (file) => resolve(this.ctx.config.root, file)
-    );
-    if (this.ctx.config.changed) {
-      includedFiles = (this.ctx.config.related || []).filter(
-        (file) => includedFiles.includes(file)
-      );
-    }
-    const uncoveredFiles = includedFiles.map((file) => pathToFileURL(file)).filter((file) => !testedFiles.includes(file.pathname));
-    let index = 0;
-    const coverageMap = this.createCoverageMap();
-    for (const chunk of this.toSlices(uncoveredFiles, this.options.processingConcurrency)) {
-      if (debug.enabled) {
-        index += chunk.length;
-        debug("Uncovered files %d/%d", index, uncoveredFiles.length);
-      }
-      await Promise.all(chunk.map(async (filename) => {
-        const sources = await this.getSources(
-          filename.href,
-          transformResults,
-          transform
-        );
-        const converter = v8ToIstanbul(
-          filename.href,
-          0,
-          sources,
-          void 0,
-          this.options.ignoreEmptyLines
-        );
-        await converter.load();
-        try {
-          converter.applyCoverage([{
-            ranges: [
-              {
-                startOffset: 0,
-                endOffset: sources.originalSource.length,
-                count: 0
-              }
-            ],
-            isBlockCoverage: true,
-            // This is magical value that indicates an empty report: https://github.com/istanbuljs/v8-to-istanbul/blob/fca5e6a9e6ef38a9cdc3a178d5a6cf9ef82e6cab/lib/v8-to-istanbul.js#LL131C40-L131C40
-            functionName: "(empty-report)"
-          }]);
-        } catch (error) {
-          this.ctx.logger.error(`Failed to convert coverage for uncovered ${filename.href}.
-`, error);
-        }
-        coverageMap.merge(converter.toIstanbul());
-      }));
-    }
-    return coverageMap;
-  }
-  async getSources(url, transformResults, onTransform, functions = []) {
-    const filePath = normalize(fileURLToPath(url));
-    let transformResult = transformResults.get(filePath);
-    if (!transformResult) {
-      transformResult = await onTransform(removeStartsWith(url, FILE_PROTOCOL)).catch(() => void 0);
-    }
-    const map = transformResult?.map;
-    const code = transformResult?.code;
-    const sourcesContent = map?.sourcesContent || [];
-    if (!sourcesContent[0]) {
-      sourcesContent[0] = await promises.readFile(filePath, "utf-8").catch(() => {
-        const length = findLongestFunctionLength(functions);
-        return ".".repeat(length);
-      });
-    }
-    if (!map) {
-      return {
-        source: code || sourcesContent[0],
-        originalSource: sourcesContent[0]
-      };
-    }
-    const sources = (map.sources || []).filter((source) => source != null).map((source) => new URL(source, url).href);
-    if (sources.length === 0) {
-      sources.push(url);
-    }
-    return {
-      originalSource: sourcesContent[0],
-      source: code || sourcesContent[0],
-      sourceMap: {
-        sourcemap: excludeGeneratedCode(code, {
-          ...map,
-          version: 3,
-          sources,
-          sourcesContent
-        })
-      }
-    };
-  }
-  async convertCoverage(coverage, project = this.ctx.getRootProject(), transformMode) {
-    let fetchCache = project.vitenode.fetchCache;
-    if (transformMode) {
-      fetchCache = transformMode === "browser" ? /* @__PURE__ */ new Map() : project.vitenode.fetchCaches[transformMode];
-    }
-    const transformResults = normalizeTransformResults(fetchCache);
-    async function onTransform(filepath) {
-      if (transformMode === "browser" && project.browser) {
-        const result = await project.browser.vite.transformRequest(removeStartsWith(filepath, project.config.root));
-        if (result) {
-          return { ...result, code: `${result.code}// <inline-source-map>` };
-        }
-      }
-      return project.vitenode.transformRequest(filepath);
-    }
-    const scriptCoverages = [];
-    for (const result of coverage.result) {
-      if (transformMode === "browser") {
-        if (result.url.startsWith("/@fs")) {
-          result.url = `${FILE_PROTOCOL}${removeStartsWith(result.url, "/@fs")}`;
-        } else {
-          result.url = `${FILE_PROTOCOL}${project.config.root}${result.url}`;
-        }
-      }
-      if (this.testExclude.shouldInstrument(fileURLToPath(result.url))) {
-        scriptCoverages.push(result);
-      }
-    }
-    const coverageMap = this.createCoverageMap();
-    let index = 0;
-    for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
-      if (debug.enabled) {
-        index += chunk.length;
-        debug("Converting %d/%d", index, scriptCoverages.length);
-      }
-      await Promise.all(
-        chunk.map(async ({ url, functions, startOffset }) => {
-          const sources = await this.getSources(
-            url,
-            transformResults,
-            onTransform,
-            functions
-          );
-          const converter = v8ToIstanbul(
-            url,
-            startOffset,
-            sources,
-            void 0,
-            this.options.ignoreEmptyLines
-          );
-          await converter.load();
-          try {
-            converter.applyCoverage(functions);
-          } catch (error) {
-            this.ctx.logger.error(`Failed to convert coverage for ${url}.
-`, error);
-          }
-          coverageMap.merge(converter.toIstanbul());
-        })
-      );
-    }
-    return coverageMap;
-  }
+	name = "v8";
+	version = version;
+	testExclude;
+	initialize(ctx) {
+		this._initialize(ctx);
+		this.testExclude = new TestExclude({
+			cwd: ctx.config.root,
+			include: this.options.include,
+			exclude: this.options.exclude,
+			excludeNodeModules: true,
+			extension: this.options.extension,
+			relativePath: !this.options.allowExternal
+		});
+	}
+	createCoverageMap() {
+		return libCoverage.createCoverageMap({});
+	}
+	async generateCoverage({ allTestsRun }) {
+		const coverageMap = this.createCoverageMap();
+		let merged = { result: [] };
+		await this.readCoverageFiles({
+			onFileRead(coverage) {
+				merged = mergeProcessCovs([merged, coverage]);
+				merged.result.forEach((result) => {
+					if (!result.startOffset) {
+						const original = coverage.result.find((r) => r.url === result.url);
+						result.startOffset = original?.startOffset || 0;
+					}
+				});
+			},
+			onFinished: async (project, transformMode) => {
+				const converted = await this.convertCoverage(merged, project, transformMode);
+				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);
+			coverageMap.merge(await transformCoverage(untestedCoverage));
+		}
+		if (this.options.excludeAfterRemap) {
+			coverageMap.filter((filename) => this.testExclude.shouldInstrument(filename));
+		}
+		return coverageMap;
+	}
+	async generateReports(coverageMap, allTestsRun) {
+		if (provider === "stackblitz") {
+			this.ctx.logger.log(c.blue(" % ") + c.yellow("@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."));
+		}
+		const context = libReport.createContext({
+			dir: this.options.reportsDirectory,
+			coverageMap,
+			watermarks: this.options.watermarks
+		});
+		if (this.hasTerminalReporter(this.options.reporter)) {
+			this.ctx.logger.log(c.blue(" % ") + c.dim("Coverage report from ") + c.yellow(this.name));
+		}
+		for (const reporter of this.options.reporter) {
+			reports.create(reporter[0], {
+				skipFull: this.options.skipFull,
+				projectRoot: this.ctx.config.root,
+				...reporter[1]
+			}).execute(context);
+		}
+		if (this.options.thresholds) {
+			await this.reportThresholds(coverageMap, allTestsRun);
+		}
+	}
+	async parseConfigModule(configFilePath) {
+		return parseModule(await promises.readFile(configFilePath, "utf8"));
+	}
+	async getUntestedFiles(testedFiles) {
+		const transformResults = normalizeTransformResults(this.ctx.vitenode.fetchCache);
+		const transform = this.createUncoveredFileTransformer(this.ctx);
+		const allFiles = await this.testExclude.glob(this.ctx.config.root);
+		let includedFiles = allFiles.map((file) => resolve(this.ctx.config.root, file));
+		if (this.ctx.config.changed) {
+			includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
+		}
+		const uncoveredFiles = includedFiles.map((file) => pathToFileURL(file)).filter((file) => !testedFiles.includes(file.pathname));
+		let index = 0;
+		const coverageMap = this.createCoverageMap();
+		for (const chunk of this.toSlices(uncoveredFiles, this.options.processingConcurrency)) {
+			if (debug.enabled) {
+				index += chunk.length;
+				debug("Uncovered files %d/%d", index, uncoveredFiles.length);
+			}
+			await Promise.all(chunk.map(async (filename) => {
+				const sources = await this.getSources(filename.href, transformResults, transform);
+				const converter = v8ToIstanbul(filename.href, 0, sources, undefined, this.options.ignoreEmptyLines);
+				await converter.load();
+				try {
+					converter.applyCoverage([{
+						ranges: [{
+							startOffset: 0,
+							endOffset: sources.originalSource.length,
+							count: 0
+						}],
+						isBlockCoverage: true,
+						functionName: "(empty-report)"
+					}]);
+				} catch (error) {
+					this.ctx.logger.error(`Failed to convert coverage for uncovered ${filename.href}.\n`, error);
+				}
+				coverageMap.merge(converter.toIstanbul());
+			}));
+		}
+		return coverageMap;
+	}
+	async getSources(url, transformResults, onTransform, functions = []) {
+		const filePath = normalize(fileURLToPath(url));
+		let transformResult = transformResults.get(filePath);
+		if (!transformResult) {
+			transformResult = await onTransform(removeStartsWith(url, FILE_PROTOCOL)).catch(() => undefined);
+		}
+		const map = transformResult?.map;
+		const code = transformResult?.code;
+		const sourcesContent = map?.sourcesContent || [];
+		if (!sourcesContent[0]) {
+			sourcesContent[0] = await promises.readFile(filePath, "utf-8").catch(() => {
+				const length = findLongestFunctionLength(functions);
+				return ".".repeat(length);
+			});
+		}
+		if (!map) {
+			return {
+				source: code || sourcesContent[0],
+				originalSource: sourcesContent[0]
+			};
+		}
+		const sources = (map.sources || []).filter((source) => source != null).map((source) => new URL(source, url).href);
+		if (sources.length === 0) {
+			sources.push(url);
+		}
+		return {
+			originalSource: sourcesContent[0],
+			source: code || sourcesContent[0],
+			sourceMap: { sourcemap: excludeGeneratedCode(code, {
+				...map,
+				version: 3,
+				sources,
+				sourcesContent
+			}) }
+		};
+	}
+	async convertCoverage(coverage, project = this.ctx.getRootProject(), transformMode) {
+		let fetchCache = project.vitenode.fetchCache;
+		if (transformMode) {
+			fetchCache = transformMode === "browser" ? new Map() : project.vitenode.fetchCaches[transformMode];
+		}
+		const transformResults = normalizeTransformResults(fetchCache);
+		async function onTransform(filepath) {
+			if (transformMode === "browser" && project.browser) {
+				const result = await project.browser.vite.transformRequest(removeStartsWith(filepath, project.config.root));
+				if (result) {
+					return {
+						...result,
+						code: `${result.code}// <inline-source-map>`
+					};
+				}
+			}
+			return project.vitenode.transformRequest(filepath);
+		}
+		const scriptCoverages = [];
+		for (const result of coverage.result) {
+			if (transformMode === "browser") {
+				if (result.url.startsWith("/@fs")) {
+					result.url = `${FILE_PROTOCOL}${removeStartsWith(result.url, "/@fs")}`;
+				} else {
+					result.url = `${FILE_PROTOCOL}${project.config.root}${result.url}`;
+				}
+			}
+			if (this.testExclude.shouldInstrument(fileURLToPath(result.url))) {
+				scriptCoverages.push(result);
+			}
+		}
+		const coverageMap = this.createCoverageMap();
+		let index = 0;
+		for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
+			if (debug.enabled) {
+				index += chunk.length;
+				debug("Converting %d/%d", index, scriptCoverages.length);
+			}
+			await Promise.all(chunk.map(async ({ url, functions, startOffset }) => {
+				const sources = await this.getSources(url, transformResults, onTransform, functions);
+				const converter = v8ToIstanbul(url, startOffset, sources, undefined, this.options.ignoreEmptyLines);
+				await converter.load();
+				try {
+					converter.applyCoverage(functions);
+				} catch (error) {
+					this.ctx.logger.error(`Failed to convert coverage for ${url}.\n`, error);
+				}
+				coverageMap.merge(converter.toIstanbul());
+			}));
+		}
+		return coverageMap;
+	}
 }
 async function transformCoverage(coverageMap) {
-  const sourceMapStore = libSourceMaps.createSourceMapStore();
-  return await sourceMapStore.transformCoverage(coverageMap);
+	const sourceMapStore = libSourceMaps.createSourceMapStore();
+	return await sourceMapStore.transformCoverage(coverageMap);
 }
+/**
+* Remove generated code from the source maps:
+* - Vite's export helpers: e.g. `Object.defineProperty(__vite_ssr_exports__, "sum", { enumerable: true, configurable: true, get(){ return sum }});`
+* - SWC's decorator metadata: e.g. `_ts_metadata("design:paramtypes", [\ntypeof Request === "undefined" ? Object : Request\n]),`
+*/
 function excludeGeneratedCode(source, map) {
-  if (!source) {
-    return map;
-  }
-  if (!source.match(VITE_EXPORTS_LINE_PATTERN) && !source.match(DECORATOR_METADATA_PATTERN)) {
-    return map;
-  }
-  const trimmed = new MagicString(source);
-  trimmed.replaceAll(VITE_EXPORTS_LINE_PATTERN, "\n");
-  trimmed.replaceAll(DECORATOR_METADATA_PATTERN, (match) => "\n".repeat(match.split("\n").length - 1));
-  const trimmedMap = trimmed.generateMap({ hires: "boundary" });
-  const combinedMap = remapping(
-    [{ ...trimmedMap, version: 3 }, map],
-    () => null
-  );
-  return combinedMap;
+	if (!source) {
+		return map;
+	}
+	if (!source.match(VITE_EXPORTS_LINE_PATTERN) && !source.match(DECORATOR_METADATA_PATTERN)) {
+		return map;
+	}
+	const trimmed = new MagicString(source);
+	trimmed.replaceAll(VITE_EXPORTS_LINE_PATTERN, "\n");
+	trimmed.replaceAll(DECORATOR_METADATA_PATTERN, (match) => "\n".repeat(match.split("\n").length - 1));
+	const trimmedMap = trimmed.generateMap({ hires: "boundary" });
+	const combinedMap = remapping([{
+		...trimmedMap,
+		version: 3
+	}, map], () => null);
+	return combinedMap;
 }
+/**
+* Find the function with highest `endOffset` to determine the length of the file
+*/
 function findLongestFunctionLength(functions) {
-  return functions.reduce((previous, current) => {
-    const maxEndOffset = current.ranges.reduce(
-      (endOffset, range) => Math.max(endOffset, range.endOffset),
-      0
-    );
-    return Math.max(previous, maxEndOffset);
-  }, 0);
+	return functions.reduce((previous, current) => {
+		const maxEndOffset = current.ranges.reduce((endOffset, range) => Math.max(endOffset, range.endOffset), 0);
+		return Math.max(previous, maxEndOffset);
+	}, 0);
 }
 function normalizeTransformResults(fetchCache) {
-  const normalized = /* @__PURE__ */ new Map();
-  for (const [key, value] of fetchCache.entries()) {
-    const cleanEntry = cleanUrl(key);
-    if (!normalized.has(cleanEntry)) {
-      normalized.set(cleanEntry, value.result);
-    }
-  }
-  return normalized;
+	const normalized = new Map();
+	for (const [key, value] of fetchCache.entries()) {
+		const cleanEntry = cleanUrl(key);
+		if (!normalized.has(cleanEntry)) {
+			normalized.set(cleanEntry, value.result);
+		}
+	}
+	return normalized;
 }
 function removeStartsWith(filepath, start) {
-  if (filepath.startsWith(start)) {
-    return filepath.slice(start.length);
-  }
-  return filepath;
+	if (filepath.startsWith(start)) {
+		return filepath.slice(start.length);
+	}
+	return filepath;
 }
 
 export { V8CoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "3.1.0-beta.1",
+  "version": "3.1.0",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -41,8 +41,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@vitest/browser": "3.1.0-beta.1",
-    "vitest": "3.1.0-beta.1"
+    "@vitest/browser": "3.1.0",
+    "vitest": "3.1.0"
   },
   "peerDependenciesMeta": {
     "@vitest/browser": {
@@ -59,7 +59,7 @@
     "istanbul-reports": "^3.1.7",
     "magic-string": "^0.30.17",
     "magicast": "^0.3.5",
-    "std-env": "^3.8.0",
+    "std-env": "^3.8.1",
     "test-exclude": "^7.0.1",
     "tinyrainbow": "^2.0.0"
   },
@@ -72,9 +72,9 @@
     "@types/test-exclude": "^6.0.2",
     "pathe": "^2.0.3",
     "v8-to-istanbul": "^9.3.0",
-    "@vitest/browser": "3.1.0-beta.1",
-    "vitest": "3.1.0-beta.1",
-    "vite-node": "3.1.0-beta.1"
+    "vite-node": "3.1.0",
+    "@vitest/browser": "3.1.0",
+    "vitest": "3.1.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/dist/load-provider-Bl5rgjsL.js

@@ -1,10 +0,0 @@
-const name = "./provider.js";
-async function loadProvider() {
-  const { V8CoverageProvider } = await import(
-    /* @vite-ignore */
-    name
-  );
-  return new V8CoverageProvider();
-}
-
-export { loadProvider as l };