vitest 0.0.113 → 0.0.117

package/dist/{index-9f4b9905.js → index-ce49e384.js}

@@ -1,12 +1,13 @@
-import path$5 from 'path';
-import fs$5 from 'fs';
+import path$2 from 'path';
+import fs$2 from 'fs';
 import require$$0 from 'util';
-import require$$0$1 from 'child_process';
-import { c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
-import { a as signalExit, b as onetime$1 } from './index-61c8686f.js';
-import require$$0$2 from 'os';
-import require$$0$4 from 'buffer';
-import require$$0$3 from 'stream';
+import childProcess$1 from 'child_process';
+import { p as pathKey, m as mergeStream$1, a as getStream$1, b as crossSpawn$1 } from './index-6e709f57.js';
+import { a as signalExit, b as onetime$1 } from './index-648e7ab2.js';
+import require$$0$1 from 'os';
+import './_commonjsHelpers-c9e3b764.js';
+import 'buffer';
+import 'stream';
 import 'assert';
 import 'events';
 
@@ -204,13 +205,13 @@ const pLocate$1 = async (iterable, tester, options) => {
 
 var pLocate_1 = pLocate$1;
 
-const path$4 = path$5;
-const fs$4 = fs$5;
-const {promisify: promisify$2} = require$$0;
+const path$1 = path$2;
+const fs$1 = fs$2;
+const {promisify: promisify$1} = require$$0;
 const pLocate = pLocate_1;
 
-const fsStat = promisify$2(fs$4.stat);
-const fsLStat = promisify$2(fs$4.lstat);
+const fsStat = promisify$1(fs$1.stat);
+const fsLStat = promisify$1(fs$1.lstat);
 
 const typeMappings = {
 	directory: 'isDirectory',
@@ -241,7 +242,7 @@ locatePath.exports = async (paths, options) => {
 
 	return pLocate(paths, async path_ => {
 		try {
-			const stat = await statFn(path$4.resolve(options.cwd, path_));
+			const stat = await statFn(path$1.resolve(options.cwd, path_));
 			return matchType(options.type, stat);
 		} catch {
 			return false;
@@ -259,11 +260,11 @@ locatePath.exports.sync = (paths, options) => {
 
 	checkType(options);
 
-	const statFn = options.allowSymlinks ? fs$4.statSync : fs$4.lstatSync;
+	const statFn = options.allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
 
 	for (const path_ of paths) {
 		try {
-			const stat = statFn(path$4.resolve(options.cwd, path_));
+			const stat = statFn(path$1.resolve(options.cwd, path_));
 
 			if (matchType(options.type, stat)) {
 				return path_;
@@ -274,10 +275,10 @@ locatePath.exports.sync = (paths, options) => {
 
 var pathExists = {exports: {}};
 
-const fs$3 = fs$5;
-const {promisify: promisify$1} = require$$0;
+const fs = fs$2;
+const {promisify} = require$$0;
 
-const pAccess = promisify$1(fs$3.access);
+const pAccess = promisify(fs.access);
 
 pathExists.exports = async path => {
 	try {
@@ -290,7 +291,7 @@ pathExists.exports = async path => {
 
 pathExists.exports.sync = path => {
 	try {
-		fs$3.accessSync(path);
+		fs.accessSync(path);
 		return true;
 	} catch (_) {
 		return false;
@@ -298,7 +299,7 @@ pathExists.exports.sync = path => {
 };
 
 (function (module) {
-const path = path$5;
+const path = path$2;
 const locatePath$1 = locatePath.exports;
 const pathExists$1 = pathExists.exports;
 
@@ -392,619 +393,6 @@ var findUp = findUp$1.exports;
 
 var execa$2 = {exports: {}};
 
-var crossSpawn$1 = {exports: {}};
-
-var windows = isexe$3;
-isexe$3.sync = sync$2;
-
-var fs$2 = fs$5;
-
-function checkPathExt (path, options) {
-  var pathext = options.pathExt !== undefined ?
-    options.pathExt : process.env.PATHEXT;
-
-  if (!pathext) {
-    return true
-  }
-
-  pathext = pathext.split(';');
-  if (pathext.indexOf('') !== -1) {
-    return true
-  }
-  for (var i = 0; i < pathext.length; i++) {
-    var p = pathext[i].toLowerCase();
-    if (p && path.substr(-p.length).toLowerCase() === p) {
-      return true
-    }
-  }
-  return false
-}
-
-function checkStat$1 (stat, path, options) {
-  if (!stat.isSymbolicLink() && !stat.isFile()) {
-    return false
-  }
-  return checkPathExt(path, options)
-}
-
-function isexe$3 (path, options, cb) {
-  fs$2.stat(path, function (er, stat) {
-    cb(er, er ? false : checkStat$1(stat, path, options));
-  });
-}
-
-function sync$2 (path, options) {
-  return checkStat$1(fs$2.statSync(path), path, options)
-}
-
-var mode = isexe$2;
-isexe$2.sync = sync$1;
-
-var fs$1 = fs$5;
-
-function isexe$2 (path, options, cb) {
-  fs$1.stat(path, function (er, stat) {
-    cb(er, er ? false : checkStat(stat, options));
-  });
-}
-
-function sync$1 (path, options) {
-  return checkStat(fs$1.statSync(path), options)
-}
-
-function checkStat (stat, options) {
-  return stat.isFile() && checkMode(stat, options)
-}
-
-function checkMode (stat, options) {
-  var mod = stat.mode;
-  var uid = stat.uid;
-  var gid = stat.gid;
-
-  var myUid = options.uid !== undefined ?
-    options.uid : process.getuid && process.getuid();
-  var myGid = options.gid !== undefined ?
-    options.gid : process.getgid && process.getgid();
-
-  var u = parseInt('100', 8);
-  var g = parseInt('010', 8);
-  var o = parseInt('001', 8);
-  var ug = u | g;
-
-  var ret = (mod & o) ||
-    (mod & g) && gid === myGid ||
-    (mod & u) && uid === myUid ||
-    (mod & ug) && myUid === 0;
-
-  return ret
-}
-
-var core$1;
-if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
-  core$1 = windows;
-} else {
-  core$1 = mode;
-}
-
-var isexe_1 = isexe$1;
-isexe$1.sync = sync;
-
-function isexe$1 (path, options, cb) {
-  if (typeof options === 'function') {
-    cb = options;
-    options = {};
-  }
-
-  if (!cb) {
-    if (typeof Promise !== 'function') {
-      throw new TypeError('callback not provided')
-    }
-
-    return new Promise(function (resolve, reject) {
-      isexe$1(path, options || {}, function (er, is) {
-        if (er) {
-          reject(er);
-        } else {
-          resolve(is);
-        }
-      });
-    })
-  }
-
-  core$1(path, options || {}, function (er, is) {
-    // ignore EACCES because that just means we aren't allowed to run it
-    if (er) {
-      if (er.code === 'EACCES' || options && options.ignoreErrors) {
-        er = null;
-        is = false;
-      }
-    }
-    cb(er, is);
-  });
-}
-
-function sync (path, options) {
-  // my kingdom for a filtered catch
-  try {
-    return core$1.sync(path, options || {})
-  } catch (er) {
-    if (options && options.ignoreErrors || er.code === 'EACCES') {
-      return false
-    } else {
-      throw er
-    }
-  }
-}
-
-const isWindows = process.platform === 'win32' ||
-    process.env.OSTYPE === 'cygwin' ||
-    process.env.OSTYPE === 'msys';
-
-const path$3 = path$5;
-const COLON = isWindows ? ';' : ':';
-const isexe = isexe_1;
-
-const getNotFoundError = (cmd) =>
-  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
-
-const getPathInfo = (cmd, opt) => {
-  const colon = opt.colon || COLON;
-
-  // If it has a slash, then we don't bother searching the pathenv.
-  // just check the file itself, and that's it.
-  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
-    : (
-      [
-        // windows always checks the cwd first
-        ...(isWindows ? [process.cwd()] : []),
-        ...(opt.path || process.env.PATH ||
-          /* istanbul ignore next: very unusual */ '').split(colon),
-      ]
-    );
-  const pathExtExe = isWindows
-    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
-    : '';
-  const pathExt = isWindows ? pathExtExe.split(colon) : [''];
-
-  if (isWindows) {
-    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
-      pathExt.unshift('');
-  }
-
-  return {
-    pathEnv,
-    pathExt,
-    pathExtExe,
-  }
-};
-
-const which$1 = (cmd, opt, cb) => {
-  if (typeof opt === 'function') {
-    cb = opt;
-    opt = {};
-  }
-  if (!opt)
-    opt = {};
-
-  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-  const found = [];
-
-  const step = i => new Promise((resolve, reject) => {
-    if (i === pathEnv.length)
-      return opt.all && found.length ? resolve(found)
-        : reject(getNotFoundError(cmd))
-
-    const ppRaw = pathEnv[i];
-    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-
-    const pCmd = path$3.join(pathPart, cmd);
-    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
-      : pCmd;
-
-    resolve(subStep(p, i, 0));
-  });
-
-  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
-    if (ii === pathExt.length)
-      return resolve(step(i + 1))
-    const ext = pathExt[ii];
-    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-      if (!er && is) {
-        if (opt.all)
-          found.push(p + ext);
-        else
-          return resolve(p + ext)
-      }
-      return resolve(subStep(p, i, ii + 1))
-    });
-  });
-
-  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
-};
-
-const whichSync = (cmd, opt) => {
-  opt = opt || {};
-
-  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-  const found = [];
-
-  for (let i = 0; i < pathEnv.length; i ++) {
-    const ppRaw = pathEnv[i];
-    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-
-    const pCmd = path$3.join(pathPart, cmd);
-    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
-      : pCmd;
-
-    for (let j = 0; j < pathExt.length; j ++) {
-      const cur = p + pathExt[j];
-      try {
-        const is = isexe.sync(cur, { pathExt: pathExtExe });
-        if (is) {
-          if (opt.all)
-            found.push(cur);
-          else
-            return cur
-        }
-      } catch (ex) {}
-    }
-  }
-
-  if (opt.all && found.length)
-    return found
-
-  if (opt.nothrow)
-    return null
-
-  throw getNotFoundError(cmd)
-};
-
-var which_1 = which$1;
-which$1.sync = whichSync;
-
-var pathKey$1 = {exports: {}};
-
-const pathKey = (options = {}) => {
-	const environment = options.env || process.env;
-	const platform = options.platform || process.platform;
-
-	if (platform !== 'win32') {
-		return 'PATH';
-	}
-
-	return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
-};
-
-pathKey$1.exports = pathKey;
-// TODO: Remove this for the next major release
-pathKey$1.exports.default = pathKey;
-
-const path$2 = path$5;
-const which = which_1;
-const getPathKey = pathKey$1.exports;
-
-function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    // Worker threads do not have process.chdir()
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
-
-    // If a custom `cwd` was specified, we need to change the process cwd
-    // because `which` will do stat calls but does not support a custom cwd
-    if (shouldSwitchCwd) {
-        try {
-            process.chdir(parsed.options.cwd);
-        } catch (err) {
-            /* Empty */
-        }
-    }
-
-    let resolved;
-
-    try {
-        resolved = which.sync(parsed.command, {
-            path: env[getPathKey({ env })],
-            pathExt: withoutPathExt ? path$2.delimiter : undefined,
-        });
-    } catch (e) {
-        /* Empty */
-    } finally {
-        if (shouldSwitchCwd) {
-            process.chdir(cwd);
-        }
-    }
-
-    // If we successfully resolved, ensure that an absolute path is returned
-    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
-    if (resolved) {
-        resolved = path$2.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
-    }
-
-    return resolved;
-}
-
-function resolveCommand$1(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-}
-
-var resolveCommand_1 = resolveCommand$1;
-
-var _escape = {};
-
-// See http://www.robvanderwoude.com/escapechars.php
-const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-
-function escapeCommand(arg) {
-    // Escape meta chars
-    arg = arg.replace(metaCharsRegExp, '^$1');
-
-    return arg;
-}
-
-function escapeArgument(arg, doubleEscapeMetaChars) {
-    // Convert to string
-    arg = `${arg}`;
-
-    // Algorithm below is based on https://qntm.org/cmd
-
-    // Sequence of backslashes followed by a double quote:
-    // double up all the backslashes and escape the double quote
-    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
-
-    // Sequence of backslashes followed by the end of the string
-    // (which will become a double quote later):
-    // double up all the backslashes
-    arg = arg.replace(/(\\*)$/, '$1$1');
-
-    // All other backslashes occur literally
-
-    // Quote the whole thing:
-    arg = `"${arg}"`;
-
-    // Escape meta chars
-    arg = arg.replace(metaCharsRegExp, '^$1');
-
-    // Double escape meta chars if necessary
-    if (doubleEscapeMetaChars) {
-        arg = arg.replace(metaCharsRegExp, '^$1');
-    }
-
-    return arg;
-}
-
-_escape.command = escapeCommand;
-_escape.argument = escapeArgument;
-
-var shebangRegex$1 = /^#!(.*)/;
-
-const shebangRegex = shebangRegex$1;
-
-var shebangCommand$1 = (string = '') => {
-	const match = string.match(shebangRegex);
-
-	if (!match) {
-		return null;
-	}
-
-	const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
-	const binary = path.split('/').pop();
-
-	if (binary === 'env') {
-		return argument;
-	}
-
-	return argument ? `${binary} ${argument}` : binary;
-};
-
-const fs = fs$5;
-const shebangCommand = shebangCommand$1;
-
-function readShebang$1(command) {
-    // Read the first 150 bytes from the file
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-
-    let fd;
-
-    try {
-        fd = fs.openSync(command, 'r');
-        fs.readSync(fd, buffer, 0, size, 0);
-        fs.closeSync(fd);
-    } catch (e) { /* Empty */ }
-
-    // Attempt to extract shebang (null is returned if not a shebang)
-    return shebangCommand(buffer.toString());
-}
-
-var readShebang_1 = readShebang$1;
-
-const path$1 = path$5;
-const resolveCommand = resolveCommand_1;
-const escape = _escape;
-const readShebang = readShebang_1;
-
-const isWin$1 = process.platform === 'win32';
-const isExecutableRegExp = /\.(?:com|exe)$/i;
-const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-
-function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
-
-    const shebang = parsed.file && readShebang(parsed.file);
-
-    if (shebang) {
-        parsed.args.unshift(parsed.file);
-        parsed.command = shebang;
-
-        return resolveCommand(parsed);
-    }
-
-    return parsed.file;
-}
-
-function parseNonShell(parsed) {
-    if (!isWin$1) {
-        return parsed;
-    }
-
-    // Detect & add support for shebangs
-    const commandFile = detectShebang(parsed);
-
-    // We don't need a shell if the command filename is an executable
-    const needsShell = !isExecutableRegExp.test(commandFile);
-
-    // If a shell is required, use cmd.exe and take care of escaping everything correctly
-    // Note that `forceShell` is an hidden option used only in tests
-    if (parsed.options.forceShell || needsShell) {
-        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
-        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
-        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
-        // we need to double escape them
-        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-
-        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
-        // This is necessary otherwise it will always fail with ENOENT in those cases
-        parsed.command = path$1.normalize(parsed.command);
-
-        // Escape command & arguments
-        parsed.command = escape.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-
-        const shellCommand = [parsed.command].concat(parsed.args).join(' ');
-
-        parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
-        parsed.command = process.env.comspec || 'cmd.exe';
-        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
-    }
-
-    return parsed;
-}
-
-function parse$1(command, args, options) {
-    // Normalize arguments, similar to nodejs
-    if (args && !Array.isArray(args)) {
-        options = args;
-        args = null;
-    }
-
-    args = args ? args.slice(0) : []; // Clone array to avoid changing the original
-    options = Object.assign({}, options); // Clone object to avoid changing the original
-
-    // Build our parsed object
-    const parsed = {
-        command,
-        args,
-        options,
-        file: undefined,
-        original: {
-            command,
-            args,
-        },
-    };
-
-    // Delegate further parsing to shell or non-shell
-    return options.shell ? parsed : parseNonShell(parsed);
-}
-
-var parse_1 = parse$1;
-
-const isWin = process.platform === 'win32';
-
-function notFoundError(original, syscall) {
-    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-        code: 'ENOENT',
-        errno: 'ENOENT',
-        syscall: `${syscall} ${original.command}`,
-        path: original.command,
-        spawnargs: original.args,
-    });
-}
-
-function hookChildProcess(cp, parsed) {
-    if (!isWin) {
-        return;
-    }
-
-    const originalEmit = cp.emit;
-
-    cp.emit = function (name, arg1) {
-        // If emitting "exit" event and exit code is 1, we need to check if
-        // the command exists and emit an "error" instead
-        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
-        if (name === 'exit') {
-            const err = verifyENOENT(arg1, parsed);
-
-            if (err) {
-                return originalEmit.call(cp, 'error', err);
-            }
-        }
-
-        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
-    };
-}
-
-function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-        return notFoundError(parsed.original, 'spawn');
-    }
-
-    return null;
-}
-
-function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-        return notFoundError(parsed.original, 'spawnSync');
-    }
-
-    return null;
-}
-
-var enoent$1 = {
-    hookChildProcess,
-    verifyENOENT,
-    verifyENOENTSync,
-    notFoundError,
-};
-
-const cp = require$$0$1;
-const parse = parse_1;
-const enoent = enoent$1;
-
-function spawn(command, args, options) {
-    // Parse the arguments
-    const parsed = parse(command, args, options);
-
-    // Spawn the child process
-    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
-
-    // Hook into child process "exit" event to emit an error if the command
-    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
-    enoent.hookChildProcess(spawned, parsed);
-
-    return spawned;
-}
-
-function spawnSync(command, args, options) {
-    // Parse the arguments
-    const parsed = parse(command, args, options);
-
-    // Spawn the child process
-    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-
-    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
-    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-
-    return result;
-}
-
-crossSpawn$1.exports = spawn;
-crossSpawn$1.exports.spawn = spawn;
-crossSpawn$1.exports.sync = spawnSync;
-
-crossSpawn$1.exports._parse = parse;
-crossSpawn$1.exports._enoent = enoent;
-
 var stripFinalNewline$1 = input => {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
 	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
@@ -1023,13 +411,13 @@ var stripFinalNewline$1 = input => {
 var npmRunPath$1 = {exports: {}};
 
 (function (module) {
-const path = path$5;
-const pathKey = pathKey$1.exports;
+const path = path$2;
+const pathKey$1 = pathKey.exports;
 
 const npmRunPath = options => {
 	options = {
 		cwd: process.cwd(),
-		path: process.env[pathKey()],
+		path: process.env[pathKey$1()],
 		execPath: process.execPath,
 		...options
 	};
@@ -1062,7 +450,7 @@ module.exports.env = options => {
 	};
 
 	const env = {...options.env};
-	const path = pathKey({env});
+	const path = pathKey$1({env});
 
 	options.path = env[path];
 	env[path] = module.exports(options);
@@ -1371,7 +759,7 @@ standard:"posix"};
 const SIGRTMIN=34;
 const SIGRTMAX=64;realtime.SIGRTMAX=SIGRTMAX;
 
-Object.defineProperty(signals,"__esModule",{value:true});signals.getSignals=void 0;var _os$1=require$$0$2;
+Object.defineProperty(signals,"__esModule",{value:true});signals.getSignals=void 0;var _os$1=require$$0$1;
 
 var _core=core;
 var _realtime$1=realtime;
@@ -1406,7 +794,7 @@ const number=supported?constantSignal:defaultNumber;
 return {name,number,description,supported,action,forced,standard};
 };
 
-Object.defineProperty(main,"__esModule",{value:true});main.signalsByNumber=main.signalsByName=void 0;var _os=require$$0$2;
+Object.defineProperty(main,"__esModule",{value:true});main.signalsByNumber=main.signalsByName=void 0;var _os=require$$0$1;
 
 var _signals=signals;
 var _realtime=realtime;
@@ -1619,7 +1007,7 @@ stdio.exports.node = options => {
 	return [...stdio, 'ipc'];
 };
 
-const os = require$$0$2;
+const os = require$$0$1;
 const onExit = signalExit.exports;
 
 const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
@@ -1761,163 +1149,8 @@ isStream$1.transform = stream =>
 
 var isStream_1 = isStream$1;
 
-var getStream$2 = {exports: {}};
-
-const {PassThrough: PassThroughStream} = require$$0$3;
-
-var bufferStream$1 = options => {
-	options = {...options};
-
-	const {array} = options;
-	let {encoding} = options;
-	const isBuffer = encoding === 'buffer';
-	let objectMode = false;
-
-	if (array) {
-		objectMode = !(encoding || isBuffer);
-	} else {
-		encoding = encoding || 'utf8';
-	}
-
-	if (isBuffer) {
-		encoding = null;
-	}
-
-	const stream = new PassThroughStream({objectMode});
-
-	if (encoding) {
-		stream.setEncoding(encoding);
-	}
-
-	let length = 0;
-	const chunks = [];
-
-	stream.on('data', chunk => {
-		chunks.push(chunk);
-
-		if (objectMode) {
-			length = chunks.length;
-		} else {
-			length += chunk.length;
-		}
-	});
-
-	stream.getBufferedValue = () => {
-		if (array) {
-			return chunks;
-		}
-
-		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-	};
-
-	stream.getBufferedLength = () => length;
-
-	return stream;
-};
-
-const {constants: BufferConstants} = require$$0$4;
-const stream$1 = require$$0$3;
-const {promisify} = require$$0;
-const bufferStream = bufferStream$1;
-
-const streamPipelinePromisified = promisify(stream$1.pipeline);
-
-class MaxBufferError extends Error {
-	constructor() {
-		super('maxBuffer exceeded');
-		this.name = 'MaxBufferError';
-	}
-}
-
-async function getStream$1(inputStream, options) {
-	if (!inputStream) {
-		throw new Error('Expected a stream');
-	}
-
-	options = {
-		maxBuffer: Infinity,
-		...options
-	};
-
-	const {maxBuffer} = options;
-	const stream = bufferStream(options);
-
-	await new Promise((resolve, reject) => {
-		const rejectPromise = error => {
-			// Don't retrieve an oversized buffer.
-			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-				error.bufferedData = stream.getBufferedValue();
-			}
-
-			reject(error);
-		};
-
-		(async () => {
-			try {
-				await streamPipelinePromisified(inputStream, stream);
-				resolve();
-			} catch (error) {
-				rejectPromise(error);
-			}
-		})();
-
-		stream.on('data', () => {
-			if (stream.getBufferedLength() > maxBuffer) {
-				rejectPromise(new MaxBufferError());
-			}
-		});
-	});
-
-	return stream.getBufferedValue();
-}
-
-getStream$2.exports = getStream$1;
-getStream$2.exports.buffer = (stream, options) => getStream$1(stream, {...options, encoding: 'buffer'});
-getStream$2.exports.array = (stream, options) => getStream$1(stream, {...options, array: true});
-getStream$2.exports.MaxBufferError = MaxBufferError;
-
-const { PassThrough } = require$$0$3;
-
-var mergeStream$1 = function (/*streams...*/) {
-  var sources = [];
-  var output  = new PassThrough({objectMode: true});
-
-  output.setMaxListeners(0);
-
-  output.add = add;
-  output.isEmpty = isEmpty;
-
-  output.on('unpipe', remove);
-
-  Array.prototype.slice.call(arguments).forEach(add);
-
-  return output
-
-  function add (source) {
-    if (Array.isArray(source)) {
-      source.forEach(add);
-      return this
-    }
-
-    sources.push(source);
-    source.once('end', remove.bind(null, source));
-    source.once('error', output.emit.bind(output, 'error'));
-    source.pipe(output, {end: false});
-    return this
-  }
-
-  function isEmpty () {
-    return sources.length == 0;
-  }
-
-  function remove (source) {
-    sources = sources.filter(function (it) { return it !== source });
-    if (!sources.length && output.readable) { output.end(); }
-  }
-};
-
 const isStream = isStream_1;
-const getStream = getStream$2.exports;
+const getStream = getStream$1.exports;
 const mergeStream = mergeStream$1;
 
 // `input` option
@@ -2108,8 +1341,8 @@ var command = {
 	parseCommand: parseCommand$1
 };
 
-const path = path$5;
-const childProcess = require$$0$1;
+const path = path$2;
+const childProcess = childProcess$1;
 const crossSpawn = crossSpawn$1.exports;
 const stripFinalNewline = stripFinalNewline$1;
 const npmRunPath = npmRunPath$1.exports;
@@ -2386,7 +1619,7 @@ var LOCKS = {
 };
 async function detectPackageManager(cwd = process.cwd()) {
   const result = await findUp(Object.keys(LOCKS), { cwd });
-  const agent = result ? LOCKS[path$5.basename(result)] : null;
+  const agent = result ? LOCKS[path$2.basename(result)] : null;
   return agent;
 }
 async function installPackage(names, options = {}) {