@vitest/coverage-v8 2.1.1 → 2.1.3

package/dist/provider.js

@@ -1,5 +1,5 @@
-import { existsSync, promises as promises$1, readdirSync, writeFileSync } from 'node:fs';
-import { pathToFileURL, fileURLToPath as fileURLToPath$1 } from 'node:url';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { promises } from 'node:fs';
 import require$$0 from 'assert';
 import require$$2 from 'util';
 import require$$3 from 'path';
@@ -7,263 +7,267 @@ import require$$4 from 'url';
 import require$$9 from 'fs';
 import require$$11 from 'module';
 import { mergeProcessCovs } from '@bcoe/v8-coverage';
-import libReport from 'istanbul-lib-report';
-import reports from 'istanbul-reports';
 import libCoverage from 'istanbul-lib-coverage';
+import libReport from 'istanbul-lib-report';
 import libSourceMaps from 'istanbul-lib-source-maps';
-import MagicString from 'magic-string';
-import { parseModule } from 'magicast';
-import remapping from '@ampproject/remapping';
-import c from 'tinyrainbow';
+import reports from 'istanbul-reports';
 import { provider } from 'std-env';
+import c from 'tinyrainbow';
 import createDebug from 'debug';
-import { builtinModules } from 'node:module';
-import { coverageConfigDefaults } from 'vitest/config';
+import MagicString from 'magic-string';
+import TestExclude from 'test-exclude';
+import remapping from '@ampproject/remapping';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import _TestExclude from 'test-exclude';
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+import { builtinModules } from 'node:module';
+import { parseModule } from 'magicast';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var convertSourceMap$1 = {};
-
-(function (exports) {
-
-	Object.defineProperty(exports, 'commentRegex', {
-	  get: function getCommentRegex () {
-	    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
-	    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
-	  }
-	});
-
-
-	Object.defineProperty(exports, 'mapFileCommentRegex', {
-	  get: function getMapFileCommentRegex () {
-	    // Matches sourceMappingURL in either // or /* comment styles.
-	    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
-	  }
-	});
-
-	var decodeBase64;
-	if (typeof Buffer !== 'undefined') {
-	  if (typeof Buffer.from === 'function') {
-	    decodeBase64 = decodeBase64WithBufferFrom;
-	  } else {
-	    decodeBase64 = decodeBase64WithNewBuffer;
-	  }
-	} else {
-	  decodeBase64 = decodeBase64WithAtob;
-	}
-
-	function decodeBase64WithBufferFrom(base64) {
-	  return Buffer.from(base64, 'base64').toString();
-	}
-
-	function decodeBase64WithNewBuffer(base64) {
-	  if (typeof value === 'number') {
-	    throw new TypeError('The value to decode must not be of type number.');
-	  }
-	  return new Buffer(base64, 'base64').toString();
-	}
-
-	function decodeBase64WithAtob(base64) {
-	  return decodeURIComponent(escape(atob(base64)));
-	}
-
-	function stripComment(sm) {
-	  return sm.split(',').pop();
-	}
-
-	function readFromFileMap(sm, read) {
-	  var r = exports.mapFileCommentRegex.exec(sm);
-	  // for some odd reason //# .. captures in 1 and /* .. */ in 2
-	  var filename = r[1] || r[2];
-
-	  try {
-	    var sm = read(filename);
-	    if (sm != null && typeof sm.catch === 'function') {
-	      return sm.catch(throwError);
-	    } else {
-	      return sm;
-	    }
-	  } catch (e) {
-	    throwError(e);
-	  }
-
-	  function throwError(e) {
-	    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
-	  }
-	}
-
-	function Converter (sm, opts) {
-	  opts = opts || {};
-
-	  if (opts.hasComment) {
-	    sm = stripComment(sm);
-	  }
-
-	  if (opts.encoding === 'base64') {
-	    sm = decodeBase64(sm);
-	  } else if (opts.encoding === 'uri') {
-	    sm = decodeURIComponent(sm);
-	  }
-
-	  if (opts.isJSON || opts.encoding) {
-	    sm = JSON.parse(sm);
-	  }
-
-	  this.sourcemap = sm;
-	}
-
-	Converter.prototype.toJSON = function (space) {
-	  return JSON.stringify(this.sourcemap, null, space);
-	};
-
-	if (typeof Buffer !== 'undefined') {
-	  if (typeof Buffer.from === 'function') {
-	    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
-	  } else {
-	    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
-	  }
-	} else {
-	  Converter.prototype.toBase64 = encodeBase64WithBtoa;
-	}
-
-	function encodeBase64WithBufferFrom() {
-	  var json = this.toJSON();
-	  return Buffer.from(json, 'utf8').toString('base64');
-	}
-
-	function encodeBase64WithNewBuffer() {
-	  var json = this.toJSON();
-	  if (typeof json === 'number') {
-	    throw new TypeError('The json to encode must not be of type number.');
-	  }
-	  return new Buffer(json, 'utf8').toString('base64');
-	}
-
-	function encodeBase64WithBtoa() {
-	  var json = this.toJSON();
-	  return btoa(unescape(encodeURIComponent(json)));
-	}
-
-	Converter.prototype.toURI = function () {
-	  var json = this.toJSON();
-	  return encodeURIComponent(json);
-	};
-
-	Converter.prototype.toComment = function (options) {
-	  var encoding, content, data;
-	  if (options != null && options.encoding === 'uri') {
-	    encoding = '';
-	    content = this.toURI();
-	  } else {
-	    encoding = ';base64';
-	    content = this.toBase64();
-	  }
-	  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
-	  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
-	};
-
-	// returns copy instead of original
-	Converter.prototype.toObject = function () {
-	  return JSON.parse(this.toJSON());
-	};
-
-	Converter.prototype.addProperty = function (key, value) {
-	  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
-	  return this.setProperty(key, value);
-	};
-
-	Converter.prototype.setProperty = function (key, value) {
-	  this.sourcemap[key] = value;
-	  return this;
-	};
-
-	Converter.prototype.getProperty = function (key) {
-	  return this.sourcemap[key];
-	};
-
-	exports.fromObject = function (obj) {
-	  return new Converter(obj);
-	};
-
-	exports.fromJSON = function (json) {
-	  return new Converter(json, { isJSON: true });
-	};
-
-	exports.fromURI = function (uri) {
-	  return new Converter(uri, { encoding: 'uri' });
-	};
-
-	exports.fromBase64 = function (base64) {
-	  return new Converter(base64, { encoding: 'base64' });
-	};
-
-	exports.fromComment = function (comment) {
-	  var m, encoding;
-	  comment = comment
-	    .replace(/^\/\*/g, '//')
-	    .replace(/\*\/$/g, '');
-	  m = exports.commentRegex.exec(comment);
-	  encoding = m && m[4] || 'uri';
-	  return new Converter(comment, { encoding: encoding, hasComment: true });
-	};
-
-	function makeConverter(sm) {
-	  return new Converter(sm, { isJSON: true });
-	}
-
-	exports.fromMapFileComment = function (comment, read) {
-	  if (typeof read === 'string') {
-	    throw new Error(
-	      'String directory paths are no longer supported with `fromMapFileComment`\n' +
-	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
-	    )
-	  }
-
-	  var sm = readFromFileMap(comment, read);
-	  if (sm != null && typeof sm.then === 'function') {
-	    return sm.then(makeConverter);
-	  } else {
-	    return makeConverter(sm);
-	  }
-	};
-
-	// Finds last sourcemap comment in file or returns null if none was found
-	exports.fromSource = function (content) {
-	  var m = content.match(exports.commentRegex);
-	  return m ? exports.fromComment(m.pop()) : null;
-	};
-
-	// Finds last sourcemap comment in file or returns null if none was found
-	exports.fromMapFileSource = function (content, read) {
-	  if (typeof read === 'string') {
-	    throw new Error(
-	      'String directory paths are no longer supported with `fromMapFileSource`\n' +
-	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
-	    )
-	  }
-	  var m = content.match(exports.mapFileCommentRegex);
-	  return m ? exports.fromMapFileComment(m.pop(), read) : null;
-	};
-
-	exports.removeComments = function (src) {
-	  return src.replace(exports.commentRegex, '');
-	};
-
-	exports.removeMapFileComments = function (src) {
-	  return src.replace(exports.mapFileCommentRegex, '');
-	};
-
-	exports.generateMapFileComment = function (file, options) {
-	  var data = 'sourceMappingURL=' + file;
-	  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
-	}; 
-} (convertSourceMap$1));
+var convertSourceMap = {};
+
+var hasRequiredConvertSourceMap;
+
+function requireConvertSourceMap () {
+	if (hasRequiredConvertSourceMap) return convertSourceMap;
+	hasRequiredConvertSourceMap = 1;
+	(function (exports) {
+
+		Object.defineProperty(exports, 'commentRegex', {
+		  get: function getCommentRegex () {
+		    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+		    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+		  }
+		});
+
+
+		Object.defineProperty(exports, 'mapFileCommentRegex', {
+		  get: function getMapFileCommentRegex () {
+		    // Matches sourceMappingURL in either // or /* comment styles.
+		    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+		  }
+		});
+
+		var decodeBase64;
+		if (typeof Buffer !== 'undefined') {
+		  if (typeof Buffer.from === 'function') {
+		    decodeBase64 = decodeBase64WithBufferFrom;
+		  } else {
+		    decodeBase64 = decodeBase64WithNewBuffer;
+		  }
+		} else {
+		  decodeBase64 = decodeBase64WithAtob;
+		}
+
+		function decodeBase64WithBufferFrom(base64) {
+		  return Buffer.from(base64, 'base64').toString();
+		}
+
+		function decodeBase64WithNewBuffer(base64) {
+		  if (typeof value === 'number') {
+		    throw new TypeError('The value to decode must not be of type number.');
+		  }
+		  return new Buffer(base64, 'base64').toString();
+		}
+
+		function decodeBase64WithAtob(base64) {
+		  return decodeURIComponent(escape(atob(base64)));
+		}
+
+		function stripComment(sm) {
+		  return sm.split(',').pop();
+		}
+
+		function readFromFileMap(sm, read) {
+		  var r = exports.mapFileCommentRegex.exec(sm);
+		  // for some odd reason //# .. captures in 1 and /* .. */ in 2
+		  var filename = r[1] || r[2];
+
+		  try {
+		    var sm = read(filename);
+		    if (sm != null && typeof sm.catch === 'function') {
+		      return sm.catch(throwError);
+		    } else {
+		      return sm;
+		    }
+		  } catch (e) {
+		    throwError(e);
+		  }
+
+		  function throwError(e) {
+		    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+		  }
+		}
+
+		function Converter (sm, opts) {
+		  opts = opts || {};
+
+		  if (opts.hasComment) {
+		    sm = stripComment(sm);
+		  }
+
+		  if (opts.encoding === 'base64') {
+		    sm = decodeBase64(sm);
+		  } else if (opts.encoding === 'uri') {
+		    sm = decodeURIComponent(sm);
+		  }
+
+		  if (opts.isJSON || opts.encoding) {
+		    sm = JSON.parse(sm);
+		  }
+
+		  this.sourcemap = sm;
+		}
+
+		Converter.prototype.toJSON = function (space) {
+		  return JSON.stringify(this.sourcemap, null, space);
+		};
+
+		if (typeof Buffer !== 'undefined') {
+		  if (typeof Buffer.from === 'function') {
+		    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+		  } else {
+		    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+		  }
+		} else {
+		  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+		}
+
+		function encodeBase64WithBufferFrom() {
+		  var json = this.toJSON();
+		  return Buffer.from(json, 'utf8').toString('base64');
+		}
+
+		function encodeBase64WithNewBuffer() {
+		  var json = this.toJSON();
+		  if (typeof json === 'number') {
+		    throw new TypeError('The json to encode must not be of type number.');
+		  }
+		  return new Buffer(json, 'utf8').toString('base64');
+		}
+
+		function encodeBase64WithBtoa() {
+		  var json = this.toJSON();
+		  return btoa(unescape(encodeURIComponent(json)));
+		}
+
+		Converter.prototype.toURI = function () {
+		  var json = this.toJSON();
+		  return encodeURIComponent(json);
+		};
+
+		Converter.prototype.toComment = function (options) {
+		  var encoding, content, data;
+		  if (options != null && options.encoding === 'uri') {
+		    encoding = '';
+		    content = this.toURI();
+		  } else {
+		    encoding = ';base64';
+		    content = this.toBase64();
+		  }
+		  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+		  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+		};
+
+		// returns copy instead of original
+		Converter.prototype.toObject = function () {
+		  return JSON.parse(this.toJSON());
+		};
+
+		Converter.prototype.addProperty = function (key, value) {
+		  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+		  return this.setProperty(key, value);
+		};
+
+		Converter.prototype.setProperty = function (key, value) {
+		  this.sourcemap[key] = value;
+		  return this;
+		};
+
+		Converter.prototype.getProperty = function (key) {
+		  return this.sourcemap[key];
+		};
+
+		exports.fromObject = function (obj) {
+		  return new Converter(obj);
+		};
+
+		exports.fromJSON = function (json) {
+		  return new Converter(json, { isJSON: true });
+		};
+
+		exports.fromURI = function (uri) {
+		  return new Converter(uri, { encoding: 'uri' });
+		};
+
+		exports.fromBase64 = function (base64) {
+		  return new Converter(base64, { encoding: 'base64' });
+		};
+
+		exports.fromComment = function (comment) {
+		  var m, encoding;
+		  comment = comment
+		    .replace(/^\/\*/g, '//')
+		    .replace(/\*\/$/g, '');
+		  m = exports.commentRegex.exec(comment);
+		  encoding = m && m[4] || 'uri';
+		  return new Converter(comment, { encoding: encoding, hasComment: true });
+		};
+
+		function makeConverter(sm) {
+		  return new Converter(sm, { isJSON: true });
+		}
+
+		exports.fromMapFileComment = function (comment, read) {
+		  if (typeof read === 'string') {
+		    throw new Error(
+		      'String directory paths are no longer supported with `fromMapFileComment`\n' +
+		      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+		    )
+		  }
+
+		  var sm = readFromFileMap(comment, read);
+		  if (sm != null && typeof sm.then === 'function') {
+		    return sm.then(makeConverter);
+		  } else {
+		    return makeConverter(sm);
+		  }
+		};
+
+		// Finds last sourcemap comment in file or returns null if none was found
+		exports.fromSource = function (content) {
+		  var m = content.match(exports.commentRegex);
+		  return m ? exports.fromComment(m.pop()) : null;
+		};
+
+		// Finds last sourcemap comment in file or returns null if none was found
+		exports.fromMapFileSource = function (content, read) {
+		  if (typeof read === 'string') {
+		    throw new Error(
+		      'String directory paths are no longer supported with `fromMapFileSource`\n' +
+		      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+		    )
+		  }
+		  var m = content.match(exports.mapFileCommentRegex);
+		  return m ? exports.fromMapFileComment(m.pop(), read) : null;
+		};
+
+		exports.removeComments = function (src) {
+		  return src.replace(exports.commentRegex, '');
+		};
+
+		exports.removeMapFileComments = function (src) {
+		  return src.replace(exports.mapFileCommentRegex, '');
+		};
+
+		exports.generateMapFileComment = function (file, options) {
+		  var data = 'sourceMappingURL=' + file;
+		  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+		}; 
+	} (convertSourceMap));
+	return convertSourceMap;
+}
 
 var branch;
 var hasRequiredBranch;
@@ -429,19 +433,21 @@ function requireRange () {
 	return range;
 }
 
-var traceMapping_umd = {exports: {}};
+var traceMapping_umd$1 = {exports: {}};
+
+var sourcemapCodec_umd$1 = {exports: {}};
 
-var sourcemapCodec_umd = {exports: {}};
+var sourcemapCodec_umd = sourcemapCodec_umd$1.exports;
 
 var hasRequiredSourcemapCodec_umd;
 
 function requireSourcemapCodec_umd () {
-	if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd.exports;
+	if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd$1.exports;
 	hasRequiredSourcemapCodec_umd = 1;
 	(function (module, exports) {
 		(function (global, factory) {
 		    factory(exports) ;
-		})(commonjsGlobal, (function (exports) {
+		})(sourcemapCodec_umd, (function (exports) {
 		    const comma = ','.charCodeAt(0);
 		    const semicolon = ';'.charCodeAt(0);
 		    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
@@ -875,21 +881,23 @@ function requireSourcemapCodec_umd () {
 
 		}));
 		
-	} (sourcemapCodec_umd, sourcemapCodec_umd.exports));
-	return sourcemapCodec_umd.exports;
+	} (sourcemapCodec_umd$1, sourcemapCodec_umd$1.exports));
+	return sourcemapCodec_umd$1.exports;
 }
 
-var resolveUri_umd = {exports: {}};
+var resolveUri_umd$1 = {exports: {}};
+
+var resolveUri_umd = resolveUri_umd$1.exports;
 
 var hasRequiredResolveUri_umd;
 
 function requireResolveUri_umd () {
-	if (hasRequiredResolveUri_umd) return resolveUri_umd.exports;
+	if (hasRequiredResolveUri_umd) return resolveUri_umd$1.exports;
 	hasRequiredResolveUri_umd = 1;
 	(function (module, exports) {
 		(function (global, factory) {
 		    module.exports = factory() ;
-		})(commonjsGlobal, (function () {
+		})(resolveUri_umd, (function () {
 		    // Matches the scheme of a URL, eg "http://"
 		    const schemeRegex = /^[\w+.-]+:\/\//;
 		    /**
@@ -1134,19 +1142,21 @@ function requireResolveUri_umd () {
 
 		}));
 		
-	} (resolveUri_umd));
-	return resolveUri_umd.exports;
+	} (resolveUri_umd$1));
+	return resolveUri_umd$1.exports;
 }
 
+var traceMapping_umd = traceMapping_umd$1.exports;
+
 var hasRequiredTraceMapping_umd;
 
 function requireTraceMapping_umd () {
-	if (hasRequiredTraceMapping_umd) return traceMapping_umd.exports;
+	if (hasRequiredTraceMapping_umd) return traceMapping_umd$1.exports;
 	hasRequiredTraceMapping_umd = 1;
 	(function (module, exports) {
 		(function (global, factory) {
 		    factory(exports, requireSourcemapCodec_umd(), requireResolveUri_umd()) ;
-		})(commonjsGlobal, (function (exports, sourcemapCodec, resolveUri) {
+		})(traceMapping_umd, (function (exports, sourcemapCodec, 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
@@ -1741,8 +1751,8 @@ function requireTraceMapping_umd () {
 
 		}));
 		
-	} (traceMapping_umd, traceMapping_umd.exports));
-	return traceMapping_umd.exports;
+	} (traceMapping_umd$1, traceMapping_umd$1.exports));
+	return traceMapping_umd$1.exports;
 }
 
 var source;
@@ -2029,337 +2039,354 @@ function requireSource () {
 	return source;
 }
 
-// Patch applied: https://github.com/istanbuljs/v8-to-istanbul/pull/244
-const assert = require$$0;
-const convertSourceMap = convertSourceMap$1;
-const util = require$$2;
-const debuglog = util.debuglog('c8');
-const { dirname, isAbsolute: isAbsolute$1, join, resolve: resolve$1 } = require$$3;
-const { fileURLToPath } = require$$4;
-const CovBranch = requireBranch();
-const CovFunction = require_function();
-const CovSource = requireSource();
-const { sliceRange } = requireRange();
-const { readFileSync, promises } = require$$9;
-const readFile = promises.readFile;
-
-const { TraceMap } = requireTraceMapping_umd();
-const isOlderNode10 = /^v10\.(([0-9]\.)|(1[0-5]\.))/u.test(process.version);
-const isNode8 = /^v8\./.test(process.version);
-
-// Injected when Node.js is loading script into isolate pre Node 10.16.x.
-// see: https://github.com/nodejs/node/pull/21573.
-const cjsWrapperLength = isOlderNode10 ? require$$11.wrapper[0].length : 0;
-
-var v8ToIstanbul$2 = class V8ToIstanbul {
-  constructor (scriptPath, wrapperLength, sources, excludePath, excludeEmptyLines) {
-    assert(typeof scriptPath === 'string', 'scriptPath must be a string');
-    assert(!isNode8, 'This module does not support node 8 or lower, please upgrade to node 10');
-    this.path = parsePath(scriptPath);
-    this.wrapperLength = wrapperLength === undefined ? cjsWrapperLength : wrapperLength;
-    this.excludePath = excludePath || (() => false);
-    this.excludeEmptyLines = excludeEmptyLines === true;
-    this.sources = sources || {};
-    this.generatedLines = [];
-    this.branches = {};
-    this.functions = {};
-    this.covSources = [];
-    this.rawSourceMap = undefined;
-    this.sourceMap = undefined;
-    this.sourceTranspiled = undefined;
-    // Indicate that this report was generated with placeholder data from
-    // running --all:
-    this.all = false;
-  }
+var v8ToIstanbul$2;
+var hasRequiredV8ToIstanbul$1;
 
-  async load () {
-    const rawSource = this.sources.source || await readFile(this.path, 'utf8');
-    this.rawSourceMap = this.sources.sourceMap ||
-      // if we find a source-map (either inline, or a .map file) we load
-      // both the transpiled and original source, both of which are used during
-      // the backflips we perform to remap absolute to relative positions.
-      convertSourceMap.fromSource(rawSource) || convertSourceMap.fromMapFileSource(rawSource, this._readFileFromDir.bind(this));
-
-    if (this.rawSourceMap) {
-      if (this.rawSourceMap.sourcemap.sources.length > 1) {
-        this.sourceMap = new TraceMap(this.rawSourceMap.sourcemap);
-        if (!this.sourceMap.sourcesContent) {
-          this.sourceMap.sourcesContent = await this.sourcesContentFromSources();
-        }
-        this.covSources = this.sourceMap.sourcesContent.map((rawSource, i) => ({ source: new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null), path: this.sourceMap.sources[i] }));
-        this.sourceTranspiled = new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null);
-      } else {
-        const candidatePath = this.rawSourceMap.sourcemap.sources.length >= 1 ? this.rawSourceMap.sourcemap.sources[0] : this.rawSourceMap.sourcemap.file;
-        this.path = this._resolveSource(this.rawSourceMap, candidatePath || this.path);
-        this.sourceMap = new TraceMap(this.rawSourceMap.sourcemap);
-
-        let originalRawSource;
-        if (this.sources.sourceMap && this.sources.sourceMap.sourcemap && this.sources.sourceMap.sourcemap.sourcesContent && this.sources.sourceMap.sourcemap.sourcesContent.length === 1) {
-          // If the sourcesContent field has been provided, return it rather than attempting
-          // to load the original source from disk.
-          // TODO: investigate whether there's ever a case where we hit this logic with 1:many sources.
-          originalRawSource = this.sources.sourceMap.sourcemap.sourcesContent[0];
-        } else if (this.sources.originalSource) {
-          // Original source may be populated on the sources object.
-          originalRawSource = this.sources.originalSource;
-        } else if (this.sourceMap.sourcesContent && this.sourceMap.sourcesContent[0]) {
-          // perhaps we loaded sourcesContent was populated by an inline source map, or .map file?
-          // TODO: investigate whether there's ever a case where we hit this logic with 1:many sources.
-          originalRawSource = this.sourceMap.sourcesContent[0];
-        } else {
-          // We fallback to reading the original source from disk.
-          originalRawSource = await readFile(this.path, 'utf8');
-        }
-        this.covSources = [{ source: new CovSource(originalRawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null), path: this.path }];
-        this.sourceTranspiled = new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null);
-      }
-    } else {
-      this.covSources = [{ source: new CovSource(rawSource, this.wrapperLength), path: this.path }];
-    }
-  }
+function requireV8ToIstanbul$1 () {
+	if (hasRequiredV8ToIstanbul$1) return v8ToIstanbul$2;
+	hasRequiredV8ToIstanbul$1 = 1;
+	// Patch applied: https://github.com/istanbuljs/v8-to-istanbul/pull/244
+	const assert = require$$0;
+	const convertSourceMap = requireConvertSourceMap();
+	const util = require$$2;
+	const debuglog = util.debuglog('c8');
+	const { dirname, isAbsolute, join, resolve } = require$$3;
+	const { fileURLToPath } = require$$4;
+	const CovBranch = requireBranch();
+	const CovFunction = require_function();
+	const CovSource = requireSource();
+	const { sliceRange } = requireRange();
+	const { readFileSync, promises } = require$$9;
+	const readFile = promises.readFile;
+
+	const { TraceMap } = requireTraceMapping_umd();
+	const isOlderNode10 = /^v10\.(([0-9]\.)|(1[0-5]\.))/u.test(process.version);
+	const isNode8 = /^v8\./.test(process.version);
+
+	// Injected when Node.js is loading script into isolate pre Node 10.16.x.
+	// see: https://github.com/nodejs/node/pull/21573.
+	const cjsWrapperLength = isOlderNode10 ? require$$11.wrapper[0].length : 0;
+
+	v8ToIstanbul$2 = class V8ToIstanbul {
+	  constructor (scriptPath, wrapperLength, sources, excludePath, excludeEmptyLines) {
+	    assert(typeof scriptPath === 'string', 'scriptPath must be a string');
+	    assert(!isNode8, 'This module does not support node 8 or lower, please upgrade to node 10');
+	    this.path = parsePath(scriptPath);
+	    this.wrapperLength = wrapperLength === undefined ? cjsWrapperLength : wrapperLength;
+	    this.excludePath = excludePath || (() => false);
+	    this.excludeEmptyLines = excludeEmptyLines === true;
+	    this.sources = sources || {};
+	    this.generatedLines = [];
+	    this.branches = {};
+	    this.functions = {};
+	    this.covSources = [];
+	    this.rawSourceMap = undefined;
+	    this.sourceMap = undefined;
+	    this.sourceTranspiled = undefined;
+	    // Indicate that this report was generated with placeholder data from
+	    // running --all:
+	    this.all = false;
+	  }
 
-  _readFileFromDir (filename) {
-    return readFileSync(resolve$1(dirname(this.path), filename), 'utf-8')
-  }
+	  async load () {
+	    const rawSource = this.sources.source || await readFile(this.path, 'utf8');
+	    this.rawSourceMap = this.sources.sourceMap ||
+	      // if we find a source-map (either inline, or a .map file) we load
+	      // both the transpiled and original source, both of which are used during
+	      // the backflips we perform to remap absolute to relative positions.
+	      convertSourceMap.fromSource(rawSource) || convertSourceMap.fromMapFileSource(rawSource, this._readFileFromDir.bind(this));
+
+	    if (this.rawSourceMap) {
+	      if (this.rawSourceMap.sourcemap.sources.length > 1) {
+	        this.sourceMap = new TraceMap(this.rawSourceMap.sourcemap);
+	        if (!this.sourceMap.sourcesContent) {
+	          this.sourceMap.sourcesContent = await this.sourcesContentFromSources();
+	        }
+	        this.covSources = this.sourceMap.sourcesContent.map((rawSource, i) => ({ source: new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null), path: this.sourceMap.sources[i] }));
+	        this.sourceTranspiled = new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null);
+	      } else {
+	        const candidatePath = this.rawSourceMap.sourcemap.sources.length >= 1 ? this.rawSourceMap.sourcemap.sources[0] : this.rawSourceMap.sourcemap.file;
+	        this.path = this._resolveSource(this.rawSourceMap, candidatePath || this.path);
+	        this.sourceMap = new TraceMap(this.rawSourceMap.sourcemap);
+
+	        let originalRawSource;
+	        if (this.sources.sourceMap && this.sources.sourceMap.sourcemap && this.sources.sourceMap.sourcemap.sourcesContent && this.sources.sourceMap.sourcemap.sourcesContent.length === 1) {
+	          // If the sourcesContent field has been provided, return it rather than attempting
+	          // to load the original source from disk.
+	          // TODO: investigate whether there's ever a case where we hit this logic with 1:many sources.
+	          originalRawSource = this.sources.sourceMap.sourcemap.sourcesContent[0];
+	        } else if (this.sources.originalSource) {
+	          // Original source may be populated on the sources object.
+	          originalRawSource = this.sources.originalSource;
+	        } else if (this.sourceMap.sourcesContent && this.sourceMap.sourcesContent[0]) {
+	          // perhaps we loaded sourcesContent was populated by an inline source map, or .map file?
+	          // TODO: investigate whether there's ever a case where we hit this logic with 1:many sources.
+	          originalRawSource = this.sourceMap.sourcesContent[0];
+	        } else {
+	          // We fallback to reading the original source from disk.
+	          originalRawSource = await readFile(this.path, 'utf8');
+	        }
+	        this.covSources = [{ source: new CovSource(originalRawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null), path: this.path }];
+	        this.sourceTranspiled = new CovSource(rawSource, this.wrapperLength, this.excludeEmptyLines ? this.sourceMap : null);
+	      }
+	    } else {
+	      this.covSources = [{ source: new CovSource(rawSource, this.wrapperLength), path: this.path }];
+	    }
+	  }
 
-  async sourcesContentFromSources () {
-    const fileList = this.sourceMap.sources.map(relativePath => {
-      const realPath = this._resolveSource(this.rawSourceMap, relativePath);
-      return readFile(realPath, 'utf-8')
-        .then(result => result)
-        .catch(err => {
-          debuglog(`failed to load ${realPath}: ${err.message}`);
-        })
-    });
-    return await Promise.all(fileList)
-  }
+	  _readFileFromDir (filename) {
+	    return readFileSync(resolve(dirname(this.path), filename), 'utf-8')
+	  }
 
-  destroy () {
-    // no longer necessary, but preserved for backwards compatibility.
-  }
+	  async sourcesContentFromSources () {
+	    const fileList = this.sourceMap.sources.map(relativePath => {
+	      const realPath = this._resolveSource(this.rawSourceMap, relativePath);
+	      return readFile(realPath, 'utf-8')
+	        .then(result => result)
+	        .catch(err => {
+	          debuglog(`failed to load ${realPath}: ${err.message}`);
+	        })
+	    });
+	    return await Promise.all(fileList)
+	  }
 
-  _resolveSource (rawSourceMap, sourcePath) {
-    if (sourcePath.startsWith('file://')) {
-      return fileURLToPath(sourcePath)
-    }
-    sourcePath = sourcePath.replace(/^webpack:\/\//, '');
-    const sourceRoot = rawSourceMap.sourcemap.sourceRoot ? rawSourceMap.sourcemap.sourceRoot.replace('file://', '') : '';
-    const candidatePath = join(sourceRoot, sourcePath);
+	  destroy () {
+	    // no longer necessary, but preserved for backwards compatibility.
+	  }
 
-    if (isAbsolute$1(candidatePath)) {
-      return candidatePath
-    } else {
-      return resolve$1(dirname(this.path), candidatePath)
-    }
-  }
+	  _resolveSource (rawSourceMap, sourcePath) {
+	    if (sourcePath.startsWith('file://')) {
+	      return fileURLToPath(sourcePath)
+	    }
+	    sourcePath = sourcePath.replace(/^webpack:\/\//, '');
+	    const sourceRoot = rawSourceMap.sourcemap.sourceRoot ? rawSourceMap.sourcemap.sourceRoot.replace('file://', '') : '';
+	    const candidatePath = join(sourceRoot, sourcePath);
 
-  applyCoverage (blocks) {
-    blocks.forEach(block => {
-      block.ranges.forEach((range, i) => {
-        const isEmptyCoverage = block.functionName === '(empty-report)';
-        const { startCol, endCol, path, covSource } = this._maybeRemapStartColEndCol(range, isEmptyCoverage);
-        if (this.excludePath(path)) {
-          return
-        }
-        let lines;
-        if (isEmptyCoverage) {
-          // (empty-report), this will result in a report that has all lines zeroed out.
-          lines = covSource.lines.filter((line) => {
-            line.count = 0;
-            return true
-          });
-          this.all = lines.length > 0;
-        } else {
-          lines = sliceRange(covSource.lines, startCol, endCol);
-        }
-        if (!lines.length) {
-          return
-        }
+	    if (isAbsolute(candidatePath)) {
+	      return candidatePath
+	    } else {
+	      return resolve(dirname(this.path), candidatePath)
+	    }
+	  }
 
-        const startLineInstance = lines[0];
-        const endLineInstance = lines[lines.length - 1];
-
-        if (block.isBlockCoverage) {
-          this.branches[path] = this.branches[path] || [];
-          // record branches.
-          this.branches[path].push(new CovBranch(
-            startLineInstance.line,
-            startCol - startLineInstance.startCol,
-            endLineInstance.line,
-            endCol - endLineInstance.startCol,
-            range.count
-          ));
-
-          // if block-level granularity is enabled, we still create a single
-          // CovFunction tracking object for each set of ranges.
-          if (block.functionName && i === 0) {
-            this.functions[path] = this.functions[path] || [];
-            this.functions[path].push(new CovFunction(
-              block.functionName,
-              startLineInstance.line,
-              startCol - startLineInstance.startCol,
-              endLineInstance.line,
-              endCol - endLineInstance.startCol,
-              range.count
-            ));
-          }
-        } else if (block.functionName) {
-          this.functions[path] = this.functions[path] || [];
-          // record functions.
-          this.functions[path].push(new CovFunction(
-            block.functionName,
-            startLineInstance.line,
-            startCol - startLineInstance.startCol,
-            endLineInstance.line,
-            endCol - endLineInstance.startCol,
-            range.count
-          ));
-        }
+	  applyCoverage (blocks) {
+	    blocks.forEach(block => {
+	      block.ranges.forEach((range, i) => {
+	        const isEmptyCoverage = block.functionName === '(empty-report)';
+	        const { startCol, endCol, path, covSource } = this._maybeRemapStartColEndCol(range, isEmptyCoverage);
+	        if (this.excludePath(path)) {
+	          return
+	        }
+	        let lines;
+	        if (isEmptyCoverage) {
+	          // (empty-report), this will result in a report that has all lines zeroed out.
+	          lines = covSource.lines.filter((line) => {
+	            line.count = 0;
+	            return true
+	          });
+	          this.all = lines.length > 0;
+	        } else {
+	          lines = sliceRange(covSource.lines, startCol, endCol);
+	        }
+	        if (!lines.length) {
+	          return
+	        }
+
+	        const startLineInstance = lines[0];
+	        const endLineInstance = lines[lines.length - 1];
+
+	        if (block.isBlockCoverage) {
+	          this.branches[path] = this.branches[path] || [];
+	          // record branches.
+	          this.branches[path].push(new CovBranch(
+	            startLineInstance.line,
+	            startCol - startLineInstance.startCol,
+	            endLineInstance.line,
+	            endCol - endLineInstance.startCol,
+	            range.count
+	          ));
+
+	          // if block-level granularity is enabled, we still create a single
+	          // CovFunction tracking object for each set of ranges.
+	          if (block.functionName && i === 0) {
+	            this.functions[path] = this.functions[path] || [];
+	            this.functions[path].push(new CovFunction(
+	              block.functionName,
+	              startLineInstance.line,
+	              startCol - startLineInstance.startCol,
+	              endLineInstance.line,
+	              endCol - endLineInstance.startCol,
+	              range.count
+	            ));
+	          }
+	        } else if (block.functionName) {
+	          this.functions[path] = this.functions[path] || [];
+	          // record functions.
+	          this.functions[path].push(new CovFunction(
+	            block.functionName,
+	            startLineInstance.line,
+	            startCol - startLineInstance.startCol,
+	            endLineInstance.line,
+	            endCol - endLineInstance.startCol,
+	            range.count
+	          ));
+	        }
+
+	        // record the lines (we record these as statements, such that we're
+	        // compatible with Istanbul 2.0).
+	        lines.forEach(line => {
+	          // make sure branch spans entire line; don't record 'goodbye'
+	          // branch in `const foo = true ? 'hello' : 'goodbye'` as a
+	          // 0 for line coverage.
+	          //
+	          // All lines start out with coverage of 1, and are later set to 0
+	          // if they are not invoked; line.ignore prevents a line from being
+	          // set to 0, and is set if the special comment /* c8 ignore next */
+	          // is used.
+
+	          if (startCol <= line.startCol && endCol >= line.endCol && !line.ignore) {
+	            line.count = range.count;
+	          }
+	        });
+	      });
+	    });
+	  }
 
-        // record the lines (we record these as statements, such that we're
-        // compatible with Istanbul 2.0).
-        lines.forEach(line => {
-          // make sure branch spans entire line; don't record 'goodbye'
-          // branch in `const foo = true ? 'hello' : 'goodbye'` as a
-          // 0 for line coverage.
-          //
-          // All lines start out with coverage of 1, and are later set to 0
-          // if they are not invoked; line.ignore prevents a line from being
-          // set to 0, and is set if the special comment /* c8 ignore next */
-          // is used.
-
-          if (startCol <= line.startCol && endCol >= line.endCol && !line.ignore) {
-            line.count = range.count;
-          }
-        });
-      });
-    });
-  }
+	  _maybeRemapStartColEndCol (range, isEmptyCoverage) {
+	    let covSource = this.covSources[0].source;
+	    const covSourceWrapperLength = isEmptyCoverage ? 0 : covSource.wrapperLength;
+	    let startCol = Math.max(0, range.startOffset - covSourceWrapperLength);
+	    let endCol = Math.min(covSource.eof, range.endOffset - covSourceWrapperLength);
+	    let path = this.path;
+
+	    if (this.sourceMap) {
+	      const sourceTranspiledWrapperLength = isEmptyCoverage ? 0 : this.sourceTranspiled.wrapperLength;
+	      startCol = Math.max(0, range.startOffset - sourceTranspiledWrapperLength);
+	      endCol = Math.min(this.sourceTranspiled.eof, range.endOffset - sourceTranspiledWrapperLength);
+
+	      const { startLine, relStartCol, endLine, relEndCol, source } = this.sourceTranspiled.offsetToOriginalRelative(
+	        this.sourceMap,
+	        startCol,
+	        endCol
+	      );
+
+	      const matchingSource = this.covSources.find(covSource => covSource.path === source);
+	      covSource = matchingSource ? matchingSource.source : this.covSources[0].source;
+	      path = matchingSource ? matchingSource.path : this.covSources[0].path;
+
+	      // next we convert these relative positions back to absolute positions
+	      // in the original source (which is the format expected in the next step).
+	      startCol = covSource.relativeToOffset(startLine, relStartCol);
+	      endCol = covSource.relativeToOffset(endLine, relEndCol);
+	    }
 
-  _maybeRemapStartColEndCol (range, isEmptyCoverage) {
-    let covSource = this.covSources[0].source;
-    const covSourceWrapperLength = isEmptyCoverage ? 0 : covSource.wrapperLength;
-    let startCol = Math.max(0, range.startOffset - covSourceWrapperLength);
-    let endCol = Math.min(covSource.eof, range.endOffset - covSourceWrapperLength);
-    let path = this.path;
-
-    if (this.sourceMap) {
-      const sourceTranspiledWrapperLength = isEmptyCoverage ? 0 : this.sourceTranspiled.wrapperLength;
-      startCol = Math.max(0, range.startOffset - sourceTranspiledWrapperLength);
-      endCol = Math.min(this.sourceTranspiled.eof, range.endOffset - sourceTranspiledWrapperLength);
-
-      const { startLine, relStartCol, endLine, relEndCol, source } = this.sourceTranspiled.offsetToOriginalRelative(
-        this.sourceMap,
-        startCol,
-        endCol
-      );
+	    return {
+	      path,
+	      covSource,
+	      startCol,
+	      endCol
+	    }
+	  }
 
-      const matchingSource = this.covSources.find(covSource => covSource.path === source);
-      covSource = matchingSource ? matchingSource.source : this.covSources[0].source;
-      path = matchingSource ? matchingSource.path : this.covSources[0].path;
+	  getInnerIstanbul (source, path) {
+	    // We apply the "Resolving Sources" logic (as defined in
+	    // sourcemaps.info/spec.html) as a final step for 1:many source maps.
+	    // for 1:1 source maps, the resolve logic is applied while loading.
+	    //
+	    // TODO: could we move the resolving logic for 1:1 source maps to the final
+	    // step as well? currently this breaks some tests in c8.
+	    let resolvedPath = path;
+	    if (this.rawSourceMap && this.rawSourceMap.sourcemap.sources.length > 1) {
+	      resolvedPath = this._resolveSource(this.rawSourceMap, path);
+	    }
 
-      // next we convert these relative positions back to absolute positions
-      // in the original source (which is the format expected in the next step).
-      startCol = covSource.relativeToOffset(startLine, relStartCol);
-      endCol = covSource.relativeToOffset(endLine, relEndCol);
-    }
+	    if (this.excludePath(resolvedPath)) {
+	      return
+	    }
 
-    return {
-      path,
-      covSource,
-      startCol,
-      endCol
-    }
-  }
+	    return {
+	      [resolvedPath]: {
+	        path: resolvedPath,
+	        all: this.all,
+	        ...this._statementsToIstanbul(source, path),
+	        ...this._branchesToIstanbul(source, path),
+	        ...this._functionsToIstanbul(source, path)
+	      }
+	    }
+	  }
 
-  getInnerIstanbul (source, path) {
-    // We apply the "Resolving Sources" logic (as defined in
-    // sourcemaps.info/spec.html) as a final step for 1:many source maps.
-    // for 1:1 source maps, the resolve logic is applied while loading.
-    //
-    // TODO: could we move the resolving logic for 1:1 source maps to the final
-    // step as well? currently this breaks some tests in c8.
-    let resolvedPath = path;
-    if (this.rawSourceMap && this.rawSourceMap.sourcemap.sources.length > 1) {
-      resolvedPath = this._resolveSource(this.rawSourceMap, path);
-    }
+	  toIstanbul () {
+	    return this.covSources.reduce((istanbulOuter, { source, path }) => Object.assign(istanbulOuter, this.getInnerIstanbul(source, path)), {})
+	  }
 
-    if (this.excludePath(resolvedPath)) {
-      return
-    }
+	  _statementsToIstanbul (source, path) {
+	    const statements = {
+	      statementMap: {},
+	      s: {}
+	    };
+	    source.lines.forEach((line, index) => {
+	      if (!line.ignore) {
+	        statements.statementMap[`${index}`] = line.toIstanbul();
+	        statements.s[`${index}`] = line.count;
+	      }
+	    });
+	    return statements
+	  }
 
-    return {
-      [resolvedPath]: {
-        path: resolvedPath,
-        all: this.all,
-        ...this._statementsToIstanbul(source, path),
-        ...this._branchesToIstanbul(source, path),
-        ...this._functionsToIstanbul(source, path)
-      }
-    }
-  }
+	  _branchesToIstanbul (source, path) {
+	    const branches = {
+	      branchMap: {},
+	      b: {}
+	    };
+	    this.branches[path] = this.branches[path] || [];
+	    this.branches[path].forEach((branch, index) => {
+	      const srcLine = source.lines[branch.startLine - 1];
+	      const ignore = srcLine === undefined ? true : srcLine.ignore;
+	      branches.branchMap[`${index}`] = branch.toIstanbul();
+	      branches.b[`${index}`] = [ignore ? 1 : branch.count];
+	    });
+	    return branches
+	  }
 
-  toIstanbul () {
-    return this.covSources.reduce((istanbulOuter, { source, path }) => Object.assign(istanbulOuter, this.getInnerIstanbul(source, path)), {})
-  }
+	  _functionsToIstanbul (source, path) {
+	    const functions = {
+	      fnMap: {},
+	      f: {}
+	    };
+	    this.functions[path] = this.functions[path] || [];
+	    this.functions[path].forEach((fn, index) => {
+	      const srcLine = source.lines[fn.startLine - 1];
+	      const ignore = srcLine === undefined ? true : srcLine.ignore;
+	      functions.fnMap[`${index}`] = fn.toIstanbul();
+	      functions.f[`${index}`] = ignore ? 1 : fn.count;
+	    });
+	    return functions
+	  }
+	};
 
-  _statementsToIstanbul (source, path) {
-    const statements = {
-      statementMap: {},
-      s: {}
-    };
-    source.lines.forEach((line, index) => {
-      if (!line.ignore) {
-        statements.statementMap[`${index}`] = line.toIstanbul();
-        statements.s[`${index}`] = line.count;
-      }
-    });
-    return statements
-  }
+	function parsePath (scriptPath) {
+	  return scriptPath.startsWith('file://') ? fileURLToPath(scriptPath) : scriptPath
+	}
+	return v8ToIstanbul$2;
+}
 
-  _branchesToIstanbul (source, path) {
-    const branches = {
-      branchMap: {},
-      b: {}
-    };
-    this.branches[path] = this.branches[path] || [];
-    this.branches[path].forEach((branch, index) => {
-      const srcLine = source.lines[branch.startLine - 1];
-      const ignore = srcLine === undefined ? true : srcLine.ignore;
-      branches.branchMap[`${index}`] = branch.toIstanbul();
-      branches.b[`${index}`] = [ignore ? 1 : branch.count];
-    });
-    return branches
-  }
+var v8ToIstanbul$1;
+var hasRequiredV8ToIstanbul;
 
-  _functionsToIstanbul (source, path) {
-    const functions = {
-      fnMap: {},
-      f: {}
-    };
-    this.functions[path] = this.functions[path] || [];
-    this.functions[path].forEach((fn, index) => {
-      const srcLine = source.lines[fn.startLine - 1];
-      const ignore = srcLine === undefined ? true : srcLine.ignore;
-      functions.fnMap[`${index}`] = fn.toIstanbul();
-      functions.f[`${index}`] = ignore ? 1 : fn.count;
-    });
-    return functions
-  }
-};
+function requireV8ToIstanbul () {
+	if (hasRequiredV8ToIstanbul) return v8ToIstanbul$1;
+	hasRequiredV8ToIstanbul = 1;
+	// Patch applied: https://github.com/istanbuljs/v8-to-istanbul/pull/244
+	const V8ToIstanbul = requireV8ToIstanbul$1();
 
-function parsePath (scriptPath) {
-  return scriptPath.startsWith('file://') ? fileURLToPath(scriptPath) : scriptPath
+	v8ToIstanbul$1 = function (path, wrapperLength, sources, excludePath, excludeEmptyLines) {
+	  return new V8ToIstanbul(path, wrapperLength, sources, excludePath, excludeEmptyLines)
+	};
+	return v8ToIstanbul$1;
 }
 
-// Patch applied: https://github.com/istanbuljs/v8-to-istanbul/pull/244
-const V8ToIstanbul = v8ToIstanbul$2;
-
-var v8ToIstanbul = function (path, wrapperLength, sources, excludePath, excludeEmptyLines) {
-  return new V8ToIstanbul(path, wrapperLength, sources, excludePath, excludeEmptyLines)
-};
-
-var v8ToIstanbul$1 = /*@__PURE__*/getDefaultExportFromCjs(v8ToIstanbul);
+var v8ToIstanbulExports = requireV8ToIstanbul();
+var v8ToIstanbul = /*@__PURE__*/getDefaultExportFromCjs(v8ToIstanbulExports);
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -2512,57 +2539,20 @@ function cleanUrl(url) {
   "wasi"
 ]);
 
-var version = "2.1.1";
+var version = "2.1.3";
 
 const WRAPPER_LENGTH = 185;
 const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
 const DECORATOR_METADATA_PATTERN = /_ts_metadata\("design:paramtypes", \[[^\]]*\]\),*/g;
-const DEFAULT_PROJECT = Symbol.for("default-project");
 const FILE_PROTOCOL = "file://";
 const debug = createDebug("vitest:coverage");
-let uniqueId = 0;
 class V8CoverageProvider extends BaseCoverageProvider {
   name = "v8";
-  ctx;
-  options;
+  version = version;
   testExclude;
-  coverageFiles = /* @__PURE__ */ new Map();
-  coverageFilesDirectory;
-  pendingPromises = [];
   initialize(ctx) {
-    const config = ctx.config.coverage;
-    if (ctx.version !== version) {
-      ctx.logger.warn(
-        c.yellow(
-          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-v8@${version} `))}.
-Running mixed versions is not supported and may lead into bugs
-Update your dependencies and make sure the versions match.`
-        )
-      );
-    }
-    this.ctx = ctx;
-    this.options = {
-      ...coverageConfigDefaults,
-      // User's options
-      ...config,
-      // Resolved fields
-      provider: "v8",
-      reporter: this.resolveReporters(
-        config.reporter || coverageConfigDefaults.reporter
-      ),
-      reportsDirectory: resolve(
-        ctx.config.root,
-        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
-      ),
-      thresholds: config.thresholds && {
-        ...config.thresholds,
-        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
-        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
-        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
-        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
-      }
-    };
-    this.testExclude = new _TestExclude({
+    this._initialize(ctx);
+    this.testExclude = new TestExclude({
       cwd: ctx.config.root,
       include: this.options.include,
       exclude: this.options.exclude,
@@ -2570,80 +2560,18 @@ Update your dependencies and make sure the versions match.`
       extension: this.options.extension,
       relativePath: !this.options.allowExternal
     });
-    const shard = this.ctx.config.shard;
-    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-    this.coverageFilesDirectory = resolve(
-      this.options.reportsDirectory,
-      tempDirectory
-    );
   }
-  resolveOptions() {
-    return this.options;
-  }
-  async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory)) {
-      await promises$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 = [];
-  }
-  /*
-   * Coverage and meta information passed from Vitest runners.
-   * Note that adding new entries here and requiring on those without
-   * backwards compatibility is a breaking change.
-   */
-  onAfterSuiteRun({ coverage, transformMode, projectName }) {
-    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
-      throw new Error(`Invalid transform mode: ${transformMode}`);
-    }
-    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
-    if (!entry) {
-      entry = { web: [], ssr: [], browser: [] };
-      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-    }
-    const 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);
+  createCoverageMap() {
+    return libCoverage.createCoverageMap({});
   }
   async generateCoverage({ allTestsRun }) {
-    const coverageMap = libCoverage.createCoverageMap({});
-    let index = 0;
-    const total = this.pendingPromises.length;
-    await Promise.all(this.pendingPromises);
-    this.pendingPromises = [];
-    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-      for (const [transformMode, filenames] of Object.entries(coveragePerProject)) {
-        let merged = { result: [] };
-        const project = this.ctx.projects.find((p) => p.getName() === projectName) || this.ctx.getCoreWorkspaceProject();
-        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
-          if (debug.enabled) {
-            index += chunk.length;
-            debug("Covered files %d/%d", index, total);
-          }
-          await Promise.all(
-            chunk.map(async (filename) => {
-              const contents = await promises$1.readFile(filename, "utf-8");
-              const coverage = JSON.parse(contents);
-              merged = mergeProcessCovs([merged, coverage]);
-            })
-          );
-        }
+    const coverageMap = this.createCoverageMap();
+    let merged = { result: [] };
+    await this.readCoverageFiles({
+      onFileRead(coverage) {
+        merged = mergeProcessCovs([merged, coverage]);
+      },
+      onFinished: async (project, transformMode) => {
         const converted = await this.convertCoverage(
           merged,
           project,
@@ -2651,9 +2579,11 @@ Update your dependencies and make sure the versions match.`
         );
         const transformedCoverage = await transformCoverage(converted);
         coverageMap.merge(transformedCoverage);
-      }
-    }
-    if (this.options.all && allTestsRun) {
+        merged = { result: [] };
+      },
+      onDebug: debug
+    });
+    if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
       const coveredFiles = coverageMap.files();
       const untestedCoverage = await this.getUntestedFiles(coveredFiles);
       const converted = await this.convertCoverage(untestedCoverage);
@@ -2664,7 +2594,7 @@ Update your dependencies and make sure the versions match.`
     }
     return coverageMap;
   }
-  async reportCoverage(coverageMap, { allTestsRun }) {
+  async generateReports(coverageMap, allTestsRun) {
     if (provider === "stackblitz") {
       this.ctx.logger.log(
         c.blue(" % ") + c.yellow(
@@ -2672,20 +2602,6 @@ Update your dependencies and make sure the versions match.`
         )
       );
     }
-    await this.generateReports(
-      coverageMap || libCoverage.createCoverageMap({}),
-      allTestsRun
-    );
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-    if (!keepResults) {
-      this.coverageFiles = /* @__PURE__ */ new Map();
-      await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
-      if (readdirSync(this.options.reportsDirectory).length === 0) {
-        await promises$1.rm(this.options.reportsDirectory, { recursive: true });
-      }
-    }
-  }
-  async generateReports(coverageMap, allTestsRun) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -2704,46 +2620,13 @@ Update your dependencies and make sure the versions match.`
       }).execute(context);
     }
     if (this.options.thresholds) {
-      const resolvedThresholds = this.resolveThresholds({
-        coverageMap,
-        thresholds: this.options.thresholds,
-        createCoverageMap: () => libCoverage.createCoverageMap({}),
-        root: this.ctx.config.root
-      });
-      this.checkThresholds({
-        thresholds: resolvedThresholds,
-        perFile: this.options.thresholds.perFile,
-        onError: (error) => this.ctx.logger.error(error)
-      });
-      if (this.options.thresholds.autoUpdate && allTestsRun) {
-        if (!this.ctx.server.config.configFile) {
-          throw new Error(
-            'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
-          );
-        }
-        const configFilePath = this.ctx.server.config.configFile;
-        const configModule = parseModule(
-          await promises$1.readFile(configFilePath, "utf8")
-        );
-        this.updateThresholds({
-          thresholds: resolvedThresholds,
-          perFile: this.options.thresholds.perFile,
-          configurationFile: configModule,
-          onUpdate: () => writeFileSync(
-            configFilePath,
-            configModule.generate().code,
-            "utf-8"
-          )
-        });
-      }
+      await this.reportThresholds(coverageMap, allTestsRun);
     }
   }
-  async mergeReports(coverageMaps) {
-    const coverageMap = libCoverage.createCoverageMap({});
-    for (const coverage of coverageMaps) {
-      coverageMap.merge(coverage);
-    }
-    await this.generateReports(coverageMap, true);
+  async parseConfigModule(configFilePath) {
+    return parseModule(
+      await promises.readFile(configFilePath, "utf8")
+    );
   }
   async getUntestedFiles(testedFiles) {
     const transformResults = normalizeTransformResults(
@@ -2762,10 +2645,7 @@ Update your dependencies and make sure the versions match.`
     const uncoveredFiles = includedFiles.map((file) => pathToFileURL(file)).filter((file) => !testedFiles.includes(file.pathname));
     let merged = { result: [] };
     let index = 0;
-    for (const chunk of this.toSlices(
-      uncoveredFiles,
-      this.options.processingConcurrency
-    )) {
+    for (const chunk of this.toSlices(uncoveredFiles, this.options.processingConcurrency)) {
       if (debug.enabled) {
         index += chunk.length;
         debug("Uncovered files %d/%d", index, uncoveredFiles.length);
@@ -2809,7 +2689,7 @@ Update your dependencies and make sure the versions match.`
     return merged;
   }
   async getSources(url, transformResults, onTransform, functions = []) {
-    const filePath = normalize(fileURLToPath$1(url));
+    const filePath = normalize(fileURLToPath(url));
     let isExecuted = true;
     let transformResult = transformResults.get(filePath);
     if (!transformResult) {
@@ -2820,7 +2700,7 @@ Update your dependencies and make sure the versions match.`
     const code = transformResult?.code;
     const sourcesContent = map?.sourcesContent || [];
     if (!sourcesContent[0]) {
-      sourcesContent[0] = await promises$1.readFile(filePath, "utf-8").catch(() => {
+      sourcesContent[0] = await promises.readFile(filePath, "utf-8").catch(() => {
         const length = findLongestFunctionLength(functions);
         return ".".repeat(length);
       });
@@ -2874,11 +2754,11 @@ Update your dependencies and make sure the versions match.`
           result.url = `${FILE_PROTOCOL}${project.config.root}${result.url}`;
         }
       }
-      if (this.testExclude.shouldInstrument(fileURLToPath$1(result.url))) {
+      if (this.testExclude.shouldInstrument(fileURLToPath(result.url))) {
         scriptCoverages.push(result);
       }
     }
-    const coverageMap = libCoverage.createCoverageMap({});
+    const coverageMap = this.createCoverageMap();
     let index = 0;
     for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
       if (debug.enabled) {
@@ -2894,7 +2774,7 @@ Update your dependencies and make sure the versions match.`
             functions
           );
           const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
-          const converter = v8ToIstanbul$1(
+          const converter = v8ToIstanbul(
             url,
             wrapperLength,
             sources,