@depup/vitest__coverage-v8 4.1.0-depup.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @depup/vitest__coverage-v8
+
+> Dependency-bumped version of [@vitest/coverage-v8](https://www.npmjs.com/package/@vitest/coverage-v8)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/vitest__coverage-v8
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@vitest/coverage-v8](https://www.npmjs.com/package/@vitest/coverage-v8) @ 4.1.0 |
+| Processed | 2026-03-17 |
+| Smoke test | passed |
+| Deps updated | 1 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| tinyrainbow | ^3.0.3 | ^3.1.0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@vitest/coverage-v8
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,10 @@
+{
+  "bumped": {
+    "tinyrainbow": {
+      "from": "^3.0.3",
+      "to": "^3.1.0"
+    }
+  },
+  "timestamp": "2026-03-17T16:33:54.484Z",
+  "totalUpdated": 1
+}

package/dist/browser.d.ts

@@ -0,0 +1,5 @@
+import { CoverageProviderModule } from 'vitest/node';
+
+declare const mod: CoverageProviderModule;
+
+export { mod as default };

package/dist/browser.js

@@ -0,0 +1,64 @@
+import { cdp } from 'vitest/browser';
+import { l as loadProvider } from './load-provider-CdgAx3rL.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 = [];
+		// Reduce amount of data sent over rpc by doing some early result filtering
+		for (const entry of coverage.result) {
+			if (filterResult(entry)) {
+				result.push({
+					...entry,
+					url: decodeURIComponent(entry.url.replace(window.location.origin, ""))
+				});
+			}
+		}
+		return { result };
+	},
+	stopCoverage() {
+		// Browser mode should not stop coverage as same V8 instance is shared between tests
+	},
+	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("/@id/@vitest/")) {
+		return false;
+	}
+	if (coverage.url.includes("/@vite/client")) {
+		return false;
+	}
+	return true;
+}
+
+export { mod as default };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { CoverageProviderModule } from 'vitest/node';
+
+declare const mod: CoverageProviderModule;
+
+export { mod as default };

package/dist/index.js

@@ -0,0 +1,67 @@
+import inspector from 'node:inspector/promises';
+import { fileURLToPath } from 'node:url';
+import { provider } from 'std-env';
+import { l as loadProvider } from './load-provider-CdgAx3rL.js';
+import { n as normalize } from './pathe.M-eThtNZ-BTaAGrLg.js';
+
+const session = new inspector.Session();
+let enabled = false;
+const mod = {
+	async startCoverage({ isolate }) {
+		if (isolate === false && enabled) {
+			return;
+		}
+		enabled = true;
+		session.connect();
+		await session.post("Profiler.enable");
+		await session.post("Profiler.startPreciseCoverage", {
+			callCount: true,
+			detailed: true
+		});
+	},
+	async takeCoverage(options) {
+		if (provider === "stackblitz") {
+			return { result: [] };
+		}
+		const coverage = await session.post("Profiler.takePreciseCoverage");
+		const result = [];
+		// Reduce amount of data sent over rpc by doing some early result filtering
+		for (const entry of coverage.result) {
+			if (filterResult(entry)) {
+				result.push({
+					...entry,
+					startOffset: options?.moduleExecutionInfo?.get(normalize(fileURLToPath(entry.url)))?.startOffset || 0
+				});
+			}
+		}
+		return { result };
+	},
+	async stopCoverage({ isolate }) {
+		if (isolate === false) {
+			return;
+		}
+		await session.post("Profiler.stopPreciseCoverage");
+		await 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;
+	}
+	if (coverage.url.includes("/@id/@vitest/")) {
+		return false;
+	}
+	if (coverage.url.includes("/@vite/client")) {
+		return false;
+	}
+	return true;
+}
+
+export { mod as default };

package/dist/load-provider-CdgAx3rL.js

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

package/dist/pathe.M-eThtNZ-BTaAGrLg.js

@@ -0,0 +1,104 @@
+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 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);
+};
+
+export { normalize as n };

package/dist/provider.d.ts

@@ -0,0 +1,24 @@
+import { CoverageMap } from 'istanbul-lib-coverage';
+import { ProxifiedModule } from 'magicast';
+import { Profiler } from 'node:inspector';
+import { BaseCoverageProvider, ResolvedCoverageOptions, CoverageProvider, Vitest, ReportContext } from 'vitest/node';
+
+interface ScriptCoverageWithOffset extends Profiler.ScriptCoverage {
+	startOffset: number;
+}
+declare class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOptions<"v8">> implements CoverageProvider {
+	name: "v8";
+	version: string;
+	initialize(ctx: Vitest): void;
+	createCoverageMap(): CoverageMap;
+	generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
+	generateReports(coverageMap: CoverageMap, allTestsRun?: boolean): Promise<void>;
+	parseConfigModule(configFilePath: string): Promise<ProxifiedModule<any>>;
+	private getCoverageMapForUncoveredFiles;
+	private remapCoverage;
+	private getSources;
+	private convertCoverage;
+}
+
+export { V8CoverageProvider };
+export type { ScriptCoverageWithOffset };

package/dist/provider.js

@@ -0,0 +1,297 @@
+import { existsSync, promises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { mergeProcessCovs } from '@bcoe/v8-coverage';
+import astV8ToIstanbul from 'ast-v8-to-istanbul';
+import libCoverage from 'istanbul-lib-coverage';
+import libReport from 'istanbul-lib-report';
+import reports from 'istanbul-reports';
+import { parseModule } from 'magicast';
+import { createDebug } from 'obug';
+import { provider } from 'std-env';
+import c from 'tinyrainbow';
+import { BaseCoverageProvider, parseAstAsync } from 'vitest/node';
+import { n as normalize } from './pathe.M-eThtNZ-BTaAGrLg.js';
+
+var version = "4.1.0";
+
+const FILE_PROTOCOL = "file://";
+const debug = createDebug("vitest:coverage");
+class V8CoverageProvider extends BaseCoverageProvider {
+	name = "v8";
+	version = version;
+	initialize(ctx) {
+		this._initialize(ctx);
+	}
+	createCoverageMap() {
+		return libCoverage.createCoverageMap({});
+	}
+	async generateCoverage({ allTestsRun }) {
+		const start = debug.enabled ? performance.now() : 0;
+		const coverageMap = this.createCoverageMap();
+		let merged = { result: [] };
+		await this.readCoverageFiles({
+			onFileRead(coverage) {
+				merged = mergeProcessCovs([merged, coverage]);
+				// mergeProcessCovs sometimes loses startOffset, e.g. in vue
+				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, environment) => {
+				// Source maps can change based on projectName and transform mode.
+				// Coverage transform re-uses source maps so we need to separate transforms from each other.
+				const converted = await this.convertCoverage(merged, project, environment);
+				coverageMap.merge(converted);
+				merged = { result: [] };
+			},
+			onDebug: debug
+		});
+		// Include untested files when all tests were run (not a single file re-run)
+		// or if previous results are preserved by "cleanOnRerun: false"
+		if (this.options.include != null && (allTestsRun || !this.options.cleanOnRerun)) {
+			const coveredFiles = coverageMap.files();
+			const untestedCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles);
+			coverageMap.merge(untestedCoverage);
+		}
+		coverageMap.filter((filename) => {
+			const exists = existsSync(filename);
+			if (this.options.excludeAfterRemap) {
+				return exists && this.isIncluded(filename);
+			}
+			return exists;
+		});
+		if (debug.enabled) {
+			debug(`Generate coverage total time ${(performance.now() - start).toFixed()} ms`);
+		}
+		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) {
+			// Type assertion required for custom reporters
+			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) {
+		const contents = await promises.readFile(configFilePath, "utf8");
+		return parseModule(`${contents}${this.autoUpdateMarker}`);
+	}
+	async getCoverageMapForUncoveredFiles(testedFiles) {
+		const transform = this.createUncoveredFileTransformer(this.ctx);
+		const uncoveredFiles = await this.getUntestedFiles(testedFiles);
+		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) => {
+				let timeout;
+				let start;
+				if (debug.enabled) {
+					start = performance.now();
+					timeout = setTimeout(() => debug(c.bgRed(`File "${filename}" is taking longer than 3s`)), 3e3);
+				}
+				// Do not use pathToFileURL to avoid encoding filename parts
+				const url = `file://${filename[0] === "/" ? "" : "/"}${filename}`;
+				const sources = await this.getSources(url, transform);
+				coverageMap.merge(await this.remapCoverage(url, 0, sources, []));
+				if (debug.enabled) {
+					clearTimeout(timeout);
+					const diff = performance.now() - start;
+					const color = diff > 500 ? c.bgRed : c.bgGreen;
+					debug(`${color(` ${diff.toFixed()} ms `)} ${filename}`);
+				}
+			}));
+		}
+		return coverageMap;
+	}
+	async remapCoverage(filename, wrapperLength, result, functions) {
+		let ast;
+		try {
+			ast = await parseAstAsync(result.code);
+		} catch (error) {
+			this.ctx.logger.error(`Failed to parse ${filename}. Excluding it from coverage.\n`, error);
+			return {};
+		}
+		return await astV8ToIstanbul({
+			code: result.code,
+			sourceMap: result.map,
+			ast,
+			coverage: {
+				functions,
+				url: filename
+			},
+			ignoreClassMethods: this.options.ignoreClassMethods,
+			wrapperLength,
+			ignoreNode: (node, type) => {
+				// SSR transformed imports
+				if (type === "statement" && node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.id.name.startsWith("__vite_ssr_import_")) {
+					return true;
+				}
+				// SSR transformed exports vite@>6.3.5
+				if (type === "statement" && node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && node.expression.left.type === "MemberExpression" && node.expression.left.object.type === "Identifier" && node.expression.left.object.name === "__vite_ssr_exports__") {
+					return true;
+				}
+				// SSR transformed exports vite@^6.3.5
+				if (type === "statement" && node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.id.name === "__vite_ssr_export_default__") {
+					return true;
+				}
+				// CJS imports as ternaries - e.g.
+				// const React = __vite__cjsImport0_react.__esModule ? __vite__cjsImport0_react.default : __vite__cjsImport0_react;
+				if (type === "branch" && node.type === "ConditionalExpression" && node.test.type === "MemberExpression" && node.test.object.type === "Identifier" && node.test.object.name.startsWith("__vite__cjsImport") && node.test.property.type === "Identifier" && node.test.property.name === "__esModule") {
+					return true;
+				}
+				// in-source test with "if (import.meta.vitest)"
+				if ((type === "branch" || type === "statement") && node.type === "IfStatement" && node.test.type === "MemberExpression" && node.test.property.type === "Identifier" && node.test.property.name === "vitest") {
+					// SSR
+					if (node.test.object.type === "Identifier" && node.test.object.name === "__vite_ssr_import_meta__") {
+						return "ignore-this-and-nested-nodes";
+					}
+					// Web
+					if (node.test.object.type === "MetaProperty" && node.test.object.meta.name === "import" && node.test.object.property.name === "meta") {
+						return "ignore-this-and-nested-nodes";
+					}
+				}
+				// Browser mode's "import.meta.env ="
+				if (type === "statement" && node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && node.expression.left.type === "MemberExpression" && node.expression.left.object.type === "MetaProperty" && node.expression.left.object.meta.name === "import" && node.expression.left.object.property.name === "meta" && node.expression.left.property.type === "Identifier" && node.expression.left.property.name === "env") {
+					return true;
+				}
+				// SSR mode's "import.meta.env ="
+				if (type === "statement" && node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && node.expression.left.type === "MemberExpression" && node.expression.left.object.type === "Identifier" && node.expression.left.object.name === "__vite_ssr_import_meta__") {
+					return true;
+				}
+				// SWC's decorators
+				if (type === "statement" && node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "_ts_decorate") {
+					return "ignore-this-and-nested-nodes";
+				}
+			}
+		});
+	}
+	async getSources(url, onTransform, functions = []) {
+		// TODO: need to standardize file urls before this call somehow, this is messy
+		const filepath = url.match(/^file:\/\/\/\w:\//) ? url.slice(8) : removeStartsWith(url, FILE_PROTOCOL);
+		// TODO: do we still need to "catch" here? why would it fail?
+		const transformResult = await onTransform(filepath).catch(() => null);
+		const map = transformResult?.map;
+		const code = transformResult?.code;
+		if (code == null) {
+			const filePath = normalize(fileURLToPath(url));
+			const original = await promises.readFile(filePath, "utf-8").catch(() => {
+				// If file does not exist construct a dummy source for it.
+				// These can be files that were generated dynamically during the test run and were removed after it.
+				const length = findLongestFunctionLength(functions);
+				return "/".repeat(length);
+			});
+			return { code: original };
+		}
+		// Vue needs special handling for "map.sources"
+		if (map) {
+			map.sources ||= [];
+			map.sources = map.sources.filter((source) => source != null).map((source) => new URL(source, url).href);
+			if (map.sources.length === 0) {
+				map.sources.push(url);
+			}
+		}
+		return {
+			code,
+			map
+		};
+	}
+	async convertCoverage(coverage, project = this.ctx.getRootProject(), environment) {
+		if (environment === "__browser__" && !project.browser) {
+			throw new Error(`Cannot access browser module graph because it was torn down.`);
+		}
+		const onTransform = async (filepath) => {
+			const result = await this.transformFile(filepath, project, environment);
+			if (result && environment === "__browser__" && project.browser) {
+				return {
+					...result,
+					code: `${result.code}// <inline-source-map>`
+				};
+			}
+			return result;
+		};
+		const scriptCoverages = [];
+		for (const result of coverage.result) {
+			if (environment === "__browser__") {
+				if (result.url.startsWith("/@fs")) {
+					result.url = `${FILE_PROTOCOL}${removeStartsWith(result.url, "/@fs")}`;
+				} else if (result.url.startsWith(project.config.root)) {
+					result.url = `${FILE_PROTOCOL}${result.url}`;
+				} else {
+					result.url = `${FILE_PROTOCOL}${project.config.root}${result.url}`;
+				}
+			}
+			if (this.isIncluded(fileURLToPath(result.url))) {
+				scriptCoverages.push({
+					...result,
+					url: decodeURIComponent(result.url)
+				});
+			}
+		}
+		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 }) => {
+				let timeout;
+				let start;
+				if (debug.enabled) {
+					start = performance.now();
+					timeout = setTimeout(() => debug(c.bgRed(`File "${fileURLToPath(url)}" is taking longer than 3s`)), 3e3);
+				}
+				const sources = await this.getSources(url, onTransform, functions);
+				coverageMap.merge(await this.remapCoverage(url, startOffset, sources, functions));
+				if (debug.enabled) {
+					clearTimeout(timeout);
+					const diff = performance.now() - start;
+					const color = diff > 500 ? c.bgRed : c.bgGreen;
+					debug(`${color(` ${diff.toFixed()} ms `)} ${fileURLToPath(url)}`);
+				}
+			}));
+		}
+		return coverageMap;
+	}
+}
+/**
+* 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);
+}
+function removeStartsWith(filepath, start) {
+	if (filepath.startsWith(start)) {
+		return filepath.slice(start.length);
+	}
+	return filepath;
+}
+
+export { V8CoverageProvider };

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@depup/vitest__coverage-v8",
+  "type": "module",
+  "version": "4.1.0-depup.0",
+  "description": "[DepUp] V8 coverage provider for Vitest",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://vitest.dev/guide/coverage",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/coverage-v8"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@vitest/coverage-v8",
+    "vite",
+    "vitest",
+    "test",
+    "coverage",
+    "v8"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "changes.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@vitest/browser": "4.1.0",
+    "vitest": "4.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@vitest/browser": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@bcoe/v8-coverage": "^1.0.2",
+    "ast-v8-to-istanbul": "^1.0.0",
+    "istanbul-lib-coverage": "^3.2.2",
+    "istanbul-lib-report": "^3.0.1",
+    "istanbul-reports": "^3.2.0",
+    "magicast": "^0.5.2",
+    "obug": "^2.1.1",
+    "std-env": "^4.0.0-rc.1",
+    "tinyrainbow": "^3.1.0",
+    "@vitest/utils": "4.1.0"
+  },
+  "devDependencies": {
+    "@types/istanbul-lib-coverage": "^2.0.6",
+    "@types/istanbul-lib-report": "^3.0.3",
+    "@types/istanbul-reports": "^3.0.4",
+    "pathe": "^2.0.3",
+    "vitest": "4.1.0",
+    "@vitest/browser-playwright": "4.1.0",
+    "@vitest/browser": "4.1.0"
+  },
+  "scripts": {
+    "build": "premove dist && rollup -c",
+    "dev": "rollup -c --watch --watch.include 'src/**'"
+  },
+  "depup": {
+    "changes": {
+      "tinyrainbow": {
+        "from": "^3.0.3",
+        "to": "^3.1.0"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "@vitest/coverage-v8",
+    "originalVersion": "4.1.0",
+    "processedAt": "2026-03-17T16:33:59.211Z",
+    "smokeTest": "passed"
+  }
+}