snyk 1.1058.0 → 1.1059.0

package/dist/cli/263.index.js

@@ -137531,6 +137531,138 @@ module.exports = typeof setImmediate === 'function' ? setImmediate :
 	};
 
 
+/***/ }),
+
+/***/ 53267:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys'
+
+const path = __webpack_require__(85622)
+const COLON = isWindows ? ';' : ':'
+const isexe = __webpack_require__(31959)
+
+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 = (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.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.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)
+}
+
+module.exports = which
+which.sync = whichSync
+
+
 /***/ }),
 
 /***/ 83859:
@@ -160606,7 +160738,7 @@ exports.findChildren = findChildren;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.exportsForTests = exports.formatArgWithWhiteSpace = exports.processProjectsInExtractedJSON = exports.inspect = exports.debugLog = void 0;
+exports.exportsForTests = exports.processProjectsInExtractedJSON = exports.inspect = exports.debugLog = void 0;
 const os = __webpack_require__(12087);
 const fs = __webpack_require__(35747);
 const path = __webpack_require__(85622);
@@ -160634,8 +160766,6 @@ function debugLog(s) {
     logger(s);
 }
 exports.debugLog = debugLog;
-const isWin = /^win/.test(os.platform());
-const quot = isWin ? '"' : "'";
 const cannotResolveVariantMarkers = [
     'Cannot choose between the following',
     'Could not select value from candidates',
@@ -160656,6 +160786,7 @@ async function inspect(root, targetFile, options, snykHttpClient) {
     let subProject = options.subProject;
     if (subProject) {
         subProject = subProject.trim();
+        options.subProject = subProject;
     }
     const plugin = {
         name: 'bundled:gradle',
@@ -161042,13 +161173,6 @@ function getCommand(root, targetFile) {
     }
     return 'gradle';
 }
-function formatArgWithWhiteSpace(arg) {
-    if (/\s/.test(arg)) {
-        return quot + arg + quot;
-    }
-    return arg;
-}
-exports.formatArgWithWhiteSpace = formatArgWithWhiteSpace;
 function buildArgs(root, targetFile, initGradlePath, options) {
     const args = [];
     const taskName = options.gradleNormalizeDeps
@@ -161056,22 +161180,22 @@ function buildArgs(root, targetFile, initGradlePath, options) {
         : 'snykResolvedDepsJson';
     args.push(taskName, '-q');
     if (targetFile) {
-        if (!fs.existsSync(path.resolve(root, targetFile))) {
-            throw new Error('File not found: "' + targetFile + '"');
+        const resolvedTargetFilePath = path.resolve(root, targetFile);
+        if (!fs.existsSync(resolvedTargetFilePath)) {
+            throw new Error('File not found: "' + resolvedTargetFilePath + '"');
         }
         args.push('--build-file');
-        const formattedTargetFile = formatArgWithWhiteSpace(targetFile);
-        args.push(formattedTargetFile);
+        args.push(resolvedTargetFilePath);
     }
     // Arguments to init script are supplied as properties: https://stackoverflow.com/a/48370451
     if (options['configuration-matching']) {
-        args.push(`-Pconfiguration=${quot}${options['configuration-matching']}${quot}`);
+        args.push(`-Pconfiguration=${options['configuration-matching']}`);
     }
     if (options['configuration-attributes']) {
-        args.push(`-PconfAttr=${quot}${options['configuration-attributes']}${quot}`);
+        args.push(`-PconfAttr=${options['configuration-attributes']}`);
     }
     if (options.initScript) {
-        const formattedInitScript = formatArgWithWhiteSpace(path.resolve(options.initScript));
+        const formattedInitScript = path.resolve(options.initScript);
         args.push('--init-script', formattedInitScript);
     }
     if (!options.daemon) {
@@ -161088,7 +161212,7 @@ function buildArgs(root, targetFile, initGradlePath, options) {
     if (!cli_interface_1.legacyPlugin.isMultiSubProject(options)) {
         args.push('-PonlySubProject=' + (options.subProject || '.'));
     }
-    args.push('-I ' + initGradlePath);
+    args.push('-I', initGradlePath);
     if (options.args) {
         args.push(...options.args);
     }
@@ -161097,14 +161221,14 @@ function buildArgs(root, targetFile, initGradlePath, options) {
     // but we are handling it to support the legacy setups.
     args.forEach((a, i) => {
         // Transform --configuration=foo
-        args[i] = a.replace(/^--configuration[= ]([a-zA-Z_]+)/, `-Pconfiguration=${quot}^$1$$${quot}`);
+        args[i] = a.replace(/^--configuration[= ]([a-zA-Z_]+)/, `-Pconfiguration=^$1$$`);
         // Transform --configuration foo
         if (a === '--configuration') {
-            args[i] = `-Pconfiguration=${quot}^${args[i + 1]}$${quot}`;
+            args[i] = `-Pconfiguration=^${args[i + 1]}$`;
             args[i + 1] = '';
         }
     });
-    return args;
+    return args.filter(Boolean);
 }
 exports.exportsForTests = {
     buildArgs,
@@ -161179,6 +161303,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.execute = void 0;
 const childProcess = __webpack_require__(63129);
 const debugModule = __webpack_require__(15158);
+const shescape_1 = __webpack_require__(79114);
 const debugLogging = debugModule('snyk-gradle-plugin');
 // Executes a subprocess. Resolves successfully with stdout contents if the exit code is 0.
 function execute(command, args, options, perLineCallback) {
@@ -161186,6 +161311,7 @@ function execute(command, args, options, perLineCallback) {
     if (options && options.cwd) {
         spawnOptions.cwd = options.cwd;
     }
+    args = (0, shescape_1.quoteAll)(args, spawnOptions);
     return new Promise((resolve, reject) => {
         let stdout = '';
         let stderr = '';
@@ -237043,6 +237169,838 @@ function extend() {
 }
 
 
+/***/ }),
+
+/***/ 79114:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var os = __webpack_require__(12087);
+var process = __webpack_require__(61765);
+var fs = __webpack_require__(35747);
+var path = __webpack_require__(85622);
+var which = __webpack_require__(53267);
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+/**
+ * @overview Provides functionality related to working with executables.
+ * @license MPL-2.0
+ */
+
+/**
+ * Resolves the location of an executable given an arbitrary valid string
+ * representation of that executable.
+ *
+ * To obtain the location of the executable this function (if necessary):
+ * - Expands the provided string to a absolute path.
+ * - Follows symbolic links.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.executable A string representation of the executable.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.exists A function to check if a file exists.
+ * @param {Function} deps.readlink A function to resolve (sym)links.
+ * @param {Function} deps.which A function to perform a `which(1)`-like lookup.
+ * @returns {string} The full path to the binary of the executable.
+ * @throws {Error} If the `deps` aren't provided.
+ */
+function resolveExecutable({ executable }, { exists, readlink, which }) {
+  if (readlink === undefined || which === undefined) {
+    throw new Error();
+  }
+
+  try {
+    executable = which(executable);
+  } catch (_) {
+    // For backwards compatibility return the executable even if its location
+    // cannot be obtained
+    return executable;
+  }
+
+  if (!exists(executable)) {
+    // For backwards compatibility return the executable even if there exists no
+    // file at the specified path
+    return executable;
+  }
+
+  try {
+    executable = readlink(executable);
+  } catch (_) {
+    // An error will be thrown if the executable is not a (sym)link, this is not
+    // a problem so the error is ignored
+  }
+
+  return executable;
+}
+
+/**
+ * @overview Provides an API to consistently escape or quote shell arguments
+ * across platforms.
+ * @license MPL-2.0
+ */
+
+/**
+ * The error message for incorrect parameter types.
+ *
+ * @constant
+ * @type {string}
+ */
+const typeError =
+  "Shescape requires strings or values that can be converted into a string using .toString()";
+
+/**
+ * The `typeof` value of functions.
+ *
+ * @constant
+ * @type {string}
+ */
+const typeofFunction = "function";
+
+/**
+ * The `typeof` value of strings.
+ *
+ * @constant
+ * @type {string}
+ */
+const typeofString = "string";
+
+/**
+ * Checks if a value is a string.
+ *
+ * @param {any} value The value of interest.
+ * @returns {boolean} `true` if `value` is a string, `false` otherwise.
+ */
+function isString(value) {
+  return typeof value === typeofString;
+}
+
+/**
+ * Checks if a value can be converted into a string.
+ *
+ * @param {any} value The value of interest.
+ * @returns {boolean} `true` if `value` is stringable, `false` otherwise.
+ */
+function isStringable(value) {
+  if (value === undefined || value === null) {
+    return false;
+  }
+
+  if (typeof value.toString !== typeofFunction) {
+    return false;
+  }
+
+  const str = value.toString();
+  return isString(str);
+}
+
+/**
+ * Merges any number of objects into a single object.
+ *
+ * Note: the values of objects appearing later in the list of arguments take
+ * precedence when merging.
+ *
+ * @param {...object} objects The objects to merge.
+ * @returns {object} The merged object.
+ */
+function mergeObjects(...objects) {
+  const baseObject = Object.create(null);
+  const mergedObjects = Object.assign(baseObject, ...objects);
+  return mergedObjects;
+}
+
+/**
+ * Parses arguments provided to {@link escapeShellArg} or {@link quoteShellArg}.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.arg The argument to escape.
+ * @param {object} args.options The options for escaping `arg`.
+ * @param {string} [args.options.shell] The shell to escape `arg` for.
+ * @param {boolean} [args.options.interpolation] Is interpolation enabled.
+ * @param {boolean} [args.options.quoted] Is `arg` being quoted.
+ * @param {object} args.process The `process` values.
+ * @param {object} args.process.env The environment variables.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.getDefaultShell Get the default shell for the system.
+ * @param {Function} deps.getShellName Get the name of a shell.
+ * @returns {object} The parsed arguments.
+ */
+function parseArgs(
+  { arg, options: { interpolation, quoted, shell }, process: { env } },
+  { getDefaultShell, getShellName }
+) {
+  interpolation = interpolation ? true : false;
+  shell = isString(shell) ? shell : getDefaultShell({ env });
+
+  const shellName = getShellName({ shell }, { resolveExecutable });
+  return { arg, interpolation, quoted, shellName };
+}
+
+/**
+ * Escapes an argument for the given shell.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.arg The argument to escape.
+ * @param {boolean} args.interpolation Is interpolation enabled.
+ * @param {boolean} args.quoted Is `arg` being quoted.
+ * @param {string} args.shellName The name of the shell to escape `arg` for.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.getEscapeFunction Get the escape function for a shell.
+ * @returns {string} The escaped argument.
+ * @throws {TypeError} The argument to escape is not stringable.
+ */
+function escape$1(
+  { arg, interpolation, quoted, shellName },
+  { getEscapeFunction }
+) {
+  if (!isStringable(arg)) {
+    throw new TypeError(typeError);
+  }
+
+  const argAsString = arg.toString();
+  const escape = getEscapeFunction(shellName);
+  const escapedArg = escape(argAsString, interpolation, quoted);
+  return escapedArg;
+}
+
+/**
+ * Quotes and escape an argument for the given shell.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.arg The argument to escape.
+ * @param {string} args.shellName The name of the shell to escape `arg` for.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.getEscapeFunction Get the escape function for a shell.
+ * @param {Function} deps.getQuoteFunction Get the quote function for a shell.
+ * @returns {string} The quoted and escaped argument.
+ * @throws {TypeError} The argument to escape is not stringable.
+ */
+function quote$1({ arg, shellName }, { getEscapeFunction, getQuoteFunction }) {
+  const escapedArg = escape$1(
+    { arg, interpolation: false, quoted: true, shellName },
+    { getEscapeFunction }
+  );
+  const quote = getQuoteFunction(shellName);
+  const escapedAndQuotedArg = quote(escapedArg);
+  return escapedAndQuotedArg;
+}
+
+/**
+ * Escapes an argument for the given shell.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.arg The argument to escape.
+ * @param {object} args.options The options for escaping `arg`.
+ * @param {object} args.process The `process` values.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.getDefaultShell Get the default shell for the system.
+ * @param {Function} deps.getEscapeFunction Get an escape function for a shell.
+ * @param {Function} deps.getShellName Get the name of a shell.
+ * @returns {string} The escaped argument.
+ */
+function escapeShellArg({ arg, options, process }, deps) {
+  options = mergeObjects(options, { quoted: false });
+  const escapeArgs = parseArgs({ arg, options, process }, deps);
+  return escape$1(escapeArgs, deps);
+}
+
+/**
+ * Quotes and escape an argument for the given shell.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.arg The argument to escape.
+ * @param {object} args.options The options for escaping `arg`.
+ * @param {string} [args.options.shell] The shell to escape `arg` for.
+ * @param {object} args.process The `process` values.
+ * @param {object} args.process.env The environment variables.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.getDefaultShell Get the default shell for the system.
+ * @param {Function} deps.getEscapeFunction Get an escape function for a shell.
+ * @param {Function} deps.getQuoteFunction Get a quote function for a shell.
+ * @param {Function} deps.getShellName Get the name of a shell.
+ * @returns {string} The quoted and escaped argument.
+ */
+function quoteShellArg(args, deps) {
+  const quoteArgs = parseArgs(args, deps);
+  return quote$1(quoteArgs, deps);
+}
+
+/**
+ * @overview Provides functionality specifically for Unix systems.
+ * @license MPL-2.0
+ */
+
+/**
+ * The name of the Bourne-again shell (Bash) binary.
+ *
+ * @constant
+ * @type {string}
+ */
+const binBash = "bash";
+
+/**
+ * The name of the Debian Almquist shell (Dash) binary.
+ *
+ * @constant
+ * @type {string}
+ */
+const binDash = "dash";
+
+/**
+ * The name of the Z shell (Zsh) binary.
+ *
+ * @constant
+ * @type {string}
+ */
+const binZsh = "zsh";
+
+/**
+ * Escapes a shell argument for use in Bash(-like shells).
+ *
+ * @param {string} arg The argument to escape.
+ * @param {boolean} interpolation Is interpolation enabled.
+ * @param {boolean} quoted Is `arg` being quoted.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgBash(arg, interpolation, quoted) {
+  let result = arg.replace(/[\0\u0008\u001B\u009B]/gu, "");
+
+  if (interpolation) {
+    result = result
+      .replace(/\\/gu, "\\\\")
+      .replace(/\n/gu, " ")
+      .replace(/(^|\s)([#~])/gu, "$1\\$2")
+      .replace(/(["$&'()*;<>?`{|])/gu, "\\$1")
+      .replace(/(?<=[:=])(~)(?=[\s+\-/0:=]|$)/gu, "\\$1");
+  } else if (quoted) {
+    result = result.replace(/'/gu, `'\\''`);
+  }
+
+  result = result.replace(/\r(?!\n)/gu, "");
+
+  return result;
+}
+
+/**
+ * Escapes a shell argument for use in Dash.
+ *
+ * @param {string} arg The argument to escape.
+ * @param {boolean} interpolation Is interpolation enabled.
+ * @param {boolean} quoted Is `arg` being quoted.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgDash(arg, interpolation, quoted) {
+  let result = arg.replace(/[\0\u0008\u001B\u009B]/gu, "");
+
+  if (interpolation) {
+    result = result
+      .replace(/\\/gu, "\\\\")
+      .replace(/\n/gu, " ")
+      .replace(/(^|\s)([#~])/gu, "$1\\$2")
+      .replace(/(["$&'()*;<>?`|])/gu, "\\$1");
+  } else if (quoted) {
+    result = result.replace(/'/gu, `'\\''`);
+  }
+
+  result = result.replace(/\r(?!\n)/gu, "");
+
+  return result;
+}
+
+/**
+ * Escapes a shell argument for use in Zsh.
+ *
+ * @param {string} arg The argument to escape.
+ * @param {boolean} interpolation Is interpolation enabled.
+ * @param {boolean} quoted Is `arg` being quoted.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgZsh(arg, interpolation, quoted) {
+  let result = arg.replace(/[\0\u0008\u001B\u009B]/gu, "");
+
+  if (interpolation) {
+    result = result
+      .replace(/\\/gu, "\\\\")
+      .replace(/\n/gu, " ")
+      .replace(/(^|\s)([#=~])/gu, "$1\\$2")
+      .replace(/(["$&'()*;<>?[\]`{|}])/gu, "\\$1");
+  } else if (quoted) {
+    result = result.replace(/'/gu, `'\\''`);
+  }
+
+  result = result.replace(/\r(?!\n)/gu, "");
+
+  return result;
+}
+
+/**
+ * Quotes an argument for use in a Unix shell.
+ *
+ * @param {string} arg The argument to quote.
+ * @returns {string} The quoted argument.
+ */
+function quoteArg$1(arg) {
+  return `'${arg}'`;
+}
+
+/**
+ * Returns the basename of a directory or file path on a Unix system.
+ *
+ * @param {string} fullPath A Unix-style directory or file path.
+ * @returns {string} The basename of `fullPath`.
+ */
+function getBasename$1(fullPath) {
+  return path__namespace.basename(fullPath);
+}
+
+/**
+ * Returns the default shell for Unix systems.
+ *
+ * For more information, see `options.shell` in:
+ * https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback.
+ *
+ * @returns {string} The default shell.
+ */
+function getDefaultShell$1() {
+  return "/bin/sh";
+}
+
+/**
+ * Returns a function to escape arguments for use in a particular shell.
+ *
+ * @param {string} shellName The name of a Unix shell.
+ * @returns {Function?} A function to escape arguments for use in the shell.
+ */
+function getEscapeFunction$1(shellName) {
+  switch (shellName) {
+    case binBash:
+      return escapeArgBash;
+    case binDash:
+      return escapeArgDash;
+    case binZsh:
+      return escapeArgZsh;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Returns a function to quote arguments for use in a particular shell.
+ *
+ * @param {string} shellName The name of a Unix shell.
+ * @returns {Function?} A function to quote arguments for use in the shell.
+ */
+function getQuoteFunction$1(shellName) {
+  switch (shellName) {
+    case binBash:
+    case binDash:
+    case binZsh:
+      return quoteArg$1;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Determines the name of the shell identified by a file path or file name.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.shell The name or path of the shell.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.resolveExecutable Resolve the path to an executable.
+ * @returns {string} The shell name.
+ */
+function getShellName$1({ shell }, { resolveExecutable }) {
+  shell = resolveExecutable(
+    { executable: shell },
+    { exists: fs__namespace.existsSync, readlink: fs__namespace.readlinkSync, which: which.sync }
+  );
+
+  const shellName = getBasename$1(shell);
+  if (getEscapeFunction$1(shellName) === null) {
+    return binBash;
+  }
+
+  return shellName;
+}
+
+var unix = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getDefaultShell: getDefaultShell$1,
+  getEscapeFunction: getEscapeFunction$1,
+  getQuoteFunction: getQuoteFunction$1,
+  getShellName: getShellName$1
+});
+
+/**
+ * @overview Provides functionality specifically for Windows systems.
+ * @license MPL-2.0
+ */
+
+/**
+ * The name of the Windows Command Prompt binary.
+ *
+ * @constant
+ * @type {string}
+ */
+const binCmd = "cmd.exe";
+
+/**
+ * The name of the Windows PowerShell binary.
+ *
+ * @constant
+ * @type {string}
+ */
+const binPowerShell = "powershell.exe";
+
+/**
+ * Escapes a shell argument for use in Windows Command Prompt.
+ *
+ * @param {string} arg The argument to escape.
+ * @param {boolean} interpolation Is interpolation enabled.
+ * @param {boolean} quoted Is `arg` being quoted.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgCmd(arg, interpolation, quoted) {
+  let result = arg
+    .replace(/[\0\u0008\u001B\u009B]/gu, "")
+    .replace(/\r?\n|\r/gu, " ");
+
+  if (interpolation) {
+    result = result.replace(/\^/gu, "^^").replace(/(["&<>|])/gu, "^$1");
+  } else if (quoted) {
+    result = result.replace(/"/gu, `""`);
+  }
+
+  return result;
+}
+
+/**
+ * Escapes a shell argument for use in Windows PowerShell.
+ *
+ * @param {string} arg The argument to escape.
+ * @param {boolean} interpolation Is interpolation enabled.
+ * @param {boolean} quoted Is `arg` being quoted.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgPowerShell(arg, interpolation, quoted) {
+  let result = arg
+    .replace(/[\0\u0008\u001B\u009B]/gu, "")
+    .replace(/`/gu, "``")
+    .replace(/\$/gu, "`$$")
+    .replace(/\r(?!\n)/gu, "");
+
+  if (interpolation) {
+    result = result
+      .replace(/\r?\n|\r/gu, " ")
+      .replace(/(^|[\s\u0085])([*1-6]?)(>)/gu, "$1$2`$3")
+      .replace(/(^|[\s\u0085])([#\-:<@\]])/gu, "$1`$2")
+      .replace(/(["&'(),;{|}‘’‚‛“”„])/gu, "`$1");
+  } else if (quoted) {
+    result = result.replace(/(["“”„])/gu, "$1$1");
+  }
+
+  return result;
+}
+
+/**
+ * Quotes an argument for use in a Windows shell.
+ *
+ * @param {string} arg The argument to quote.
+ * @returns {string} The quoted argument.
+ */
+function quoteArg(arg) {
+  return `"${arg}"`;
+}
+
+/**
+ * Returns the basename of a directory or file path on a Windows system.
+ *
+ * @param {string} fullPath A Windows-style directory or file path.
+ * @returns {string} The basename of `fullPath`.
+ */
+function getBasename(fullPath) {
+  return path__namespace.win32.basename(fullPath);
+}
+
+/**
+ * Returns the default shell for Windows systems.
+ *
+ * For more information, see:
+ * https://nodejs.org/api/child_process.html#default-windows-shell.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {object} args.env The environment variables.
+ * @param {string} [args.env.ComSpec] The %COMSPEC% value.
+ * @returns {string} The default shell.
+ */
+function getDefaultShell({ env: { ComSpec } }) {
+  if (ComSpec !== undefined) {
+    return ComSpec;
+  }
+
+  return binCmd;
+}
+
+/**
+ * Returns a function to escape arguments for use in a particular shell.
+ *
+ * @param {string} shellName The name of a Windows shell.
+ * @returns {Function?} A function to escape arguments for use in the shell.
+ */
+function getEscapeFunction(shellName) {
+  switch (shellName) {
+    case binCmd:
+      return escapeArgCmd;
+    case binPowerShell:
+      return escapeArgPowerShell;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Returns a function to quote arguments for use in a particular shell.
+ *
+ * @param {string} shellName The name of a Windows shell.
+ * @returns {Function?} A function to quote arguments for use in the shell.
+ */
+function getQuoteFunction(shellName) {
+  switch (shellName) {
+    case binCmd:
+    case binPowerShell:
+      return quoteArg;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Determines the name of the shell identified by a file path or file name.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {string} args.shell The name or path of the shell.
+ * @param {object} deps The dependencies for this function.
+ * @param {Function} deps.resolveExecutable Resolve the path to an executable.
+ * @returns {string} The shell name.
+ */
+function getShellName({ shell }, { resolveExecutable }) {
+  shell = resolveExecutable(
+    { executable: shell },
+    { exists: fs__namespace.existsSync, readlink: fs__namespace.readlinkSync, which: which.sync }
+  );
+
+  const shellName = getBasename(shell);
+  if (getEscapeFunction(shellName) === null) {
+    return binCmd;
+  }
+
+  return shellName;
+}
+
+var win = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getDefaultShell: getDefaultShell,
+  getEscapeFunction: getEscapeFunction,
+  getQuoteFunction: getQuoteFunction,
+  getShellName: getShellName
+});
+
+/**
+ * @overview Provides functionality related to getting the platform module for
+ * the current system.
+ * @license MPL-2.0
+ */
+
+/**
+ * The string identifying the OS type Cygwin.
+ *
+ * @constant
+ * @type {string}
+ */
+const cygwin = "cygwin";
+
+/**
+ * The string identifying the OS type MSYS.
+ *
+ * @constant
+ * @type {string}
+ */
+const msys = "msys";
+
+/**
+ * The string identifying Windows platforms.
+ *
+ * @constant
+ * @type {string}
+ */
+const win32 = "win32";
+
+/**
+ * Checks if the current system is a Windows system.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {Object<string, string>} args.env The environment variables.
+ * @param {string} args.platform The `os.platform()` value.
+ * @returns {boolean} `true` if the system is Windows, `false` otherwise.
+ */
+function isWindow({ env, platform }) {
+  return env.OSTYPE === cygwin || env.OSTYPE === msys || platform === win32;
+}
+
+/**
+ * Returns all helper functions for a specific system.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {Object<string, string>} args.env The environment variables.
+ * @param {string} args.platform The `os.platform()` value.
+ * @returns {object} The helper functions for the current system.
+ */
+function getHelpersByPlatform(args) {
+  if (isWindow(args)) {
+    return win;
+  }
+
+  return unix;
+}
+
+/**
+ * A simple shell escape package. Use it to escape user-controlled inputs to
+ * shell commands to prevent shell injection.
+ *
+ * @example
+ * import cp from "child_process";
+ * import * as shescape from "shescape";
+ * cp.spawn("command", shescape.escapeAll(userInput), options);
+ * @overview Entrypoint for the package.
+ * @module shescape
+ * @version 1.6.1
+ * @license MPL-2.0
+ */
+
+/**
+ * Get the helper functions for the current platform.
+ *
+ * @returns {object} The helper functions for the current platform.
+ */
+function getPlatformHelpers() {
+  const platform = os.platform();
+  const helpers = getHelpersByPlatform({ env: process.env, platform });
+  return helpers;
+}
+
+/**
+ * Converts the provided value into an array if it is not already an array and
+ * returns the array.
+ *
+ * @param {Array | any} x The value to convert to an array if necessary.
+ * @returns {Array} An array containing `x` or `x` itself.
+ */
+function toArrayIfNecessary(x) {
+  return Array.isArray(x) ? x : [x];
+}
+
+/**
+ * Take a single value, the argument, and escape any dangerous characters.
+ *
+ * Non-string inputs will be converted to strings using a `toString()` method.
+ *
+ * @param {string} arg The argument to escape.
+ * @param {object} [options] The escape options.
+ * @param {boolean} [options.interpolation=false] Is interpolation enabled.
+ * @param {boolean | string} [options.shell] The shell to escape for.
+ * @returns {string} The escaped argument.
+ * @throws {TypeError} The argument is not stringable.
+ * @since 0.1.0
+ */
+function escape(arg, options = {}) {
+  const helpers = getPlatformHelpers();
+  return escapeShellArg({ arg, options, process }, helpers);
+}
+
+/**
+ * Take a array of values, the arguments, and escape any dangerous characters in
+ * every argument.
+ *
+ * Non-array inputs will be converted to one-value arrays and non-string values
+ * will be converted to strings using a `toString()` method.
+ *
+ * @param {string[]} args The arguments to escape.
+ * @param {object} [options] The escape options.
+ * @param {boolean} [options.interpolation=false] Is interpolation enabled.
+ * @param {boolean | string} [options.shell] The shell to escape for.
+ * @returns {string[]} The escaped arguments.
+ * @throws {TypeError} One of the arguments is not stringable.
+ * @since 1.1.0
+ */
+function escapeAll(args, options = {}) {
+  args = toArrayIfNecessary(args);
+  return args.map((arg) => escape(arg, options));
+}
+
+/**
+ * Take a single value, the argument, put OS-specific quotes around it and
+ * escape any dangerous characters.
+ *
+ * Non-string inputs will be converted to strings using a `toString()` method.
+ *
+ * @param {string} arg The argument to quote and escape.
+ * @param {object} [options] The escape and quote options.
+ * @param {boolean | string} [options.shell] The shell to escape for.
+ * @returns {string} The quoted and escaped argument.
+ * @throws {TypeError} The argument is not stringable.
+ * @since 0.3.0
+ */
+function quote(arg, options = {}) {
+  const helpers = getPlatformHelpers();
+  return quoteShellArg({ arg, options, process }, helpers);
+}
+
+/**
+ * Take an array of values, the arguments, put OS-specific quotes around every
+ * argument and escape any dangerous characters in every argument.
+ *
+ * Non-array inputs will be converted to one-value arrays and non-string values
+ * will be converted to strings using a `toString()` method.
+ *
+ * @param {string[]} args The arguments to quote and escape.
+ * @param {object} [options] The escape and quote options.
+ * @param {boolean | string} [options.shell] The shell to escape for.
+ * @returns {string[]} The quoted and escaped arguments.
+ * @throws {TypeError} One of the arguments is not stringable.
+ * @since 0.4.0
+ */
+function quoteAll(args, options = {}) {
+  args = toArrayIfNecessary(args);
+  return args.map((arg) => quote(arg, options));
+}
+
+exports.escape = escape;
+exports.escapeAll = escapeAll;
+exports.quote = quote;
+exports.quoteAll = quoteAll;
+
+
 /***/ }),
 
 /***/ 53966: