vitest 0.0.128 → 0.0.129

package/dist/{index-05648ba5.js → index-d30b5ed0.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-f0488a5d.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-42a3a132.js';
 import { createServer, mergeConfig } from 'vite';
 import path$a from 'path';
 import process$1 from 'process';
@@ -7,16 +7,17 @@ import require$$0 from 'os';
 import require$$0$1 from 'util';
 import require$$0$2 from 'stream';
 import require$$2 from 'events';
-import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-2cd49e0a.js';
-import MagicString from './magic-string.es-94000aea.js';
+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 { 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-711cddf1.js';
-import { o as onetime, s as signalExit } from './index-7975be53.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-be830986.js';
+import { o as onetime, s as signalExit } from './index-cb02ee01.js';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
-import { c as createBirpc } from './index-e909c175.js';
+import { c as createBirpc } from './index-a73f33e0.js';
 
 /*
 How it works:
@@ -4984,61 +4985,65 @@ 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) {
-            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);
+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);
 }
 
 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 = {};
@@ -5046,63 +5051,64 @@ 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') {
-        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);
+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);
 }
 
 var out$2 = {};
@@ -5120,7 +5126,7 @@ var async$1 = {};
 let promise;
 
 var queueMicrotask_1 = typeof queueMicrotask === 'function'
-  ? queueMicrotask.bind(globalThis)
+  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : commonjsGlobal)
   // reuse resolved promise, and allocate it lazily
   : cb => (promise || (promise = Promise.resolve()))
     .then(cb)
@@ -5181,209 +5187,224 @@ 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('.');
-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.
- */
+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.
+ */
 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) {
-        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);
+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);
 }
 
 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 = {};
@@ -5391,74 +5412,77 @@ 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') {
-        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);
+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);
+}
+
+var queue = {exports: {}};
 
 function reusify$1 (Constructor) {
   var head = new Constructor();
@@ -5492,6 +5516,8 @@ function reusify$1 (Constructor) {
 
 var reusify_1 = reusify$1;
 
+/* eslint-disable no-var */
+
 var reusify = reusify_1;
 
 function fastqueue (context, worker, concurrency) {
@@ -5692,352 +5718,432 @@ function Task () {
   };
 }
 
-var queue = fastqueue;
+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 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;
-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);
-    }
-}
+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);
+    }
+}
 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 = 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);
+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);
 }
 
 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 = 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);
-    }
-}
+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);
+    }
+}
 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, 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, 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;
+    }
+}
 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') {
-        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);
+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);
 }
 
 var reader = {};
@@ -7823,25 +7929,25 @@ const ReportersMap = {
   dot: DotReporter
 };
 
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 const defaultExcludes = [
   "coverage/**",
   "packages/*/test{,s}/**",
@@ -7854,7 +7960,7 @@ const defaultExcludes = [
   "**/.{eslint,mocha}rc.{js,cjs}"
 ];
 function resolveC8Options(options, root) {
-  const resolved = __spreadValues$1({
+  const resolved = __spreadValues$2({
     enabled: false,
     clean: true,
     cleanOnRerun: false,
@@ -7883,7 +7989,7 @@ async function reportCoverage(ctx) {
     const url = pathToFileURL(file).href;
     const sources = map.sources.length ? map.sources.map((i) => pathToFileURL(i).href) : [url];
     report.sourceMapCache[url] = {
-      data: __spreadProps$1(__spreadValues$1({}, map), { sources })
+      data: __spreadProps$2(__spreadValues$2({}, map), { sources })
     };
   });
   await report.run();
@@ -7924,30 +8030,56 @@ class StateManager {
   }
 }
 
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function resolveApiConfig(options, viteOverrides) {
+  let api;
+  if (options.api === true)
+    api = { port: defaultPort };
+  else if (typeof options.api === "number")
+    api = { port: options.api };
+  if (typeof options.api === "object") {
+    if (api) {
+      if (options.api.port)
+        api.port = options.api.port;
+      if (options.api.strictPort)
+        api.strictPort = options.api.strictPort;
+      if (options.api.host)
+        api.host = options.api.host;
+    } else {
+      api = __spreadValues$1({}, options.api);
+    }
+  }
+  if (api) {
+    if (!api.port)
+      api.port = defaultPort;
+    if (viteOverrides)
+      viteOverrides.server = Object.assign(viteOverrides.server || {}, api);
+  }
+  return api;
+}
 function resolveConfig(options, viteConfig) {
   var _a, _b, _c, _d;
   if (options.dom)
     options.environment = "happy-dom";
-  const resolved = __spreadProps(__spreadValues({}, deepMerge(options, viteConfig.test)), {
+  const resolved = __spreadProps$1(__spreadValues$1({}, deepMerge(options, viteConfig.test)), {
     root: viteConfig.root
   });
   resolved.coverage = resolveC8Options(resolved.coverage, resolved.root);
@@ -7977,8 +8109,7 @@ function resolveConfig(options, viteConfig) {
   if (process.env.VITEST_MIN_THREADS)
     resolved.minThreads = parseInt(process.env.VITEST_MIN_THREADS);
   resolved.setupFiles = Array.from(resolved.setupFiles || []).map((i) => resolve(resolved.root, i));
-  if (resolved.api === true)
-    resolved.api = defaultPort;
+  resolved.api = resolveApiConfig(options);
   if (options.related)
     resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
   return resolved;
@@ -8136,6 +8267,25 @@ function createChannel(ctx) {
   return { workerPort, port };
 }
 
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 const WATCHER_DEBOUNCE = 100;
 class Vitest {
   constructor() {
@@ -8376,6 +8526,7 @@ class Vitest {
   }
 }
 async function createVitest(options, viteOverrides = {}) {
+  var _a;
   const ctx = new Vitest();
   const root = resolve(options.root || process.cwd());
   const configPath = options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
@@ -8386,6 +8537,7 @@ async function createVitest(options, viteOverrides = {}) {
     await ensurePackageInstalled("@vitest/ui");
     return (await import('@vitest/ui')).default();
   }
+  options.api = resolveApiConfig(options, viteOverrides);
   const config = {
     root,
     logLevel: "error",
@@ -8394,35 +8546,33 @@ async function createVitest(options, viteOverrides = {}) {
     plugins: [
       {
         name: "vitest",
+        enforce: "pre",
         async configureServer(server2) {
           if (haveStarted)
             await ctx.report("onServerRestart");
           await ctx.setServer(options, server2);
           haveStarted = true;
           if (options.api)
-            (await import('./setup-3d1395ff.js')).setup(ctx);
+            (await import('./setup-6e09a65a.js')).setup(ctx);
+          if (!options.watch)
+            await server2.watcher.close();
         }
       },
       MocksPlugin(),
       await UIPlugin()
     ],
-    server: {
+    server: __spreadProps(__spreadValues({}, options.api), {
       open: options.open ? "/__vitest__/" : void 0,
-      strictPort: true,
       preTransformRequests: false
-    },
+    }),
     build: {
       sourcemap: true
     }
   };
   const server = await createServer(mergeConfig(config, viteOverrides));
   await server.pluginContainer.buildStart({});
-  if (options.api === true)
-    options.api = defaultPort;
-  if (options.open && typeof options.api !== "number")
-    options.api = defaultPort;
-  if (typeof options.api === "number")
-    await server.listen(options.api);
+  if ((_a = options.api) == null ? void 0 : _a.port)
+    await server.listen();
   return ctx;
 }