vitest 0.0.129 → 0.0.130

package/dist/{index-d30b5ed0.js → index-bc2183ca.js}

@@ -1,5 +1,5 @@
 import fs$8, { promises, existsSync } from 'fs';
-import { c, s as slash$1, a as isAbsolute, r as relative, d as dirname, b as basename, g as getFullName, h as hasFailed, f as getSuites, j as getTests, t as toArray, k as resolve, l as deepMerge, m as toFilePath, n as noop$1, e as ensurePackageInstalled } from './index-42a3a132.js';
+import { c, s as slash$1, a as isAbsolute, r as relative, d as dirname, b as basename, g as getFullName, h as hasFailed, f as getSuites, j as getTests, t as toArray, k as resolve, l as deepMerge, m as toFilePath, n as noop$1, e as ensurePackageInstalled } from './index-9fdde2e8.js';
 import { createServer, mergeConfig } from 'vite';
 import path$a from 'path';
 import process$1 from 'process';
@@ -7,17 +7,16 @@ import require$$0 from 'os';
 import require$$0$1 from 'util';
 import require$$0$2 from 'stream';
 import require$$2 from 'events';
-import { c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
-import { d as defaultPort, a as defaultInclude, b as defaultExclude, c as distDir, e as configFiles } from './constants-868b9a2e.js';
-import MagicString from './magic-string.es-98a8bfa0.js';
+import { d as defaultPort, a as defaultInclude, b as defaultExclude, c as distDir, e as configFiles } from './constants-5b9c0d41.js';
+import MagicString from './magic-string.es-94000aea.js';
 import { performance } from 'perf_hooks';
-import { F as F_POINTER, a as F_DOWN, s as stripAnsi, b as F_LONG_DASH, c as F_DOWN_RIGHT, d as F_DOT, e as F_CHECK, f as F_CROSS, g as F_RIGHT, p as printError, h as stringWidth, i as ansiStyles, j as sliceAnsi, k as cliTruncate } from './diff-be830986.js';
-import { o as onetime, s as signalExit } from './index-cb02ee01.js';
+import { F as F_POINTER, a as F_DOWN, s as stripAnsi, b as F_LONG_DASH, c as F_DOWN_RIGHT, d as F_DOT, e as F_CHECK, f as F_CROSS, g as F_RIGHT, p as printError, h as stringWidth, i as ansiStyles, j as sliceAnsi, k as cliTruncate } from './diff-3adb959a.js';
+import { o as onetime, s as signalExit } from './index-648e7ab2.js';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
-import { c as createBirpc } from './index-a73f33e0.js';
+import { c as createBirpc } from './index-e909c175.js';
 
 /*
 How it works:
@@ -4985,65 +4984,61 @@ var out$3 = {};
 
 var async$5 = {};
 
-Object.defineProperty(async$5, "__esModule", { value: true });
-async$5.read = void 0;
-function read$3(path, settings, callback) {
-    settings.fs.lstat(path, (lstatError, lstat) => {
-        if (lstatError !== null) {
-            callFailureCallback$2(callback, lstatError);
-            return;
-        }
-        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
-            callSuccessCallback$2(callback, lstat);
-            return;
-        }
-        settings.fs.stat(path, (statError, stat) => {
-            if (statError !== null) {
-                if (settings.throwErrorOnBrokenSymbolicLink) {
-                    callFailureCallback$2(callback, statError);
-                    return;
-                }
-                callSuccessCallback$2(callback, lstat);
-                return;
-            }
-            if (settings.markSymbolicLink) {
-                stat.isSymbolicLink = () => true;
-            }
-            callSuccessCallback$2(callback, stat);
-        });
-    });
-}
-async$5.read = read$3;
-function callFailureCallback$2(callback, error) {
-    callback(error);
-}
-function callSuccessCallback$2(callback, result) {
-    callback(null, result);
+Object.defineProperty(async$5, "__esModule", { value: true });
+async$5.read = void 0;
+function read$3(path, settings, callback) {
+    settings.fs.lstat(path, (lstatError, lstat) => {
+        if (lstatError !== null) {
+            return callFailureCallback$2(callback, lstatError);
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            return callSuccessCallback$2(callback, lstat);
+        }
+        settings.fs.stat(path, (statError, stat) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return callFailureCallback$2(callback, statError);
+                }
+                return callSuccessCallback$2(callback, lstat);
+            }
+            if (settings.markSymbolicLink) {
+                stat.isSymbolicLink = () => true;
+            }
+            callSuccessCallback$2(callback, stat);
+        });
+    });
+}
+async$5.read = read$3;
+function callFailureCallback$2(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$2(callback, result) {
+    callback(null, result);
 }
 
 var sync$7 = {};
 
-Object.defineProperty(sync$7, "__esModule", { value: true });
-sync$7.read = void 0;
-function read$2(path, settings) {
-    const lstat = settings.fs.lstatSync(path);
-    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
-        return lstat;
-    }
-    try {
-        const stat = settings.fs.statSync(path);
-        if (settings.markSymbolicLink) {
-            stat.isSymbolicLink = () => true;
-        }
-        return stat;
-    }
-    catch (error) {
-        if (!settings.throwErrorOnBrokenSymbolicLink) {
-            return lstat;
-        }
-        throw error;
-    }
-}
+Object.defineProperty(sync$7, "__esModule", { value: true });
+sync$7.read = void 0;
+function read$2(path, settings) {
+    const lstat = settings.fs.lstatSync(path);
+    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+        return lstat;
+    }
+    try {
+        const stat = settings.fs.statSync(path);
+        if (settings.markSymbolicLink) {
+            stat.isSymbolicLink = () => true;
+        }
+        return stat;
+    }
+    catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink) {
+            return lstat;
+        }
+        throw error;
+    }
+}
 sync$7.read = read$2;
 
 var settings$3 = {};
@@ -5051,64 +5046,63 @@ var settings$3 = {};
 var fs$5 = {};
 
 (function (exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs$8;
-exports.FILE_SYSTEM_ADAPTER = {
-    lstat: fs.lstat,
-    stat: fs.stat,
-    lstatSync: fs.lstatSync,
-    statSync: fs.statSync
-};
-function createFileSystemAdapter(fsMethods) {
-    if (fsMethods === undefined) {
-        return exports.FILE_SYSTEM_ADAPTER;
-    }
-    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = fs$8;
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
 exports.createFileSystemAdapter = createFileSystemAdapter;
 }(fs$5));
 
-Object.defineProperty(settings$3, "__esModule", { value: true });
-const fs$4 = fs$5;
-class Settings$2 {
-    constructor(_options = {}) {
-        this._options = _options;
-        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs$4.createFileSystemAdapter(this._options.fs);
-        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
-        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
-    }
-    _getValue(option, value) {
-        return option !== null && option !== void 0 ? option : value;
-    }
-}
+Object.defineProperty(settings$3, "__esModule", { value: true });
+const fs$4 = fs$5;
+class Settings$2 {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = fs$4.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
 settings$3.default = Settings$2;
 
-Object.defineProperty(out$3, "__esModule", { value: true });
-out$3.statSync = out$3.stat = out$3.Settings = void 0;
-const async$4 = async$5;
-const sync$6 = sync$7;
-const settings_1$3 = settings$3;
-out$3.Settings = settings_1$3.default;
-function stat(path, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === 'function') {
-        async$4.read(path, getSettings$2(), optionsOrSettingsOrCallback);
-        return;
-    }
-    async$4.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
-}
-out$3.stat = stat;
-function statSync(path, optionsOrSettings) {
-    const settings = getSettings$2(optionsOrSettings);
-    return sync$6.read(path, settings);
-}
-out$3.statSync = statSync;
-function getSettings$2(settingsOrOptions = {}) {
-    if (settingsOrOptions instanceof settings_1$3.default) {
-        return settingsOrOptions;
-    }
-    return new settings_1$3.default(settingsOrOptions);
+Object.defineProperty(out$3, "__esModule", { value: true });
+out$3.statSync = out$3.stat = out$3.Settings = void 0;
+const async$4 = async$5;
+const sync$6 = sync$7;
+const settings_1$3 = settings$3;
+out$3.Settings = settings_1$3.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async$4.read(path, getSettings$2(), optionsOrSettingsOrCallback);
+    }
+    async$4.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
+}
+out$3.stat = stat;
+function statSync(path, optionsOrSettings) {
+    const settings = getSettings$2(optionsOrSettings);
+    return sync$6.read(path, settings);
+}
+out$3.statSync = statSync;
+function getSettings$2(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$3.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$3.default(settingsOrOptions);
 }
 
 var out$2 = {};
@@ -5126,7 +5120,7 @@ var async$1 = {};
 let promise;
 
 var queueMicrotask_1 = typeof queueMicrotask === 'function'
-  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : commonjsGlobal)
+  ? queueMicrotask.bind(globalThis)
   // reuse resolved promise, and allocate it lazily
   : cb => (promise || (promise = Promise.resolve()))
     .then(cb)
@@ -5187,224 +5181,209 @@ function runParallel (tasks, cb) {
 
 var constants = {};
 
-Object.defineProperty(constants, "__esModule", { value: true });
-constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
-const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
-if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
-    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
-}
-const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
-const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
-const SUPPORTED_MAJOR_VERSION = 10;
-const SUPPORTED_MINOR_VERSION = 10;
-const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
-const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
-/**
- * IS `true` for Node.js 10.10 and greater.
- */
+Object.defineProperty(constants, "__esModule", { value: true });
+constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
 constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
 
 var utils$9 = {};
 
 var fs$3 = {};
 
-Object.defineProperty(fs$3, "__esModule", { value: true });
-fs$3.createDirentFromStats = void 0;
-class DirentFromStats {
-    constructor(name, stats) {
-        this.name = name;
-        this.isBlockDevice = stats.isBlockDevice.bind(stats);
-        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
-        this.isDirectory = stats.isDirectory.bind(stats);
-        this.isFIFO = stats.isFIFO.bind(stats);
-        this.isFile = stats.isFile.bind(stats);
-        this.isSocket = stats.isSocket.bind(stats);
-        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
-    }
-}
-function createDirentFromStats(name, stats) {
-    return new DirentFromStats(name, stats);
-}
+Object.defineProperty(fs$3, "__esModule", { value: true });
+fs$3.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
 fs$3.createDirentFromStats = createDirentFromStats;
 
-Object.defineProperty(utils$9, "__esModule", { value: true });
-utils$9.fs = void 0;
-const fs$2 = fs$3;
+Object.defineProperty(utils$9, "__esModule", { value: true });
+utils$9.fs = void 0;
+const fs$2 = fs$3;
 utils$9.fs = fs$2;
 
 var common$6 = {};
 
-Object.defineProperty(common$6, "__esModule", { value: true });
-common$6.joinPathSegments = void 0;
-function joinPathSegments$1(a, b, separator) {
-    /**
-     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
-     */
-    if (a.endsWith(separator)) {
-        return a + b;
-    }
-    return a + separator + b;
-}
+Object.defineProperty(common$6, "__esModule", { value: true });
+common$6.joinPathSegments = void 0;
+function joinPathSegments$1(a, b, separator) {
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
 common$6.joinPathSegments = joinPathSegments$1;
 
-Object.defineProperty(async$1, "__esModule", { value: true });
-async$1.readdir = async$1.readdirWithFileTypes = async$1.read = void 0;
-const fsStat$5 = out$3;
-const rpl = runParallel_1;
-const constants_1$1 = constants;
-const utils$8 = utils$9;
-const common$5 = common$6;
-function read$1(directory, settings, callback) {
-    if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
-        readdirWithFileTypes$1(directory, settings, callback);
-        return;
-    }
-    readdir$1(directory, settings, callback);
-}
-async$1.read = read$1;
-function readdirWithFileTypes$1(directory, settings, callback) {
-    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
-        if (readdirError !== null) {
-            callFailureCallback$1(callback, readdirError);
-            return;
-        }
-        const entries = dirents.map((dirent) => ({
-            dirent,
-            name: dirent.name,
-            path: common$5.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
-        }));
-        if (!settings.followSymbolicLinks) {
-            callSuccessCallback$1(callback, entries);
-            return;
-        }
-        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
-        rpl(tasks, (rplError, rplEntries) => {
-            if (rplError !== null) {
-                callFailureCallback$1(callback, rplError);
-                return;
-            }
-            callSuccessCallback$1(callback, rplEntries);
-        });
-    });
-}
-async$1.readdirWithFileTypes = readdirWithFileTypes$1;
-function makeRplTaskEntry(entry, settings) {
-    return (done) => {
-        if (!entry.dirent.isSymbolicLink()) {
-            done(null, entry);
-            return;
-        }
-        settings.fs.stat(entry.path, (statError, stats) => {
-            if (statError !== null) {
-                if (settings.throwErrorOnBrokenSymbolicLink) {
-                    done(statError);
-                    return;
-                }
-                done(null, entry);
-                return;
-            }
-            entry.dirent = utils$8.fs.createDirentFromStats(entry.name, stats);
-            done(null, entry);
-        });
-    };
-}
-function readdir$1(directory, settings, callback) {
-    settings.fs.readdir(directory, (readdirError, names) => {
-        if (readdirError !== null) {
-            callFailureCallback$1(callback, readdirError);
-            return;
-        }
-        const tasks = names.map((name) => {
-            const path = common$5.joinPathSegments(directory, name, settings.pathSegmentSeparator);
-            return (done) => {
-                fsStat$5.stat(path, settings.fsStatSettings, (error, stats) => {
-                    if (error !== null) {
-                        done(error);
-                        return;
-                    }
-                    const entry = {
-                        name,
-                        path,
-                        dirent: utils$8.fs.createDirentFromStats(name, stats)
-                    };
-                    if (settings.stats) {
-                        entry.stats = stats;
-                    }
-                    done(null, entry);
-                });
-            };
-        });
-        rpl(tasks, (rplError, entries) => {
-            if (rplError !== null) {
-                callFailureCallback$1(callback, rplError);
-                return;
-            }
-            callSuccessCallback$1(callback, entries);
-        });
-    });
-}
-async$1.readdir = readdir$1;
-function callFailureCallback$1(callback, error) {
-    callback(error);
-}
-function callSuccessCallback$1(callback, result) {
-    callback(null, result);
+Object.defineProperty(async$1, "__esModule", { value: true });
+async$1.readdir = async$1.readdirWithFileTypes = async$1.read = void 0;
+const fsStat$5 = out$3;
+const rpl = runParallel_1;
+const constants_1$1 = constants;
+const utils$8 = utils$9;
+const common$5 = common$6;
+function read$1(directory, settings, callback) {
+    if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes$1(directory, settings, callback);
+    }
+    return readdir$1(directory, settings, callback);
+}
+async$1.read = read$1;
+function readdirWithFileTypes$1(directory, settings, callback) {
+    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+            return callFailureCallback$1(callback, readdirError);
+        }
+        const entries = dirents.map((dirent) => ({
+            dirent,
+            name: dirent.name,
+            path: common$5.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        }));
+        if (!settings.followSymbolicLinks) {
+            return callSuccessCallback$1(callback, entries);
+        }
+        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+            if (rplError !== null) {
+                return callFailureCallback$1(callback, rplError);
+            }
+            callSuccessCallback$1(callback, rplEntries);
+        });
+    });
+}
+async$1.readdirWithFileTypes = readdirWithFileTypes$1;
+function makeRplTaskEntry(entry, settings) {
+    return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+            return done(null, entry);
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return done(statError);
+                }
+                return done(null, entry);
+            }
+            entry.dirent = utils$8.fs.createDirentFromStats(entry.name, stats);
+            return done(null, entry);
+        });
+    };
+}
+function readdir$1(directory, settings, callback) {
+    settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+            return callFailureCallback$1(callback, readdirError);
+        }
+        const filepaths = names.map((name) => common$5.joinPathSegments(directory, name, settings.pathSegmentSeparator));
+        const tasks = filepaths.map((filepath) => {
+            return (done) => fsStat$5.stat(filepath, settings.fsStatSettings, done);
+        });
+        rpl(tasks, (rplError, results) => {
+            if (rplError !== null) {
+                return callFailureCallback$1(callback, rplError);
+            }
+            const entries = [];
+            names.forEach((name, index) => {
+                const stats = results[index];
+                const entry = {
+                    name,
+                    path: filepaths[index],
+                    dirent: utils$8.fs.createDirentFromStats(name, stats)
+                };
+                if (settings.stats) {
+                    entry.stats = stats;
+                }
+                entries.push(entry);
+            });
+            callSuccessCallback$1(callback, entries);
+        });
+    });
+}
+async$1.readdir = readdir$1;
+function callFailureCallback$1(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$1(callback, result) {
+    callback(null, result);
 }
 
 var sync$5 = {};
 
-Object.defineProperty(sync$5, "__esModule", { value: true });
-sync$5.readdir = sync$5.readdirWithFileTypes = sync$5.read = void 0;
-const fsStat$4 = out$3;
-const constants_1 = constants;
-const utils$7 = utils$9;
-const common$4 = common$6;
-function read(directory, settings) {
-    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
-        return readdirWithFileTypes(directory, settings);
-    }
-    return readdir(directory, settings);
-}
-sync$5.read = read;
-function readdirWithFileTypes(directory, settings) {
-    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
-    return dirents.map((dirent) => {
-        const entry = {
-            dirent,
-            name: dirent.name,
-            path: common$4.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
-        };
-        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
-            try {
-                const stats = settings.fs.statSync(entry.path);
-                entry.dirent = utils$7.fs.createDirentFromStats(entry.name, stats);
-            }
-            catch (error) {
-                if (settings.throwErrorOnBrokenSymbolicLink) {
-                    throw error;
-                }
-            }
-        }
-        return entry;
-    });
-}
-sync$5.readdirWithFileTypes = readdirWithFileTypes;
-function readdir(directory, settings) {
-    const names = settings.fs.readdirSync(directory);
-    return names.map((name) => {
-        const entryPath = common$4.joinPathSegments(directory, name, settings.pathSegmentSeparator);
-        const stats = fsStat$4.statSync(entryPath, settings.fsStatSettings);
-        const entry = {
-            name,
-            path: entryPath,
-            dirent: utils$7.fs.createDirentFromStats(name, stats)
-        };
-        if (settings.stats) {
-            entry.stats = stats;
-        }
-        return entry;
-    });
-}
+Object.defineProperty(sync$5, "__esModule", { value: true });
+sync$5.readdir = sync$5.readdirWithFileTypes = sync$5.read = void 0;
+const fsStat$4 = out$3;
+const constants_1 = constants;
+const utils$7 = utils$9;
+const common$4 = common$6;
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir(directory, settings);
+}
+sync$5.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: common$4.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils$7.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+sync$5.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = common$4.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+        const stats = fsStat$4.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils$7.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
 sync$5.readdir = readdir;
 
 var settings$2 = {};
@@ -5412,78 +5391,75 @@ var settings$2 = {};
 var fs$1 = {};
 
 (function (exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs$8;
-exports.FILE_SYSTEM_ADAPTER = {
-    lstat: fs.lstat,
-    stat: fs.stat,
-    lstatSync: fs.lstatSync,
-    statSync: fs.statSync,
-    readdir: fs.readdir,
-    readdirSync: fs.readdirSync
-};
-function createFileSystemAdapter(fsMethods) {
-    if (fsMethods === undefined) {
-        return exports.FILE_SYSTEM_ADAPTER;
-    }
-    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = fs$8;
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
 exports.createFileSystemAdapter = createFileSystemAdapter;
 }(fs$1));
 
-Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$3 = path$a;
-const fsStat$3 = out$3;
-const fs = fs$1;
-class Settings$1 {
-    constructor(_options = {}) {
-        this._options = _options;
-        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs.createFileSystemAdapter(this._options.fs);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$3.sep);
-        this.stats = this._getValue(this._options.stats, false);
-        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
-        this.fsStatSettings = new fsStat$3.Settings({
-            followSymbolicLink: this.followSymbolicLinks,
-            fs: this.fs,
-            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
-        });
-    }
-    _getValue(option, value) {
-        return option !== null && option !== void 0 ? option : value;
-    }
-}
+Object.defineProperty(settings$2, "__esModule", { value: true });
+const path$3 = path$a;
+const fsStat$3 = out$3;
+const fs = fs$1;
+class Settings$1 {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$3.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat$3.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
 settings$2.default = Settings$1;
 
-Object.defineProperty(out$1, "__esModule", { value: true });
-out$1.Settings = out$1.scandirSync = out$1.scandir = void 0;
-const async = async$1;
-const sync$4 = sync$5;
-const settings_1$2 = settings$2;
-out$1.Settings = settings_1$2.default;
-function scandir(path, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === 'function') {
-        async.read(path, getSettings$1(), optionsOrSettingsOrCallback);
-        return;
-    }
-    async.read(path, getSettings$1(optionsOrSettingsOrCallback), callback);
-}
-out$1.scandir = scandir;
-function scandirSync(path, optionsOrSettings) {
-    const settings = getSettings$1(optionsOrSettings);
-    return sync$4.read(path, settings);
-}
-out$1.scandirSync = scandirSync;
-function getSettings$1(settingsOrOptions = {}) {
-    if (settingsOrOptions instanceof settings_1$2.default) {
-        return settingsOrOptions;
-    }
-    return new settings_1$2.default(settingsOrOptions);
+Object.defineProperty(out$1, "__esModule", { value: true });
+out$1.Settings = out$1.scandirSync = out$1.scandir = void 0;
+const async = async$1;
+const sync$4 = sync$5;
+const settings_1$2 = settings$2;
+out$1.Settings = settings_1$2.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async.read(path, getSettings$1(), optionsOrSettingsOrCallback);
+    }
+    async.read(path, getSettings$1(optionsOrSettingsOrCallback), callback);
+}
+out$1.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings$1(optionsOrSettings);
+    return sync$4.read(path, settings);
+}
+out$1.scandirSync = scandirSync;
+function getSettings$1(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$2.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$2.default(settingsOrOptions);
 }
 
-var queue = {exports: {}};
-
 function reusify$1 (Constructor) {
   var head = new Constructor();
   var tail = head;
@@ -5516,8 +5492,6 @@ function reusify$1 (Constructor) {
 
 var reusify_1 = reusify$1;
 
-/* eslint-disable no-var */
-
 var reusify = reusify_1;
 
 function fastqueue (context, worker, concurrency) {
@@ -5718,432 +5692,352 @@ function Task () {
   };
 }
 
-function queueAsPromised (context, worker, concurrency) {
-  if (typeof context === 'function') {
-    concurrency = worker;
-    worker = context;
-    context = null;
-  }
-
-  function asyncWrapper (arg, cb) {
-    worker.call(this, arg)
-      .then(function (res) {
-        cb(null, res);
-      }, cb);
-  }
-
-  var queue = fastqueue(context, asyncWrapper, concurrency);
-
-  var pushCb = queue.push;
-  var unshiftCb = queue.unshift;
-
-  queue.push = push;
-  queue.unshift = unshift;
-  queue.drained = drained;
-
-  return queue
-
-  function push (value) {
-    var p = new Promise(function (resolve, reject) {
-      pushCb(value, function (err, result) {
-        if (err) {
-          reject(err);
-          return
-        }
-        resolve(result);
-      });
-    });
-
-    // Let's fork the promise chain to
-    // make the error bubble up to the user but
-    // not lead to a unhandledRejection
-    p.catch(noop);
-
-    return p
-  }
-
-  function unshift (value) {
-    var p = new Promise(function (resolve, reject) {
-      unshiftCb(value, function (err, result) {
-        if (err) {
-          reject(err);
-          return
-        }
-        resolve(result);
-      });
-    });
-
-    // Let's fork the promise chain to
-    // make the error bubble up to the user but
-    // not lead to a unhandledRejection
-    p.catch(noop);
-
-    return p
-  }
-
-  function drained () {
-    var previousDrain = queue.drain;
-
-    var p = new Promise(function (resolve) {
-      queue.drain = function () {
-        previousDrain();
-        resolve();
-      };
-    });
-
-    return p
-  }
-}
-
-queue.exports = fastqueue;
-queue.exports.promise = queueAsPromised;
+var queue = fastqueue;
 
 var common$3 = {};
 
-Object.defineProperty(common$3, "__esModule", { value: true });
-common$3.joinPathSegments = common$3.replacePathSegmentSeparator = common$3.isAppliedFilter = common$3.isFatalError = void 0;
-function isFatalError(settings, error) {
-    if (settings.errorFilter === null) {
-        return true;
-    }
-    return !settings.errorFilter(error);
-}
-common$3.isFatalError = isFatalError;
-function isAppliedFilter(filter, value) {
-    return filter === null || filter(value);
-}
-common$3.isAppliedFilter = isAppliedFilter;
-function replacePathSegmentSeparator(filepath, separator) {
-    return filepath.split(/[/\\]/).join(separator);
-}
-common$3.replacePathSegmentSeparator = replacePathSegmentSeparator;
-function joinPathSegments(a, b, separator) {
-    if (a === '') {
-        return b;
-    }
-    /**
-     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
-     */
-    if (a.endsWith(separator)) {
-        return a + b;
-    }
-    return a + separator + b;
-}
+Object.defineProperty(common$3, "__esModule", { value: true });
+common$3.joinPathSegments = common$3.replacePathSegmentSeparator = common$3.isAppliedFilter = common$3.isFatalError = void 0;
+function isFatalError(settings, error) {
+    if (settings.errorFilter === null) {
+        return true;
+    }
+    return !settings.errorFilter(error);
+}
+common$3.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+}
+common$3.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[/\\]/).join(separator);
+}
+common$3.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+    if (a === '') {
+        return b;
+    }
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
 common$3.joinPathSegments = joinPathSegments;
 
 var reader$1 = {};
 
-Object.defineProperty(reader$1, "__esModule", { value: true });
-const common$2 = common$3;
-class Reader$1 {
-    constructor(_root, _settings) {
-        this._root = _root;
-        this._settings = _settings;
-        this._root = common$2.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
-    }
-}
+Object.defineProperty(reader$1, "__esModule", { value: true });
+const common$2 = common$3;
+class Reader$1 {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._root = common$2.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
+}
 reader$1.default = Reader$1;
 
-Object.defineProperty(async$2, "__esModule", { value: true });
-const events_1 = require$$2;
-const fsScandir$2 = out$1;
-const fastq = queue.exports;
-const common$1 = common$3;
-const reader_1$3 = reader$1;
-class AsyncReader extends reader_1$3.default {
-    constructor(_root, _settings) {
-        super(_root, _settings);
-        this._settings = _settings;
-        this._scandir = fsScandir$2.scandir;
-        this._emitter = new events_1.EventEmitter();
-        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
-        this._isFatalError = false;
-        this._isDestroyed = false;
-        this._queue.drain = () => {
-            if (!this._isFatalError) {
-                this._emitter.emit('end');
-            }
-        };
-    }
-    read() {
-        this._isFatalError = false;
-        this._isDestroyed = false;
-        setImmediate(() => {
-            this._pushToQueue(this._root, this._settings.basePath);
-        });
-        return this._emitter;
-    }
-    get isDestroyed() {
-        return this._isDestroyed;
-    }
-    destroy() {
-        if (this._isDestroyed) {
-            throw new Error('The reader is already destroyed');
-        }
-        this._isDestroyed = true;
-        this._queue.killAndDrain();
-    }
-    onEntry(callback) {
-        this._emitter.on('entry', callback);
-    }
-    onError(callback) {
-        this._emitter.once('error', callback);
-    }
-    onEnd(callback) {
-        this._emitter.once('end', callback);
-    }
-    _pushToQueue(directory, base) {
-        const queueItem = { directory, base };
-        this._queue.push(queueItem, (error) => {
-            if (error !== null) {
-                this._handleError(error);
-            }
-        });
-    }
-    _worker(item, done) {
-        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
-            if (error !== null) {
-                done(error, undefined);
-                return;
-            }
-            for (const entry of entries) {
-                this._handleEntry(entry, item.base);
-            }
-            done(null, undefined);
-        });
-    }
-    _handleError(error) {
-        if (this._isDestroyed || !common$1.isFatalError(this._settings, error)) {
-            return;
-        }
-        this._isFatalError = true;
-        this._isDestroyed = true;
-        this._emitter.emit('error', error);
-    }
-    _handleEntry(entry, base) {
-        if (this._isDestroyed || this._isFatalError) {
-            return;
-        }
-        const fullpath = entry.path;
-        if (base !== undefined) {
-            entry.path = common$1.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
-        }
-        if (common$1.isAppliedFilter(this._settings.entryFilter, entry)) {
-            this._emitEntry(entry);
-        }
-        if (entry.dirent.isDirectory() && common$1.isAppliedFilter(this._settings.deepFilter, entry)) {
-            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
-        }
-    }
-    _emitEntry(entry) {
-        this._emitter.emit('entry', entry);
-    }
-}
+Object.defineProperty(async$2, "__esModule", { value: true });
+const events_1 = require$$2;
+const fsScandir$2 = out$1;
+const fastq = queue;
+const common$1 = common$3;
+const reader_1$3 = reader$1;
+class AsyncReader extends reader_1$3.default {
+    constructor(_root, _settings) {
+        super(_root, _settings);
+        this._settings = _settings;
+        this._scandir = fsScandir$2.scandir;
+        this._emitter = new events_1.EventEmitter();
+        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit('end');
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error('The reader is already destroyed');
+        }
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(callback) {
+        this._emitter.on('entry', callback);
+    }
+    onError(callback) {
+        this._emitter.once('error', callback);
+    }
+    onEnd(callback) {
+        this._emitter.once('end', callback);
+    }
+    _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+            if (error !== null) {
+                this._handleError(error);
+            }
+        });
+    }
+    _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+            if (error !== null) {
+                return done(error, undefined);
+            }
+            for (const entry of entries) {
+                this._handleEntry(entry, item.base);
+            }
+            done(null, undefined);
+        });
+    }
+    _handleError(error) {
+        if (this._isDestroyed || !common$1.isFatalError(this._settings, error)) {
+            return;
+        }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit('error', error);
+    }
+    _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
+        }
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common$1.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common$1.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._emitEntry(entry);
+        }
+        if (entry.dirent.isDirectory() && common$1.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _emitEntry(entry) {
+        this._emitter.emit('entry', entry);
+    }
+}
 async$2.default = AsyncReader;
 
-Object.defineProperty(async$3, "__esModule", { value: true });
-const async_1$3 = async$2;
-class AsyncProvider {
-    constructor(_root, _settings) {
-        this._root = _root;
-        this._settings = _settings;
-        this._reader = new async_1$3.default(this._root, this._settings);
-        this._storage = [];
-    }
-    read(callback) {
-        this._reader.onError((error) => {
-            callFailureCallback(callback, error);
-        });
-        this._reader.onEntry((entry) => {
-            this._storage.push(entry);
-        });
-        this._reader.onEnd(() => {
-            callSuccessCallback(callback, this._storage);
-        });
-        this._reader.read();
-    }
-}
-async$3.default = AsyncProvider;
-function callFailureCallback(callback, error) {
-    callback(error);
-}
-function callSuccessCallback(callback, entries) {
-    callback(null, entries);
+Object.defineProperty(async$3, "__esModule", { value: true });
+const async_1$3 = async$2;
+class AsyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$3.default(this._root, this._settings);
+        this._storage = new Set();
+    }
+    read(callback) {
+        this._reader.onError((error) => {
+            callFailureCallback(callback, error);
+        });
+        this._reader.onEntry((entry) => {
+            this._storage.add(entry);
+        });
+        this._reader.onEnd(() => {
+            callSuccessCallback(callback, [...this._storage]);
+        });
+        this._reader.read();
+    }
+}
+async$3.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, entries) {
+    callback(null, entries);
 }
 
 var stream$1 = {};
 
-Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$5 = require$$0$2;
-const async_1$2 = async$2;
-class StreamProvider {
-    constructor(_root, _settings) {
-        this._root = _root;
-        this._settings = _settings;
-        this._reader = new async_1$2.default(this._root, this._settings);
-        this._stream = new stream_1$5.Readable({
-            objectMode: true,
-            read: () => { },
-            destroy: () => {
-                if (!this._reader.isDestroyed) {
-                    this._reader.destroy();
-                }
-            }
-        });
-    }
-    read() {
-        this._reader.onError((error) => {
-            this._stream.emit('error', error);
-        });
-        this._reader.onEntry((entry) => {
-            this._stream.push(entry);
-        });
-        this._reader.onEnd(() => {
-            this._stream.push(null);
-        });
-        this._reader.read();
-        return this._stream;
-    }
-}
+Object.defineProperty(stream$1, "__esModule", { value: true });
+const stream_1$5 = require$$0$2;
+const async_1$2 = async$2;
+class StreamProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$2.default(this._root, this._settings);
+        this._stream = new stream_1$5.Readable({
+            objectMode: true,
+            read: () => { },
+            destroy: () => {
+                if (!this._reader.isDestroyed) {
+                    this._reader.destroy();
+                }
+            }
+        });
+    }
+    read() {
+        this._reader.onError((error) => {
+            this._stream.emit('error', error);
+        });
+        this._reader.onEntry((entry) => {
+            this._stream.push(entry);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
+    }
+}
 stream$1.default = StreamProvider;
 
 var sync$3 = {};
 
 var sync$2 = {};
 
-Object.defineProperty(sync$2, "__esModule", { value: true });
-const fsScandir$1 = out$1;
-const common = common$3;
-const reader_1$2 = reader$1;
-class SyncReader extends reader_1$2.default {
-    constructor() {
-        super(...arguments);
-        this._scandir = fsScandir$1.scandirSync;
-        this._storage = [];
-        this._queue = new Set();
-    }
-    read() {
-        this._pushToQueue(this._root, this._settings.basePath);
-        this._handleQueue();
-        return this._storage;
-    }
-    _pushToQueue(directory, base) {
-        this._queue.add({ directory, base });
-    }
-    _handleQueue() {
-        for (const item of this._queue.values()) {
-            this._handleDirectory(item.directory, item.base);
-        }
-    }
-    _handleDirectory(directory, base) {
-        try {
-            const entries = this._scandir(directory, this._settings.fsScandirSettings);
-            for (const entry of entries) {
-                this._handleEntry(entry, base);
-            }
-        }
-        catch (error) {
-            this._handleError(error);
-        }
-    }
-    _handleError(error) {
-        if (!common.isFatalError(this._settings, error)) {
-            return;
-        }
-        throw error;
-    }
-    _handleEntry(entry, base) {
-        const fullpath = entry.path;
-        if (base !== undefined) {
-            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
-        }
-        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
-            this._pushToStorage(entry);
-        }
-        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
-        }
-    }
-    _pushToStorage(entry) {
-        this._storage.push(entry);
-    }
-}
+Object.defineProperty(sync$2, "__esModule", { value: true });
+const fsScandir$1 = out$1;
+const common = common$3;
+const reader_1$2 = reader$1;
+class SyncReader extends reader_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = fsScandir$1.scandirSync;
+        this._storage = new Set();
+        this._queue = new Set();
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return [...this._storage];
+    }
+    _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+        for (const item of this._queue.values()) {
+            this._handleDirectory(item.directory, item.base);
+        }
+    }
+    _handleDirectory(directory, base) {
+        try {
+            const entries = this._scandir(directory, this._settings.fsScandirSettings);
+            for (const entry of entries) {
+                this._handleEntry(entry, base);
+            }
+        }
+        catch (error) {
+            this._handleError(error);
+        }
+    }
+    _handleError(error) {
+        if (!common.isFatalError(this._settings, error)) {
+            return;
+        }
+        throw error;
+    }
+    _handleEntry(entry, base) {
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._pushToStorage(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _pushToStorage(entry) {
+        this._storage.add(entry);
+    }
+}
 sync$2.default = SyncReader;
 
-Object.defineProperty(sync$3, "__esModule", { value: true });
-const sync_1$3 = sync$2;
-class SyncProvider {
-    constructor(_root, _settings) {
-        this._root = _root;
-        this._settings = _settings;
-        this._reader = new sync_1$3.default(this._root, this._settings);
-    }
-    read() {
-        return this._reader.read();
-    }
-}
+Object.defineProperty(sync$3, "__esModule", { value: true });
+const sync_1$3 = sync$2;
+class SyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new sync_1$3.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
 sync$3.default = SyncProvider;
 
 var settings$1 = {};
 
-Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$2 = path$a;
-const fsScandir = out$1;
-class Settings {
-    constructor(_options = {}) {
-        this._options = _options;
-        this.basePath = this._getValue(this._options.basePath, undefined);
-        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
-        this.deepFilter = this._getValue(this._options.deepFilter, null);
-        this.entryFilter = this._getValue(this._options.entryFilter, null);
-        this.errorFilter = this._getValue(this._options.errorFilter, null);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$2.sep);
-        this.fsScandirSettings = new fsScandir.Settings({
-            followSymbolicLinks: this._options.followSymbolicLinks,
-            fs: this._options.fs,
-            pathSegmentSeparator: this._options.pathSegmentSeparator,
-            stats: this._options.stats,
-            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
-        });
-    }
-    _getValue(option, value) {
-        return option !== null && option !== void 0 ? option : value;
-    }
-}
+Object.defineProperty(settings$1, "__esModule", { value: true });
+const path$2 = path$a;
+const fsScandir = out$1;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Infinity);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$2.sep);
+        this.fsScandirSettings = new fsScandir.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
 settings$1.default = Settings;
 
-Object.defineProperty(out$2, "__esModule", { value: true });
-out$2.Settings = out$2.walkStream = out$2.walkSync = out$2.walk = void 0;
-const async_1$1 = async$3;
-const stream_1$4 = stream$1;
-const sync_1$2 = sync$3;
-const settings_1$1 = settings$1;
-out$2.Settings = settings_1$1.default;
-function walk(directory, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === 'function') {
-        new async_1$1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
-        return;
-    }
-    new async_1$1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
-}
-out$2.walk = walk;
-function walkSync(directory, optionsOrSettings) {
-    const settings = getSettings(optionsOrSettings);
-    const provider = new sync_1$2.default(directory, settings);
-    return provider.read();
-}
-out$2.walkSync = walkSync;
-function walkStream(directory, optionsOrSettings) {
-    const settings = getSettings(optionsOrSettings);
-    const provider = new stream_1$4.default(directory, settings);
-    return provider.read();
-}
-out$2.walkStream = walkStream;
-function getSettings(settingsOrOptions = {}) {
-    if (settingsOrOptions instanceof settings_1$1.default) {
-        return settingsOrOptions;
-    }
-    return new settings_1$1.default(settingsOrOptions);
+Object.defineProperty(out$2, "__esModule", { value: true });
+out$2.Settings = out$2.walkStream = out$2.walkSync = out$2.walk = void 0;
+const async_1$1 = async$3;
+const stream_1$4 = stream$1;
+const sync_1$2 = sync$3;
+const settings_1$1 = settings$1;
+out$2.Settings = settings_1$1.default;
+function walk(directory, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return new async_1$1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+    }
+    new async_1$1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+out$2.walk = walk;
+function walkSync(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new sync_1$2.default(directory, settings);
+    return provider.read();
+}
+out$2.walkSync = walkSync;
+function walkStream(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new stream_1$4.default(directory, settings);
+    return provider.read();
+}
+out$2.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$1.default(settingsOrOptions);
 }
 
 var reader = {};
@@ -8336,7 +8230,7 @@ class Vitest {
       await cleanCoverage(resolved.coverage, resolved.coverage.clean);
   }
   async start(filters) {
-    this.report("onInit", this);
+    await this.report("onInit", this);
     const files = await this.filterTestsBySource(await this.globTestFiles(filters));
     if (!files.length) {
       if (this.config.passWithNoTests)
@@ -8553,7 +8447,7 @@ async function createVitest(options, viteOverrides = {}) {
           await ctx.setServer(options, server2);
           haveStarted = true;
           if (options.api)
-            (await import('./setup-6e09a65a.js')).setup(ctx);
+            (await import('./setup-a6f22d64.js')).setup(ctx);
           if (!options.watch)
             await server2.watcher.close();
         }