@modern-js/repo-generator 0.0.0-canary-20221012094820 → 0.0.0-canary-20221013114431

package/dist/index.js

@@ -142949,6 +142949,11 @@ var require_logger4 = __commonJSMin((exports) => {
       label: "info",
       level: "info"
     },
+    success: {
+      color: "green",
+      label: "Success",
+      level: "info"
+    },
     warn: {
       color: "yellow",
       label: "warn",
@@ -144526,1587 +144531,6 @@ var require_chainId2 = __commonJSMin((exports) => {
     }
   };
 });
-var require_windows = __commonJSMin((exports, module2) => {
-  module2.exports = isexe;
-  isexe.sync = sync;
-  var fs4 = __require("fs");
-  function checkPathExt(path6, options3) {
-    var pathext = options3.pathExt !== void 0 ? options3.pathExt : process.env.PATHEXT;
-    if (!pathext) {
-      return true;
-    }
-    pathext = pathext.split(";");
-    if (pathext.indexOf("") !== -1) {
-      return true;
-    }
-    for (var i = 0; i < pathext.length; i++) {
-      var p = pathext[i].toLowerCase();
-      if (p && path6.substr(-p.length).toLowerCase() === p) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function checkStat(stat, path6, options3) {
-    if (!stat.isSymbolicLink() && !stat.isFile()) {
-      return false;
-    }
-    return checkPathExt(path6, options3);
-  }
-  function isexe(path6, options3, cb) {
-    fs4.stat(path6, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path6, options3));
-    });
-  }
-  function sync(path6, options3) {
-    return checkStat(fs4.statSync(path6), path6, options3);
-  }
-});
-var require_mode = __commonJSMin((exports, module2) => {
-  module2.exports = isexe;
-  isexe.sync = sync;
-  var fs4 = __require("fs");
-  function isexe(path6, options3, cb) {
-    fs4.stat(path6, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, options3));
-    });
-  }
-  function sync(path6, options3) {
-    return checkStat(fs4.statSync(path6), options3);
-  }
-  function checkStat(stat, options3) {
-    return stat.isFile() && checkMode(stat, options3);
-  }
-  function checkMode(stat, options3) {
-    var mod = stat.mode;
-    var uid2 = stat.uid;
-    var gid = stat.gid;
-    var myUid = options3.uid !== void 0 ? options3.uid : process.getuid && process.getuid();
-    var myGid = options3.gid !== void 0 ? options3.gid : process.getgid && process.getgid();
-    var u = parseInt("100", 8);
-    var g = parseInt("010", 8);
-    var o = parseInt("001", 8);
-    var ug = u | g;
-    var ret = mod & o || mod & g && gid === myGid || mod & u && uid2 === myUid || mod & ug && myUid === 0;
-    return ret;
-  }
-});
-var require_isexe = __commonJSMin((exports, module2) => {
-  var fs4 = __require("fs");
-  var core;
-  if (process.platform === "win32" || global.TESTING_WINDOWS) {
-    core = require_windows();
-  } else {
-    core = require_mode();
-  }
-  module2.exports = isexe;
-  isexe.sync = sync;
-  function isexe(path6, options3, cb) {
-    if (typeof options3 === "function") {
-      cb = options3;
-      options3 = {};
-    }
-    if (!cb) {
-      if (typeof Promise !== "function") {
-        throw new TypeError("callback not provided");
-      }
-      return new Promise(function(resolve, reject) {
-        isexe(path6, options3 || {}, function(er, is) {
-          if (er) {
-            reject(er);
-          } else {
-            resolve(is);
-          }
-        });
-      });
-    }
-    core(path6, options3 || {}, function(er, is) {
-      if (er) {
-        if (er.code === "EACCES" || options3 && options3.ignoreErrors) {
-          er = null;
-          is = false;
-        }
-      }
-      cb(er, is);
-    });
-  }
-  function sync(path6, options3) {
-    try {
-      return core.sync(path6, options3 || {});
-    } catch (er) {
-      if (options3 && options3.ignoreErrors || er.code === "EACCES") {
-        return false;
-      } else {
-        throw er;
-      }
-    }
-  }
-});
-var require_which = __commonJSMin((exports, module2) => {
-  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path6 = __require("path");
-  var COLON = isWindows ? ";" : ":";
-  var isexe = require_isexe();
-  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-  var getPathInfo = (cmd, opt) => {
-    const colon = opt.colon || COLON;
-    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
-      ...isWindows ? [process.cwd()] : [],
-      ...(opt.path || process.env.PATH || "").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
-    };
-  };
-  var 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 = path6.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);
-  };
-  var 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 = path6.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);
-  };
-  module2.exports = which;
-  which.sync = whichSync;
-});
-var require_path_key = __commonJSMin((exports, module2) => {
-  "use strict";
-  var pathKey = (options3 = {}) => {
-    const environment = options3.env || process.env;
-    const platform = options3.platform || process.platform;
-    if (platform !== "win32") {
-      return "PATH";
-    }
-    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-  };
-  module2.exports = pathKey;
-  module2.exports.default = pathKey;
-});
-var require_resolveCommand = __commonJSMin((exports, module2) => {
-  "use strict";
-  var path6 = __require("path");
-  var which = require_which();
-  var getPathKey = require_path_key();
-  function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
-    if (shouldSwitchCwd) {
-      try {
-        process.chdir(parsed.options.cwd);
-      } catch (err) {
-      }
-    }
-    let resolved;
-    try {
-      resolved = which.sync(parsed.command, {
-        path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path6.delimiter : void 0
-      });
-    } catch (e) {
-    } finally {
-      if (shouldSwitchCwd) {
-        process.chdir(cwd);
-      }
-    }
-    if (resolved) {
-      resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
-    }
-    return resolved;
-  }
-  function resolveCommand(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-  }
-  module2.exports = resolveCommand;
-});
-var require_escape = __commonJSMin((exports, module2) => {
-  "use strict";
-  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-  function escapeCommand(arg) {
-    arg = arg.replace(metaCharsRegExp, "^$1");
-    return arg;
-  }
-  function escapeArgument(arg, doubleEscapeMetaChars) {
-    arg = `${arg}`;
-    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
-    arg = arg.replace(/(\\*)$/, "$1$1");
-    arg = `"${arg}"`;
-    arg = arg.replace(metaCharsRegExp, "^$1");
-    if (doubleEscapeMetaChars) {
-      arg = arg.replace(metaCharsRegExp, "^$1");
-    }
-    return arg;
-  }
-  module2.exports.command = escapeCommand;
-  module2.exports.argument = escapeArgument;
-});
-var require_shebang_regex = __commonJSMin((exports, module2) => {
-  "use strict";
-  module2.exports = /^#!(.*)/;
-});
-var require_shebang_command = __commonJSMin((exports, module2) => {
-  "use strict";
-  var shebangRegex = require_shebang_regex();
-  module2.exports = (string = "") => {
-    const match = string.match(shebangRegex);
-    if (!match) {
-      return null;
-    }
-    const [path6, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path6.split("/").pop();
-    if (binary === "env") {
-      return argument;
-    }
-    return argument ? `${binary} ${argument}` : binary;
-  };
-});
-var require_readShebang = __commonJSMin((exports, module2) => {
-  "use strict";
-  var fs4 = __require("fs");
-  var shebangCommand = require_shebang_command();
-  function readShebang(command) {
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-    let fd;
-    try {
-      fd = fs4.openSync(command, "r");
-      fs4.readSync(fd, buffer, 0, size, 0);
-      fs4.closeSync(fd);
-    } catch (e) {
-    }
-    return shebangCommand(buffer.toString());
-  }
-  module2.exports = readShebang;
-});
-var require_parse3 = __commonJSMin((exports, module2) => {
-  "use strict";
-  var path6 = __require("path");
-  var resolveCommand = require_resolveCommand();
-  var escape = require_escape();
-  var readShebang = require_readShebang();
-  var isWin = process.platform === "win32";
-  var isExecutableRegExp = /\.(?:com|exe)$/i;
-  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-  function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
-    const shebang = parsed.file && readShebang(parsed.file);
-    if (shebang) {
-      parsed.args.unshift(parsed.file);
-      parsed.command = shebang;
-      return resolveCommand(parsed);
-    }
-    return parsed.file;
-  }
-  function parseNonShell(parsed) {
-    if (!isWin) {
-      return parsed;
-    }
-    const commandFile = detectShebang(parsed);
-    const needsShell = !isExecutableRegExp.test(commandFile);
-    if (parsed.options.forceShell || needsShell) {
-      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path6.normalize(parsed.command);
-      parsed.command = escape.command(parsed.command);
-      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-      parsed.command = process.env.comspec || "cmd.exe";
-      parsed.options.windowsVerbatimArguments = true;
-    }
-    return parsed;
-  }
-  function parse2(command, args, options3) {
-    if (args && !Array.isArray(args)) {
-      options3 = args;
-      args = null;
-    }
-    args = args ? args.slice(0) : [];
-    options3 = Object.assign({}, options3);
-    const parsed = {
-      command,
-      args,
-      options: options3,
-      file: void 0,
-      original: {
-        command,
-        args
-      }
-    };
-    return options3.shell ? parsed : parseNonShell(parsed);
-  }
-  module2.exports = parse2;
-});
-var require_enoent = __commonJSMin((exports, module2) => {
-  "use strict";
-  var isWin = process.platform === "win32";
-  function notFoundError(original, syscall) {
-    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-      code: "ENOENT",
-      errno: "ENOENT",
-      syscall: `${syscall} ${original.command}`,
-      path: original.command,
-      spawnargs: original.args
-    });
-  }
-  function hookChildProcess(cp, parsed) {
-    if (!isWin) {
-      return;
-    }
-    const originalEmit = cp.emit;
-    cp.emit = function(name5, arg1) {
-      if (name5 === "exit") {
-        const err = verifyENOENT(arg1, parsed, "spawn");
-        if (err) {
-          return originalEmit.call(cp, "error", err);
-        }
-      }
-      return originalEmit.apply(cp, arguments);
-    };
-  }
-  function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawn");
-    }
-    return null;
-  }
-  function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawnSync");
-    }
-    return null;
-  }
-  module2.exports = {
-    hookChildProcess,
-    verifyENOENT,
-    verifyENOENTSync,
-    notFoundError
-  };
-});
-var require_cross_spawn = __commonJSMin((exports, module2) => {
-  "use strict";
-  var cp = __require("child_process");
-  var parse2 = require_parse3();
-  var enoent = require_enoent();
-  function spawn(command, args, options3) {
-    const parsed = parse2(command, args, options3);
-    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
-    enoent.hookChildProcess(spawned, parsed);
-    return spawned;
-  }
-  function spawnSync(command, args, options3) {
-    const parsed = parse2(command, args, options3);
-    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-    return result;
-  }
-  module2.exports = spawn;
-  module2.exports.spawn = spawn;
-  module2.exports.sync = spawnSync;
-  module2.exports._parse = parse2;
-  module2.exports._enoent = enoent;
-});
-var require_strip_final_newline = __commonJSMin((exports, module2) => {
-  "use strict";
-  module2.exports = (input) => {
-    const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
-    const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
-    if (input[input.length - 1] === LF) {
-      input = input.slice(0, input.length - 1);
-    }
-    if (input[input.length - 1] === CR) {
-      input = input.slice(0, input.length - 1);
-    }
-    return input;
-  };
-});
-var require_npm_run_path = __commonJSMin((exports, module2) => {
-  "use strict";
-  var path6 = __require("path");
-  var pathKey = require_path_key();
-  var npmRunPath = (options3) => {
-    options3 = {
-      cwd: process.cwd(),
-      path: process.env[pathKey()],
-      execPath: process.execPath,
-      ...options3
-    };
-    let previous;
-    let cwdPath = path6.resolve(options3.cwd);
-    const result = [];
-    while (previous !== cwdPath) {
-      result.push(path6.join(cwdPath, "node_modules/.bin"));
-      previous = cwdPath;
-      cwdPath = path6.resolve(cwdPath, "..");
-    }
-    const execPathDir = path6.resolve(options3.cwd, options3.execPath, "..");
-    result.push(execPathDir);
-    return result.concat(options3.path).join(path6.delimiter);
-  };
-  module2.exports = npmRunPath;
-  module2.exports.default = npmRunPath;
-  module2.exports.env = (options3) => {
-    options3 = {
-      env: process.env,
-      ...options3
-    };
-    const env = { ...options3.env };
-    const path7 = pathKey({ env });
-    options3.path = env[path7];
-    env[path7] = module2.exports(options3);
-    return env;
-  };
-});
-var require_core = __commonJSMin((exports) => {
-  "use strict";
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.SIGNALS = void 0;
-  var SIGNALS = [
-    {
-      name: "SIGHUP",
-      number: 1,
-      action: "terminate",
-      description: "Terminal closed",
-      standard: "posix"
-    },
-    {
-      name: "SIGINT",
-      number: 2,
-      action: "terminate",
-      description: "User interruption with CTRL-C",
-      standard: "ansi"
-    },
-    {
-      name: "SIGQUIT",
-      number: 3,
-      action: "core",
-      description: "User interruption with CTRL-\\",
-      standard: "posix"
-    },
-    {
-      name: "SIGILL",
-      number: 4,
-      action: "core",
-      description: "Invalid machine instruction",
-      standard: "ansi"
-    },
-    {
-      name: "SIGTRAP",
-      number: 5,
-      action: "core",
-      description: "Debugger breakpoint",
-      standard: "posix"
-    },
-    {
-      name: "SIGABRT",
-      number: 6,
-      action: "core",
-      description: "Aborted",
-      standard: "ansi"
-    },
-    {
-      name: "SIGIOT",
-      number: 6,
-      action: "core",
-      description: "Aborted",
-      standard: "bsd"
-    },
-    {
-      name: "SIGBUS",
-      number: 7,
-      action: "core",
-      description: "Bus error due to misaligned, non-existing address or paging error",
-      standard: "bsd"
-    },
-    {
-      name: "SIGEMT",
-      number: 7,
-      action: "terminate",
-      description: "Command should be emulated but is not implemented",
-      standard: "other"
-    },
-    {
-      name: "SIGFPE",
-      number: 8,
-      action: "core",
-      description: "Floating point arithmetic error",
-      standard: "ansi"
-    },
-    {
-      name: "SIGKILL",
-      number: 9,
-      action: "terminate",
-      description: "Forced termination",
-      standard: "posix",
-      forced: true
-    },
-    {
-      name: "SIGUSR1",
-      number: 10,
-      action: "terminate",
-      description: "Application-specific signal",
-      standard: "posix"
-    },
-    {
-      name: "SIGSEGV",
-      number: 11,
-      action: "core",
-      description: "Segmentation fault",
-      standard: "ansi"
-    },
-    {
-      name: "SIGUSR2",
-      number: 12,
-      action: "terminate",
-      description: "Application-specific signal",
-      standard: "posix"
-    },
-    {
-      name: "SIGPIPE",
-      number: 13,
-      action: "terminate",
-      description: "Broken pipe or socket",
-      standard: "posix"
-    },
-    {
-      name: "SIGALRM",
-      number: 14,
-      action: "terminate",
-      description: "Timeout or timer",
-      standard: "posix"
-    },
-    {
-      name: "SIGTERM",
-      number: 15,
-      action: "terminate",
-      description: "Termination",
-      standard: "ansi"
-    },
-    {
-      name: "SIGSTKFLT",
-      number: 16,
-      action: "terminate",
-      description: "Stack is empty or overflowed",
-      standard: "other"
-    },
-    {
-      name: "SIGCHLD",
-      number: 17,
-      action: "ignore",
-      description: "Child process terminated, paused or unpaused",
-      standard: "posix"
-    },
-    {
-      name: "SIGCLD",
-      number: 17,
-      action: "ignore",
-      description: "Child process terminated, paused or unpaused",
-      standard: "other"
-    },
-    {
-      name: "SIGCONT",
-      number: 18,
-      action: "unpause",
-      description: "Unpaused",
-      standard: "posix",
-      forced: true
-    },
-    {
-      name: "SIGSTOP",
-      number: 19,
-      action: "pause",
-      description: "Paused",
-      standard: "posix",
-      forced: true
-    },
-    {
-      name: "SIGTSTP",
-      number: 20,
-      action: "pause",
-      description: 'Paused using CTRL-Z or "suspend"',
-      standard: "posix"
-    },
-    {
-      name: "SIGTTIN",
-      number: 21,
-      action: "pause",
-      description: "Background process cannot read terminal input",
-      standard: "posix"
-    },
-    {
-      name: "SIGBREAK",
-      number: 21,
-      action: "terminate",
-      description: "User interruption with CTRL-BREAK",
-      standard: "other"
-    },
-    {
-      name: "SIGTTOU",
-      number: 22,
-      action: "pause",
-      description: "Background process cannot write to terminal output",
-      standard: "posix"
-    },
-    {
-      name: "SIGURG",
-      number: 23,
-      action: "ignore",
-      description: "Socket received out-of-band data",
-      standard: "bsd"
-    },
-    {
-      name: "SIGXCPU",
-      number: 24,
-      action: "core",
-      description: "Process timed out",
-      standard: "bsd"
-    },
-    {
-      name: "SIGXFSZ",
-      number: 25,
-      action: "core",
-      description: "File too big",
-      standard: "bsd"
-    },
-    {
-      name: "SIGVTALRM",
-      number: 26,
-      action: "terminate",
-      description: "Timeout or timer",
-      standard: "bsd"
-    },
-    {
-      name: "SIGPROF",
-      number: 27,
-      action: "terminate",
-      description: "Timeout or timer",
-      standard: "bsd"
-    },
-    {
-      name: "SIGWINCH",
-      number: 28,
-      action: "ignore",
-      description: "Terminal window size changed",
-      standard: "bsd"
-    },
-    {
-      name: "SIGIO",
-      number: 29,
-      action: "terminate",
-      description: "I/O is available",
-      standard: "other"
-    },
-    {
-      name: "SIGPOLL",
-      number: 29,
-      action: "terminate",
-      description: "Watched event",
-      standard: "other"
-    },
-    {
-      name: "SIGINFO",
-      number: 29,
-      action: "ignore",
-      description: "Request for process information",
-      standard: "other"
-    },
-    {
-      name: "SIGPWR",
-      number: 30,
-      action: "terminate",
-      description: "Device running out of power",
-      standard: "systemv"
-    },
-    {
-      name: "SIGSYS",
-      number: 31,
-      action: "core",
-      description: "Invalid system call",
-      standard: "other"
-    },
-    {
-      name: "SIGUNUSED",
-      number: 31,
-      action: "terminate",
-      description: "Invalid system call",
-      standard: "other"
-    }
-  ];
-  exports.SIGNALS = SIGNALS;
-});
-var require_realtime = __commonJSMin((exports) => {
-  "use strict";
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.SIGRTMAX = exports.getRealtimeSignals = void 0;
-  var getRealtimeSignals = function() {
-    const length = SIGRTMAX - SIGRTMIN + 1;
-    return Array.from({ length }, getRealtimeSignal);
-  };
-  exports.getRealtimeSignals = getRealtimeSignals;
-  var getRealtimeSignal = function(value, index) {
-    return {
-      name: `SIGRT${index + 1}`,
-      number: SIGRTMIN + index,
-      action: "terminate",
-      description: "Application-specific signal (realtime)",
-      standard: "posix"
-    };
-  };
-  var SIGRTMIN = 34;
-  var SIGRTMAX = 64;
-  exports.SIGRTMAX = SIGRTMAX;
-});
-var require_signals2 = __commonJSMin((exports) => {
-  "use strict";
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.getSignals = void 0;
-  var _os = __require("os");
-  var _core = require_core();
-  var _realtime = require_realtime();
-  var getSignals = function() {
-    const realtimeSignals = (0, _realtime.getRealtimeSignals)();
-    const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal);
-    return signals;
-  };
-  exports.getSignals = getSignals;
-  var normalizeSignal = function({
-    name: name5,
-    number: defaultNumber,
-    description: description3,
-    action: action3,
-    forced = false,
-    standard
-  }) {
-    const {
-      signals: { [name5]: constantSignal }
-    } = _os.constants;
-    const supported = constantSignal !== void 0;
-    const number = supported ? constantSignal : defaultNumber;
-    return { name: name5, number, description: description3, supported, action: action3, forced, standard };
-  };
-});
-var require_main2 = __commonJSMin((exports) => {
-  "use strict";
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.signalsByNumber = exports.signalsByName = void 0;
-  var _os = __require("os");
-  var _signals = require_signals2();
-  var _realtime = require_realtime();
-  var getSignalsByName = function() {
-    const signals = (0, _signals.getSignals)();
-    return signals.reduce(getSignalByName, {});
-  };
-  var getSignalByName = function(signalByNameMemo, { name: name5, number, description: description3, supported, action: action3, forced, standard }) {
-    return {
-      ...signalByNameMemo,
-      [name5]: { name: name5, number, description: description3, supported, action: action3, forced, standard }
-    };
-  };
-  var signalsByName = getSignalsByName();
-  exports.signalsByName = signalsByName;
-  var getSignalsByNumber = function() {
-    const signals = (0, _signals.getSignals)();
-    const length = _realtime.SIGRTMAX + 1;
-    const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
-    return Object.assign({}, ...signalsA);
-  };
-  var getSignalByNumber = function(number, signals) {
-    const signal = findSignalByNumber(number, signals);
-    if (signal === void 0) {
-      return {};
-    }
-    const { name: name5, description: description3, supported, action: action3, forced, standard } = signal;
-    return {
-      [number]: {
-        name: name5,
-        number,
-        description: description3,
-        supported,
-        action: action3,
-        forced,
-        standard
-      }
-    };
-  };
-  var findSignalByNumber = function(number, signals) {
-    const signal = signals.find(({ name: name5 }) => _os.constants.signals[name5] === number);
-    if (signal !== void 0) {
-      return signal;
-    }
-    return signals.find((signalA) => signalA.number === number);
-  };
-  var signalsByNumber = getSignalsByNumber();
-  exports.signalsByNumber = signalsByNumber;
-});
-var require_error = __commonJSMin((exports, module2) => {
-  "use strict";
-  var { signalsByName } = require_main2();
-  var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
-    if (timedOut) {
-      return `timed out after ${timeout} milliseconds`;
-    }
-    if (isCanceled) {
-      return "was canceled";
-    }
-    if (errorCode !== void 0) {
-      return `failed with ${errorCode}`;
-    }
-    if (signal !== void 0) {
-      return `was killed with ${signal} (${signalDescription})`;
-    }
-    if (exitCode !== void 0) {
-      return `failed with exit code ${exitCode}`;
-    }
-    return "failed";
-  };
-  var makeError = ({
-    stdout,
-    stderr,
-    all,
-    error,
-    signal,
-    exitCode,
-    command,
-    escapedCommand,
-    timedOut,
-    isCanceled,
-    killed,
-    parsed: { options: { timeout } }
-  }) => {
-    exitCode = exitCode === null ? void 0 : exitCode;
-    signal = signal === null ? void 0 : signal;
-    const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
-    const errorCode = error && error.code;
-    const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
-    const execaMessage = `Command ${prefix}: ${command}`;
-    const isError = Object.prototype.toString.call(error) === "[object Error]";
-    const shortMessage = isError ? `${execaMessage}
-${error.message}` : execaMessage;
-    const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
-    if (isError) {
-      error.originalMessage = error.message;
-      error.message = message;
-    } else {
-      error = new Error(message);
-    }
-    error.shortMessage = shortMessage;
-    error.command = command;
-    error.escapedCommand = escapedCommand;
-    error.exitCode = exitCode;
-    error.signal = signal;
-    error.signalDescription = signalDescription;
-    error.stdout = stdout;
-    error.stderr = stderr;
-    if (all !== void 0) {
-      error.all = all;
-    }
-    if ("bufferedData" in error) {
-      delete error.bufferedData;
-    }
-    error.failed = true;
-    error.timedOut = Boolean(timedOut);
-    error.isCanceled = isCanceled;
-    error.killed = killed && !timedOut;
-    return error;
-  };
-  module2.exports = makeError;
-});
-var require_stdio = __commonJSMin((exports, module2) => {
-  "use strict";
-  var aliases = ["stdin", "stdout", "stderr"];
-  var hasAlias = (options3) => aliases.some((alias) => options3[alias] !== void 0);
-  var normalizeStdio = (options3) => {
-    if (!options3) {
-      return;
-    }
-    const { stdio } = options3;
-    if (stdio === void 0) {
-      return aliases.map((alias) => options3[alias]);
-    }
-    if (hasAlias(options3)) {
-      throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
-    }
-    if (typeof stdio === "string") {
-      return stdio;
-    }
-    if (!Array.isArray(stdio)) {
-      throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
-    }
-    const length = Math.max(stdio.length, aliases.length);
-    return Array.from({ length }, (value, index) => stdio[index]);
-  };
-  module2.exports = normalizeStdio;
-  module2.exports.node = (options3) => {
-    const stdio = normalizeStdio(options3);
-    if (stdio === "ipc") {
-      return "ipc";
-    }
-    if (stdio === void 0 || typeof stdio === "string") {
-      return [stdio, stdio, stdio, "ipc"];
-    }
-    if (stdio.includes("ipc")) {
-      return stdio;
-    }
-    return [...stdio, "ipc"];
-  };
-});
-var require_kill = __commonJSMin((exports, module2) => {
-  "use strict";
-  var os = __require("os");
-  var onExit = require_signal_exit();
-  var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
-  var spawnedKill = (kill, signal = "SIGTERM", options3 = {}) => {
-    const killResult = kill(signal);
-    setKillTimeout(kill, signal, options3, killResult);
-    return killResult;
-  };
-  var setKillTimeout = (kill, signal, options3, killResult) => {
-    if (!shouldForceKill(signal, options3, killResult)) {
-      return;
-    }
-    const timeout = getForceKillAfterTimeout(options3);
-    const t = setTimeout(() => {
-      kill("SIGKILL");
-    }, timeout);
-    if (t.unref) {
-      t.unref();
-    }
-  };
-  var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => {
-    return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
-  };
-  var isSigterm = (signal) => {
-    return signal === os.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
-  };
-  var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
-    if (forceKillAfterTimeout === true) {
-      return DEFAULT_FORCE_KILL_TIMEOUT;
-    }
-    if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
-      throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
-    }
-    return forceKillAfterTimeout;
-  };
-  var spawnedCancel = (spawned, context) => {
-    const killResult = spawned.kill();
-    if (killResult) {
-      context.isCanceled = true;
-    }
-  };
-  var timeoutKill = (spawned, signal, reject) => {
-    spawned.kill(signal);
-    reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
-  };
-  var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
-    if (timeout === 0 || timeout === void 0) {
-      return spawnedPromise;
-    }
-    let timeoutId;
-    const timeoutPromise2 = new Promise((resolve, reject) => {
-      timeoutId = setTimeout(() => {
-        timeoutKill(spawned, killSignal, reject);
-      }, timeout);
-    });
-    const safeSpawnedPromise = spawnedPromise.finally(() => {
-      clearTimeout(timeoutId);
-    });
-    return Promise.race([timeoutPromise2, safeSpawnedPromise]);
-  };
-  var validateTimeout = ({ timeout }) => {
-    if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
-      throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-    }
-  };
-  var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
-    if (!cleanup || detached) {
-      return timedPromise;
-    }
-    const removeExitHandler = onExit(() => {
-      spawned.kill();
-    });
-    return timedPromise.finally(() => {
-      removeExitHandler();
-    });
-  };
-  module2.exports = {
-    spawnedKill,
-    spawnedCancel,
-    setupTimeout,
-    validateTimeout,
-    setExitHandler
-  };
-});
-var require_is_stream = __commonJSMin((exports, module2) => {
-  "use strict";
-  var isStream = (stream) => stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
-  isStream.writable = (stream) => isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
-  isStream.readable = (stream) => isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
-  isStream.duplex = (stream) => isStream.writable(stream) && isStream.readable(stream);
-  isStream.transform = (stream) => isStream.duplex(stream) && typeof stream._transform === "function";
-  module2.exports = isStream;
-});
-var require_buffer_stream = __commonJSMin((exports, module2) => {
-  "use strict";
-  var { PassThrough: PassThroughStream } = __require("stream");
-  module2.exports = (options3) => {
-    options3 = { ...options3 };
-    const { array } = options3;
-    let { encoding } = options3;
-    const isBuffer = encoding === "buffer";
-    let objectMode = false;
-    if (array) {
-      objectMode = !(encoding || isBuffer);
-    } else {
-      encoding = encoding || "utf8";
-    }
-    if (isBuffer) {
-      encoding = null;
-    }
-    const stream = new PassThroughStream({ objectMode });
-    if (encoding) {
-      stream.setEncoding(encoding);
-    }
-    let length = 0;
-    const chunks = [];
-    stream.on("data", (chunk) => {
-      chunks.push(chunk);
-      if (objectMode) {
-        length = chunks.length;
-      } else {
-        length += chunk.length;
-      }
-    });
-    stream.getBufferedValue = () => {
-      if (array) {
-        return chunks;
-      }
-      return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
-    };
-    stream.getBufferedLength = () => length;
-    return stream;
-  };
-});
-var require_get_stream = __commonJSMin((exports, module2) => {
-  "use strict";
-  var { constants: BufferConstants } = __require("buffer");
-  var stream = __require("stream");
-  var { promisify } = __require("util");
-  var bufferStream = require_buffer_stream();
-  var streamPipelinePromisified = promisify(stream.pipeline);
-  var MaxBufferError = class extends Error {
-    constructor() {
-      super("maxBuffer exceeded");
-      this.name = "MaxBufferError";
-    }
-  };
-  async function getStream(inputStream, options3) {
-    if (!inputStream) {
-      throw new Error("Expected a stream");
-    }
-    options3 = {
-      maxBuffer: Infinity,
-      ...options3
-    };
-    const { maxBuffer } = options3;
-    const stream2 = bufferStream(options3);
-    await new Promise((resolve, reject) => {
-      const rejectPromise = (error) => {
-        if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-          error.bufferedData = stream2.getBufferedValue();
-        }
-        reject(error);
-      };
-      (async () => {
-        try {
-          await streamPipelinePromisified(inputStream, stream2);
-          resolve();
-        } catch (error) {
-          rejectPromise(error);
-        }
-      })();
-      stream2.on("data", () => {
-        if (stream2.getBufferedLength() > maxBuffer) {
-          rejectPromise(new MaxBufferError());
-        }
-      });
-    });
-    return stream2.getBufferedValue();
-  }
-  module2.exports = getStream;
-  module2.exports.buffer = (stream2, options3) => getStream(stream2, { ...options3, encoding: "buffer" });
-  module2.exports.array = (stream2, options3) => getStream(stream2, { ...options3, array: true });
-  module2.exports.MaxBufferError = MaxBufferError;
-});
-var require_merge_stream = __commonJSMin((exports, module2) => {
-  "use strict";
-  var { PassThrough } = __require("stream");
-  module2.exports = function() {
-    var sources = [];
-    var output2 = new PassThrough({ objectMode: true });
-    output2.setMaxListeners(0);
-    output2.add = add;
-    output2.isEmpty = isEmpty2;
-    output2.on("unpipe", remove);
-    Array.prototype.slice.call(arguments).forEach(add);
-    return output2;
-    function add(source) {
-      if (Array.isArray(source)) {
-        source.forEach(add);
-        return this;
-      }
-      sources.push(source);
-      source.once("end", remove.bind(null, source));
-      source.once("error", output2.emit.bind(output2, "error"));
-      source.pipe(output2, { end: false });
-      return this;
-    }
-    function isEmpty2() {
-      return sources.length == 0;
-    }
-    function remove(source) {
-      sources = sources.filter(function(it) {
-        return it !== source;
-      });
-      if (!sources.length && output2.readable) {
-        output2.end();
-      }
-    }
-  };
-});
-var require_stream2 = __commonJSMin((exports, module2) => {
-  "use strict";
-  var isStream = require_is_stream();
-  var getStream = require_get_stream();
-  var mergeStream = require_merge_stream();
-  var handleInput = (spawned, input) => {
-    if (input === void 0 || spawned.stdin === void 0) {
-      return;
-    }
-    if (isStream(input)) {
-      input.pipe(spawned.stdin);
-    } else {
-      spawned.stdin.end(input);
-    }
-  };
-  var makeAllStream = (spawned, { all }) => {
-    if (!all || !spawned.stdout && !spawned.stderr) {
-      return;
-    }
-    const mixed = mergeStream();
-    if (spawned.stdout) {
-      mixed.add(spawned.stdout);
-    }
-    if (spawned.stderr) {
-      mixed.add(spawned.stderr);
-    }
-    return mixed;
-  };
-  var getBufferedData = async (stream, streamPromise) => {
-    if (!stream) {
-      return;
-    }
-    stream.destroy();
-    try {
-      return await streamPromise;
-    } catch (error) {
-      return error.bufferedData;
-    }
-  };
-  var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
-    if (!stream || !buffer) {
-      return;
-    }
-    if (encoding) {
-      return getStream(stream, { encoding, maxBuffer });
-    }
-    return getStream.buffer(stream, { maxBuffer });
-  };
-  var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
-    const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
-    const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
-    const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
-    try {
-      return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
-    } catch (error) {
-      return Promise.all([
-        { error, signal: error.signal, timedOut: error.timedOut },
-        getBufferedData(stdout, stdoutPromise),
-        getBufferedData(stderr, stderrPromise),
-        getBufferedData(all, allPromise)
-      ]);
-    }
-  };
-  var validateInputSync = ({ input }) => {
-    if (isStream(input)) {
-      throw new TypeError("The `input` option cannot be a stream in sync mode");
-    }
-  };
-  module2.exports = {
-    handleInput,
-    makeAllStream,
-    getSpawnedResult,
-    validateInputSync
-  };
-});
-var require_promise = __commonJSMin((exports, module2) => {
-  "use strict";
-  var nativePromisePrototype = (async () => {
-  })().constructor.prototype;
-  var descriptors = ["then", "catch", "finally"].map((property) => [
-    property,
-    Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
-  ]);
-  var mergePromise = (spawned, promise) => {
-    for (const [property, descriptor] of descriptors) {
-      const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
-      Reflect.defineProperty(spawned, property, { ...descriptor, value });
-    }
-    return spawned;
-  };
-  var getSpawnedPromise = (spawned) => {
-    return new Promise((resolve, reject) => {
-      spawned.on("exit", (exitCode, signal) => {
-        resolve({ exitCode, signal });
-      });
-      spawned.on("error", (error) => {
-        reject(error);
-      });
-      if (spawned.stdin) {
-        spawned.stdin.on("error", (error) => {
-          reject(error);
-        });
-      }
-    });
-  };
-  module2.exports = {
-    mergePromise,
-    getSpawnedPromise
-  };
-});
-var require_command = __commonJSMin((exports, module2) => {
-  "use strict";
-  var normalizeArgs = (file, args = []) => {
-    if (!Array.isArray(args)) {
-      return [file];
-    }
-    return [file, ...args];
-  };
-  var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-  var DOUBLE_QUOTES_REGEXP = /"/g;
-  var escapeArg = (arg) => {
-    if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
-      return arg;
-    }
-    return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
-  };
-  var joinCommand = (file, args) => {
-    return normalizeArgs(file, args).join(" ");
-  };
-  var getEscapedCommand = (file, args) => {
-    return normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
-  };
-  var SPACES_REGEXP = / +/g;
-  var parseCommand = (command) => {
-    const tokens = [];
-    for (const token of command.trim().split(SPACES_REGEXP)) {
-      const previousToken = tokens[tokens.length - 1];
-      if (previousToken && previousToken.endsWith("\\")) {
-        tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
-      } else {
-        tokens.push(token);
-      }
-    }
-    return tokens;
-  };
-  module2.exports = {
-    joinCommand,
-    getEscapedCommand,
-    parseCommand
-  };
-});
-var require_execa3 = __commonJSMin((exports, module2) => {
-  "use strict";
-  var path6 = __require("path");
-  var childProcess = __require("child_process");
-  var crossSpawn = require_cross_spawn();
-  var stripFinalNewline = require_strip_final_newline();
-  var npmRunPath = require_npm_run_path();
-  var onetime = require_onetime();
-  var makeError = require_error();
-  var normalizeStdio = require_stdio();
-  var { spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler } = require_kill();
-  var { handleInput, getSpawnedResult, makeAllStream, validateInputSync } = require_stream2();
-  var { mergePromise, getSpawnedPromise } = require_promise();
-  var { joinCommand, parseCommand, getEscapedCommand } = require_command();
-  var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
-  var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
-    const env = extendEnv ? { ...process.env, ...envOption } : envOption;
-    if (preferLocal) {
-      return npmRunPath.env({ env, cwd: localDir, execPath });
-    }
-    return env;
-  };
-  var handleArguments = (file, args, options3 = {}) => {
-    const parsed = crossSpawn._parse(file, args, options3);
-    file = parsed.command;
-    args = parsed.args;
-    options3 = parsed.options;
-    options3 = {
-      maxBuffer: DEFAULT_MAX_BUFFER,
-      buffer: true,
-      stripFinalNewline: true,
-      extendEnv: true,
-      preferLocal: false,
-      localDir: options3.cwd || process.cwd(),
-      execPath: process.execPath,
-      encoding: "utf8",
-      reject: true,
-      cleanup: true,
-      all: false,
-      windowsHide: true,
-      ...options3
-    };
-    options3.env = getEnv(options3);
-    options3.stdio = normalizeStdio(options3);
-    if (process.platform === "win32" && path6.basename(file, ".exe") === "cmd") {
-      args.unshift("/q");
-    }
-    return { file, args, options: options3, parsed };
-  };
-  var handleOutput = (options3, value, error) => {
-    if (typeof value !== "string" && !Buffer.isBuffer(value)) {
-      return error === void 0 ? void 0 : "";
-    }
-    if (options3.stripFinalNewline) {
-      return stripFinalNewline(value);
-    }
-    return value;
-  };
-  var execa2 = (file, args, options3) => {
-    const parsed = handleArguments(file, args, options3);
-    const command = joinCommand(file, args);
-    const escapedCommand = getEscapedCommand(file, args);
-    validateTimeout(parsed.options);
-    let spawned;
-    try {
-      spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
-    } catch (error) {
-      const dummySpawned = new childProcess.ChildProcess();
-      const errorPromise = Promise.reject(makeError({
-        error,
-        stdout: "",
-        stderr: "",
-        all: "",
-        command,
-        escapedCommand,
-        parsed,
-        timedOut: false,
-        isCanceled: false,
-        killed: false
-      }));
-      return mergePromise(dummySpawned, errorPromise);
-    }
-    const spawnedPromise = getSpawnedPromise(spawned);
-    const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
-    const processDone = setExitHandler(spawned, parsed.options, timedPromise);
-    const context = { isCanceled: false };
-    spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
-    spawned.cancel = spawnedCancel.bind(null, spawned, context);
-    const handlePromise = async () => {
-      const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
-      const stdout = handleOutput(parsed.options, stdoutResult);
-      const stderr = handleOutput(parsed.options, stderrResult);
-      const all = handleOutput(parsed.options, allResult);
-      if (error || exitCode !== 0 || signal !== null) {
-        const returnedError = makeError({
-          error,
-          exitCode,
-          signal,
-          stdout,
-          stderr,
-          all,
-          command,
-          escapedCommand,
-          parsed,
-          timedOut,
-          isCanceled: context.isCanceled,
-          killed: spawned.killed
-        });
-        if (!parsed.options.reject) {
-          return returnedError;
-        }
-        throw returnedError;
-      }
-      return {
-        command,
-        escapedCommand,
-        exitCode: 0,
-        stdout,
-        stderr,
-        all,
-        failed: false,
-        timedOut: false,
-        isCanceled: false,
-        killed: false
-      };
-    };
-    const handlePromiseOnce = onetime(handlePromise);
-    handleInput(spawned, parsed.options.input);
-    spawned.all = makeAllStream(spawned, parsed.options);
-    return mergePromise(spawned, handlePromiseOnce);
-  };
-  module2.exports = execa2;
-  module2.exports.sync = (file, args, options3) => {
-    const parsed = handleArguments(file, args, options3);
-    const command = joinCommand(file, args);
-    const escapedCommand = getEscapedCommand(file, args);
-    validateInputSync(parsed.options);
-    let result;
-    try {
-      result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
-    } catch (error) {
-      throw makeError({
-        error,
-        stdout: "",
-        stderr: "",
-        all: "",
-        command,
-        escapedCommand,
-        parsed,
-        timedOut: false,
-        isCanceled: false,
-        killed: false
-      });
-    }
-    const stdout = handleOutput(parsed.options, result.stdout, result.error);
-    const stderr = handleOutput(parsed.options, result.stderr, result.error);
-    if (result.error || result.status !== 0 || result.signal !== null) {
-      const error = makeError({
-        stdout,
-        stderr,
-        error: result.error,
-        signal: result.signal,
-        exitCode: result.status,
-        command,
-        escapedCommand,
-        parsed,
-        timedOut: result.error && result.error.code === "ETIMEDOUT",
-        isCanceled: false,
-        killed: result.signal !== null
-      });
-      if (!parsed.options.reject) {
-        return error;
-      }
-      throw error;
-    }
-    return {
-      command,
-      escapedCommand,
-      exitCode: 0,
-      stdout,
-      stderr,
-      failed: false,
-      timedOut: false,
-      isCanceled: false,
-      killed: false
-    };
-  };
-  module2.exports.command = (command, options3) => {
-    const [file, ...args] = parseCommand(command);
-    return execa2(file, args, options3);
-  };
-  module2.exports.commandSync = (command, options3) => {
-    const [file, ...args] = parseCommand(command);
-    return execa2.sync(file, args, options3);
-  };
-  module2.exports.node = (scriptPath, args, options3 = {}) => {
-    if (args && !Array.isArray(args) && typeof args === "object") {
-      options3 = args;
-      args = [];
-    }
-    const stdio = normalizeStdio.node(options3);
-    const defaultExecArgv = process.execArgv.filter((arg) => !arg.startsWith("--inspect"));
-    const {
-      nodePath = process.execPath,
-      nodeOptions = defaultExecArgv
-    } = options3;
-    return execa2(nodePath, [
-      ...nodeOptions,
-      scriptPath,
-      ...Array.isArray(args) ? args : []
-    ], {
-      ...options3,
-      stdin: void 0,
-      stdout: void 0,
-      stderr: void 0,
-      stdio,
-      shell: false
-    });
-  };
-});
 var require_version = __commonJSMin((exports) => {
   "use strict";
   var __importDefault = exports && exports.__importDefault || function(mod) {
@@ -146115,10 +144539,9 @@ var require_version = __commonJSMin((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isReact18 = exports.getPnpmVersion = void 0;
   var path_1 = __importDefault(__require("path"));
-  var execa_1 = __importDefault(require_execa3());
   var compiled_1 = require_compiled2();
   async function getPnpmVersion() {
-    const { stdout } = await (0, execa_1.default)("pnpm", ["--version"]);
+    const { stdout } = await (0, compiled_1.execa)("pnpm", ["--version"]);
     return stdout;
   }
   exports.getPnpmVersion = getPnpmVersion;
@@ -148295,8 +146718,8 @@ var PluginFileAPI = /* @__PURE__ */ function() {
         updateTextRawFile: this.updateTextRawFile.bind(this),
         rmFile: this.rmFile.bind(this),
         rmDir: this.rmDir.bind(this),
-        addHelper: this.handlebarAPI.addHelper.bind(this),
-        addPartial: this.handlebarAPI.addPartial.bind(this)
+        addHelper: this.handlebarAPI.addHelper.bind(this.handlebarAPI),
+        addPartial: this.handlebarAPI.addPartial.bind(this.handlebarAPI)
       };
     }
   }, {