@storybook/addon-vitest 0.0.0-pr-30601-sha-d70f67e1 → 0.0.0-pr-31819-sha-b1c88d51

package/dist/_node-chunks/chunk-XWQZZ2C3.js

@@ -0,0 +1,1586 @@
+import CJS_COMPAT_NODE_URL from 'node:url';
+import CJS_COMPAT_NODE_PATH from 'node:path';
+import CJS_COMPAT_NODE_MODULE from "node:module";
+
+const __filename = CJS_COMPAT_NODE_URL.fileURLToPath(import.meta.url);
+const __dirname = CJS_COMPAT_NODE_PATH.dirname(__filename);
+const require = CJS_COMPAT_NODE_MODULE.createRequire(import.meta.url);
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  a as o,
+  b as S,
+  c as h,
+  e as Ge
+} from "./chunk-KVKHJ5OL.js";
+
+// ../../node_modules/isexe/windows.js
+var je = h((no, ke) => {
+  ke.exports = Ne;
+  Ne.sync = fn;
+  var Re = S("fs");
+  function un(e, t) {
+    var n = t.pathExt !== void 0 ? t.pathExt : process.env.PATHEXT;
+    if (!n || (n = n.split(";"), n.indexOf("") !== -1))
+      return !0;
+    for (var r = 0; r < n.length; r++) {
+      var i = n[r].toLowerCase();
+      if (i && e.substr(-i.length).toLowerCase() === i)
+        return !0;
+    }
+    return !1;
+  }
+  o(un, "checkPathExt");
+  function $e(e, t, n) {
+    return !e.isSymbolicLink() && !e.isFile() ? !1 : un(t, n);
+  }
+  o($e, "checkStat");
+  function Ne(e, t, n) {
+    Re.stat(e, function(r, i) {
+      n(r, r ? !1 : $e(i, e, t));
+    });
+  }
+  o(Ne, "isexe");
+  function fn(e, t) {
+    return $e(Re.statSync(e), e, t);
+  }
+  o(fn, "sync");
+});
+
+// ../../node_modules/isexe/mode.js
+var Me = h((oo, Fe) => {
+  Fe.exports = Le;
+  Le.sync = ln;
+  var Be = S("fs");
+  function Le(e, t, n) {
+    Be.stat(e, function(r, i) {
+      n(r, r ? !1 : Ue(i, t));
+    });
+  }
+  o(Le, "isexe");
+  function ln(e, t) {
+    return Ue(Be.statSync(e), t);
+  }
+  o(ln, "sync");
+  function Ue(e, t) {
+    return e.isFile() && dn(e, t);
+  }
+  o(Ue, "checkStat");
+  function dn(e, t) {
+    var n = e.mode, r = e.uid, i = e.gid, s = t.uid !== void 0 ? t.uid : process.getuid && process.getuid(), a = t.gid !== void 0 ? t.gid : process.getgid && process.getgid(), c = parseInt("100", 8), u = parseInt("010", 8), f = parseInt("001", 8), l = c | u, p = n & f || n & u && i === a || n & c && r === s || n & l && s === 0;
+    return p;
+  }
+  o(dn, "checkMode");
+});
+
+// ../../node_modules/isexe/index.js
+var De = h((ao, _e) => {
+  var so = S("fs"), R;
+  process.platform === "win32" || global.TESTING_WINDOWS ? R = je() : R = Me();
+  _e.exports = W;
+  W.sync = pn;
+  function W(e, t, n) {
+    if (typeof t == "function" && (n = t, t = {}), !n) {
+      if (typeof Promise != "function")
+        throw new TypeError("callback not provided");
+      return new Promise(function(r, i) {
+        W(e, t || {}, function(s, a) {
+          s ? i(s) : r(a);
+        });
+      });
+    }
+    R(e, t || {}, function(r, i) {
+      r && (r.code === "EACCES" || t && t.ignoreErrors) && (r = null, i = !1), n(r, i);
+    });
+  }
+  o(W, "isexe");
+  function pn(e, t) {
+    try {
+      return R.sync(e, t || {});
+    } catch (n) {
+      if (t && t.ignoreErrors || n.code === "EACCES")
+        return !1;
+      throw n;
+    }
+  }
+  o(pn, "sync");
+});
+
+// ../../node_modules/which/which.js
+var Ve = h((uo, Xe) => {
+  var w = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", ze = S("path"), mn = w ? ";" : ":", qe = De(), We = /* @__PURE__ */ o((e) => Object.assign(new Error(`not found: ${e}`), { code: "ENOENT" }), "getNotFoundError"), He = /* @__PURE__ */ o((e, t) => {
+    let n = t.colon || mn, r = e.match(/\//) || w && e.match(/\\/) ? [""] : [
+      // windows always checks the cwd first
+      ...w ? [process.cwd()] : [],
+      ...(t.path || process.env.PATH || /* istanbul ignore next: very unusual */
+      "").split(n)
+    ], i = w ? t.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", s = w ? i.split(n) : [""];
+    return w && e.indexOf(".") !== -1 && s[0] !== "" && s.unshift(""), {
+      pathEnv: r,
+      pathExt: s,
+      pathExtExe: i
+    };
+  }, "getPathInfo"), Ke = /* @__PURE__ */ o((e, t, n) => {
+    typeof t == "function" && (n = t, t = {}), t || (t = {});
+    let { pathEnv: r, pathExt: i, pathExtExe: s } = He(e, t), a = [], c = /* @__PURE__ */ o((f) => new Promise((l, p) => {
+      if (f === r.length)
+        return t.all && a.length ? l(a) : p(We(e));
+      let d = r[f], y = /^".*"$/.test(d) ? d.slice(1, -1) : d, m = ze.join(y, e), g = !y && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + m : m;
+      l(u(g, f, 0));
+    }), "step"), u = /* @__PURE__ */ o((f, l, p) => new Promise((d, y) => {
+      if (p === i.length)
+        return d(c(l + 1));
+      let m = i[p];
+      qe(f + m, { pathExt: s }, (g, x) => {
+        if (!g && x)
+          if (t.all)
+            a.push(f + m);
+          else
+            return d(f + m);
+        return d(u(f, l, p + 1));
+      });
+    }), "subStep");
+    return n ? c(0).then((f) => n(null, f), n) : c(0);
+  }, "which"), hn = /* @__PURE__ */ o((e, t) => {
+    t = t || {};
+    let { pathEnv: n, pathExt: r, pathExtExe: i } = He(e, t), s = [];
+    for (let a = 0; a < n.length; a++) {
+      let c = n[a], u = /^".*"$/.test(c) ? c.slice(1, -1) : c, f = ze.join(u, e), l = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + f : f;
+      for (let p = 0; p < r.length; p++) {
+        let d = l + r[p];
+        try {
+          if (qe.sync(d, { pathExt: i }))
+            if (t.all)
+              s.push(d);
+            else
+              return d;
+        } catch {
+        }
+      }
+    }
+    if (t.all && s.length)
+      return s;
+    if (t.nothrow)
+      return null;
+    throw We(e);
+  }, "whichSync");
+  Xe.exports = Ke;
+  Ke.sync = hn;
+});
+
+// ../../node_modules/path-key/index.js
+var Ze = h((lo, H) => {
+  "use strict";
+  var Ye = /* @__PURE__ */ o((e = {}) => {
+    let t = e.env || process.env;
+    return (e.platform || process.platform) !== "win32" ? "PATH" : Object.keys(t).reverse().find((r) => r.toUpperCase() === "PATH") || "Path";
+  }, "pathKey");
+  H.exports = Ye;
+  H.exports.default = Ye;
+});
+
+// ../../node_modules/cross-spawn/lib/util/resolveCommand.js
+var tt = h((mo, et) => {
+  "use strict";
+  var Qe = S("path"), yn = Ve(), gn = Ze();
+  function Je(e, t) {
+    let n = e.options.env || process.env, r = process.cwd(), i = e.options.cwd != null, s = i && process.chdir !== void 0 && !process.chdir.disabled;
+    if (s)
+      try {
+        process.chdir(e.options.cwd);
+      } catch {
+      }
+    let a;
+    try {
+      a = yn.sync(e.command, {
+        path: n[gn({ env: n })],
+        pathExt: t ? Qe.delimiter : void 0
+      });
+    } catch {
+    } finally {
+      s && process.chdir(r);
+    }
+    return a && (a = Qe.resolve(i ? e.options.cwd : "", a)), a;
+  }
+  o(Je, "resolveCommandAttempt");
+  function Sn(e) {
+    return Je(e) || Je(e, !0);
+  }
+  o(Sn, "resolveCommand");
+  et.exports = Sn;
+});
+
+// ../../node_modules/cross-spawn/lib/util/escape.js
+var nt = h((yo, X) => {
+  "use strict";
+  var K = /([()\][%!^"`<>&|;, *?])/g;
+  function bn(e) {
+    return e = e.replace(K, "^$1"), e;
+  }
+  o(bn, "escapeCommand");
+  function xn(e, t) {
+    return e = `${e}`, e = e.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"'), e = e.replace(/(?=(\\+?)?)\1$/, "$1$1"), e = `"${e}"`, e = e.replace(K, "^$1"), t && (e = e.replace(K, "^$1")), e;
+  }
+  o(xn, "escapeArgument");
+  X.exports.command = bn;
+  X.exports.argument = xn;
+});
+
+// ../../node_modules/shebang-regex/index.js
+var ot = h((So, rt) => {
+  "use strict";
+  rt.exports = /^#!(.*)/;
+});
+
+// ../../node_modules/shebang-command/index.js
+var st = h((bo, it) => {
+  "use strict";
+  var wn = ot();
+  it.exports = (e = "") => {
+    let t = e.match(wn);
+    if (!t)
+      return null;
+    let [n, r] = t[0].replace(/#! ?/, "").split(" "), i = n.split("/").pop();
+    return i === "env" ? r : r ? `${i} ${r}` : i;
+  };
+});
+
+// ../../node_modules/cross-spawn/lib/util/readShebang.js
+var ct = h((xo, at) => {
+  "use strict";
+  var V = S("fs"), En = st();
+  function Tn(e) {
+    let n = Buffer.alloc(150), r;
+    try {
+      r = V.openSync(e, "r"), V.readSync(r, n, 0, 150, 0), V.closeSync(r);
+    } catch {
+    }
+    return En(n.toString());
+  }
+  o(Tn, "readShebang");
+  at.exports = Tn;
+});
+
+// ../../node_modules/cross-spawn/lib/parse.js
+var dt = h((Eo, lt) => {
+  "use strict";
+  var An = S("path"), ut = tt(), ft = nt(), Cn = ct(), In = process.platform === "win32", Pn = /\.(?:com|exe)$/i, vn = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function On(e) {
+    e.file = ut(e);
+    let t = e.file && Cn(e.file);
+    return t ? (e.args.unshift(e.file), e.command = t, ut(e)) : e.file;
+  }
+  o(On, "detectShebang");
+  function Gn(e) {
+    if (!In)
+      return e;
+    let t = On(e), n = !Pn.test(t);
+    if (e.options.forceShell || n) {
+      let r = vn.test(t);
+      e.command = An.normalize(e.command), e.command = ft.command(e.command), e.args = e.args.map((s) => ft.argument(s, r));
+      let i = [e.command].concat(e.args).join(" ");
+      e.args = ["/d", "/s", "/c", `"${i}"`], e.command = process.env.comspec || "cmd.exe", e.options.windowsVerbatimArguments = !0;
+    }
+    return e;
+  }
+  o(Gn, "parseNonShell");
+  function Rn(e, t, n) {
+    t && !Array.isArray(t) && (n = t, t = null), t = t ? t.slice(0) : [], n = Object.assign({}, n);
+    let r = {
+      command: e,
+      args: t,
+      options: n,
+      file: void 0,
+      original: {
+        command: e,
+        args: t
+      }
+    };
+    return n.shell ? r : Gn(r);
+  }
+  o(Rn, "parse");
+  lt.exports = Rn;
+});
+
+// ../../node_modules/cross-spawn/lib/enoent.js
+var ht = h((Ao, mt) => {
+  "use strict";
+  var Y = process.platform === "win32";
+  function Z(e, t) {
+    return Object.assign(new Error(`${t} ${e.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${t} ${e.command}`,
+      path: e.command,
+      spawnargs: e.args
+    });
+  }
+  o(Z, "notFoundError");
+  function $n(e, t) {
+    if (!Y)
+      return;
+    let n = e.emit;
+    e.emit = function(r, i) {
+      if (r === "exit") {
+        let s = pt(i, t);
+        if (s)
+          return n.call(e, "error", s);
+      }
+      return n.apply(e, arguments);
+    };
+  }
+  o($n, "hookChildProcess");
+  function pt(e, t) {
+    return Y && e === 1 && !t.file ? Z(t.original, "spawn") : null;
+  }
+  o(pt, "verifyENOENT");
+  function Nn(e, t) {
+    return Y && e === 1 && !t.file ? Z(t.original, "spawnSync") : null;
+  }
+  o(Nn, "verifyENOENTSync");
+  mt.exports = {
+    hookChildProcess: $n,
+    verifyENOENT: pt,
+    verifyENOENTSync: Nn,
+    notFoundError: Z
+  };
+});
+
+// ../../node_modules/cross-spawn/index.js
+var St = h((Io, E) => {
+  "use strict";
+  var yt = S("child_process"), Q = dt(), J = ht();
+  function gt(e, t, n) {
+    let r = Q(e, t, n), i = yt.spawn(r.command, r.args, r.options);
+    return J.hookChildProcess(i, r), i;
+  }
+  o(gt, "spawn");
+  function kn(e, t, n) {
+    let r = Q(e, t, n), i = yt.spawnSync(r.command, r.args, r.options);
+    return i.error = i.error || J.verifyENOENTSync(i.status, r), i;
+  }
+  o(kn, "spawnSync");
+  E.exports = gt;
+  E.exports.spawn = gt;
+  E.exports.sync = kn;
+  E.exports._parse = Q;
+  E.exports._enoent = J;
+});
+
+// ../../node_modules/merge-stream/index.js
+var Wt = h((Qi, qt) => {
+  "use strict";
+  var { PassThrough: $r } = S("stream");
+  qt.exports = function() {
+    var e = [], t = new $r({ objectMode: !0 });
+    return t.setMaxListeners(0), t.add = n, t.isEmpty = r, t.on("unpipe", i), Array.prototype.slice.call(arguments).forEach(n), t;
+    function n(s) {
+      return Array.isArray(s) ? (s.forEach(n), this) : (e.push(s), s.once("end", i.bind(null, s)), s.once("error", t.emit.bind(t, "error")), s.pipe(t, { end: !1 }), this);
+    }
+    o(n, "add");
+    function r() {
+      return e.length == 0;
+    }
+    o(r, "isEmpty");
+    function i(s) {
+      e = e.filter(function(a) {
+        return a !== s;
+      }), !e.length && t.readable && t.end();
+    }
+    o(i, "remove");
+  };
+});
+
+// node_modules/execa/index.js
+var on = Ge(St(), 1);
+import { Buffer as Yr } from "node:buffer";
+import Zr from "node:path";
+import Ce from "node:child_process";
+import T from "node:process";
+
+// ../../node_modules/strip-final-newline/index.js
+function ee(e) {
+  let t = typeof e == "string" ? `
+` : 10, n = typeof e == "string" ? "\r" : 13;
+  return e[e.length - 1] === t && (e = e.slice(0, -1)), e[e.length - 1] === n && (e = e.slice(0, -1)), e;
+}
+o(ee, "stripFinalNewline");
+
+// node_modules/npm-run-path/index.js
+import N from "node:process";
+import A from "node:path";
+import { fileURLToPath as bt } from "node:url";
+
+// node_modules/path-key/index.js
+function $(e = {}) {
+  let {
+    env: t = process.env,
+    platform: n = process.platform
+  } = e;
+  return n !== "win32" ? "PATH" : Object.keys(t).reverse().find((r) => r.toUpperCase() === "PATH") || "Path";
+}
+o($, "pathKey");
+
+// node_modules/npm-run-path/index.js
+var jn = /* @__PURE__ */ o(({
+  cwd: e = N.cwd(),
+  path: t = N.env[$()],
+  preferLocal: n = !0,
+  execPath: r = N.execPath,
+  addExecPath: i = !0
+} = {}) => {
+  let s = e instanceof URL ? bt(e) : e, a = A.resolve(s), c = [];
+  return n && Bn(c, a), i && Ln(c, r, a), [...c, t].join(A.delimiter);
+}, "npmRunPath"), Bn = /* @__PURE__ */ o((e, t) => {
+  let n;
+  for (; n !== t; )
+    e.push(A.join(t, "node_modules/.bin")), n = t, t = A.resolve(t, "..");
+}, "applyPreferLocal"), Ln = /* @__PURE__ */ o((e, t, n) => {
+  let r = t instanceof URL ? bt(t) : t;
+  e.push(A.resolve(n, r, ".."));
+}, "applyExecPath"), xt = /* @__PURE__ */ o(({ env: e = N.env, ...t } = {}) => {
+  e = { ...e };
+  let n = $({ env: e });
+  return t.path = e[n], e[n] = jn(t), e;
+}, "npmRunPathEnv");
+
+// node_modules/mimic-fn/index.js
+var Un = /* @__PURE__ */ o((e, t, n, r) => {
+  if (n === "length" || n === "prototype" || n === "arguments" || n === "caller")
+    return;
+  let i = Object.getOwnPropertyDescriptor(e, n), s = Object.getOwnPropertyDescriptor(t, n);
+  !Fn(i, s) && r || Object.defineProperty(e, n, s);
+}, "copyProperty"), Fn = /* @__PURE__ */ o(function(e, t) {
+  return e === void 0 || e.configurable || e.writable === t.writable && e.enumerable === t.enumerable && e.configurable === t.configurable && (e.writable || e.value === t.value);
+}, "canCopyProperty"), Mn = /* @__PURE__ */ o((e, t) => {
+  let n = Object.getPrototypeOf(t);
+  n !== Object.getPrototypeOf(e) && Object.setPrototypeOf(e, n);
+}, "changePrototype"), _n = /* @__PURE__ */ o((e, t) => `/* Wrapped ${e}*/
+${t}`, "wrappedToString"), Dn = Object.getOwnPropertyDescriptor(Function.prototype, "toString"), zn = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name"), qn = /* @__PURE__ */ o((e, t, n) => {
+  let r = n === "" ? "" : `with ${n.trim()}() `, i = _n.bind(null, r, t.toString());
+  Object.defineProperty(i, "name", zn), Object.defineProperty(e, "toString", { ...Dn, value: i });
+}, "changeToString");
+function te(e, t, { ignoreNonConfigurable: n = !1 } = {}) {
+  let { name: r } = e;
+  for (let i of Reflect.ownKeys(t))
+    Un(e, t, i, n);
+  return Mn(e, t), qn(e, t, r), e;
+}
+o(te, "mimicFunction");
+
+// node_modules/onetime/index.js
+var k = /* @__PURE__ */ new WeakMap(), wt = /* @__PURE__ */ o((e, t = {}) => {
+  if (typeof e != "function")
+    throw new TypeError("Expected a function");
+  let n, r = 0, i = e.displayName || e.name || "<anonymous>", s = /* @__PURE__ */ o(function(...a) {
+    if (k.set(s, ++r), r === 1)
+      n = e.apply(this, a), e = null;
+    else if (t.throw === !0)
+      throw new Error(`Function \`${i}\` can only be called once`);
+    return n;
+  }, "onetime");
+  return te(s, e), k.set(s, r), s;
+}, "onetime");
+wt.callCount = (e) => {
+  if (!k.has(e))
+    throw new Error(`The given function \`${e.name}\` is not wrapped by the \`onetime\` package`);
+  return k.get(e);
+};
+var Et = wt;
+
+// node_modules/execa/lib/error.js
+import er from "node:process";
+
+// node_modules/human-signals/build/src/main.js
+import { constants as Xn } from "node:os";
+
+// node_modules/human-signals/build/src/realtime.js
+var Tt = /* @__PURE__ */ o(() => {
+  let e = ne - At + 1;
+  return Array.from({ length: e }, Wn);
+}, "getRealtimeSignals"), Wn = /* @__PURE__ */ o((e, t) => ({
+  name: `SIGRT${t + 1}`,
+  number: At + t,
+  action: "terminate",
+  description: "Application-specific signal (realtime)",
+  standard: "posix"
+}), "getRealtimeSignal"), At = 34, ne = 64;
+
+// node_modules/human-signals/build/src/signals.js
+import { constants as Hn } from "node:os";
+
+// node_modules/human-signals/build/src/core.js
+var Ct = [
+  {
+    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: !0
+  },
+  {
+    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: !0
+  },
+  {
+    name: "SIGSTOP",
+    number: 19,
+    action: "pause",
+    description: "Paused",
+    standard: "posix",
+    forced: !0
+  },
+  {
+    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"
+  }
+];
+
+// node_modules/human-signals/build/src/signals.js
+var re = /* @__PURE__ */ o(() => {
+  let e = Tt();
+  return [...Ct, ...e].map(Kn);
+}, "getSignals"), Kn = /* @__PURE__ */ o(({
+  name: e,
+  number: t,
+  description: n,
+  action: r,
+  forced: i = !1,
+  standard: s
+}) => {
+  let {
+    signals: { [e]: a }
+  } = Hn, c = a !== void 0;
+  return { name: e, number: c ? a : t, description: n, supported: c, action: r, forced: i, standard: s };
+}, "normalizeSignal");
+
+// node_modules/human-signals/build/src/main.js
+var Vn = /* @__PURE__ */ o(() => {
+  let e = re();
+  return Object.fromEntries(e.map(Yn));
+}, "getSignalsByName"), Yn = /* @__PURE__ */ o(({
+  name: e,
+  number: t,
+  description: n,
+  supported: r,
+  action: i,
+  forced: s,
+  standard: a
+}) => [e, { name: e, number: t, description: n, supported: r, action: i, forced: s, standard: a }], "getSignalByName"), It = Vn(), Zn = /* @__PURE__ */ o(() => {
+  let e = re(), t = ne + 1, n = Array.from(
+    { length: t },
+    (r, i) => Qn(i, e)
+  );
+  return Object.assign({}, ...n);
+}, "getSignalsByNumber"), Qn = /* @__PURE__ */ o((e, t) => {
+  let n = Jn(e, t);
+  if (n === void 0)
+    return {};
+  let { name: r, description: i, supported: s, action: a, forced: c, standard: u } = n;
+  return {
+    [e]: {
+      name: r,
+      number: e,
+      description: i,
+      supported: s,
+      action: a,
+      forced: c,
+      standard: u
+    }
+  };
+}, "getSignalByNumber"), Jn = /* @__PURE__ */ o((e, t) => {
+  let n = t.find(({ name: r }) => Xn.signals[r] === e);
+  return n !== void 0 ? n : t.find((r) => r.number === e);
+}, "findSignalByNumber"), ei = Zn();
+
+// node_modules/execa/lib/error.js
+var tr = /* @__PURE__ */ o(({ timedOut: e, timeout: t, errorCode: n, signal: r, signalDescription: i, exitCode: s, isCanceled: a }) => e ? `timed out after ${t} milliseconds` : a ? "was canceled" : n !== void 0 ? `failed with ${n}` : r !== void 0 ? `was killed with ${r} (${i})` : s !== void 0 ? `failed with exit code ${s}` : "failed", "getErrorPrefix"), C = /* @__PURE__ */ o(({
+  stdout: e,
+  stderr: t,
+  all: n,
+  error: r,
+  signal: i,
+  exitCode: s,
+  command: a,
+  escapedCommand: c,
+  timedOut: u,
+  isCanceled: f,
+  killed: l,
+  parsed: { options: { timeout: p, cwd: d = er.cwd() } }
+}) => {
+  s = s === null ? void 0 : s, i = i === null ? void 0 : i;
+  let y = i === void 0 ? void 0 : It[i].description, m = r && r.code, x = `Command ${tr({ timedOut: u, timeout: p, errorCode: m, signal: i, signalDescription: y, exitCode: s, isCanceled: f })}: ${a}`, v = Object.prototype.toString.call(r) === "[object Error]", O = v ? `${x}
+${r.message}` : x, G = [O, t, e].filter(Boolean).join(`
+`);
+  return v ? (r.originalMessage = r.message, r.message = G) : r = new Error(G), r.shortMessage = O, r.command = a, r.escapedCommand = c, r.exitCode = s, r.signal = i, r.signalDescription = y, r.stdout = e, r.stderr = t, r.cwd = d, n !== void 0 && (r.all = n), "bufferedData" in r && delete r.bufferedData, r.failed = !0, r.timedOut = !!u, r.isCanceled = f, r.killed = l && !u, r;
+}, "makeError");
+
+// node_modules/execa/lib/stdio.js
+var j = ["stdin", "stdout", "stderr"], nr = /* @__PURE__ */ o((e) => j.some((t) => e[t] !== void 0), "hasAlias"), oe = /* @__PURE__ */ o((e) => {
+  if (!e)
+    return;
+  let { stdio: t } = e;
+  if (t === void 0)
+    return j.map((r) => e[r]);
+  if (nr(e))
+    throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${j.map((r) => `\`${r}\``).join(", ")}`);
+  if (typeof t == "string")
+    return t;
+  if (!Array.isArray(t))
+    throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof t}\``);
+  let n = Math.max(t.length, j.length);
+  return Array.from({ length: n }, (r, i) => t[i]);
+}, "normalizeStdio"), Pt = /* @__PURE__ */ o((e) => {
+  let t = oe(e);
+  return t === "ipc" ? "ipc" : t === void 0 || typeof t == "string" ? [t, t, t, "ipc"] : t.includes("ipc") ? t : [...t, "ipc"];
+}, "normalizeStdioNode");
+
+// node_modules/execa/lib/kill.js
+import ir from "node:os";
+
+// node_modules/signal-exit/dist/mjs/signals.js
+var b = [];
+b.push("SIGHUP", "SIGINT", "SIGTERM");
+process.platform !== "win32" && b.push(
+  "SIGALRM",
+  "SIGABRT",
+  "SIGVTALRM",
+  "SIGXCPU",
+  "SIGXFSZ",
+  "SIGUSR2",
+  "SIGTRAP",
+  "SIGSYS",
+  "SIGQUIT",
+  "SIGIOT"
+  // should detect profiler and enable/disable accordingly.
+  // see #21
+  // 'SIGPROF'
+);
+process.platform === "linux" && b.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+
+// node_modules/signal-exit/dist/mjs/index.js
+var B = /* @__PURE__ */ o((e) => !!e && typeof e == "object" && typeof e.removeListener == "function" && typeof e.emit == "function" && typeof e.reallyExit == "function" && typeof e.listeners == "function" && typeof e.kill == "function" && typeof e.pid == "number" && typeof e.on == "function", "processOk"), ie = Symbol.for("signal-exit emitter"), se = globalThis, rr = Object.defineProperty.bind(Object), ae = class {
+  static {
+    o(this, "Emitter");
+  }
+  emitted = {
+    afterExit: !1,
+    exit: !1
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (se[ie])
+      return se[ie];
+    rr(se, ie, {
+      value: this,
+      writable: !1,
+      enumerable: !1,
+      configurable: !1
+    });
+  }
+  on(t, n) {
+    this.listeners[t].push(n);
+  }
+  removeListener(t, n) {
+    let r = this.listeners[t], i = r.indexOf(n);
+    i !== -1 && (i === 0 && r.length === 1 ? r.length = 0 : r.splice(i, 1));
+  }
+  emit(t, n, r) {
+    if (this.emitted[t])
+      return !1;
+    this.emitted[t] = !0;
+    let i = !1;
+    for (let s of this.listeners[t])
+      i = s(n, r) === !0 || i;
+    return t === "exit" && (i = this.emit("afterExit", n, r) || i), i;
+  }
+}, L = class {
+  static {
+    o(this, "SignalExitBase");
+  }
+}, or = /* @__PURE__ */ o((e) => ({
+  onExit(t, n) {
+    return e.onExit(t, n);
+  },
+  load() {
+    return e.load();
+  },
+  unload() {
+    return e.unload();
+  }
+}), "signalExitWrap"), ce = class extends L {
+  static {
+    o(this, "SignalExitFallback");
+  }
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+}, ue = class extends L {
+  static {
+    o(this, "SignalExit");
+  }
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #s = fe.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #t = new ae();
+  #e;
+  #o;
+  #i;
+  #r = {};
+  #n = !1;
+  constructor(t) {
+    super(), this.#e = t, this.#r = {};
+    for (let n of b)
+      this.#r[n] = () => {
+        let r = this.#e.listeners(n), { count: i } = this.#t, s = t;
+        if (typeof s.__signal_exit_emitter__ == "object" && typeof s.__signal_exit_emitter__.count == "number" && (i += s.__signal_exit_emitter__.count), r.length === i) {
+          this.unload();
+          let a = this.#t.emit("exit", null, n), c = n === "SIGHUP" ? this.#s : n;
+          a || t.kill(t.pid, c);
+        }
+      };
+    this.#i = t.reallyExit, this.#o = t.emit;
+  }
+  onExit(t, n) {
+    if (!B(this.#e))
+      return () => {
+      };
+    this.#n === !1 && this.load();
+    let r = n?.alwaysLast ? "afterExit" : "exit";
+    return this.#t.on(r, t), () => {
+      this.#t.removeListener(r, t), this.#t.listeners.exit.length === 0 && this.#t.listeners.afterExit.length === 0 && this.unload();
+    };
+  }
+  load() {
+    if (!this.#n) {
+      this.#n = !0, this.#t.count += 1;
+      for (let t of b)
+        try {
+          let n = this.#r[t];
+          n && this.#e.on(t, n);
+        } catch {
+        }
+      this.#e.emit = (t, ...n) => this.#c(t, ...n), this.#e.reallyExit = (t) => this.#a(t);
+    }
+  }
+  unload() {
+    this.#n && (this.#n = !1, b.forEach((t) => {
+      let n = this.#r[t];
+      if (!n)
+        throw new Error("Listener not defined for signal: " + t);
+      try {
+        this.#e.removeListener(t, n);
+      } catch {
+      }
+    }), this.#e.emit = this.#o, this.#e.reallyExit = this.#i, this.#t.count -= 1);
+  }
+  #a(t) {
+    return B(this.#e) ? (this.#e.exitCode = t || 0, this.#t.emit("exit", this.#e.exitCode, null), this.#i.call(this.#e, this.#e.exitCode)) : 0;
+  }
+  #c(t, ...n) {
+    let r = this.#o;
+    if (t === "exit" && B(this.#e)) {
+      typeof n[0] == "number" && (this.#e.exitCode = n[0]);
+      let i = r.call(this.#e, t, ...n);
+      return this.#t.emit("exit", this.#e.exitCode, null), i;
+    } else
+      return r.call(this.#e, t, ...n);
+  }
+}, fe = globalThis.process, {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit: vt,
+  /**
+   * Load the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  load: li,
+  /**
+   * Unload the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  unload: di
+} = or(B(fe) ? new ue(fe) : new ce());
+
+// node_modules/execa/lib/kill.js
+var sr = 1e3 * 5, Ot = /* @__PURE__ */ o((e, t = "SIGTERM", n = {}) => {
+  let r = e(t);
+  return ar(e, t, n, r), r;
+}, "spawnedKill"), ar = /* @__PURE__ */ o((e, t, n, r) => {
+  if (!cr(t, n, r))
+    return;
+  let i = fr(n), s = setTimeout(() => {
+    e("SIGKILL");
+  }, i);
+  s.unref && s.unref();
+}, "setKillTimeout"), cr = /* @__PURE__ */ o((e, { forceKillAfterTimeout: t }, n) => ur(e) && t !== !1 && n, "shouldForceKill"), ur = /* @__PURE__ */ o((e) => e === ir.constants.signals.SIGTERM || typeof e == "string" && e.toUpperCase() === "SIGTERM", "isSigterm"), fr = /* @__PURE__ */ o(({ forceKillAfterTimeout: e = !0 }) => {
+  if (e === !0)
+    return sr;
+  if (!Number.isFinite(e) || e < 0)
+    throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${e}\` (${typeof e})`);
+  return e;
+}, "getForceKillAfterTimeout"), Gt = /* @__PURE__ */ o((e, t) => {
+  e.kill() && (t.isCanceled = !0);
+}, "spawnedCancel"), lr = /* @__PURE__ */ o((e, t, n) => {
+  e.kill(t), n(Object.assign(new Error("Timed out"), { timedOut: !0, signal: t }));
+}, "timeoutKill"), Rt = /* @__PURE__ */ o((e, { timeout: t, killSignal: n = "SIGTERM" }, r) => {
+  if (t === 0 || t === void 0)
+    return r;
+  let i, s = new Promise((c, u) => {
+    i = setTimeout(() => {
+      lr(e, n, u);
+    }, t);
+  }), a = r.finally(() => {
+    clearTimeout(i);
+  });
+  return Promise.race([s, a]);
+}, "setupTimeout"), $t = /* @__PURE__ */ o(({ timeout: e }) => {
+  if (e !== void 0 && (!Number.isFinite(e) || e < 0))
+    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${e}\` (${typeof e})`);
+}, "validateTimeout"), Nt = /* @__PURE__ */ o(async (e, { cleanup: t, detached: n }, r) => {
+  if (!t || n)
+    return r;
+  let i = vt(() => {
+    e.kill();
+  });
+  return r.finally(() => {
+    i();
+  });
+}, "setExitHandler");
+
+// node_modules/execa/lib/pipe.js
+import { createWriteStream as dr } from "node:fs";
+import { ChildProcess as pr } from "node:child_process";
+
+// node_modules/is-stream/index.js
+function U(e) {
+  return e !== null && typeof e == "object" && typeof e.pipe == "function";
+}
+o(U, "isStream");
+function le(e) {
+  return U(e) && e.writable !== !1 && typeof e._write == "function" && typeof e._writableState == "object";
+}
+o(le, "isWritableStream");
+
+// node_modules/execa/lib/pipe.js
+var mr = /* @__PURE__ */ o((e) => e instanceof pr && typeof e.then == "function", "isExecaChildProcess"), de = /* @__PURE__ */ o((e, t, n) => {
+  if (typeof n == "string")
+    return e[t].pipe(dr(n)), e;
+  if (le(n))
+    return e[t].pipe(n), e;
+  if (!mr(n))
+    throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
+  if (!le(n.stdin))
+    throw new TypeError("The target child process's stdin must be available.");
+  return e[t].pipe(n.stdin), n;
+}, "pipeToTarget"), kt = /* @__PURE__ */ o((e) => {
+  e.stdout !== null && (e.pipeStdout = de.bind(void 0, e, "stdout")), e.stderr !== null && (e.pipeStderr = de.bind(void 0, e, "stderr")), e.all !== void 0 && (e.pipeAll = de.bind(void 0, e, "all"));
+}, "addPipeMethods");
+
+// node_modules/execa/lib/stream.js
+import { createReadStream as Nr, readFileSync as kr } from "node:fs";
+import { setTimeout as jr } from "node:timers/promises";
+
+// node_modules/get-stream/source/contents.js
+var I = /* @__PURE__ */ o(async (e, { init: t, convertChunk: n, getSize: r, truncateChunk: i, addChunk: s, getFinalChunk: a, finalize: c }, { maxBuffer: u = Number.POSITIVE_INFINITY } = {}) => {
+  if (!yr(e))
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+  let f = t();
+  f.length = 0;
+  try {
+    for await (let l of e) {
+      let p = gr(l), d = n[p](l, f);
+      Lt({ convertedChunk: d, state: f, getSize: r, truncateChunk: i, addChunk: s, maxBuffer: u });
+    }
+    return hr({ state: f, convertChunk: n, getSize: r, truncateChunk: i, addChunk: s, getFinalChunk: a, maxBuffer: u }), c(f);
+  } catch (l) {
+    throw l.bufferedData = c(f), l;
+  }
+}, "getStreamContents"), hr = /* @__PURE__ */ o(({ state: e, getSize: t, truncateChunk: n, addChunk: r, getFinalChunk: i, maxBuffer: s }) => {
+  let a = i(e);
+  a !== void 0 && Lt({ convertedChunk: a, state: e, getSize: t, truncateChunk: n, addChunk: r, maxBuffer: s });
+}, "appendFinalChunk"), Lt = /* @__PURE__ */ o(({ convertedChunk: e, state: t, getSize: n, truncateChunk: r, addChunk: i, maxBuffer: s }) => {
+  let a = n(e), c = t.length + a;
+  if (c <= s) {
+    jt(e, t, i, c);
+    return;
+  }
+  let u = r(e, s - t.length);
+  throw u !== void 0 && jt(u, t, i, s), new F();
+}, "appendChunk"), jt = /* @__PURE__ */ o((e, t, n, r) => {
+  t.contents = n(e, t, r), t.length = r;
+}, "addNewChunk"), yr = /* @__PURE__ */ o((e) => typeof e == "object" && e !== null && typeof e[Symbol.asyncIterator] == "function", "isAsyncIterable"), gr = /* @__PURE__ */ o((e) => {
+  let t = typeof e;
+  if (t === "string")
+    return "string";
+  if (t !== "object" || e === null)
+    return "others";
+  if (globalThis.Buffer?.isBuffer(e))
+    return "buffer";
+  let n = Bt.call(e);
+  return n === "[object ArrayBuffer]" ? "arrayBuffer" : n === "[object DataView]" ? "dataView" : Number.isInteger(e.byteLength) && Number.isInteger(e.byteOffset) && Bt.call(e.buffer) === "[object ArrayBuffer]" ? "typedArray" : "others";
+}, "getChunkType"), { toString: Bt } = Object.prototype, F = class extends Error {
+  static {
+    o(this, "MaxBufferError");
+  }
+  name = "MaxBufferError";
+  constructor() {
+    super("maxBuffer exceeded");
+  }
+};
+
+// node_modules/get-stream/source/utils.js
+var pe = /* @__PURE__ */ o((e) => e, "identity"), me = /* @__PURE__ */ o(() => {
+}, "noop"), he = /* @__PURE__ */ o(({ contents: e }) => e, "getContentsProp"), M = /* @__PURE__ */ o((e) => {
+  throw new Error(`Streams in object mode are not supported: ${String(e)}`);
+}, "throwObjectStream"), _ = /* @__PURE__ */ o((e) => e.length, "getLengthProp");
+
+// node_modules/get-stream/source/array-buffer.js
+async function ye(e, t) {
+  return I(e, Ir, t);
+}
+o(ye, "getStreamAsArrayBuffer");
+var Sr = /* @__PURE__ */ o(() => ({ contents: new ArrayBuffer(0) }), "initArrayBuffer"), br = /* @__PURE__ */ o((e) => xr.encode(e), "useTextEncoder"), xr = new TextEncoder(), Ut = /* @__PURE__ */ o((e) => new Uint8Array(e), "useUint8Array"), Ft = /* @__PURE__ */ o((e) => new Uint8Array(e.buffer, e.byteOffset, e.byteLength), "useUint8ArrayWithOffset"), wr = /* @__PURE__ */ o((e, t) => e.slice(0, t), "truncateArrayBufferChunk"), Er = /* @__PURE__ */ o((e, { contents: t, length: n }, r) => {
+  let i = Dt() ? Ar(t, r) : Tr(t, r);
+  return new Uint8Array(i).set(e, n), i;
+}, "addArrayBufferChunk"), Tr = /* @__PURE__ */ o((e, t) => {
+  if (t <= e.byteLength)
+    return e;
+  let n = new ArrayBuffer(_t(t));
+  return new Uint8Array(n).set(new Uint8Array(e), 0), n;
+}, "resizeArrayBufferSlow"), Ar = /* @__PURE__ */ o((e, t) => {
+  if (t <= e.maxByteLength)
+    return e.resize(t), e;
+  let n = new ArrayBuffer(t, { maxByteLength: _t(t) });
+  return new Uint8Array(n).set(new Uint8Array(e), 0), n;
+}, "resizeArrayBuffer"), _t = /* @__PURE__ */ o((e) => Mt ** Math.ceil(Math.log(e) / Math.log(Mt)), "getNewContentsLength"), Mt = 2, Cr = /* @__PURE__ */ o(({ contents: e, length: t }) => Dt() ? e : e.slice(0, t), "finalizeArrayBuffer"), Dt = /* @__PURE__ */ o(() => "resize" in ArrayBuffer.prototype, "hasArrayBufferResize"), Ir = {
+  init: Sr,
+  convertChunk: {
+    string: br,
+    buffer: Ut,
+    arrayBuffer: Ut,
+    dataView: Ft,
+    typedArray: Ft,
+    others: M
+  },
+  getSize: _,
+  truncateChunk: wr,
+  addChunk: Er,
+  getFinalChunk: me,
+  finalize: Cr
+};
+
+// node_modules/get-stream/source/buffer.js
+async function D(e, t) {
+  if (!("Buffer" in globalThis))
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  try {
+    return zt(await ye(e, t));
+  } catch (n) {
+    throw n.bufferedData !== void 0 && (n.bufferedData = zt(n.bufferedData)), n;
+  }
+}
+o(D, "getStreamAsBuffer");
+var zt = /* @__PURE__ */ o((e) => globalThis.Buffer.from(e), "arrayBufferToNodeBuffer");
+
+// node_modules/get-stream/source/string.js
+async function ge(e, t) {
+  return I(e, Rr, t);
+}
+o(ge, "getStreamAsString");
+var Pr = /* @__PURE__ */ o(() => ({ contents: "", textDecoder: new TextDecoder() }), "initString"), z = /* @__PURE__ */ o((e, { textDecoder: t }) => t.decode(e, { stream: !0 }), "useTextDecoder"), vr = /* @__PURE__ */ o((e, { contents: t }) => t + e, "addStringChunk"), Or = /* @__PURE__ */ o((e, t) => e.slice(0, t), "truncateStringChunk"), Gr = /* @__PURE__ */ o(({ textDecoder: e }) => {
+  let t = e.decode();
+  return t === "" ? void 0 : t;
+}, "getFinalStringChunk"), Rr = {
+  init: Pr,
+  convertChunk: {
+    string: pe,
+    buffer: z,
+    arrayBuffer: z,
+    dataView: z,
+    typedArray: z,
+    others: M
+  },
+  getSize: _,
+  truncateChunk: Or,
+  addChunk: vr,
+  getFinalChunk: Gr,
+  finalize: he
+};
+
+// node_modules/execa/lib/stream.js
+var Ht = Ge(Wt(), 1);
+var Kt = /* @__PURE__ */ o((e) => {
+  if (e !== void 0)
+    throw new TypeError("The `input` and `inputFile` options cannot be both set.");
+}, "validateInputOptions"), Br = /* @__PURE__ */ o(({ input: e, inputFile: t }) => typeof t != "string" ? e : (Kt(e), kr(t)), "getInputSync"), Xt = /* @__PURE__ */ o((e) => {
+  let t = Br(e);
+  if (U(t))
+    throw new TypeError("The `input` option cannot be a stream in sync mode");
+  return t;
+}, "handleInputSync"), Lr = /* @__PURE__ */ o(({ input: e, inputFile: t }) => typeof t != "string" ? e : (Kt(e), Nr(t)), "getInput"), Vt = /* @__PURE__ */ o((e, t) => {
+  let n = Lr(t);
+  n !== void 0 && (U(n) ? n.pipe(e.stdin) : e.stdin.end(n));
+}, "handleInput"), Yt = /* @__PURE__ */ o((e, { all: t }) => {
+  if (!t || !e.stdout && !e.stderr)
+    return;
+  let n = (0, Ht.default)();
+  return e.stdout && n.add(e.stdout), e.stderr && n.add(e.stderr), n;
+}, "makeAllStream"), Se = /* @__PURE__ */ o(async (e, t) => {
+  if (!(!e || t === void 0)) {
+    await jr(0), e.destroy();
+    try {
+      return await t;
+    } catch (n) {
+      return n.bufferedData;
+    }
+  }
+}, "getBufferedData"), be = /* @__PURE__ */ o((e, { encoding: t, buffer: n, maxBuffer: r }) => {
+  if (!(!e || !n))
+    return t === "utf8" || t === "utf-8" ? ge(e, { maxBuffer: r }) : t === null || t === "buffer" ? D(e, { maxBuffer: r }) : Ur(e, r, t);
+}, "getStreamPromise"), Ur = /* @__PURE__ */ o(async (e, t, n) => (await D(e, { maxBuffer: t })).toString(n), "applyEncoding"), Zt = /* @__PURE__ */ o(async ({ stdout: e, stderr: t, all: n }, { encoding: r, buffer: i, maxBuffer: s }, a) => {
+  let c = be(e, { encoding: r, buffer: i, maxBuffer: s }), u = be(t, { encoding: r, buffer: i, maxBuffer: s }), f = be(n, { encoding: r, buffer: i, maxBuffer: s * 2 });
+  try {
+    return await Promise.all([a, c, u, f]);
+  } catch (l) {
+    return Promise.all([
+      { error: l, signal: l.signal, timedOut: l.timedOut },
+      Se(e, c),
+      Se(t, u),
+      Se(n, f)
+    ]);
+  }
+}, "getSpawnedResult");
+
+// node_modules/execa/lib/promise.js
+var Fr = (async () => {
+})().constructor.prototype, Mr = ["then", "catch", "finally"].map((e) => [
+  e,
+  Reflect.getOwnPropertyDescriptor(Fr, e)
+]), xe = /* @__PURE__ */ o((e, t) => {
+  for (let [n, r] of Mr) {
+    let i = typeof t == "function" ? (...s) => Reflect.apply(r.value, t(), s) : r.value.bind(t);
+    Reflect.defineProperty(e, n, { ...r, value: i });
+  }
+}, "mergePromise"), Qt = /* @__PURE__ */ o((e) => new Promise((t, n) => {
+  e.on("exit", (r, i) => {
+    t({ exitCode: r, signal: i });
+  }), e.on("error", (r) => {
+    n(r);
+  }), e.stdin && e.stdin.on("error", (r) => {
+    n(r);
+  });
+}), "getSpawnedPromise");
+
+// node_modules/execa/lib/command.js
+import { Buffer as _r } from "node:buffer";
+import { ChildProcess as Dr } from "node:child_process";
+var tn = /* @__PURE__ */ o((e, t = []) => Array.isArray(t) ? [e, ...t] : [e], "normalizeArgs"), zr = /^[\w.-]+$/, qr = /* @__PURE__ */ o((e) => typeof e != "string" || zr.test(e) ? e : `"${e.replaceAll('"', '\\"')}"`, "escapeArg"), we = /* @__PURE__ */ o((e, t) => tn(e, t).join(" "), "joinCommand"), Ee = /* @__PURE__ */ o((e, t) => tn(e, t).map((n) => qr(n)).join(" "), "getEscapedCommand"), Wr = / +/g;
+var Jt = /* @__PURE__ */ o((e) => {
+  let t = typeof e;
+  if (t === "string")
+    return e;
+  if (t === "number")
+    return String(e);
+  if (t === "object" && e !== null && !(e instanceof Dr) && "stdout" in e) {
+    let n = typeof e.stdout;
+    if (n === "string")
+      return e.stdout;
+    if (_r.isBuffer(e.stdout))
+      return e.stdout.toString();
+    throw new TypeError(`Unexpected "${n}" stdout in template expression`);
+  }
+  throw new TypeError(`Unexpected "${t}" in template expression`);
+}, "parseExpression"), en = /* @__PURE__ */ o((e, t, n) => n || e.length === 0 || t.length === 0 ? [...e, ...t] : [
+  ...e.slice(0, -1),
+  `${e.at(-1)}${t[0]}`,
+  ...t.slice(1)
+], "concatTokens"), Hr = /* @__PURE__ */ o(({ templates: e, expressions: t, tokens: n, index: r, template: i }) => {
+  let s = i ?? e.raw[r], a = s.split(Wr).filter(Boolean), c = en(
+    n,
+    a,
+    s.startsWith(" ")
+  );
+  if (r === t.length)
+    return c;
+  let u = t[r], f = Array.isArray(u) ? u.map((l) => Jt(l)) : [Jt(u)];
+  return en(
+    c,
+    f,
+    s.endsWith(" ")
+  );
+}, "parseTemplate"), Te = /* @__PURE__ */ o((e, t) => {
+  let n = [];
+  for (let [r, i] of e.entries())
+    n = Hr({ templates: e, expressions: t, tokens: n, index: r, template: i });
+  return n;
+}, "parseTemplates");
+
+// node_modules/execa/lib/verbose.js
+import { debuglog as Kr } from "node:util";
+import Xr from "node:process";
+var nn = Kr("execa").enabled, q = /* @__PURE__ */ o((e, t) => String(e).padStart(t, "0"), "padField"), Vr = /* @__PURE__ */ o(() => {
+  let e = /* @__PURE__ */ new Date();
+  return `${q(e.getHours(), 2)}:${q(e.getMinutes(), 2)}:${q(e.getSeconds(), 2)}.${q(e.getMilliseconds(), 3)}`;
+}, "getTimestamp"), Ae = /* @__PURE__ */ o((e, { verbose: t }) => {
+  t && Xr.stderr.write(`[${Vr()}] ${e}
+`);
+}, "logCommand");
+
+// node_modules/execa/index.js
+var Qr = 1e3 * 1e3 * 100, Jr = /* @__PURE__ */ o(({ env: e, extendEnv: t, preferLocal: n, localDir: r, execPath: i }) => {
+  let s = t ? { ...T.env, ...e } : e;
+  return n ? xt({ env: s, cwd: r, execPath: i }) : s;
+}, "getEnv"), sn = /* @__PURE__ */ o((e, t, n = {}) => {
+  let r = on.default._parse(e, t, n);
+  return e = r.command, t = r.args, n = r.options, n = {
+    maxBuffer: Qr,
+    buffer: !0,
+    stripFinalNewline: !0,
+    extendEnv: !0,
+    preferLocal: !1,
+    localDir: n.cwd || T.cwd(),
+    execPath: T.execPath,
+    encoding: "utf8",
+    reject: !0,
+    cleanup: !0,
+    all: !1,
+    windowsHide: !0,
+    verbose: nn,
+    ...n
+  }, n.env = Jr(n), n.stdio = oe(n), T.platform === "win32" && Zr.basename(e, ".exe") === "cmd" && t.unshift("/q"), { file: e, args: t, options: n, parsed: r };
+}, "handleArguments"), P = /* @__PURE__ */ o((e, t, n) => typeof t != "string" && !Yr.isBuffer(t) ? n === void 0 ? void 0 : "" : e.stripFinalNewline ? ee(t) : t, "handleOutput");
+function an(e, t, n) {
+  let r = sn(e, t, n), i = we(e, t), s = Ee(e, t);
+  Ae(s, r.options), $t(r.options);
+  let a;
+  try {
+    a = Ce.spawn(r.file, r.args, r.options);
+  } catch (y) {
+    let m = new Ce.ChildProcess(), g = Promise.reject(C({
+      error: y,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command: i,
+      escapedCommand: s,
+      parsed: r,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    }));
+    return xe(m, g), m;
+  }
+  let c = Qt(a), u = Rt(a, r.options, c), f = Nt(a, r.options, u), l = { isCanceled: !1 };
+  a.kill = Ot.bind(null, a.kill.bind(a)), a.cancel = Gt.bind(null, a, l);
+  let d = Et(/* @__PURE__ */ o(async () => {
+    let [{ error: y, exitCode: m, signal: g, timedOut: x }, v, O, G] = await Zt(a, r.options, f), Ie = P(r.options, v), Pe = P(r.options, O), ve = P(r.options, G);
+    if (y || m !== 0 || g !== null) {
+      let Oe = C({
+        error: y,
+        exitCode: m,
+        signal: g,
+        stdout: Ie,
+        stderr: Pe,
+        all: ve,
+        command: i,
+        escapedCommand: s,
+        parsed: r,
+        timedOut: x,
+        isCanceled: l.isCanceled || (r.options.signal ? r.options.signal.aborted : !1),
+        killed: a.killed
+      });
+      if (!r.options.reject)
+        return Oe;
+      throw Oe;
+    }
+    return {
+      command: i,
+      escapedCommand: s,
+      exitCode: 0,
+      stdout: Ie,
+      stderr: Pe,
+      all: ve,
+      failed: !1,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    };
+  }, "handlePromise"));
+  return Vt(a, r.options), a.all = Yt(a, r.options), kt(a), xe(a, d), a;
+}
+o(an, "execa");
+function eo(e, t, n) {
+  let r = sn(e, t, n), i = we(e, t), s = Ee(e, t);
+  Ae(s, r.options);
+  let a = Xt(r.options), c;
+  try {
+    c = Ce.spawnSync(r.file, r.args, { ...r.options, input: a });
+  } catch (l) {
+    throw C({
+      error: l,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command: i,
+      escapedCommand: s,
+      parsed: r,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    });
+  }
+  let u = P(r.options, c.stdout, c.error), f = P(r.options, c.stderr, c.error);
+  if (c.error || c.status !== 0 || c.signal !== null) {
+    let l = C({
+      stdout: u,
+      stderr: f,
+      error: c.error,
+      signal: c.signal,
+      exitCode: c.status,
+      command: i,
+      escapedCommand: s,
+      parsed: r,
+      timedOut: c.error && c.error.code === "ETIMEDOUT",
+      isCanceled: !1,
+      killed: c.signal !== null
+    });
+    if (!r.options.reject)
+      return l;
+    throw l;
+  }
+  return {
+    command: i,
+    escapedCommand: s,
+    exitCode: 0,
+    stdout: u,
+    stderr: f,
+    failed: !1,
+    timedOut: !1,
+    isCanceled: !1,
+    killed: !1
+  };
+}
+o(eo, "execaSync");
+var to = /* @__PURE__ */ o(({ input: e, inputFile: t, stdio: n }) => e === void 0 && t === void 0 && n === void 0 ? { stdin: "inherit" } : {}, "normalizeScriptStdin"), rn = /* @__PURE__ */ o((e = {}) => ({
+  preferLocal: !0,
+  ...to(e),
+  ...e
+}), "normalizeScriptOptions");
+function cn(e) {
+  function t(n, ...r) {
+    if (!Array.isArray(n))
+      return cn({ ...e, ...n });
+    let [i, ...s] = Te(n, r);
+    return an(i, s, rn(e));
+  }
+  return o(t, "$"), t.sync = (n, ...r) => {
+    if (!Array.isArray(n))
+      throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
+    let [i, ...s] = Te(n, r);
+    return eo(i, s, rn(e));
+  }, t;
+}
+o(cn, "create$");
+var $s = cn();
+function Ns(e, t, n = {}) {
+  t && !Array.isArray(t) && typeof t == "object" && (n = t, t = []);
+  let r = Pt(n), i = T.execArgv.filter((c) => !c.startsWith("--inspect")), {
+    nodePath: s = T.execPath,
+    nodeOptions: a = i
+  } = n;
+  return an(
+    s,
+    [
+      ...a,
+      e,
+      ...Array.isArray(t) ? t : []
+    ],
+    {
+      ...n,
+      stdin: void 0,
+      stdout: void 0,
+      stderr: void 0,
+      stdio: r,
+      shell: !1
+    }
+  );
+}
+o(Ns, "execaNode");
+
+export {
+  an as a,
+  Ns as b
+};