snyk 1.1298.0 → 1.1298.2

package/dist/cli/464.index.js

@@ -209431,8 +209431,8 @@ async function getImageArchive(targetImage, imageSavePath, username, password, p
     try {
         inspectResult = await getInspectResult(docker, targetImage);
     }
-    catch (_a) {
-        debug(`${targetImage} does not exist locally, proceeding to pull image.`);
+    catch (error) {
+        debug(`${targetImage} does not exist locally, proceeding to pull image.`, error.stack || error);
     }
     if (inspectResult === undefined) {
         const imageName = await pullImage(docker, targetImage, saveLocation, imageSavePath, username, password, platform);
@@ -212058,8 +212058,13 @@ async function extractArchive(ociArchiveFilesystemPath, extractActions, options)
 }
 exports.extractArchive = extractArchive;
 function getLayersContentAndArchiveManifest(imageIndex, manifestCollection, indexFiles, configs, layers, options) {
+    const filteredConfigs = configs.filter((config) => {
+        return (config === null || config === void 0 ? void 0 : config.os) !== "unknown" || (config === null || config === void 0 ? void 0 : config.architecture) !== "unknown";
+    });
     const platform = (options === null || options === void 0 ? void 0 : options.platform) ||
-        (configs.length === 1 ? (0, __1.getPlatformFromConfig)(configs[0]) : "linux/amd64");
+        (filteredConfigs.length === 1
+            ? (0, __1.getPlatformFromConfig)(filteredConfigs[0])
+            : "linux/amd64");
     const platformInfo = getOciPlatformInfoFromOptionString(platform);
     // get manifest file first
     const manifest = getManifest(imageIndex, manifestCollection, indexFiles, platformInfo);
@@ -214587,16 +214592,16 @@ exports.streamToJson = streamToJson;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.execute = void 0;
 const childProcess = __webpack_require__(32081);
-const stateless_1 = __webpack_require__(11977);
+const shescape_1 = __webpack_require__(66710);
 function execute(command, args, options) {
     const spawnOptions = {
-        shell: process.platform !== "win32" ? "/bin/bash" : true,
+        shell: true,
         env: { ...process.env },
     };
     if (options && options.cwd) {
         spawnOptions.cwd = options.cwd;
     }
-    args = (0, stateless_1.quoteAll)(args, { ...spawnOptions, flagProtection: false });
+    args = (0, shescape_1.quoteAll)(args, spawnOptions);
     // Before spawning an external process, we look if we need to restore the system proxy configuration,
     // which overrides the cli internal proxy configuration.
     if (process.env.SNYK_SYSTEM_HTTP_PROXY !== undefined) {
@@ -219301,118 +219306,128 @@ module.exports.setGracefulCleanup = setGracefulCleanup;
 
 /***/ }),
 
-/***/ 25190:
+/***/ 81918:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const isexe = __webpack_require__(31959)
-const { join, delimiter, sep, posix } = __webpack_require__(71017)
-
-const isWindows = process.platform === 'win32'
+const isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys'
 
-// used to check for slashed in commands passed in. always checks for the posix
-// seperator on all platforms, and checks for the current separator when not on
-// a posix platform. don't use the isWindows check for this since that is mocked
-// in tests but we still need the code to actually work when called. that is also
-// why it is ignored from coverage.
-/* istanbul ignore next */
-const rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? '' : sep}]`.replace(/(\\)/g, '\\$1'))
-const rRel = new RegExp(`^\\.${rSlash.source}`)
+const path = __webpack_require__(71017)
+const COLON = isWindows ? ';' : ':'
+const isexe = __webpack_require__(31959)
 
 const getNotFoundError = (cmd) =>
   Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' })
 
-const getPathInfo = (cmd, {
-  path: optPath = process.env.PATH,
-  pathExt: optPathExt = process.env.PATHEXT,
-  delimiter: optDelimiter = delimiter,
-}) => {
+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(rSlash) ? [''] : [
-    // windows always checks the cwd first
-    ...(isWindows ? [process.cwd()] : []),
-    ...(optPath || /* istanbul ignore next: very unusual */ '').split(optDelimiter),
-  ]
+  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) {
-    const pathExtExe = optPathExt ||
-      ['.EXE', '.CMD', '.BAT', '.COM'].join(optDelimiter)
-    const pathExt = pathExtExe.split(optDelimiter).reduce((acc, item) => {
-      acc.push(item)
-      acc.push(item.toLowerCase())
-      return acc
-    }, [])
-    if (cmd.includes('.') && pathExt[0] !== '') {
+    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
       pathExt.unshift('')
-    }
-    return { pathEnv, pathExt, pathExtExe }
   }
 
-  return { pathEnv, pathExt: [''] }
+  return {
+    pathEnv,
+    pathExt,
+    pathExtExe,
+  }
 }
 
-const getPathPart = (raw, cmd) => {
-  const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw
-  const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : ''
-  return prefix + join(pathPart, cmd)
-}
+const which = (cmd, opt, cb) => {
+  if (typeof opt === 'function') {
+    cb = opt
+    opt = {}
+  }
+  if (!opt)
+    opt = {}
 
-const which = async (cmd, opt = {}) => {
   const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
   const found = []
 
-  for (const envPart of pathEnv) {
-    const p = getPathPart(envPart, cmd)
+  const step = i => new Promise((resolve, reject) => {
+    if (i === pathEnv.length)
+      return opt.all && found.length ? resolve(found)
+        : reject(getNotFoundError(cmd))
 
-    for (const ext of pathExt) {
-      const withExt = p + ext
-      const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true })
-      if (is) {
-        if (!opt.all) {
-          return withExt
-        }
-        found.push(withExt)
-      }
-    }
-  }
+    const ppRaw = pathEnv[i]
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
 
-  if (opt.all && found.length) {
-    return found
-  }
+    const pCmd = path.join(pathPart, cmd)
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd
 
-  if (opt.nothrow) {
-    return null
-  }
+    resolve(subStep(p, i, 0))
+  })
 
-  throw getNotFoundError(cmd)
+  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 = {}) => {
+const whichSync = (cmd, opt) => {
+  opt = opt || {}
+
   const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
   const found = []
 
-  for (const pathEnvPart of pathEnv) {
-    const p = getPathPart(pathEnvPart, cmd)
+  for (let i = 0; i < pathEnv.length; i ++) {
+    const ppRaw = pathEnv[i]
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
 
-    for (const ext of pathExt) {
-      const withExt = p + ext
-      const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true })
-      if (is) {
-        if (!opt.all) {
-          return withExt
+    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
         }
-        found.push(withExt)
-      }
+      } catch (ex) {}
     }
   }
 
-  if (opt.all && found.length) {
+  if (opt.all && found.length)
     return found
-  }
 
-  if (opt.nothrow) {
+  if (opt.nothrow)
     return null
-  }
 
   throw getNotFoundError(cmd)
 }
@@ -367744,18 +367759,18 @@ exports["default"] = version;
 
 /***/ }),
 
-/***/ 11977:
+/***/ 66710:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
-var os = __webpack_require__(70612);
-var process = __webpack_require__(97742);
-var fs = __webpack_require__(87561);
-var path = __webpack_require__(49411);
-var which = __webpack_require__(25190);
-var node_util = __webpack_require__(47261);
+var os = __webpack_require__(22037);
+var process = __webpack_require__(77282);
+var fs = __webpack_require__(57147);
+var path = __webpack_require__(71017);
+var which = __webpack_require__(81918);
+var util = __webpack_require__(73837);
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -367777,6 +367792,56 @@ function _interopNamespaceDefault(e) {
 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 an absolute path.
+ * - Follows symbolic links.
+ *
+ * @param {object} args The arguments for this function.
+ * @param {object} args.env The environment variables.
+ * @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.
+ */
+function resolveExecutable(
+  { env, executable },
+  { exists, readlink, which },
+) {
+  try {
+    executable = which(executable, { path: env.PATH || env.Path });
+  } 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 reflection functionality.
  * @license MPL-2.0
@@ -367807,20 +367872,6 @@ const typeofFunction = "function";
  */
 const typeofString = "string";
 
-/**
- * Check if the given object has the given property as an own property.
- *
- * This custom function is used over `Object.hasOwn` because that isn't
- * available in all supported Node.js versions.
- *
- * @param {object} object The object of interest.
- * @param {string} property The property of interest.
- * @returns {boolean} `true` if property is an own-property, `false` otherwise.
- */
-function hasOwn(object, property) {
-  return Object.prototype.hasOwnProperty.call(object, property);
-}
-
 /**
  * Checks if a value can be converted into a string and converts it if possible.
  *
@@ -367875,67 +367926,14 @@ function isString(value) {
 }
 
 /**
- * @overview Provides functionality related to working with executables.
- * @license MPL-2.0
- */
-
-
-/**
- * Build error messages for when executables cannot be found.
+ * Converts the provided value into an array if it is not already an array and
+ * returns the array.
  *
- * @param {string} executable The executable being looked up.
- * @returns {string} The executable not found error message.
+ * @param {Array | any} value The value to convert to an array if necessary.
+ * @returns {Array} An array containing `value` or `value` itself.
  */
-function notFoundError(executable) {
-  return `No executable could be found for ${executable}`;
-}
-
-/**
- * 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 an absolute path.
- * - Follows symbolic links.
- *
- * @param {object} args The arguments for this function.
- * @param {Object<string, string>} args.env The environment variables.
- * @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 executable could not be found.
- */
-function resolveExecutable(
-  { env, executable },
-  { exists, readlink, which },
-) {
-  let resolved = executable;
-  try {
-    const path = hasOwn(env, "PATH")
-      ? env.PATH
-      : hasOwn(env, "Path")
-        ? env.Path
-        : undefined;
-    resolved = which(resolved, { path });
-  } catch (_) {
-    throw new Error(notFoundError(executable));
-  }
-
-  if (!exists(resolved)) {
-    throw new Error(notFoundError(executable));
-  }
-
-  try {
-    resolved = readlink(resolved);
-  } 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 resolved;
+function toArrayIfNecessary(value) {
+  return Array.isArray(value) ? value : [value];
 }
 
 /**
@@ -367944,63 +367942,30 @@ function resolveExecutable(
  */
 
 
-/**
- * The identifier for 'no shell' or the absence of a shell.
- *
- * @constant
- * @type {symbol}
- */
-const noShell = Symbol();
-
-/**
- * Build error messages for unsupported shells.
- *
- * @param {string} shellName The full name of a shell.
- * @returns {string} The unsupported shell error message.
- */
-function unsupportedError$2(shellName) {
-  return `Shescape does not support the shell ${shellName}`;
-}
-
 /**
  * Parses options provided to shescape.
  *
  * @param {object} args The arguments for this function.
- * @param {Object<string, string>} args.env The environment variables.
+ * @param {object} args.env The environment variables.
  * @param {object} args.options The options for escaping.
+ * @param {boolean} [args.options.flagProtection] Is flag protection enabled.
+ * @param {boolean} [args.options.interpolation] Is interpolation enabled.
+ * @param {boolean | string} [args.options.shell] The shell to escape for.
  * @param {object} deps The dependencies for this function.
  * @param {Function} deps.getDefaultShell Function to get the default shell.
  * @param {Function} deps.getShellName Function to get the name of a shell.
- * @param {Function} deps.isShellSupported Function to see if a shell is usable.
  * @returns {object} The parsed arguments.
- * @throws {Error} The shell is not supported or could not be found.
  */
 function parseOptions(
-  { env, options },
-  { getDefaultShell, getShellName, isShellSupported },
+  { env, options: { flagProtection, interpolation, shell } },
+  { getDefaultShell, getShellName },
 ) {
-  let flagProtection = hasOwn(options, "flagProtection")
-    ? options.flagProtection
-    : undefined;
-  let shell = hasOwn(options, "shell") ? options.shell : undefined;
-
-  flagProtection =
-    flagProtection === undefined ? true : flagProtection ? true : false;
-
-  let shellName = noShell;
-  if (shell !== false) {
-    if (!isString(shell)) {
-      shell = getDefaultShell({ env });
-    }
-
-    shellName = getShellName({ env, shell }, { resolveExecutable });
-  }
-
-  if (!isShellSupported(shellName)) {
-    throw new Error(unsupportedError$2(shellName));
-  }
+  flagProtection = flagProtection ? true : false;
+  interpolation = interpolation ? true : false;
+  shell = isString(shell) ? shell : getDefaultShell({ env });
 
-  return { flagProtection, shellName };
+  const shellName = getShellName({ env, shell }, { resolveExecutable });
+  return { flagProtection, interpolation, shellName };
 }
 
 /**
@@ -368009,12 +367974,12 @@ function parseOptions(
  */
 
 /**
- * Escape an argument for use in Bash.
+ * Escape an argument for use in Bash when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg$7(arg) {
+function escapeArgForInterpolation$5(arg) {
   return arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
     .replace(/\n/gu, " ")
@@ -368025,14 +367990,31 @@ function escapeArg$7(arg) {
     .replace(/([\t ])/gu, "\\$1");
 }
 
+/**
+ * Escape an argument for use in Bash when the argument is not being quoted (but
+ * interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation$5(arg) {
+  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
+}
+
 /**
  * Returns a function to escape arguments for use in Bash for the given use
  * case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$9() {
-  return escapeArg$7;
+function getEscapeFunction$7(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation$5;
+  } else {
+    return escapeArgForNoInterpolation$5;
+  }
 }
 
 /**
@@ -368063,7 +368045,7 @@ function quoteArg$5(arg) {
  *
  * @returns {Function[]} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$9() {
+function getQuoteFunction$7() {
   return [escapeArgForQuoted$5, quoteArg$5];
 }
 
@@ -368074,7 +368056,7 @@ function getQuoteFunction$9() {
  * @param {string} arg The argument to update.
  * @returns {string} The updated argument.
  */
-function stripFlagPrefix$7(arg) {
+function stripFlagPrefix$5(arg) {
   return arg.replace(/^-+/gu, "");
 }
 
@@ -368083,8 +368065,8 @@ function stripFlagPrefix$7(arg) {
  *
  * @returns {Function} A function to protect against flag injection.
  */
-function getFlagProtectionFunction$9() {
-  return stripFlagPrefix$7;
+function getFlagProtectionFunction$7() {
+  return stripFlagPrefix$5;
 }
 
 /**
@@ -368094,13 +368076,13 @@ function getFlagProtectionFunction$9() {
 
 
 /**
- * Escape an argument for use in csh.
+ * Escape an argument for use in csh when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg$6(arg) {
-  const textEncoder = new node_util.TextEncoder();
+function escapeArgForInterpolation$4(arg) {
+  const textEncoder = new util.TextEncoder();
   return arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
     .replace(/\n/gu, " ")
@@ -368121,13 +368103,34 @@ function escapeArg$6(arg) {
     .join("");
 }
 
+/**
+ * Escape an argument for use in csh when the argument is not being quoted (but
+ * interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation$4(arg) {
+  return arg
+    .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
+    .replace(/\n/gu, " ")
+    .replace(/\\!$/gu, "\\\\!")
+    .replace(/!(?!$)/gu, "\\!");
+}
+
 /**
  * Returns a function to escape arguments for use in csh for the given use case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$8() {
-  return escapeArg$6;
+function getEscapeFunction$6(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation$4;
+  } else {
+    return escapeArgForNoInterpolation$4;
+  }
 }
 
 /**
@@ -368160,7 +368163,7 @@ function quoteArg$4(arg) {
  *
  * @returns {Function[]} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$8() {
+function getQuoteFunction$6() {
   return [escapeArgForQuoted$4, quoteArg$4];
 }
 
@@ -368171,7 +368174,7 @@ function getQuoteFunction$8() {
  * @param {string} arg The argument to update.
  * @returns {string} The updated argument.
  */
-function stripFlagPrefix$6(arg) {
+function stripFlagPrefix$4(arg) {
   return arg.replace(/^-+/gu, "");
 }
 
@@ -368180,8 +368183,8 @@ function stripFlagPrefix$6(arg) {
  *
  * @returns {Function} A function to protect against flag injection.
  */
-function getFlagProtectionFunction$8() {
-  return stripFlagPrefix$6;
+function getFlagProtectionFunction$6() {
+  return stripFlagPrefix$4;
 }
 
 /**
@@ -368190,12 +368193,12 @@ function getFlagProtectionFunction$8() {
  */
 
 /**
- * Escape an argument for use in Dash.
+ * Escape an argument for use in Dash when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg$5(arg) {
+function escapeArgForInterpolation$3(arg) {
   return arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
     .replace(/\n/gu, " ")
@@ -368205,14 +368208,31 @@ function escapeArg$5(arg) {
     .replace(/([\t ])/gu, "\\$1");
 }
 
+/**
+ * Escape an argument for use in Dash when the argument is not being quoted (but
+ * interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation$3(arg) {
+  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
+}
+
 /**
  * Returns a function to escape arguments for use in Dash for the given use
  * case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$7() {
-  return escapeArg$5;
+function getEscapeFunction$5(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation$3;
+  } else {
+    return escapeArgForNoInterpolation$3;
+  }
 }
 
 /**
@@ -368243,7 +368263,7 @@ function quoteArg$3(arg) {
  *
  * @returns {Function[]} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$7() {
+function getQuoteFunction$5() {
   return [escapeArgForQuoted$3, quoteArg$3];
 }
 
@@ -368254,7 +368274,7 @@ function getQuoteFunction$7() {
  * @param {string} arg The argument to update.
  * @returns {string} The updated argument.
  */
-function stripFlagPrefix$5(arg) {
+function stripFlagPrefix$3(arg) {
   return arg.replace(/^-+/gu, "");
 }
 
@@ -368263,78 +368283,8 @@ function stripFlagPrefix$5(arg) {
  *
  * @returns {Function} A function to protect against flag injection.
  */
-function getFlagProtectionFunction$7() {
-  return stripFlagPrefix$5;
-}
-
-/**
- * @overview Provides functionality for shell-less escaping on Unix systems.
- * @license MPL-2.0
- */
-
-/**
- * The error message for use of quoting functionality.
- *
- * @constant
- * @type {string}
- */
-const unsupportedError$1 = "Quoting is not supported when no shell is used";
-
-/**
- * Escape an argument for shell-less use.
- *
- * @param {string} arg The argument to escape.
- * @returns {string} The escaped argument.
- */
-function escapeArg$4(arg) {
-  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
-}
-
-/**
- * Returns a function to escape arguments for shell-less use.
- *
- * @returns {Function} A function to escape arguments.
- */
-function getEscapeFunction$6() {
-  return escapeArg$4;
-}
-
-/**
- * Returns the provided value.
- *
- * @throws {Error} Always.
- */
-function unsupported$1() {
-  throw new Error(unsupportedError$1);
-}
-
-/**
- * Returns a pair of functions that will indicate this operation is unsupported.
- *
- * @returns {Function[]} A pair of functions.
- */
-function getQuoteFunction$6() {
-  return [unsupported$1, unsupported$1];
-}
-
-/**
- * Remove any prefix from the provided argument that might be interpreted as a
- * flag on Unix systems.
- *
- * @param {string} arg The argument to update.
- * @returns {string} The updated argument.
- */
-function stripFlagPrefix$4(arg) {
-  return arg.replace(/^-+/gu, "");
-}
-
-/**
- * Returns a function to protect against flag injection for Unix systems.
- *
- * @returns {Function} A function to protect against flag injection.
- */
-function getFlagProtectionFunction$6() {
-  return stripFlagPrefix$4;
+function getFlagProtectionFunction$5() {
+  return stripFlagPrefix$3;
 }
 
 /**
@@ -368343,12 +368293,12 @@ function getFlagProtectionFunction$6() {
  */
 
 /**
- * Escape an argument for use in Zsh.
+ * Escape an argument for use in Zsh when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg$3(arg) {
+function escapeArgForInterpolation$2(arg) {
   return arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
     .replace(/\n/gu, " ")
@@ -368358,13 +368308,30 @@ function escapeArg$3(arg) {
     .replace(/([\t ])/gu, "\\$1");
 }
 
+/**
+ * Escape an argument for use in Zsh when the argument is not being quoted (but
+ * interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation$2(arg) {
+  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
+}
+
 /**
  * Returns a function to escape arguments for use in Zsh for the given use case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$5() {
-  return escapeArg$3;
+function getEscapeFunction$4(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation$2;
+  } else {
+    return escapeArgForNoInterpolation$2;
+  }
 }
 
 /**
@@ -368395,7 +368362,7 @@ function quoteArg$2(arg) {
  *
  * @returns {Function[]} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$5() {
+function getQuoteFunction$4() {
   return [escapeArgForQuoted$2, quoteArg$2];
 }
 
@@ -368406,7 +368373,7 @@ function getQuoteFunction$5() {
  * @param {string} arg The argument to update.
  * @returns {string} The updated argument.
  */
-function stripFlagPrefix$3(arg) {
+function stripFlagPrefix$2(arg) {
   return arg.replace(/^-+/gu, "");
 }
 
@@ -368415,8 +368382,8 @@ function stripFlagPrefix$3(arg) {
  *
  * @returns {Function} A function to protect against flag injection.
  */
-function getFlagProtectionFunction$5() {
-  return stripFlagPrefix$3;
+function getFlagProtectionFunction$4() {
+  return stripFlagPrefix$2;
 }
 
 /**
@@ -368472,21 +368439,21 @@ function getDefaultShell$1() {
 /**
  * Returns a function to escape arguments for use in a particular shell.
  *
- * @param {string | symbol} shellName The name of a Unix shell.
+ * @param {string} shellName The name of a Unix shell.
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function | undefined} A function to escape arguments.
  */
-function getEscapeFunction$4(shellName) {
+function getEscapeFunction$3(shellName, options) {
   switch (shellName) {
-    case noShell:
-      return getEscapeFunction$6();
     case binBash:
-      return getEscapeFunction$9();
+      return getEscapeFunction$7(options);
     case binCsh:
-      return getEscapeFunction$8();
+      return getEscapeFunction$6(options);
     case binDash:
-      return getEscapeFunction$7();
+      return getEscapeFunction$5(options);
     case binZsh:
-      return getEscapeFunction$5();
+      return getEscapeFunction$4(options);
   }
 }
 
@@ -368494,42 +368461,38 @@ function getEscapeFunction$4(shellName) {
  * Returns a pair of functions to escape and quote arguments for use in a
  * particular shell.
  *
- * @param {string | symbol} shellName The name of a Unix shell.
+ * @param {string} shellName The name of a Unix shell.
  * @returns {Function[] | undefined} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$4(shellName) {
+function getQuoteFunction$3(shellName) {
   switch (shellName) {
-    case noShell:
-      return getQuoteFunction$6();
     case binBash:
-      return getQuoteFunction$9();
+      return getQuoteFunction$7();
     case binCsh:
-      return getQuoteFunction$8();
+      return getQuoteFunction$6();
     case binDash:
-      return getQuoteFunction$7();
-    case binZsh:
       return getQuoteFunction$5();
+    case binZsh:
+      return getQuoteFunction$4();
   }
 }
 
 /**
  * Returns a function to protect against flag injection.
  *
- * @param {string | symbol} shellName The name of a Unix shell.
+ * @param {string} shellName The name of a Unix shell.
  * @returns {Function | undefined} A function to protect against flag injection.
  */
-function getFlagProtectionFunction$4(shellName) {
+function getFlagProtectionFunction$3(shellName) {
   switch (shellName) {
-    case noShell:
-      return getFlagProtectionFunction$6();
     case binBash:
-      return getFlagProtectionFunction$9();
+      return getFlagProtectionFunction$7();
     case binCsh:
-      return getFlagProtectionFunction$8();
+      return getFlagProtectionFunction$6();
     case binDash:
-      return getFlagProtectionFunction$7();
-    case binZsh:
       return getFlagProtectionFunction$5();
+    case binZsh:
+      return getFlagProtectionFunction$4();
   }
 }
 
@@ -368537,7 +368500,7 @@ function getFlagProtectionFunction$4(shellName) {
  * Determines the name of the shell identified by a file path or file name.
  *
  * @param {object} args The arguments for this function.
- * @param {Object<string, string>} args.env The environment variables.
+ * @param {object} args.env The environment variables.
  * @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.
@@ -368550,27 +368513,20 @@ function getShellName$1({ env, shell }, { resolveExecutable }) {
   );
 
   const shellName = path__namespace.basename(shell);
-  return shellName;
-}
+  if (getEscapeFunction$3(shellName, {}) === undefined) {
+    return binBash;
+  }
 
-/**
- * Checks if the given shell is supported on Unix or not.
- *
- * @param {string} shellName The name of a Unix shell.
- * @returns {boolean} `true` if the shell is supported, `false` otherwise.
- */
-function isShellSupported$1(shellName) {
-  return getEscapeFunction$4(shellName) !== undefined;
+  return shellName;
 }
 
 var unix = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getDefaultShell: getDefaultShell$1,
-  getEscapeFunction: getEscapeFunction$4,
-  getFlagProtectionFunction: getFlagProtectionFunction$4,
-  getQuoteFunction: getQuoteFunction$4,
-  getShellName: getShellName$1,
-  isShellSupported: isShellSupported$1
+  getEscapeFunction: getEscapeFunction$3,
+  getFlagProtectionFunction: getFlagProtectionFunction$3,
+  getQuoteFunction: getQuoteFunction$3,
+  getShellName: getShellName$1
 });
 
 /**
@@ -368579,12 +368535,12 @@ var unix = /*#__PURE__*/Object.freeze({
  */
 
 /**
- * Escape an argument for use in CMD.
+ * Escape an argument for use in CMD when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg$2(arg) {
+function escapeArgForInterpolation$1(arg) {
   let shouldEscapeSpecialChar = true;
   return arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
@@ -368610,13 +368566,30 @@ function escapeArg$2(arg) {
     .join("");
 }
 
+/**
+ * Escape an argument for use in CMD when the argument is not being quoted (but
+ * interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation$1(arg) {
+  return arg.replace(/[\0\u0008\r\u001B\u009B]/gu, "").replace(/\n/gu, " ");
+}
+
 /**
  * Returns a function to escape arguments for use in CMD for the given use case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$3() {
-  return escapeArg$2;
+function getEscapeFunction$2(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation$1;
+  } else {
+    return escapeArgForNoInterpolation$1;
+  }
 }
 
 /**
@@ -368626,7 +368599,10 @@ function getEscapeFunction$3() {
  * @returns {string} The escaped argument.
  */
 function escapeArgForQuoted$1(arg) {
-  return escapeArg$2(arg).replace(/(?<!\\)(\\*)([\t ])/gu, "$1$1$2");
+  return escapeArgForInterpolation$1(arg).replace(
+    /(?<!\\)(\\*)([\t ])/gu,
+    "$1$1$2",
+  );
 }
 
 /**
@@ -368644,7 +368620,7 @@ function quoteArg$1(arg) {
  *
  * @returns {Function[]} A function pair to escape & quote arguments.
  */
-function getQuoteFunction$3() {
+function getQuoteFunction$2() {
   return [escapeArgForQuoted$1, quoteArg$1];
 }
 
@@ -368655,82 +368631,12 @@ function getQuoteFunction$3() {
  * @param {string} arg The argument to update.
  * @returns {string} The updated argument.
  */
-function stripFlagPrefix$2(arg) {
-  return arg.replace(/^(?:-+|\/+)/gu, "");
-}
-
-/**
- * Returns a function to protect against flag injection for CMD.
- *
- * @returns {Function} A function to protect against flag injection.
- */
-function getFlagProtectionFunction$3() {
-  return stripFlagPrefix$2;
-}
-
-/**
- * @overview Provides functionality for shell-less escaping on Windows systems.
- * @license MPL-2.0
- */
-
-/**
- * The error message for use of quoting functionality.
- *
- * @constant
- * @type {string}
- */
-const unsupportedError = "Quoting is not supported when no shell is used";
-
-/**
- * Escape an argument for shell-less use.
- *
- * @param {string} arg The argument to escape.
- * @returns {string} The escaped argument.
- */
-function escapeArg$1(arg) {
-  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
-}
-
-/**
- * Returns a function to escape arguments for shell-less use.
- *
- * @returns {Function} A function to escape arguments.
- */
-function getEscapeFunction$2() {
-  return escapeArg$1;
-}
-
-/**
- * Returns the provided value.
- *
- * @throws {Error} Always.
- */
-function unsupported() {
-  throw new Error(unsupportedError);
-}
-
-/**
- * Returns a pair of functions that will indicate this operation is unsupported.
- *
- * @returns {Function[]} A pair of functions.
- */
-function getQuoteFunction$2() {
-  return [unsupported, unsupported];
-}
-
-/**
- * Remove any prefix from the provided argument that might be interpreted as a
- * flag on Windows systems.
- *
- * @param {string} arg The argument to update.
- * @returns {string} The updated argument.
- */
 function stripFlagPrefix$1(arg) {
   return arg.replace(/^(?:-+|\/+)/gu, "");
 }
 
 /**
- * Returns a function to protect against flag injection for Windows systems.
+ * Returns a function to protect against flag injection for CMD.
  *
  * @returns {Function} A function to protect against flag injection.
  */
@@ -368744,12 +368650,12 @@ function getFlagProtectionFunction$2() {
  */
 
 /**
- * Escape an argument for use in PowerShell.
+ * Escape an argument for use in PowerShell when interpolation is active.
  *
  * @param {string} arg The argument to escape.
  * @returns {string} The escaped argument.
  */
-function escapeArg(arg) {
+function escapeArgForInterpolation(arg) {
   arg = arg
     .replace(/[\0\u0008\r\u001B\u009B]/gu, "")
     .replace(/\n/gu, " ")
@@ -368771,14 +368677,31 @@ function escapeArg(arg) {
   return arg;
 }
 
+/**
+ * Escape an argument for use in PowerShell when the argument is not being
+ * quoted (but interpolation is inactive).
+ *
+ * @param {string} arg The argument to escape.
+ * @returns {string} The escaped argument.
+ */
+function escapeArgForNoInterpolation(arg) {
+  return arg.replace(/[\0\u0008\u001B\u009B]/gu, "").replace(/\r(?!\n)/gu, "");
+}
+
 /**
  * Returns a function to escape arguments for use in PowerShell for the given
  * use case.
  *
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function} A function to escape arguments.
  */
-function getEscapeFunction$1() {
-  return escapeArg;
+function getEscapeFunction$1(options) {
+  if (options.interpolation) {
+    return escapeArgForInterpolation;
+  } else {
+    return escapeArgForNoInterpolation;
+  }
 }
 
 /**
@@ -368873,11 +368796,11 @@ const binPowerShell = "powershell.exe";
  * https://nodejs.org/api/child_process.html#default-windows-shell.
  *
  * @param {object} args The arguments for this function.
- * @param {Object<string, string>} args.env The environment variables.
+ * @param {object} args.env The environment variables.
+ * @param {string} [args.env.ComSpec] The %COMSPEC% value.
  * @returns {string} The default shell.
  */
-function getDefaultShell({ env }) {
-  const ComSpec = hasOwn(env, "ComSpec") ? env.ComSpec : undefined;
+function getDefaultShell({ env: { ComSpec } }) {
   if (ComSpec !== undefined) {
     return ComSpec;
   }
@@ -368888,19 +368811,17 @@ function getDefaultShell({ env }) {
 /**
  * Returns a function to escape arguments for use in a particular shell.
  *
- * @param {string | symbol} shellName The name of a Windows shell.
+ * @param {string} shellName The name of a Windows shell.
+ * @param {object} options The options for escaping arguments.
+ * @param {boolean} options.interpolation Is interpolation enabled.
  * @returns {Function | undefined} A function to escape arguments.
  */
-function getEscapeFunction(shellName) {
-  if (shellName === noShell) {
-    return getEscapeFunction$2();
-  }
-
+function getEscapeFunction(shellName, options) {
   switch (shellName.toLowerCase()) {
     case binCmd:
-      return getEscapeFunction$3();
+      return getEscapeFunction$2(options);
     case binPowerShell:
-      return getEscapeFunction$1();
+      return getEscapeFunction$1(options);
   }
 }
 
@@ -368908,17 +368829,13 @@ function getEscapeFunction(shellName) {
  * Returns a pair of functions to escape and quote arguments for use in a
  * particular shell.
  *
- * @param {string | symbol} shellName The name of a Windows shell.
+ * @param {string} shellName The name of a Windows shell.
  * @returns {Function[] | undefined} A function pair to escape & quote arguments.
  */
 function getQuoteFunction(shellName) {
-  if (shellName === noShell) {
-    return getQuoteFunction$2();
-  }
-
   switch (shellName.toLowerCase()) {
     case binCmd:
-      return getQuoteFunction$3();
+      return getQuoteFunction$2();
     case binPowerShell:
       return getQuoteFunction$1();
   }
@@ -368927,17 +368844,13 @@ function getQuoteFunction(shellName) {
 /**
  * Returns a function to protect against flag injection.
  *
- * @param {string | symbol} shellName The name of a Windows shell.
+ * @param {string} shellName The name of a Windows shell.
  * @returns {Function | undefined} A function to protect against flag injection.
  */
 function getFlagProtectionFunction(shellName) {
-  if (shellName === noShell) {
-    return getFlagProtectionFunction$2();
-  }
-
   switch (shellName.toLowerCase()) {
     case binCmd:
-      return getFlagProtectionFunction$3();
+      return getFlagProtectionFunction$2();
     case binPowerShell:
       return getFlagProtectionFunction$1();
   }
@@ -368947,7 +368860,7 @@ function getFlagProtectionFunction(shellName) {
  * Determines the name of the shell identified by a file path or file name.
  *
  * @param {object} args The arguments for this function.
- * @param {Object<string, string>} args.env The environment variables.
+ * @param {object} args.env The environment variables.
  * @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.
@@ -368960,17 +368873,11 @@ function getShellName({ env, shell }, { resolveExecutable }) {
   );
 
   const shellName = path__namespace.win32.basename(shell);
-  return shellName;
-}
+  if (getEscapeFunction(shellName, {}) === undefined) {
+    return binCmd;
+  }
 
-/**
- * Checks if the given shell is supported on Windows or not.
- *
- * @param {string} shellName The name of a Windows shell.
- * @returns {boolean} `true` if the shell is supported, `false` otherwise.
- */
-function isShellSupported(shellName) {
-  return getEscapeFunction(shellName) !== undefined;
+  return shellName;
 }
 
 var win = /*#__PURE__*/Object.freeze({
@@ -368979,8 +368886,7 @@ var win = /*#__PURE__*/Object.freeze({
   getEscapeFunction: getEscapeFunction,
   getFlagProtectionFunction: getFlagProtectionFunction,
   getQuoteFunction: getQuoteFunction,
-  getShellName: getShellName,
-  isShellSupported: isShellSupported
+  getShellName: getShellName
 });
 
 /**
@@ -369023,8 +368929,7 @@ const win32 = "win32";
  * @returns {boolean} `true` if the system is Windows, `false` otherwise.
  */
 function isWindow({ env, platform }) {
-  const osType = hasOwn(env, "OSTYPE") ? env.OSTYPE : undefined;
-  return osType === cygwin || osType === msys || platform === win32;
+  return env.OSTYPE === cygwin || env.OSTYPE === msys || platform === win32;
 }
 
 /**
@@ -369049,185 +368954,61 @@ function getHelpersByPlatform({ env, platform }) {
  *
  * @overview Entrypoint for the library.
  * @module shescape
- * @version 2.1.0
+ * @version 1.7.4
  * @license MPL-2.0
  */
 
 
 /**
- * A class to escape user-controlled inputs to shell commands to prevent shell
- * injection.
+ * Get the helper functions for the current platform.
  *
- * @example
- * import { spawn } from "node:child_process";
- * const shescape = new Shescape({ shell: false });
- * spawn(
- *   "echo",
- *   ["Hello", shescape.escape(userInput)],
- *   null // `options.shell` MUST be falsy
- * );
- * @example
- * import { spawn } from "node:child_process";
- * const shescape = new Shescape({ shell: false });
- * spawn(
- *   "echo",
- *   shescape.escapeAll(["Hello", userInput]),
- *   null // `options.shell` MUST be falsy
- * );
- * @example
- * import { spawn } from "node:child_process";
- * const spawnOptions = { shell: true }; // `options.shell` SHOULD be truthy
- * const shescape = new Shescape({ shell: spawnOptions.shell });
- * spawn(
- *   "echo",
- *   ["Hello", shescape.quote(userInput)],
- *   spawnOptions
- * );
- * @example
- * import { spawn } from "node:child_process";
- * const spawnOptions = { shell: true }; // `options.shell` SHOULD be truthy
- * const shescape = new Shescape({ shell: spawnOptions.shell });
- * spawn(
- *   "echo",
- *   shescape.quoteAll(["Hello", userInput]),
- *   spawnOptions
- * );
+ * @returns {object} The helper functions for the current platform.
  */
-class Shescape {
-  /**
-   * Create a new {@link Shescape} instance.
-   *
-   * @param {object} [options] The escape options.
-   * @param {boolean} [options.flagProtection=true] Is flag protection enabled.
-   * @param {boolean | string} [options.shell=true] The shell to escape for.
-   * @throws {Error} The shell is not supported or could not be found.
-   * @since 2.0.0
-   */
-  constructor(options = {}) {
-    const platform = os.platform();
-    const helpers = getHelpersByPlatform({ env: process.env, platform });
-
-    options = parseOptions({ env: process.env, options }, helpers);
-    const { flagProtection, shellName } = options;
-
-    {
-      const escape = helpers.getEscapeFunction(shellName);
-      if (flagProtection) {
-        const flagProtect = helpers.getFlagProtectionFunction(shellName);
-        this._escape = (arg) => flagProtect(escape(arg));
-      } else {
-        this._escape = escape;
-      }
-    }
-
-    {
-      const [escape, quote] = helpers.getQuoteFunction(shellName);
-      if (flagProtection) {
-        const flagProtect = helpers.getFlagProtectionFunction(shellName);
-        this._quote = (arg) => quote(flagProtect(escape(arg)));
-      } else {
-        this._quote = (arg) => quote(escape(arg));
-      }
-    }
-  }
-
-  /**
-   * 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.
-   * @returns {string} The escaped argument.
-   * @throws {TypeError} The argument is not stringable.
-   * @since 2.0.0
-   */
-  escape(arg) {
-    const argAsString = checkedToString(arg);
-    return this._escape(argAsString);
-  }
-
-  /**
-   * Take an array of values, the arguments, and escape any dangerous characters
-   * in every argument.
-   *
-   * Non-string inputs will be converted to strings using a `toString()` method.
-   *
-   * @param {string[]} args The arguments to escape.
-   * @returns {string[]} The escaped arguments.
-   * @throws {TypeError} The arguments are not an array.
-   * @throws {TypeError} One of the arguments is not stringable.
-   * @since 2.0.0
-   */
-  escapeAll(args) {
-    return args.map((arg) => this.escape(arg));
-  }
-
-  /**
-   * Take a single value, the argument, put shell-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.
-   * @returns {string} The quoted and escaped argument.
-   * @throws {TypeError} The argument is not stringable.
-   * @throws {Error} Quoting is not supported with `shell: false`.
-   * @since 2.0.0
-   */
-  quote(arg) {
-    const argAsString = checkedToString(arg);
-    return this._quote(argAsString);
-  }
-
-  /**
-   * Take an array of values, the arguments, put shell-specific quotes around
-   * every argument and escape any dangerous characters in every argument.
-   *
-   * Non-string inputs will be converted to strings using a `toString()` method.
-   *
-   * @param {string[]} args The arguments to quote and escape.
-   * @returns {string[]} The quoted and escaped arguments.
-   * @throws {TypeError} The arguments are not an array.
-   * @throws {TypeError} One of the arguments is not stringable.
-   * @throws {Error} Quoting is not supported with `shell: false`.
-   * @since 2.0.0
-   */
-  quoteAll(args) {
-    return args.map((arg) => this.quote(arg));
-  }
+function getPlatformHelpers() {
+  const platform = os.platform();
+  const helpers = getHelpersByPlatform({ env: process.env, platform });
+  return helpers;
 }
 
-/**
- * @overview Alternative entrypoint for the library that provides a stateless
- * API.
- * @license MPL-2.0
- */
-
-
 /**
  * Take a single value, the argument, and escape any dangerous characters.
  *
  * Non-string inputs will be converted to strings using a `toString()` method.
  *
+ * NOTE: when the `interpolation` option is set to `true`, whitespace is escaped
+ * to prevent argument splitting except for cmd.exe (which does not support it).
+ *
  * @example
  * import { spawn } from "node:child_process";
  * spawn(
  *   "echo",
- *   ["Hello", shescape.escape(userInput, { shell: false })],
+ *   ["Hello", shescape.escape(userInput)],
  *   null // `options.shell` MUST be falsy
  * );
  * @param {string} arg The argument to escape.
  * @param {object} [options] The escape options.
- * @param {boolean} [options.flagProtection=true] Is flag protection enabled.
- * @param {boolean | string} [options.shell=true] The shell to escape for.
+ * @param {boolean} [options.flagProtection=false] Is flag protection enabled.
+ * @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.
- * @throws {Error} The shell is not supported or could not be found.
- * @since 2.1.0
+ * @since 0.1.0
  */
-function escape(arg, options) {
-  const shescape = new Shescape(options);
-  return shescape.escape(arg);
+function escape(arg, options = {}) {
+  const helpers = getPlatformHelpers();
+  const { flagProtection, interpolation, shellName } = parseOptions(
+    { env: process.env, options },
+    helpers,
+  );
+  const argAsString = checkedToString(arg);
+  const escape = helpers.getEscapeFunction(shellName, { interpolation });
+  const escapedArg = escape(argAsString);
+  if (flagProtection) {
+    const flagProtect = helpers.getFlagProtectionFunction(shellName);
+    return flagProtect(escapedArg);
+  } else {
+    return escapedArg;
+  }
 }
 
 /**
@@ -369241,21 +369022,21 @@ function escape(arg, options) {
  * import { spawn } from "node:child_process";
  * spawn(
  *   "echo",
- *   shescape.escapeAll(["Hello", userInput], { shell: false }),
+ *   shescape.escapeAll(["Hello", userInput]),
  *   null // `options.shell` MUST be falsy
  * );
  * @param {string[]} args The arguments to escape.
  * @param {object} [options] The escape options.
- * @param {boolean} [options.flagProtection=true] Is flag protection enabled.
- * @param {boolean | string} [options.shell=true] The shell to escape for.
+ * @param {boolean} [options.flagProtection=false] Is flag protection enabled.
+ * @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.
- * @throws {Error} The shell is not supported or could not be found.
- * @since 2.1.0
+ * @since 1.1.0
  */
-function escapeAll(args, options) {
-  const shescape = new Shescape(options);
-  return shescape.escapeAll(args);
+function escapeAll(args, options = {}) {
+  args = toArrayIfNecessary(args);
+  return args.map((arg) => escape(arg, options));
 }
 
 /**
@@ -369267,54 +369048,72 @@ function escapeAll(args, options) {
  * @example
  * import { spawn } from "node:child_process";
  * const spawnOptions = { shell: true }; // `options.shell` SHOULD be truthy
+ * const shescapeOptions = { shell: spawnOptions.shell };
  * spawn(
  *   "echo",
- *   ["Hello", shescape.quote(userInput, { shell: spawnOptions.shell })],
+ *   ["Hello", shescape.quote(userInput, shescapeOptions)],
  *   spawnOptions
  * );
+ * @example
+ * import { exec } from "node:child_process";
+ * const execOptions = null || { };
+ * const shescapeOptions = { shell: execOptions.shell };
+ * exec(
+ *   `echo Hello ${shescape.quote(userInput, shescapeOptions)}`,
+ *   execOptions
+ * );
  * @param {string} arg The argument to quote and escape.
- * @param {object} [options] The escape options.
- * @param {boolean} [options.flagProtection=true] Is flag protection enabled.
- * @param {boolean | string} [options.shell=true] The shell to escape for.
+ * @param {object} [options] The escape and quote options.
+ * @param {boolean} [options.flagProtection=false] Is flag protection enabled.
+ * @param {boolean | string} [options.shell] The shell to escape for.
  * @returns {string} The quoted and escaped argument.
  * @throws {TypeError} The argument is not stringable.
- * @throws {Error} The shell is not supported or could not be found.
- * @throws {Error} Quoting is not supported with `shell: false`.
- * @since 2.1.0
+ * @since 0.3.0
  */
-function quote(arg, options) {
-  const shescape = new Shescape(options);
-  return shescape.quote(arg);
+function quote(arg, options = {}) {
+  const helpers = getPlatformHelpers();
+  const { flagProtection, shellName } = parseOptions(
+    { env: process.env, options },
+    helpers,
+  );
+  const argAsString = checkedToString(arg);
+  const [escape, quote] = helpers.getQuoteFunction(shellName);
+  const escapedArg = escape(argAsString);
+  if (flagProtection) {
+    const flagProtect = helpers.getFlagProtectionFunction(shellName);
+    return quote(flagProtect(escapedArg));
+  } else {
+    return quote(escapedArg);
+  }
 }
 
 /**
  * Take an array of values, the arguments, put shell-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.
+ * Non-array inputs will be converted to one-value arrays and non-string values
+ * will be converted to strings using a `toString()` method.
  *
  * @example
  * import { spawn } from "node:child_process";
  * const spawnOptions = { shell: true }; // `options.shell` SHOULD be truthy
+ * const shescapeOptions = { shell: spawnOptions.shell };
  * spawn(
  *   "echo",
- *   shescape.quoteAll(["Hello", userInput], { shell: spawnOptions.shell }),
+ *   shescape.quoteAll(["Hello", userInput], shescapeOptions),
  *   spawnOptions
  * );
  * @param {string[]} args The arguments to quote and escape.
- * @param {object} [options] The escape options.
- * @param {boolean} [options.flagProtection=true] Is flag protection enabled.
- * @param {boolean | string} [options.shell=true] The shell to escape for.
+ * @param {object} [options] The escape and quote options.
+ * @param {boolean} [options.flagProtection=false] Is flag protection enabled.
+ * @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.
- * @throws {Error} The shell is not supported or could not be found.
- * @throws {Error} Quoting is not supported with `shell: false`.
- * @since 2.1.0
+ * @since 0.4.0
  */
-function quoteAll(args, options) {
-  const shescape = new Shescape(options);
-  return shescape.quoteAll(args);
+function quoteAll(args, options = {}) {
+  args = toArrayIfNecessary(args);
+  return args.map((arg) => quote(arg, options));
 }
 
 exports.escape = escape;