import { g as getDefaultExportFromCjs } from '../virtual/_commonjsHelpers.mjs';
import { r as require$$0$1 } from '../virtual/_os.mjs';
import { r as require$$0$2, a as require$$0$3 } from '../virtual/_path.mjs';
import { r as require$$0 } from '../virtual/_child_process.mjs';

/*
* @Author: zoujie.wzj
* @Date:   2016-01-23 18:17:55
* @Last Modified by:   Sahel LUCAS--SAOUDI
* @Last Modified on: 2021-11-12
*/

const cp = require$$0;

const UNIT_MB = 1024 * 1024;

const utils$2 = {
  /**
   * exec command with maxBuffer size
   */
  exec (cmd, callback) {
    cp.exec(cmd, {
      maxBuffer: 2 * UNIT_MB,
      windowsHide: true
    }, callback);
  },
  /**
   * spawn command
   */
  spawn (cmd, args, options) {
    return cp.spawn(cmd, args, options)
  },
  /**
   * Strip top lines of text
   *
   * @param  {String} text
   * @param  {Number} num
   * @return {String}
   */
  stripLine (text, num) {
    let idx = 0;

    while (num-- > 0) {
      const nIdx = text.indexOf('\n', idx);
      if (nIdx >= 0) {
        idx = nIdx + 1;
      }
    }

    return idx > 0 ? text.substring(idx) : text
  },

  /**
   * Split string and stop at max parts
   *
   * @param  {Number} line
   * @param  {Number} max
   * @return {Array}
   */
  split (line, max) {
    const cols = line.trim().split(/\s+/);

    if (cols.length > max) {
      cols[max - 1] = cols.slice(max - 1).join(' ');
    }

    return cols
  },

  /**
   * Extract columns from table text
   *
   * Example:
   *
   * ```
   * extractColumns(text, [0, 2], 3)
   * ```
   *
   * From:
   * ```
   * foo       bar        bar2
   * valx      valy       valz
   * ```
   *
   * To:
   * ```
   * [ ['foo', 'bar2'], ['valx', 'valz'] ]
   * ```
   *
   * @param  {String} text  raw table text
   * @param  {Array} idxes  the column index list to extract
   * @param  {Number} max   max column number of table
   * @return {Array}
   */
  extractColumns (text, idxes, max) {
    const lines = text.split(/(\r\n|\n|\r)/);
    const columns = [];

    if (!max) {
      max = Math.max.apply(null, idxes) + 1;
    }

    lines.forEach(line => {
      const cols = utils$2.split(line, max);
      const column = [];

      idxes.forEach(idx => {
        column.push(cols[idx] || '');
      });

      columns.push(column);
    });

    return columns
  },

  /**
   * parse table text to array
   *
   * From:
   * ```
   * Header1 : foo
   * Header2 : bar
   * Header3 : val
   *
   * Header1 : foo2
   * Header2 : bar2
   * Header3 : val2
   * ```
   *
   * To:
   * ```
   * [{ Header1: 'foo', Header2: 'bar', Header3: 'val' }, ...]
   * ```
   *
   * @param  {String} data raw table data
   * @return {Array}
   */
  parseTable (data) {
    const lines = data.split(/(\r\n\r\n|\r\n\n|\n\r\n|\n\n)/).filter(line => {
      return line && line.trim().length > 0
    }).map((e) => e.split(/(\r\n|\n|\r)/).filter(line => line.trim().length > 0));

    // Join multi-ligne value
    lines.forEach((line) => {
      for (let index = 0; line[index];) {
        const entry = line[index];
        if (entry.startsWith(' ')) {
          line[index - 1] += entry.trimLeft();
          line.splice(index, 1);
        } else {
          index += 1;
        }
      }
    });

    return lines.map(line => {
      const row = {};
      line.forEach((string) => {
        const splitterIndex = string.indexOf(':');
        const key = string.slice(0, splitterIndex).trim();
        row[key] = string.slice(splitterIndex + 1).trim();
      });

      return row
    })
  }
};

var utils_1 = utils$2;

var loglevel$1 = {exports: {}};

/*
* loglevel - https://github.com/pimterry/loglevel
*
* Copyright (c) 2013 Tim Perry
* Licensed under the MIT license.
*/
var loglevel = loglevel$1.exports;

(function (module) {
	(function (root, definition) {
	    if (module.exports) {
	        module.exports = definition();
	    } else {
	        root.log = definition();
	    }
	}(loglevel, function () {

	    // Slightly dubious tricks to cut down minimized file size
	    var noop = function() {};
	    var undefinedType = "undefined";

	    var logMethods = [
	        "trace",
	        "debug",
	        "info",
	        "warn",
	        "error"
	    ];

	    var _loggersByName = {};
	    var defaultLogger = null;

	    // Cross-browser bind equivalent that works at least back to IE6
	    function bindMethod(obj, methodName) {
	        var method = obj[methodName];
	        if (typeof method.bind === 'function') {
	            return method.bind(obj);
	        } else {
	            try {
	                return Function.prototype.bind.call(method, obj);
	            } catch (e) {
	                // Missing bind shim or IE8 + Modernizr, fallback to wrapping
	                return function() {
	                    return Function.prototype.apply.apply(method, [obj, arguments]);
	                };
	            }
	        }
	    }

	    // Build the best logging method possible for this env
	    // Wherever possible we want to bind, not wrap, to preserve stack traces
	    function realMethod(methodName) {
	        if (methodName === 'debug') {
	            methodName = 'log';
	        }

	        if (typeof console === undefinedType) {
	            return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
	        } else if (console[methodName] !== undefined) {
	            return bindMethod(console, methodName);
	        } else if (console.log !== undefined) {
	            return bindMethod(console, 'log');
	        } else {
	            return noop;
	        }
	    }

	    // These private functions always need `this` to be set properly

	    function replaceLoggingMethods() {
	        /*jshint validthis:true */
	        var level = this.getLevel();

	        // Replace the actual methods.
	        for (var i = 0; i < logMethods.length; i++) {
	            var methodName = logMethods[i];
	            this[methodName] = (i < level) ?
	                noop :
	                this.methodFactory(methodName, level, this.name);
	        }

	        // Define log.log as an alias for log.debug
	        this.log = this.debug;

	        // Return any important warnings.
	        if (typeof console === undefinedType && level < this.levels.SILENT) {
	            return "No console available for logging";
	        }
	    }

	    // In old IE versions, the console isn't present until you first open it.
	    // We build realMethod() replacements here that regenerate logging methods
	    function enableLoggingWhenConsoleArrives(methodName) {
	        return function () {
	            if (typeof console !== undefinedType) {
	                replaceLoggingMethods.call(this);
	                this[methodName].apply(this, arguments);
	            }
	        };
	    }

	    // By default, we use closely bound real methods wherever possible, and
	    // otherwise we wait for a console to appear, and then try again.
	    function defaultMethodFactory(methodName, _level, _loggerName) {
	        /*jshint validthis:true */
	        return realMethod(methodName) ||
	               enableLoggingWhenConsoleArrives.apply(this, arguments);
	    }

	    function Logger(name, factory) {
	      // Private instance variables.
	      var self = this;
	      /**
	       * The level inherited from a parent logger (or a global default). We
	       * cache this here rather than delegating to the parent so that it stays
	       * in sync with the actual logging methods that we have installed (the
	       * parent could change levels but we might not have rebuilt the loggers
	       * in this child yet).
	       * @type {number}
	       */
	      var inheritedLevel;
	      /**
	       * The default level for this logger, if any. If set, this overrides
	       * `inheritedLevel`.
	       * @type {number|null}
	       */
	      var defaultLevel;
	      /**
	       * A user-specific level for this logger. If set, this overrides
	       * `defaultLevel`.
	       * @type {number|null}
	       */
	      var userLevel;

	      function persistLevelIfPossible(levelNum) {
	          (logMethods[levelNum] || 'silent').toUpperCase();

	          return;
	      }

	      function getPersistedLevel() {

	          return;
	      }

	      function normalizeLevel(input) {
	          var level = input;
	          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
	              level = self.levels[level.toUpperCase()];
	          }
	          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
	              return level;
	          } else {
	              throw new TypeError("log.setLevel() called with invalid level: " + input);
	          }
	      }

	      /*
	       *
	       * Public logger API - see https://github.com/pimterry/loglevel for details
	       *
	       */

	      self.name = name;

	      self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
	          "ERROR": 4, "SILENT": 5};

	      self.methodFactory = factory || defaultMethodFactory;

	      self.getLevel = function () {
	          if (userLevel != null) {
	            return userLevel;
	          } else if (defaultLevel != null) {
	            return defaultLevel;
	          } else {
	            return inheritedLevel;
	          }
	      };

	      self.setLevel = function (level, persist) {
	          userLevel = normalizeLevel(level);
	          if (persist !== false) {  // defaults to true
	              persistLevelIfPossible(userLevel);
	          }

	          // NOTE: in v2, this should call rebuild(), which updates children.
	          return replaceLoggingMethods.call(self);
	      };

	      self.setDefaultLevel = function (level) {
	          defaultLevel = normalizeLevel(level);
	          if (!getPersistedLevel()) {
	              self.setLevel(level, false);
	          }
	      };

	      self.resetLevel = function () {
	          userLevel = null;
	          replaceLoggingMethods.call(self);
	      };

	      self.enableAll = function(persist) {
	          self.setLevel(self.levels.TRACE, persist);
	      };

	      self.disableAll = function(persist) {
	          self.setLevel(self.levels.SILENT, persist);
	      };

	      self.rebuild = function () {
	          if (defaultLogger !== self) {
	              inheritedLevel = normalizeLevel(defaultLogger.getLevel());
	          }
	          replaceLoggingMethods.call(self);

	          if (defaultLogger === self) {
	              for (var childName in _loggersByName) {
	                _loggersByName[childName].rebuild();
	              }
	          }
	      };

	      // Initialize all the internal levels.
	      inheritedLevel = normalizeLevel(
	          defaultLogger ? defaultLogger.getLevel() : "WARN"
	      );
	      var initialLevel = getPersistedLevel();
	      if (initialLevel != null) {
	          userLevel = normalizeLevel(initialLevel);
	      }
	      replaceLoggingMethods.call(self);
	    }

	    /*
	     *
	     * Top-level API
	     *
	     */

	    defaultLogger = new Logger();

	    defaultLogger.getLogger = function getLogger(name) {
	        if ((typeof name !== "symbol" && typeof name !== "string") || name === "") {
	            throw new TypeError("You must supply a name when creating a logger.");
	        }

	        var logger = _loggersByName[name];
	        if (!logger) {
	            logger = _loggersByName[name] = new Logger(
	                name,
	                defaultLogger.methodFactory
	            );
	        }
	        return logger;
	    };
	    defaultLogger.noConflict = function() {

	        return defaultLogger;
	    };

	    defaultLogger.getLoggers = function getLoggers() {
	        return _loggersByName;
	    };

	    // ES6 default export, for compatibility
	    defaultLogger['default'] = defaultLogger;

	    return defaultLogger;
	})); 
} (loglevel$1));

var loglevelExports = loglevel$1.exports;

const log$2 = loglevelExports;

var logger = log$2;

/*
* @Author: zoujie.wzj
* @Date:   2016-01-22 19:27:17
* @Last Modified by: Ayon Lee
* @Last Modified on: 2018-10-19
*/

// find pid by port

const os = require$$0$1;
const fs = require$$0$2;
const utils$1 = utils_1;
const log$1 = logger;

const ensureDir = (path) => new Promise((resolve, reject) => {
  if (fs.existsSync(path)) {
    resolve();
  } else {
    fs.mkdir(path, err => {
      err ? reject(err) : resolve();
    });
  }
});

const finders$1 = {
  darwin (port) {
    return new Promise((resolve, reject) => {
      utils$1.exec('netstat -anv -p TCP && netstat -anv -p UDP', function (err, stdout, stderr) {
        if (err) {
          reject(err);
        } else {
          err = stderr.toString().trim();
          if (err) {
            reject(err);
            return
          }

          // replace header
          const data = utils$1.stripLine(stdout.toString(), 2);
          const found = utils$1.extractColumns(data, [0, 3, 8], 10)
            .filter(row => {
              return !!String(row[0]).match(/^(udp|tcp)/)
            })
            .find(row => {
              const matches = String(row[1]).match(/\.(\d+)$/);
              if (matches && matches[1] === String(port)) {
                return true
              }
              return false
            });

          if (found && found[2].length) {
            resolve(parseInt(found[2], 10));
          } else {
            reject(new Error(`pid of port (${port}) not found`));
          }
        }
      });
    })
  },
  freebsd: 'darwin',
  sunos: 'darwin',
  linux (port) {
    return new Promise((resolve, reject) => {
      const cmd = 'netstat -tunlp';

      utils$1.exec(cmd, function (err, stdout, stderr) {
        if (err) {
          reject(err);
        } else {
          const warn = stderr.toString().trim();
          if (warn) {
            // netstat -p ouputs warning if user is no-root
            log$1.warn(warn);
          }

          // replace header
          const data = utils$1.stripLine(stdout.toString(), 2);
          const columns = utils$1.extractColumns(data, [3, 6], 7).find(column => {
            const matches = String(column[0]).match(/:(\d+)$/);
            if (matches && matches[1] === String(port)) {
              return true
            }
            return false
          });

          if (columns && columns[1]) {
            const pid = columns[1].split('/', 1)[0];

            if (pid.length) {
              resolve(parseInt(pid, 10));
            } else {
              reject(new Error(`pid of port (${port}) not found`));
            }
          } else {
            reject(new Error(`pid of port (${port}) not found`));
          }
        }
      });
    })
  },
  win32 (port) {
    return new Promise((resolve, reject) => {
      utils$1.exec('netstat -ano', function (err, stdout, stderr) {
        if (err) {
          reject(err);
        } else {
          err = stderr.toString().trim();
          if (err) {
            reject(err);
            return
          }

          // replace header
          const data = utils$1.stripLine(stdout.toString(), 4);
          const columns = utils$1.extractColumns(data, [1, 4], 5).find(column => {
            const matches = String(column[0]).match(/:(\d+)$/);
            if (matches && matches[1] === String(port)) {
              return true
            }
            return false
          });

          if (columns && columns[1].length && parseInt(columns[1], 10) > 0) {
            resolve(parseInt(columns[1], 10));
          } else {
            reject(new Error(`pid of port (${port}) not found`));
          }
        }
      });
    })
  },
  android (port) {
    return new Promise((resolve, reject) => {
      // on Android Termux, an warning will be emitted when executing `netstat`
      // with option `-p` says 'showing only processes with your user ID', but
      // it can still fetch the information we need. However, NodeJS treat this
      // warning as an error, `util.exec()` will get nothing but the error. To
      // get the true output of the command, we need to save it to a tmpfile and
      // read that file instead.
      const dir = os.tmpdir() + '/.find-process';
      const file = dir + '/' + process.pid;
      const cmd = 'netstat -tunp >> "' + file + '"';

      ensureDir(dir).then(() => {
        utils$1.exec(cmd, () => {
          fs.readFile(file, 'utf8', (err, data) => {
            fs.unlink(file, () => { });
            if (err) {
              reject(err);
            } else {
              data = utils$1.stripLine(data, 2);
              const columns = utils$1.extractColumns(data, [3, 6], 7).find(column => {
                const matches = String(column[0]).match(/:(\d+)$/);
                if (matches && matches[1] === String(port)) {
                  return true
                }
                return false
              });

              if (columns && columns[1]) {
                const pid = columns[1].split('/', 1)[0];

                if (pid.length) {
                  resolve(parseInt(pid, 10));
                } else {
                  reject(new Error(`pid of port (${port}) not found`));
                }
              } else {
                reject(new Error(`pid of port (${port}) not found`));
              }
            }
          });
        });
      });
    })
  }
};

function findPidByPort (port) {
  const platform = process.platform;

  return new Promise((resolve, reject) => {
    if (!(platform in finders$1)) {
      return reject(new Error(`platform ${platform} is unsupported`))
    }

    let findPid = finders$1[platform];
    if (typeof findPid === 'string') {
      findPid = finders$1[findPid];
    }

    findPid(port).then(resolve, reject);
  })
}

var find_pid = findPidByPort;

/*
* @Author: zoujie.wzj
* @Date:   2016-01-23 18:25:37
* @Last Modified by: Sahel LUCAS--SAOUDI
* @Last Modified on: 2021-11-12
*/

const path = require$$0$3;
const utils = utils_1;

function matchName (text, name) {
  if (!name) {
    return true
  }
  // make sure text.match is valid, fix #30
  if (text && text.match) {
    return text.match(name)
  }
  return false
}

function fetchBin (cmd) {
  const pieces = cmd.split(path.sep);
  const last = pieces[pieces.length - 1];
  if (last) {
    pieces[pieces.length - 1] = last.split(' ')[0];
  }
  const fixed = [];
  for (const part of pieces) {
    const optIdx = part.indexOf(' -');
    if (optIdx >= 0) {
      // case: /aaa/bbb/ccc -c
      fixed.push(part.substring(0, optIdx).trim());
      break
    } else if (part.endsWith(' ')) {
      // case: node /aaa/bbb/ccc.js
      fixed.push(part.trim());
      break
    }
    fixed.push(part);
  }
  return fixed.join(path.sep)
}

function fetchName (fullpath) {
  if (process.platform === 'darwin') {
    const idx = fullpath.indexOf('.app/');
    if (idx >= 0) {
      return path.basename(fullpath.substring(0, idx))
    }
  }
  return path.basename(fullpath)
}

const finders = {
  darwin (cond) {
    return new Promise((resolve, reject) => {
      let cmd;
      if ('pid' in cond) {
        cmd = `ps -p ${cond.pid} -ww -o pid,ppid,uid,gid,args`;
      } else {
        cmd = 'ps ax -ww -o pid,ppid,uid,gid,args';
      }

      utils.exec(cmd, function (err, stdout, stderr) {
        if (err) {
          if ('pid' in cond) {
            // when pid not exists, call `ps -p ...` will cause error, we have to
            // ignore the error and resolve with empty array
            resolve([]);
          } else {
            reject(err);
          }
        } else {
          err = stderr.toString().trim();
          if (err) {
            reject(err);
            return
          }

          const data = utils.stripLine(stdout.toString(), 1);
          const columns = utils.extractColumns(data, [0, 1, 2, 3, 4], 5).filter(column => {
            if (column[0] && cond.pid) {
              return column[0] === String(cond.pid)
            } else if (column[4] && cond.name) {
              return matchName(column[4], cond.name)
            } else {
              return !!column[0]
            }
          });

          let list = columns.map(column => {
            const cmd = String(column[4]);
            const bin = fetchBin(cmd);

            return {
              pid: parseInt(column[0], 10),
              ppid: parseInt(column[1], 10),
              uid: parseInt(column[2], 10),
              gid: parseInt(column[3], 10),
              name: fetchName(bin),
              bin,
              cmd: column[4]
            }
          });

          if (cond.config.strict && cond.name) {
            list = list.filter(item => item.name === cond.name);
          }

          resolve(list);
        }
      });
    })
  },
  linux: 'darwin',
  sunos: 'darwin',
  freebsd: 'darwin',
  win32 (cond) {
    return new Promise((resolve, reject) => {
      const cmd = '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Get-CimInstance -className win32_process | select Name,ProcessId,ParentProcessId,CommandLine,ExecutablePath';
      const lines = [];

      const proc = utils.spawn('powershell.exe', ['/c', cmd], { detached: false, windowsHide: true });
      proc.stdout.on('data', data => {
        lines.push(data.toString());
      });
      proc.on('error', err => {
        reject(new Error('Command \'' + cmd + '\' failed with reason: ' + err.toString()));
      });
      proc.on('close', code => {
        if (code !== 0) {
          return reject(new Error('Command \'' + cmd + '\' terminated with code: ' + code))
        }
        const list = utils.parseTable(lines.join(''))
          .filter(row => {
            if ('pid' in cond) {
              return row.ProcessId === String(cond.pid)
            } else if (cond.name) {
              const rowName = row.Name || ''; // fix #40
              if (cond.config.strict) {
                return rowName === cond.name || (rowName.endsWith('.exe') && rowName.slice(0, -4) === cond.name)
              } else {
                // fix #9
                return matchName(row.CommandLine || rowName, cond.name)
              }
            } else {
              return true
            }
          })
          .map(row => ({
            pid: parseInt(row.ProcessId, 10),
            ppid: parseInt(row.ParentProcessId, 10),
            // uid: void 0,
            // gid: void 0,
            bin: row.ExecutablePath,
            name: row.Name || '',
            cmd: row.CommandLine
          }));
        resolve(list);
      });
    })
  },
  android (cond) {
    return new Promise((resolve, reject) => {
      const cmd = 'ps';

      utils.exec(cmd, function (err, stdout, stderr) {
        if (err) {
          if ('pid' in cond) {
            // when pid not exists, call `ps -p ...` will cause error, we have to
            // ignore the error and resolve with empty array
            resolve([]);
          } else {
            reject(err);
          }
        } else {
          err = stderr.toString().trim();
          if (err) {
            reject(err);
            return
          }

          const data = utils.stripLine(stdout.toString(), 1);
          const columns = utils.extractColumns(data, [0, 3], 4).filter(column => {
            if (column[0] && cond.pid) {
              return column[0] === String(cond.pid)
            } else if (column[1] && cond.name) {
              return matchName(column[1], cond.name)
            } else {
              return !!column[0]
            }
          });

          let list = columns.map(column => {
            const cmd = String(column[1]);
            const bin = fetchBin(cmd);

            return {
              pid: parseInt(column[0], 10),
              // ppid: void 0,
              // uid: void 0,
              // gid: void 0,
              name: fetchName(bin),
              bin,
              cmd
            }
          });

          if (cond.config.strict && cond.name) {
            list = list.filter(item => item.name === cond.name);
          }

          resolve(list);
        }
      });
    })
  }
};

function findProcess$3 (cond) {
  const platform = process.platform;

  return new Promise((resolve, reject) => {
    if (!(platform in finders)) {
      return reject(new Error(`platform ${platform} is unsupported`))
    }

    let find = finders[platform];
    if (typeof find === 'string') {
      find = finders[find];
    }

    find(cond).then((result) => {
      if (cond.skipSelf) {
        // skip find-process itself
        const filteredResult = result.filter(item => item.pid !== process.pid);

        resolve(filteredResult);
      } else {
        resolve(result);
      }
    }, reject);
  })
}

var find_process = findProcess$3;

/*
* @Author: zoujie.wzj
* @Date:   2016-01-23 18:18:28
* @Last Modified by: Ayon Lee
* @Last Modified on: 2018-10-19
*/

const findPid = find_pid;
const findProcess$2 = find_process;
const log = logger;

const findBy = {
  port (port, config) {
    return findPid(port)
      .then(pid => {
        return findBy.pid(pid, config)
      }, () => {
        // return empty array when pid not found
        return []
      })
  },
  pid (pid, config) {
    return findProcess$2({
      pid,
      config
    })
  },
  name (name, config) {
    return findProcess$2({
      name,
      config,
      skipSelf: true
    })
  }
};

/**
 * find process by condition
 *
 * return Promise: [{
 *   pid: <process id>,
 *   ppid: <process parent id>,
 *   uid: <user id (*nix)>,
 *   gid: <user group id (*nix)>,
 *   name: <command name>,
 *   cmd: <process run args>
 * }, ...]
 *
 * If no process found, resolve process with empty array (only reject when error occured)
 *
 * @param {String} by condition: port/pid/name ...
 * @param {Mixed} condition value
 * @param {Boolean|Option}
 * @return {Promise}
 */
function find (by, value, options) {
  const config = Object.assign({
    logLevel: 'warn',
    strict: typeof options === 'boolean' ? options : false
  }, options);

  log.setLevel(config.logLevel);

  return new Promise((resolve, reject) => {
    if (!(by in findBy)) {
      reject(new Error(`do not support find by "${by}"`));
    } else {
      const isNumber = /^\d+$/.test(value);
      if (by === 'pid' && !isNumber) {
        reject(new Error('pid must be a number'));
      } else if (by === 'port' && !isNumber) {
        reject(new Error('port must be a number'));
      } else {
        findBy[by](value, config).then(resolve, reject);
      }
    }
  })
}

var find_1 = find;

/*
* @Author: zoujie.wzj
* @Date:   2016-01-23 17:32:07
* @Last Modified by:   Zoujie
* @Last Modified time: 2016-02-04 17:13:18
*/

var findProcess = find_1;

const findProcess$1 = /*@__PURE__*/getDefaultExportFromCjs(findProcess);

export { findProcess$1 as f };
