@vitest/coverage-v8 2.0.0-beta.9 → 2.0.0

package/dist/index.js

@@ -13,13 +13,15 @@ function startCoverage() {
 async function takeCoverage() {
   return new Promise((resolve, reject) => {
     session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
-      if (error)
+      if (error) {
         return reject(error);
+      }
       const result = coverage.result.filter(filterResult);
       resolve({ result });
     });
-    if (provider === "stackblitz")
+    if (provider === "stackblitz") {
       resolve({ result: [] });
+    }
   });
 }
 function stopCoverage() {
@@ -28,10 +30,12 @@ function stopCoverage() {
   session.disconnect();
 }
 function filterResult(coverage) {
-  if (!coverage.url.startsWith("file://"))
+  if (!coverage.url.startsWith("file://")) {
     return false;
-  if (coverage.url.includes("/node_modules/"))
+  }
+  if (coverage.url.includes("/node_modules/")) {
     return false;
+  }
   return true;
 }
 

package/dist/provider.js

@@ -19,7 +19,7 @@ import { provider } from 'std-env';
 import { stripLiteral } from 'strip-literal';
 import createDebug from 'debug';
 import { builtinModules } from 'node:module';
-import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
+import { coverageConfigDefaults } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import _TestExclude from 'test-exclude';
 
@@ -884,17 +884,13 @@ function requireTraceMapping_umd () {
 		(function (global, factory) {
 		    factory(exports, requireSourcemapCodec_umd(), requireResolveUri_umd()) ;
 		})(commonjsGlobal, (function (exports, sourcemapCodec, resolveUri) {
-		    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-		    var resolveUri__default = /*#__PURE__*/_interopDefaultLegacy(resolveUri);
-
 		    function resolve(input, base) {
 		        // The base is always treated as a directory, if it's not empty.
 		        // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
 		        // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
 		        if (base && !base.endsWith('/'))
 		            base += '/';
-		        return resolveUri__default["default"](input, base);
+		        return resolveUri(input, base);
 		    }
 
 		    /**
@@ -1054,8 +1050,9 @@ function requireTraceMapping_umd () {
 		                // segment should go. Either way, we want to insert after that. And there may be multiple
 		                // generated segments associated with an original location, so there may need to move several
 		                // indexes before we find where we need to insert.
-		                const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
-		                insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
+		                let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+		                memo.lastIndex = ++index;
+		                insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
 		            }
 		        }
 		        return sources;
@@ -1076,14 +1073,16 @@ function requireTraceMapping_umd () {
 		    }
 
 		    const AnyMap = function (map, mapUrl) {
-		        const parsed = typeof map === 'string' ? JSON.parse(map) : map;
-		        if (!('sections' in parsed))
+		        const parsed = parse(map);
+		        if (!('sections' in parsed)) {
 		            return new TraceMap(parsed, mapUrl);
+		        }
 		        const mappings = [];
 		        const sources = [];
 		        const sourcesContent = [];
 		        const names = [];
-		        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
+		        const ignoreList = [];
+		        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
 		        const joined = {
 		            version: 3,
 		            file: parsed.file,
@@ -1091,10 +1090,14 @@ function requireTraceMapping_umd () {
 		            sources,
 		            sourcesContent,
 		            mappings,
+		            ignoreList,
 		        };
-		        return exports.presortedDecodedMap(joined);
+		        return presortedDecodedMap(joined);
 		    };
-		    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
+		    function parse(map) {
+		        return typeof map === 'string' ? JSON.parse(map) : map;
+		    }
+		    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
 		        const { sections } = input;
 		        for (let i = 0; i < sections.length; i++) {
 		            const { map, offset } = sections[i];
@@ -1110,17 +1113,18 @@ function requireTraceMapping_umd () {
 		                    sc = columnOffset + nextOffset.column;
 		                }
 		            }
-		            addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+		            addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
 		        }
 		    }
-		    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
-		        if ('sections' in input)
+		    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+		        const parsed = parse(input);
+		        if ('sections' in parsed)
 		            return recurse(...arguments);
-		        const map = new TraceMap(input, mapUrl);
+		        const map = new TraceMap(parsed, mapUrl);
 		        const sourcesOffset = sources.length;
 		        const namesOffset = names.length;
-		        const decoded = exports.decodedMappings(map);
-		        const { resolvedSources, sourcesContent: contents } = map;
+		        const decoded = decodedMappings(map);
+		        const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
 		        append(sources, resolvedSources);
 		        append(names, map.names);
 		        if (contents)
@@ -1128,6 +1132,9 @@ function requireTraceMapping_umd () {
 		        else
 		            for (let i = 0; i < resolvedSources.length; i++)
 		                sourcesContent.push(null);
+		        if (ignores)
+		            for (let i = 0; i < ignores.length; i++)
+		                ignoreList.push(ignores[i] + sourcesOffset);
 		        for (let i = 0; i < decoded.length; i++) {
 		            const lineI = lineOffset + i;
 		            // We can only add so many lines before we step into the range that the next section's map
@@ -1177,208 +1184,198 @@ function requireTraceMapping_umd () {
 		    const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
 		    const LEAST_UPPER_BOUND = -1;
 		    const GREATEST_LOWER_BOUND = 1;
+		    class TraceMap {
+		        constructor(map, mapUrl) {
+		            const isString = typeof map === 'string';
+		            if (!isString && map._decodedMemo)
+		                return map;
+		            const parsed = (isString ? JSON.parse(map) : map);
+		            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		            this.version = version;
+		            this.file = file;
+		            this.names = names || [];
+		            this.sourceRoot = sourceRoot;
+		            this.sources = sources;
+		            this.sourcesContent = sourcesContent;
+		            this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+		            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+		            this.resolvedSources = sources.map((s) => resolve(s || '', from));
+		            const { mappings } = parsed;
+		            if (typeof mappings === 'string') {
+		                this._encoded = mappings;
+		                this._decoded = undefined;
+		            }
+		            else {
+		                this._encoded = undefined;
+		                this._decoded = maybeSort(mappings, isString);
+		            }
+		            this._decodedMemo = memoizedState();
+		            this._bySources = undefined;
+		            this._bySourceMemos = undefined;
+		        }
+		    }
+		    /**
+		     * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+		     * with public access modifiers.
+		     */
+		    function cast(map) {
+		        return map;
+		    }
 		    /**
 		     * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
 		     */
-		    exports.encodedMappings = void 0;
+		    function encodedMappings(map) {
+		        var _a;
+		        var _b;
+		        return ((_a = (_b = cast(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = sourcemapCodec.encode(cast(map)._decoded)));
+		    }
 		    /**
 		     * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
 		     */
-		    exports.decodedMappings = void 0;
+		    function decodedMappings(map) {
+		        var _a;
+		        return ((_a = cast(map))._decoded || (_a._decoded = sourcemapCodec.decode(cast(map)._encoded)));
+		    }
 		    /**
 		     * A low-level API to find the segment associated with a generated line/column (think, from a
 		     * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
 		     */
-		    exports.traceSegment = void 0;
+		    function traceSegment(map, line, column) {
+		        const decoded = decodedMappings(map);
+		        // It's common for parent source maps to have pointers to lines that have no
+		        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+		        if (line >= decoded.length)
+		            return null;
+		        const segments = decoded[line];
+		        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+		        return index === -1 ? null : segments[index];
+		    }
 		    /**
 		     * A higher-level API to find the source/line/column associated with a generated line/column
 		     * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
 		     * `source-map` library.
 		     */
-		    exports.originalPositionFor = void 0;
+		    function originalPositionFor(map, needle) {
+		        let { line, column, bias } = needle;
+		        line--;
+		        if (line < 0)
+		            throw new Error(LINE_GTR_ZERO);
+		        if (column < 0)
+		            throw new Error(COL_GTR_EQ_ZERO);
+		        const decoded = decodedMappings(map);
+		        // It's common for parent source maps to have pointers to lines that have no
+		        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+		        if (line >= decoded.length)
+		            return OMapping(null, null, null, null);
+		        const segments = decoded[line];
+		        const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+		        if (index === -1)
+		            return OMapping(null, null, null, null);
+		        const segment = segments[index];
+		        if (segment.length === 1)
+		            return OMapping(null, null, null, null);
+		        const { names, resolvedSources } = map;
+		        return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+		    }
 		    /**
 		     * Finds the generated line/column position of the provided source/line/column source position.
 		     */
-		    exports.generatedPositionFor = void 0;
+		    function generatedPositionFor(map, needle) {
+		        const { source, line, column, bias } = needle;
+		        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+		    }
 		    /**
 		     * Finds all generated line/column positions of the provided source/line/column source position.
 		     */
-		    exports.allGeneratedPositionsFor = void 0;
+		    function allGeneratedPositionsFor(map, needle) {
+		        const { source, line, column, bias } = needle;
+		        // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+		        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+		    }
 		    /**
 		     * Iterates each mapping in generated position order.
 		     */
-		    exports.eachMapping = void 0;
+		    function eachMapping(map, cb) {
+		        const decoded = decodedMappings(map);
+		        const { names, resolvedSources } = map;
+		        for (let i = 0; i < decoded.length; i++) {
+		            const line = decoded[i];
+		            for (let j = 0; j < line.length; j++) {
+		                const seg = line[j];
+		                const generatedLine = i + 1;
+		                const generatedColumn = seg[0];
+		                let source = null;
+		                let originalLine = null;
+		                let originalColumn = null;
+		                let name = null;
+		                if (seg.length !== 1) {
+		                    source = resolvedSources[seg[1]];
+		                    originalLine = seg[2] + 1;
+		                    originalColumn = seg[3];
+		                }
+		                if (seg.length === 5)
+		                    name = names[seg[4]];
+		                cb({
+		                    generatedLine,
+		                    generatedColumn,
+		                    source,
+		                    originalLine,
+		                    originalColumn,
+		                    name,
+		                });
+		            }
+		        }
+		    }
+		    function sourceIndex(map, source) {
+		        const { sources, resolvedSources } = map;
+		        let index = sources.indexOf(source);
+		        if (index === -1)
+		            index = resolvedSources.indexOf(source);
+		        return index;
+		    }
 		    /**
 		     * Retrieves the source content for a particular source, if its found. Returns null if not.
 		     */
-		    exports.sourceContentFor = void 0;
+		    function sourceContentFor(map, source) {
+		        const { sourcesContent } = map;
+		        if (sourcesContent == null)
+		            return null;
+		        const index = sourceIndex(map, source);
+		        return index === -1 ? null : sourcesContent[index];
+		    }
+		    /**
+		     * Determines if the source is marked to ignore by the source map.
+		     */
+		    function isIgnored(map, source) {
+		        const { ignoreList } = map;
+		        if (ignoreList == null)
+		            return false;
+		        const index = sourceIndex(map, source);
+		        return index === -1 ? false : ignoreList.includes(index);
+		    }
 		    /**
 		     * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
 		     * maps.
 		     */
-		    exports.presortedDecodedMap = void 0;
+		    function presortedDecodedMap(map, mapUrl) {
+		        const tracer = new TraceMap(clone(map, []), mapUrl);
+		        cast(tracer)._decoded = map.mappings;
+		        return tracer;
+		    }
 		    /**
 		     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
 		     * a sourcemap, or to JSON.stringify.
 		     */
-		    exports.decodedMap = void 0;
+		    function decodedMap(map) {
+		        return clone(map, decodedMappings(map));
+		    }
 		    /**
 		     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
 		     * a sourcemap, or to JSON.stringify.
 		     */
-		    exports.encodedMap = void 0;
-		    class TraceMap {
-		        constructor(map, mapUrl) {
-		            const isString = typeof map === 'string';
-		            if (!isString && map._decodedMemo)
-		                return map;
-		            const parsed = (isString ? JSON.parse(map) : map);
-		            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-		            this.version = version;
-		            this.file = file;
-		            this.names = names || [];
-		            this.sourceRoot = sourceRoot;
-		            this.sources = sources;
-		            this.sourcesContent = sourcesContent;
-		            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-		            this.resolvedSources = sources.map((s) => resolve(s || '', from));
-		            const { mappings } = parsed;
-		            if (typeof mappings === 'string') {
-		                this._encoded = mappings;
-		                this._decoded = undefined;
-		            }
-		            else {
-		                this._encoded = undefined;
-		                this._decoded = maybeSort(mappings, isString);
-		            }
-		            this._decodedMemo = memoizedState();
-		            this._bySources = undefined;
-		            this._bySourceMemos = undefined;
-		        }
+		    function encodedMap(map) {
+		        return clone(map, encodedMappings(map));
 		    }
-		    (() => {
-		        exports.encodedMappings = (map) => {
-		            var _a;
-		            return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = sourcemapCodec.encode(map._decoded)));
-		        };
-		        exports.decodedMappings = (map) => {
-		            return (map._decoded || (map._decoded = sourcemapCodec.decode(map._encoded)));
-		        };
-		        exports.traceSegment = (map, line, column) => {
-		            const decoded = exports.decodedMappings(map);
-		            // It's common for parent source maps to have pointers to lines that have no
-		            // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-		            if (line >= decoded.length)
-		                return null;
-		            const segments = decoded[line];
-		            const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
-		            return index === -1 ? null : segments[index];
-		        };
-		        exports.originalPositionFor = (map, { line, column, bias }) => {
-		            line--;
-		            if (line < 0)
-		                throw new Error(LINE_GTR_ZERO);
-		            if (column < 0)
-		                throw new Error(COL_GTR_EQ_ZERO);
-		            const decoded = exports.decodedMappings(map);
-		            // It's common for parent source maps to have pointers to lines that have no
-		            // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-		            if (line >= decoded.length)
-		                return OMapping(null, null, null, null);
-		            const segments = decoded[line];
-		            const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-		            if (index === -1)
-		                return OMapping(null, null, null, null);
-		            const segment = segments[index];
-		            if (segment.length === 1)
-		                return OMapping(null, null, null, null);
-		            const { names, resolvedSources } = map;
-		            return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
-		        };
-		        exports.allGeneratedPositionsFor = (map, { source, line, column, bias }) => {
-		            // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
-		            return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
-		        };
-		        exports.generatedPositionFor = (map, { source, line, column, bias }) => {
-		            return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
-		        };
-		        exports.eachMapping = (map, cb) => {
-		            const decoded = exports.decodedMappings(map);
-		            const { names, resolvedSources } = map;
-		            for (let i = 0; i < decoded.length; i++) {
-		                const line = decoded[i];
-		                for (let j = 0; j < line.length; j++) {
-		                    const seg = line[j];
-		                    const generatedLine = i + 1;
-		                    const generatedColumn = seg[0];
-		                    let source = null;
-		                    let originalLine = null;
-		                    let originalColumn = null;
-		                    let name = null;
-		                    if (seg.length !== 1) {
-		                        source = resolvedSources[seg[1]];
-		                        originalLine = seg[2] + 1;
-		                        originalColumn = seg[3];
-		                    }
-		                    if (seg.length === 5)
-		                        name = names[seg[4]];
-		                    cb({
-		                        generatedLine,
-		                        generatedColumn,
-		                        source,
-		                        originalLine,
-		                        originalColumn,
-		                        name,
-		                    });
-		                }
-		            }
-		        };
-		        exports.sourceContentFor = (map, source) => {
-		            const { sources, resolvedSources, sourcesContent } = map;
-		            if (sourcesContent == null)
-		                return null;
-		            let index = sources.indexOf(source);
-		            if (index === -1)
-		                index = resolvedSources.indexOf(source);
-		            return index === -1 ? null : sourcesContent[index];
-		        };
-		        exports.presortedDecodedMap = (map, mapUrl) => {
-		            const tracer = new TraceMap(clone(map, []), mapUrl);
-		            tracer._decoded = map.mappings;
-		            return tracer;
-		        };
-		        exports.decodedMap = (map) => {
-		            return clone(map, exports.decodedMappings(map));
-		        };
-		        exports.encodedMap = (map) => {
-		            return clone(map, exports.encodedMappings(map));
-		        };
-		        function generatedPosition(map, source, line, column, bias, all) {
-		            line--;
-		            if (line < 0)
-		                throw new Error(LINE_GTR_ZERO);
-		            if (column < 0)
-		                throw new Error(COL_GTR_EQ_ZERO);
-		            const { sources, resolvedSources } = map;
-		            let sourceIndex = sources.indexOf(source);
-		            if (sourceIndex === -1)
-		                sourceIndex = resolvedSources.indexOf(source);
-		            if (sourceIndex === -1)
-		                return all ? [] : GMapping(null, null);
-		            const generated = (map._bySources || (map._bySources = buildBySources(exports.decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
-		            const segments = generated[sourceIndex][line];
-		            if (segments == null)
-		                return all ? [] : GMapping(null, null);
-		            const memo = map._bySourceMemos[sourceIndex];
-		            if (all)
-		                return sliceGeneratedPositions(segments, memo, line, column, bias);
-		            const index = traceSegmentInternal(segments, memo, line, column, bias);
-		            if (index === -1)
-		                return GMapping(null, null);
-		            const segment = segments[index];
-		            return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
-		        }
-		    })();
 		    function clone(map, mappings) {
 		        return {
 		            version: map.version,
@@ -1388,6 +1385,7 @@ function requireTraceMapping_umd () {
 		            sources: map.sources,
 		            sourcesContent: map.sourcesContent,
 		            mappings,
+		            ignoreList: map.ignoreList || map.x_google_ignoreList,
 		        };
 		    }
 		    function OMapping(source, line, column, name) {
@@ -1434,13 +1432,49 @@ function requireTraceMapping_umd () {
 		        }
 		        return result;
 		    }
+		    function generatedPosition(map, source, line, column, bias, all) {
+		        var _a;
+		        line--;
+		        if (line < 0)
+		            throw new Error(LINE_GTR_ZERO);
+		        if (column < 0)
+		            throw new Error(COL_GTR_EQ_ZERO);
+		        const { sources, resolvedSources } = map;
+		        let sourceIndex = sources.indexOf(source);
+		        if (sourceIndex === -1)
+		            sourceIndex = resolvedSources.indexOf(source);
+		        if (sourceIndex === -1)
+		            return all ? [] : GMapping(null, null);
+		        const generated = ((_a = cast(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), (cast(map)._bySourceMemos = sources.map(memoizedState)))));
+		        const segments = generated[sourceIndex][line];
+		        if (segments == null)
+		            return all ? [] : GMapping(null, null);
+		        const memo = cast(map)._bySourceMemos[sourceIndex];
+		        if (all)
+		            return sliceGeneratedPositions(segments, memo, line, column, bias);
+		        const index = traceSegmentInternal(segments, memo, line, column, bias);
+		        if (index === -1)
+		            return GMapping(null, null);
+		        const segment = segments[index];
+		        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+		    }
 
 		    exports.AnyMap = AnyMap;
 		    exports.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
 		    exports.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
 		    exports.TraceMap = TraceMap;
-
-		    Object.defineProperty(exports, '__esModule', { value: true });
+		    exports.allGeneratedPositionsFor = allGeneratedPositionsFor;
+		    exports.decodedMap = decodedMap;
+		    exports.decodedMappings = decodedMappings;
+		    exports.eachMapping = eachMapping;
+		    exports.encodedMap = encodedMap;
+		    exports.encodedMappings = encodedMappings;
+		    exports.generatedPositionFor = generatedPositionFor;
+		    exports.isIgnored = isIgnored;
+		    exports.originalPositionFor = originalPositionFor;
+		    exports.presortedDecodedMap = presortedDecodedMap;
+		    exports.sourceContentFor = sourceContentFor;
+		    exports.traceSegment = traceSegment;
 
 		}));
 		
@@ -1517,17 +1551,17 @@ function requireSource () {
 	   * @return {{count?: number, start?: boolean, stop?: boolean}|undefined}
 	   */
 	  _parseIgnore (lineStr) {
-	    const testIgnoreNextLines = lineStr.match(/^\W*\/\* [c|v]8 ignore next (?<count>[0-9]+)/);
+	    const testIgnoreNextLines = lineStr.match(/^\W*\/\* (?:[cv]8|node:coverage) ignore next (?<count>[0-9]+)/);
 	    if (testIgnoreNextLines) {
 	      return { count: Number(testIgnoreNextLines.groups.count) }
 	    }
 
 	    // Check if comment is on its own line.
-	    if (lineStr.match(/^\W*\/\* [c|v]8 ignore next/)) {
+	    if (lineStr.match(/^\W*\/\* (?:[cv]8|node:coverage) ignore next/)) {
 	      return { count: 1 }
 	    }
 
-	    if (lineStr.match(/\/\* [c|v]8 ignore next/)) {
+	    if (lineStr.match(/\/\* ([cv]8|node:coverage) ignore next/)) {
 	      // Won't ignore successive lines, but the current line will be ignored.
 	      return { count: 0 }
 	    }
@@ -1537,6 +1571,12 @@ function requireSource () {
 	      if (testIgnoreStartStop.groups.mode === 'start') return { start: true }
 	      if (testIgnoreStartStop.groups.mode === 'stop') return { stop: true }
 	    }
+
+	    const testNodeIgnoreStartStop = lineStr.match(/\/\* node:coverage (?<mode>enable|disable)/);
+	    if (testNodeIgnoreStartStop) {
+	      if (testNodeIgnoreStartStop.groups.mode === 'disable') return { start: true }
+	      if (testNodeIgnoreStartStop.groups.mode === 'enable') return { stop: true }
+	    }
 	  }
 
 	  // given a start column and end column in absolute offsets within
@@ -1712,12 +1752,14 @@ function requireSource () {
 	// Not required since Node 12, see: https://github.com/nodejs/node/pull/27375
 	const isPreNode12 = /^v1[0-1]\./u.test(process.version);
 	function getShebangLength (source) {
+	  /* c8 ignore start - platform-specific */
 	  if (isPreNode12 && source.indexOf('#!') === 0) {
 	    const match = source.match(/(?<shebang>#!.*)/);
 	    if (match) {
 	      return match.groups.shebang.length
 	    }
 	  } else {
+	  /* c8 ignore stop - platform-specific */
 	    return 0
 	  }
 	}
@@ -2230,8 +2272,13 @@ class V8CoverageProvider extends BaseCoverageProvider {
       ...config,
       // Resolved fields
       provider: "v8",
-      reporter: this.resolveReporters(config.reporter || coverageConfigDefaults.reporter),
-      reportsDirectory: resolve(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
+      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,
@@ -2242,24 +2289,37 @@ class V8CoverageProvider extends BaseCoverageProvider {
     };
     this.testExclude = new _TestExclude({
       cwd: ctx.config.root,
-      include: typeof this.options.include === "undefined" ? void 0 : [...this.options.include],
-      exclude: [...defaultExclude, ...defaultInclude, ...this.options.exclude],
+      include: this.options.include,
+      exclude: this.options.exclude,
       excludeNodeModules: true,
       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);
+    this.coverageFilesDirectory = resolve(
+      this.options.reportsDirectory,
+      tempDirectory
+    );
   }
   resolveOptions() {
     return this.options;
   }
   async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory))
-      await promises$1.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 });
-    if (existsSync(this.coverageFilesDirectory))
-      await promises$1.rm(this.coverageFilesDirectory, { recursive: true, force: true, maxRetries: 10 });
+    if (clean && existsSync(this.options.reportsDirectory)) {
+      await promises$1.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises$1.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
     await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
     this.coverageFiles = /* @__PURE__ */ new Map();
     this.pendingPromises = [];
@@ -2270,14 +2330,18 @@ class V8CoverageProvider extends BaseCoverageProvider {
    * backwards compatibility is a breaking change.
    */
   onAfterSuiteRun({ coverage, transformMode, projectName }) {
-    if (transformMode !== "web" && transformMode !== "ssr")
+    if (transformMode !== "web" && transformMode !== "ssr") {
       throw new Error(`Invalid transform mode: ${transformMode}`);
+    }
     let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
     if (!entry) {
       entry = { web: [], ssr: [] };
       this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
     }
-    const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+    const filename = resolve(
+      this.coverageFilesDirectory,
+      `coverage-${uniqueId++}.json`
+    );
     entry[transformMode].push(filename);
     const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
     this.pendingPromises.push(promise);
@@ -2288,21 +2352,35 @@ class V8CoverageProvider extends BaseCoverageProvider {
     const total = this.pendingPromises.length;
     await Promise.all(this.pendingPromises);
     this.pendingPromises = [];
-    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-      for (const [transformMode, filenames] of Object.entries(coveragePerProject)) {
+    for (const [
+      projectName,
+      coveragePerProject
+    ] of this.coverageFiles.entries()) {
+      for (const [transformMode, filenames] of Object.entries(
+        coveragePerProject
+      )) {
         let merged = { result: [] };
-        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+        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$1.readFile(filename, "utf-8");
-            const coverage = JSON.parse(contents);
-            merged = mergeProcessCovs([merged, coverage]);
-          }));
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises$1.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              merged = mergeProcessCovs([merged, coverage]);
+            })
+          );
         }
-        const converted = await this.convertCoverage(merged, projectName, transformMode);
+        const converted = await this.convertCoverage(
+          merged,
+          projectName,
+          transformMode
+        );
         const transformedCoverage = await transformCoverage(converted);
         coverageMap.merge(transformedCoverage);
       }
@@ -2316,8 +2394,13 @@ class V8CoverageProvider extends BaseCoverageProvider {
     return coverageMap;
   }
   async reportCoverage(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."));
+    if (provider === "stackblitz") {
+      this.ctx.logger.log(
+        c.blue(" % ") + c.yellow(
+          "@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."
+        )
+      );
+    }
     await this.generateReports(
       coverageMap || libCoverage.createCoverageMap({}),
       allTestsRun
@@ -2326,8 +2409,9 @@ class V8CoverageProvider extends BaseCoverageProvider {
     if (!keepResults) {
       this.coverageFiles = /* @__PURE__ */ new Map();
       await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
-      if (readdirSync(this.options.reportsDirectory).length === 0)
+      if (readdirSync(this.options.reportsDirectory).length === 0) {
         await promises$1.rm(this.options.reportsDirectory, { recursive: true });
+      }
     }
   }
   async generateReports(coverageMap, allTestsRun) {
@@ -2336,8 +2420,11 @@ class V8CoverageProvider extends BaseCoverageProvider {
       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));
+    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,
@@ -2354,66 +2441,99 @@ class V8CoverageProvider extends BaseCoverageProvider {
       });
       this.checkThresholds({
         thresholds: resolvedThresholds,
-        perFile: this.options.thresholds.perFile
+        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.');
+        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$1.readFile(configFilePath, "utf8"));
+        const configModule = parseModule(
+          await promises$1.readFile(configFilePath, "utf8")
+        );
         this.updateThresholds({
           thresholds: resolvedThresholds,
           perFile: this.options.thresholds.perFile,
           configurationFile: configModule,
-          onUpdate: () => writeFileSync(configFilePath, configModule.generate().code, "utf-8")
+          onUpdate: () => writeFileSync(
+            configFilePath,
+            configModule.generate().code,
+            "utf-8"
+          )
         });
       }
     }
   }
   async mergeReports(coverageMaps) {
     const coverageMap = libCoverage.createCoverageMap({});
-    for (const coverage of coverageMaps)
+    for (const coverage of coverageMaps) {
       coverageMap.merge(coverage);
+    }
     await this.generateReports(coverageMap, true);
   }
   async getUntestedFiles(testedFiles) {
-    const transformResults = normalizeTransformResults(this.ctx.vitenode.fetchCache);
+    const transformResults = normalizeTransformResults(
+      this.ctx.vitenode.fetchCache
+    );
     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));
+    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 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);
       }
-      const coverages = await Promise.all(chunk.map(async (filename) => {
-        const { originalSource, source } = await this.getSources(filename.href, transformResults);
-        if (source && stripLiteral(source).trim() === "")
-          return null;
-        const coverage = {
-          url: filename.href,
-          scriptId: "0",
-          // Create a made up function to mark whole file as uncovered. Note that this does not exist in source maps.
-          functions: [{
-            ranges: [{
-              startOffset: 0,
-              endOffset: 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)"
-          }]
-        };
-        return { result: [coverage] };
-      }));
+      const coverages = await Promise.all(
+        chunk.map(async (filename) => {
+          const { originalSource, source } = await this.getSources(
+            filename.href,
+            transformResults
+          );
+          if (source && stripLiteral(source).trim() === "") {
+            return null;
+          }
+          const coverage = {
+            url: filename.href,
+            scriptId: "0",
+            // Create a made up function to mark whole file as uncovered. Note that this does not exist in source maps.
+            functions: [
+              {
+                ranges: [
+                  {
+                    startOffset: 0,
+                    endOffset: 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)"
+              }
+            ]
+          };
+          return { result: [coverage] };
+        })
+      );
       merged = mergeProcessCovs([
         merged,
-        ...coverages.filter((cov) => cov != null)
+        ...coverages.filter(
+          (cov) => cov != null
+        )
       ]);
     }
     return merged;
@@ -2440,8 +2560,9 @@ class V8CoverageProvider extends BaseCoverageProvider {
       };
     }
     const sources = [url];
-    if (map.sources && map.sources[0] && !url.endsWith(map.sources[0]))
+    if (map.sources && map.sources[0] && !url.endsWith(map.sources[0])) {
       sources[0] = new URL(map.sources[0], url).href;
+    }
     return {
       isExecuted,
       originalSource: sourcesContent,
@@ -2460,22 +2581,39 @@ class V8CoverageProvider extends BaseCoverageProvider {
     const viteNode = this.ctx.projects.find((project) => project.getName() === projectName)?.vitenode || this.ctx.vitenode;
     const fetchCache = transformMode ? viteNode.fetchCaches[transformMode] : viteNode.fetchCache;
     const transformResults = normalizeTransformResults(fetchCache);
-    const scriptCoverages = coverage.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath$1(result.url)));
+    const scriptCoverages = coverage.result.filter(
+      (result) => this.testExclude.shouldInstrument(fileURLToPath$1(result.url))
+    );
     const coverageMap = libCoverage.createCoverageMap({});
     let index = 0;
-    for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
+    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 }) => {
-        const sources = await this.getSources(url, transformResults, functions);
-        const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
-        const converter = v8ToIstanbul$1(url, wrapperLength, sources, void 0, this.options.ignoreEmptyLines);
-        await converter.load();
-        converter.applyCoverage(functions);
-        coverageMap.merge(converter.toIstanbul());
-      }));
+      await Promise.all(
+        chunk.map(async ({ url, functions }) => {
+          const sources = await this.getSources(
+            url,
+            transformResults,
+            functions
+          );
+          const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
+          const converter = v8ToIstanbul$1(
+            url,
+            wrapperLength,
+            sources,
+            void 0,
+            this.options.ignoreEmptyLines
+          );
+          await converter.load();
+          converter.applyCoverage(functions);
+          coverageMap.merge(converter.toIstanbul());
+        })
+      );
     }
     return coverageMap;
   }
@@ -2485,10 +2623,12 @@ async function transformCoverage(coverageMap) {
   return await sourceMapStore.transformCoverage(coverageMap);
 }
 function excludeGeneratedCode(source, map) {
-  if (!source)
+  if (!source) {
     return map;
-  if (!source.match(VITE_EXPORTS_LINE_PATTERN) && !source.match(DECORATOR_METADATA_PATTERN))
+  }
+  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));
@@ -2501,7 +2641,10 @@ function excludeGeneratedCode(source, map) {
 }
 function findLongestFunctionLength(functions) {
   return functions.reduce((previous, current) => {
-    const maxEndOffset = current.ranges.reduce((endOffset, range) => Math.max(endOffset, range.endOffset), 0);
+    const maxEndOffset = current.ranges.reduce(
+      (endOffset, range) => Math.max(endOffset, range.endOffset),
+      0
+    );
     return Math.max(previous, maxEndOffset);
   }, 0);
 }
@@ -2509,8 +2652,9 @@ function normalizeTransformResults(fetchCache) {
   const normalized = /* @__PURE__ */ new Map();
   for (const [key, value] of fetchCache.entries()) {
     const cleanEntry = cleanUrl(key);
-    if (!normalized.has(cleanEntry))
+    if (!normalized.has(cleanEntry)) {
       normalized.set(cleanEntry, value.result);
+    }
   }
   return normalized;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,22 +37,22 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.0.0-beta.9"
+    "vitest": "2.0.0"
   },
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
     "@bcoe/v8-coverage": "^0.2.3",
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-report": "^3.0.1",
-    "istanbul-lib-source-maps": "^5.0.4",
+    "istanbul-lib-source-maps": "^5.0.6",
     "istanbul-reports": "^3.1.7",
     "magic-string": "^0.30.10",
     "magicast": "^0.3.4",
-    "picocolors": "^1.0.0",
+    "picocolors": "^1.0.1",
     "std-env": "^3.7.0",
     "strip-literal": "^2.1.0",
-    "test-exclude": "^6.0.0"
+    "test-exclude": "^7.0.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
@@ -61,9 +61,9 @@
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.2",
-    "v8-to-istanbul": "^9.2.0",
-    "vite-node": "2.0.0-beta.9",
-    "vitest": "2.0.0-beta.9"
+    "v8-to-istanbul": "^9.3.0",
+    "vite-node": "2.0.0",
+    "vitest": "2.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",