storybook 9.0.0-alpha.1 → 9.0.0-alpha.2

package/dist/telemetry/index.cjs

@@ -0,0 +1,3683 @@
+"use strict";
+var Cs = Object.create;
+var Z = Object.defineProperty;
+var Os = Object.getOwnPropertyDescriptor;
+var As = Object.getOwnPropertyNames;
+var Rs = Object.getPrototypeOf, _s = Object.prototype.hasOwnProperty;
+var o = (e, t) => Z(e, "name", { value: t, configurable: !0 });
+var p = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), Gs = (e, t) => {
+  for (var r in t)
+    Z(e, r, { get: t[r], enumerable: !0 });
+}, Ir = (e, t, r, n) => {
+  if (t && typeof t == "object" || typeof t == "function")
+    for (let i of As(t))
+      !_s.call(e, i) && i !== r && Z(e, i, { get: () => t[i], enumerable: !(n = Os(t, i)) || n.enumerable });
+  return e;
+};
+var b = (e, t, r) => (r = e != null ? Cs(Rs(e)) : {}, Ir(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  t || !e || !e.__esModule ? Z(r, "default", { value: e, enumerable: !0 }) : r,
+  e
+)), js = (e) => Ir(Z({}, "__esModule", { value: !0 }), e);
+
+// ../node_modules/picocolors/picocolors.js
+var Ar = p((Ol, pt) => {
+  var xe = process || {}, Cr = xe.argv || [], be = xe.env || {}, Ns = !(be.NO_COLOR || Cr.includes("--no-color")) && (!!be.FORCE_COLOR || Cr.
+  includes("--color") || xe.platform === "win32" || (xe.stdout || {}).isTTY && be.TERM !== "dumb" || !!be.CI), Bs = /* @__PURE__ */ o((e, t, r = e) => (n) => {
+    let i = "" + n, s = i.indexOf(t, e.length);
+    return ~s ? e + Ds(i, t, r, s) + t : e + i + t;
+  }, "formatter"), Ds = /* @__PURE__ */ o((e, t, r, n) => {
+    let i = "", s = 0;
+    do
+      i += e.substring(s, n) + r, s = n + t.length, n = e.indexOf(t, s);
+    while (~n);
+    return i + e.substring(s);
+  }, "replaceClose"), Or = /* @__PURE__ */ o((e = Ns) => {
+    let t = e ? Bs : () => String;
+    return {
+      isColorSupported: e,
+      reset: t("\x1B[0m", "\x1B[0m"),
+      bold: t("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: t("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: t("\x1B[3m", "\x1B[23m"),
+      underline: t("\x1B[4m", "\x1B[24m"),
+      inverse: t("\x1B[7m", "\x1B[27m"),
+      hidden: t("\x1B[8m", "\x1B[28m"),
+      strikethrough: t("\x1B[9m", "\x1B[29m"),
+      black: t("\x1B[30m", "\x1B[39m"),
+      red: t("\x1B[31m", "\x1B[39m"),
+      green: t("\x1B[32m", "\x1B[39m"),
+      yellow: t("\x1B[33m", "\x1B[39m"),
+      blue: t("\x1B[34m", "\x1B[39m"),
+      magenta: t("\x1B[35m", "\x1B[39m"),
+      cyan: t("\x1B[36m", "\x1B[39m"),
+      white: t("\x1B[37m", "\x1B[39m"),
+      gray: t("\x1B[90m", "\x1B[39m"),
+      bgBlack: t("\x1B[40m", "\x1B[49m"),
+      bgRed: t("\x1B[41m", "\x1B[49m"),
+      bgGreen: t("\x1B[42m", "\x1B[49m"),
+      bgYellow: t("\x1B[43m", "\x1B[49m"),
+      bgBlue: t("\x1B[44m", "\x1B[49m"),
+      bgMagenta: t("\x1B[45m", "\x1B[49m"),
+      bgCyan: t("\x1B[46m", "\x1B[49m"),
+      bgWhite: t("\x1B[47m", "\x1B[49m"),
+      blackBright: t("\x1B[90m", "\x1B[39m"),
+      redBright: t("\x1B[91m", "\x1B[39m"),
+      greenBright: t("\x1B[92m", "\x1B[39m"),
+      yellowBright: t("\x1B[93m", "\x1B[39m"),
+      blueBright: t("\x1B[94m", "\x1B[39m"),
+      magentaBright: t("\x1B[95m", "\x1B[39m"),
+      cyanBright: t("\x1B[96m", "\x1B[39m"),
+      whiteBright: t("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: t("\x1B[100m", "\x1B[49m"),
+      bgRedBright: t("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: t("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: t("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: t("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: t("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: t("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: t("\x1B[107m", "\x1B[49m")
+    };
+  }, "createColors");
+  pt.exports = Or();
+  pt.exports.createColors = Or;
+});
+
+// ../node_modules/isexe/windows.js
+var Mr = p((Nl, Dr) => {
+  Dr.exports = Br;
+  Br.sync = Ls;
+  var jr = require("fs");
+  function Ms(e, t) {
+    var r = t.pathExt !== void 0 ? t.pathExt : process.env.PATHEXT;
+    if (!r || (r = r.split(";"), r.indexOf("") !== -1))
+      return !0;
+    for (var n = 0; n < r.length; n++) {
+      var i = r[n].toLowerCase();
+      if (i && e.substr(-i.length).toLowerCase() === i)
+        return !0;
+    }
+    return !1;
+  }
+  o(Ms, "checkPathExt");
+  function Nr(e, t, r) {
+    return !e.isSymbolicLink() && !e.isFile() ? !1 : Ms(t, r);
+  }
+  o(Nr, "checkStat");
+  function Br(e, t, r) {
+    jr.stat(e, function(n, i) {
+      r(n, n ? !1 : Nr(i, e, t));
+    });
+  }
+  o(Br, "isexe");
+  function Ls(e, t) {
+    return Nr(jr.statSync(e), e, t);
+  }
+  o(Ls, "sync");
+});
+
+// ../node_modules/isexe/mode.js
+var qr = p((Dl, $r) => {
+  $r.exports = Fr;
+  Fr.sync = Fs;
+  var Lr = require("fs");
+  function Fr(e, t, r) {
+    Lr.stat(e, function(n, i) {
+      r(n, n ? !1 : Ur(i, t));
+    });
+  }
+  o(Fr, "isexe");
+  function Fs(e, t) {
+    return Ur(Lr.statSync(e), t);
+  }
+  o(Fs, "sync");
+  function Ur(e, t) {
+    return e.isFile() && Us(e, t);
+  }
+  o(Ur, "checkStat");
+  function Us(e, t) {
+    var r = e.mode, n = 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), l = parseInt("001", 8), f = c | u, x = r & l || r & u && i ===
+    a || r & c && n === s || r & f && s === 0;
+    return x;
+  }
+  o(Us, "checkMode");
+});
+
+// ../node_modules/isexe/index.js
+var Hr = p((Fl, Wr) => {
+  var Ll = require("fs"), we;
+  process.platform === "win32" || global.TESTING_WINDOWS ? we = Mr() : we = qr();
+  Wr.exports = yt;
+  yt.sync = $s;
+  function yt(e, t, r) {
+    if (typeof t == "function" && (r = t, t = {}), !r) {
+      if (typeof Promise != "function")
+        throw new TypeError("callback not provided");
+      return new Promise(function(n, i) {
+        yt(e, t || {}, function(s, a) {
+          s ? i(s) : n(a);
+        });
+      });
+    }
+    we(e, t || {}, function(n, i) {
+      n && (n.code === "EACCES" || t && t.ignoreErrors) && (n = null, i = !1), r(n, i);
+    });
+  }
+  o(yt, "isexe");
+  function $s(e, t) {
+    try {
+      return we.sync(e, t || {});
+    } catch (r) {
+      if (t && t.ignoreErrors || r.code === "EACCES")
+        return !1;
+      throw r;
+    }
+  }
+  o($s, "sync");
+});
+
+// ../node_modules/cross-spawn/node_modules/which/which.js
+var Qr = p(($l, Xr) => {
+  var U = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", Vr = require("path"), qs = U ? "\
+;" : ":", zr = Hr(), Jr = /* @__PURE__ */ o((e) => Object.assign(new Error(`not found: ${e}`), { code: "ENOENT" }), "getNotFoundError"), Kr = /* @__PURE__ */ o(
+  (e, t) => {
+    let r = t.colon || qs, n = e.match(/\//) || U && e.match(/\\/) ? [""] : [
+      // windows always checks the cwd first
+      ...U ? [process.cwd()] : [],
+      ...(t.path || process.env.PATH || /* istanbul ignore next: very unusual */
+      "").split(r)
+    ], i = U ? t.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", s = U ? i.split(r) : [""];
+    return U && e.indexOf(".") !== -1 && s[0] !== "" && s.unshift(""), {
+      pathEnv: n,
+      pathExt: s,
+      pathExtExe: i
+    };
+  }, "getPathInfo"), Yr = /* @__PURE__ */ o((e, t, r) => {
+    typeof t == "function" && (r = t, t = {}), t || (t = {});
+    let { pathEnv: n, pathExt: i, pathExtExe: s } = Kr(e, t), a = [], c = /* @__PURE__ */ o((l) => new Promise((f, x) => {
+      if (l === n.length)
+        return t.all && a.length ? f(a) : x(Jr(e));
+      let g = n[l], m = /^".*"$/.test(g) ? g.slice(1, -1) : g, y = Vr.join(m, e), h = !m && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + y : y;
+      f(u(h, l, 0));
+    }), "step"), u = /* @__PURE__ */ o((l, f, x) => new Promise((g, m) => {
+      if (x === i.length)
+        return g(c(f + 1));
+      let y = i[x];
+      zr(l + y, { pathExt: s }, (h, S) => {
+        if (!h && S)
+          if (t.all)
+            a.push(l + y);
+          else
+            return g(l + y);
+        return g(u(l, f, x + 1));
+      });
+    }), "subStep");
+    return r ? c(0).then((l) => r(null, l), r) : c(0);
+  }, "which"), Ws = /* @__PURE__ */ o((e, t) => {
+    t = t || {};
+    let { pathEnv: r, pathExt: n, pathExtExe: i } = Kr(e, t), s = [];
+    for (let a = 0; a < r.length; a++) {
+      let c = r[a], u = /^".*"$/.test(c) ? c.slice(1, -1) : c, l = Vr.join(u, e), f = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + l : l;
+      for (let x = 0; x < n.length; x++) {
+        let g = f + n[x];
+        try {
+          if (zr.sync(g, { pathExt: i }))
+            if (t.all)
+              s.push(g);
+            else
+              return g;
+        } catch {
+        }
+      }
+    }
+    if (t.all && s.length)
+      return s;
+    if (t.nothrow)
+      return null;
+    throw Jr(e);
+  }, "whichSync");
+  Xr.exports = Yr;
+  Yr.sync = Ws;
+});
+
+// ../node_modules/path-key/index.js
+var bt = p((Wl, gt) => {
+  "use strict";
+  var Zr = /* @__PURE__ */ o((e = {}) => {
+    let t = e.env || process.env;
+    return (e.platform || process.platform) !== "win32" ? "PATH" : Object.keys(t).reverse().find((n) => n.toUpperCase() === "PATH") || "Path";
+  }, "pathKey");
+  gt.exports = Zr;
+  gt.exports.default = Zr;
+});
+
+// ../node_modules/cross-spawn/lib/util/resolveCommand.js
+var nn = p((Vl, rn) => {
+  "use strict";
+  var en = require("path"), Hs = Qr(), Vs = bt();
+  function tn(e, t) {
+    let r = e.options.env || process.env, n = 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 = Hs.sync(e.command, {
+        path: r[Vs({ env: r })],
+        pathExt: t ? en.delimiter : void 0
+      });
+    } catch {
+    } finally {
+      s && process.chdir(n);
+    }
+    return a && (a = en.resolve(i ? e.options.cwd : "", a)), a;
+  }
+  o(tn, "resolveCommandAttempt");
+  function zs(e) {
+    return tn(e) || tn(e, !0);
+  }
+  o(zs, "resolveCommand");
+  rn.exports = zs;
+});
+
+// ../node_modules/cross-spawn/lib/util/escape.js
+var on = p((Jl, St) => {
+  "use strict";
+  var xt = /([()\][%!^"`<>&|;, *?])/g;
+  function Js(e) {
+    return e = e.replace(xt, "^$1"), e;
+  }
+  o(Js, "escapeCommand");
+  function Ks(e, t) {
+    return e = `${e}`, e = e.replace(/(\\*)"/g, '$1$1\\"'), e = e.replace(/(\\*)$/, "$1$1"), e = `"${e}"`, e = e.replace(xt, "^$1"), t && (e =
+    e.replace(xt, "^$1")), e;
+  }
+  o(Ks, "escapeArgument");
+  St.exports.command = Js;
+  St.exports.argument = Ks;
+});
+
+// ../node_modules/shebang-regex/index.js
+var an = p((Yl, sn) => {
+  "use strict";
+  sn.exports = /^#!(.*)/;
+});
+
+// ../node_modules/shebang-command/index.js
+var un = p((Xl, cn) => {
+  "use strict";
+  var Ys = an();
+  cn.exports = (e = "") => {
+    let t = e.match(Ys);
+    if (!t)
+      return null;
+    let [r, n] = t[0].replace(/#! ?/, "").split(" "), i = r.split("/").pop();
+    return i === "env" ? n : n ? `${i} ${n}` : i;
+  };
+});
+
+// ../node_modules/cross-spawn/lib/util/readShebang.js
+var fn = p((Ql, ln) => {
+  "use strict";
+  var wt = require("fs"), Xs = un();
+  function Qs(e) {
+    let r = Buffer.alloc(150), n;
+    try {
+      n = wt.openSync(e, "r"), wt.readSync(n, r, 0, 150, 0), wt.closeSync(n);
+    } catch {
+    }
+    return Xs(r.toString());
+  }
+  o(Qs, "readShebang");
+  ln.exports = Qs;
+});
+
+// ../node_modules/cross-spawn/lib/parse.js
+var hn = p((ef, mn) => {
+  "use strict";
+  var Zs = require("path"), pn = nn(), dn = on(), ea = fn(), ta = process.platform === "win32", ra = /\.(?:com|exe)$/i, na = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function oa(e) {
+    e.file = pn(e);
+    let t = e.file && ea(e.file);
+    return t ? (e.args.unshift(e.file), e.command = t, pn(e)) : e.file;
+  }
+  o(oa, "detectShebang");
+  function ia(e) {
+    if (!ta)
+      return e;
+    let t = oa(e), r = !ra.test(t);
+    if (e.options.forceShell || r) {
+      let n = na.test(t);
+      e.command = Zs.normalize(e.command), e.command = dn.command(e.command), e.args = e.args.map((s) => dn.argument(s, n));
+      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(ia, "parseNonShell");
+  function sa(e, t, r) {
+    t && !Array.isArray(t) && (r = t, t = null), t = t ? t.slice(0) : [], r = Object.assign({}, r);
+    let n = {
+      command: e,
+      args: t,
+      options: r,
+      file: void 0,
+      original: {
+        command: e,
+        args: t
+      }
+    };
+    return r.shell ? n : ia(n);
+  }
+  o(sa, "parse");
+  mn.exports = sa;
+});
+
+// ../node_modules/cross-spawn/lib/enoent.js
+var bn = p((rf, gn) => {
+  "use strict";
+  var vt = process.platform === "win32";
+  function Pt(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(Pt, "notFoundError");
+  function aa(e, t) {
+    if (!vt)
+      return;
+    let r = e.emit;
+    e.emit = function(n, i) {
+      if (n === "exit") {
+        let s = yn(i, t, "spawn");
+        if (s)
+          return r.call(e, "error", s);
+      }
+      return r.apply(e, arguments);
+    };
+  }
+  o(aa, "hookChildProcess");
+  function yn(e, t) {
+    return vt && e === 1 && !t.file ? Pt(t.original, "spawn") : null;
+  }
+  o(yn, "verifyENOENT");
+  function ca(e, t) {
+    return vt && e === 1 && !t.file ? Pt(t.original, "spawnSync") : null;
+  }
+  o(ca, "verifyENOENTSync");
+  gn.exports = {
+    hookChildProcess: aa,
+    verifyENOENT: yn,
+    verifyENOENTSync: ca,
+    notFoundError: Pt
+  };
+});
+
+// ../node_modules/cross-spawn/index.js
+var kt = p((of, $) => {
+  "use strict";
+  var xn = require("child_process"), Et = hn(), Tt = bn();
+  function Sn(e, t, r) {
+    let n = Et(e, t, r), i = xn.spawn(n.command, n.args, n.options);
+    return Tt.hookChildProcess(i, n), i;
+  }
+  o(Sn, "spawn");
+  function ua(e, t, r) {
+    let n = Et(e, t, r), i = xn.spawnSync(n.command, n.args, n.options);
+    return i.error = i.error || Tt.verifyENOENTSync(i.status, n), i;
+  }
+  o(ua, "spawnSync");
+  $.exports = Sn;
+  $.exports.spawn = Sn;
+  $.exports.sync = ua;
+  $.exports._parse = Et;
+  $.exports._enoent = Tt;
+});
+
+// ../node_modules/execa/node_modules/strip-final-newline/index.js
+var vn = p((af, wn) => {
+  "use strict";
+  wn.exports = (e) => {
+    let t = typeof e == "string" ? `
+` : 10, r = typeof e == "string" ? "\r" : 13;
+    return e[e.length - 1] === t && (e = e.slice(0, e.length - 1)), e[e.length - 1] === r && (e = e.slice(0, e.length - 1)), e;
+  };
+});
+
+// ../node_modules/npm-run-path/index.js
+var Tn = p((cf, re) => {
+  "use strict";
+  var te = require("path"), Pn = bt(), En = /* @__PURE__ */ o((e) => {
+    e = {
+      cwd: process.cwd(),
+      path: process.env[Pn()],
+      execPath: process.execPath,
+      ...e
+    };
+    let t, r = te.resolve(e.cwd), n = [];
+    for (; t !== r; )
+      n.push(te.join(r, "node_modules/.bin")), t = r, r = te.resolve(r, "..");
+    let i = te.resolve(e.cwd, e.execPath, "..");
+    return n.push(i), n.concat(e.path).join(te.delimiter);
+  }, "npmRunPath");
+  re.exports = En;
+  re.exports.default = En;
+  re.exports.env = (e) => {
+    e = {
+      env: process.env,
+      ...e
+    };
+    let t = { ...e.env }, r = Pn({ env: t });
+    return e.path = t[r], t[r] = re.exports(e), t;
+  };
+});
+
+// ../node_modules/mimic-fn/index.js
+var In = p((lf, It) => {
+  "use strict";
+  var kn = /* @__PURE__ */ o((e, t) => {
+    for (let r of Reflect.ownKeys(t))
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    return e;
+  }, "mimicFn");
+  It.exports = kn;
+  It.exports.default = kn;
+});
+
+// ../node_modules/onetime/index.js
+var On = p((pf, Pe) => {
+  "use strict";
+  var la = In(), ve = /* @__PURE__ */ new WeakMap(), Cn = /* @__PURE__ */ o((e, t = {}) => {
+    if (typeof e != "function")
+      throw new TypeError("Expected a function");
+    let r, n = 0, i = e.displayName || e.name || "<anonymous>", s = /* @__PURE__ */ o(function(...a) {
+      if (ve.set(s, ++n), n === 1)
+        r = e.apply(this, a), e = null;
+      else if (t.throw === !0)
+        throw new Error(`Function \`${i}\` can only be called once`);
+      return r;
+    }, "onetime");
+    return la(s, e), ve.set(s, n), s;
+  }, "onetime");
+  Pe.exports = Cn;
+  Pe.exports.default = Cn;
+  Pe.exports.callCount = (e) => {
+    if (!ve.has(e))
+      throw new Error(`The given function \`${e.name}\` is not wrapped by the \`onetime\` package`);
+    return ve.get(e);
+  };
+});
+
+// ../node_modules/execa/node_modules/human-signals/build/src/core.js
+var An = p((Ee) => {
+  "use strict";
+  Object.defineProperty(Ee, "__esModule", { value: !0 });
+  Ee.SIGNALS = void 0;
+  var fa = [
+    {
+      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"
+    }
+  ];
+  Ee.SIGNALS = fa;
+});
+
+// ../node_modules/execa/node_modules/human-signals/build/src/realtime.js
+var Ct = p((q) => {
+  "use strict";
+  Object.defineProperty(q, "__esModule", { value: !0 });
+  q.SIGRTMAX = q.getRealtimeSignals = void 0;
+  var pa = /* @__PURE__ */ o(function() {
+    let e = _n - Rn + 1;
+    return Array.from({ length: e }, da);
+  }, "getRealtimeSignals");
+  q.getRealtimeSignals = pa;
+  var da = /* @__PURE__ */ o(function(e, t) {
+    return {
+      name: `SIGRT${t + 1}`,
+      number: Rn + t,
+      action: "terminate",
+      description: "Application-specific signal (realtime)",
+      standard: "posix"
+    };
+  }, "getRealtimeSignal"), Rn = 34, _n = 64;
+  q.SIGRTMAX = _n;
+});
+
+// ../node_modules/execa/node_modules/human-signals/build/src/signals.js
+var Gn = p((Te) => {
+  "use strict";
+  Object.defineProperty(Te, "__esModule", { value: !0 });
+  Te.getSignals = void 0;
+  var ma = require("os"), ha = An(), ya = Ct(), ga = /* @__PURE__ */ o(function() {
+    let e = (0, ya.getRealtimeSignals)();
+    return [...ha.SIGNALS, ...e].map(ba);
+  }, "getSignals");
+  Te.getSignals = ga;
+  var ba = /* @__PURE__ */ o(function({
+    name: e,
+    number: t,
+    description: r,
+    action: n,
+    forced: i = !1,
+    standard: s
+  }) {
+    let {
+      signals: { [e]: a }
+    } = ma.constants, c = a !== void 0;
+    return { name: e, number: c ? a : t, description: r, supported: c, action: n, forced: i, standard: s };
+  }, "normalizeSignal");
+});
+
+// ../node_modules/execa/node_modules/human-signals/build/src/main.js
+var Nn = p((W) => {
+  "use strict";
+  Object.defineProperty(W, "__esModule", { value: !0 });
+  W.signalsByNumber = W.signalsByName = void 0;
+  var xa = require("os"), jn = Gn(), Sa = Ct(), wa = /* @__PURE__ */ o(function() {
+    return (0, jn.getSignals)().reduce(va, {});
+  }, "getSignalsByName"), va = /* @__PURE__ */ o(function(e, { name: t, number: r, description: n, supported: i, action: s, forced: a, standard: c }) {
+    return {
+      ...e,
+      [t]: { name: t, number: r, description: n, supported: i, action: s, forced: a, standard: c }
+    };
+  }, "getSignalByName"), Pa = wa();
+  W.signalsByName = Pa;
+  var Ea = /* @__PURE__ */ o(function() {
+    let e = (0, jn.getSignals)(), t = Sa.SIGRTMAX + 1, r = Array.from({ length: t }, (n, i) => Ta(i, e));
+    return Object.assign({}, ...r);
+  }, "getSignalsByNumber"), Ta = /* @__PURE__ */ o(function(e, t) {
+    let r = ka(e, t);
+    if (r === void 0)
+      return {};
+    let { name: n, description: i, supported: s, action: a, forced: c, standard: u } = r;
+    return {
+      [e]: {
+        name: n,
+        number: e,
+        description: i,
+        supported: s,
+        action: a,
+        forced: c,
+        standard: u
+      }
+    };
+  }, "getSignalByNumber"), ka = /* @__PURE__ */ o(function(e, t) {
+    let r = t.find(({ name: n }) => xa.constants.signals[n] === e);
+    return r !== void 0 ? r : t.find((n) => n.number === e);
+  }, "findSignalByNumber"), Ia = Ea();
+  W.signalsByNumber = Ia;
+});
+
+// ../node_modules/execa/lib/error.js
+var Dn = p((wf, Bn) => {
+  "use strict";
+  var { signalsByName: Ca } = Nn(), Oa = /* @__PURE__ */ o(({ timedOut: e, timeout: t, errorCode: r, signal: n, signalDescription: i, exitCode: s,
+  isCanceled: a }) => e ? `timed out after ${t} milliseconds` : a ? "was canceled" : r !== void 0 ? `failed with ${r}` : n !== void 0 ? `was\
+ killed with ${n} (${i})` : s !== void 0 ? `failed with exit code ${s}` : "failed", "getErrorPrefix"), Aa = /* @__PURE__ */ o(({
+    stdout: e,
+    stderr: t,
+    all: r,
+    error: n,
+    signal: i,
+    exitCode: s,
+    command: a,
+    escapedCommand: c,
+    timedOut: u,
+    isCanceled: l,
+    killed: f,
+    parsed: { options: { timeout: x } }
+  }) => {
+    s = s === null ? void 0 : s, i = i === null ? void 0 : i;
+    let g = i === void 0 ? void 0 : Ca[i].description, m = n && n.code, h = `Command ${Oa({ timedOut: u, timeout: x, errorCode: m, signal: i,
+    signalDescription: g, exitCode: s, isCanceled: l })}: ${a}`, S = Object.prototype.toString.call(n) === "[object Error]", k = S ? `${h}
+${n.message}` : h, E = [k, t, e].filter(Boolean).join(`
+`);
+    return S ? (n.originalMessage = n.message, n.message = E) : n = new Error(E), n.shortMessage = k, n.command = a, n.escapedCommand = c, n.
+    exitCode = s, n.signal = i, n.signalDescription = g, n.stdout = e, n.stderr = t, r !== void 0 && (n.all = r), "bufferedData" in n && delete n.
+    bufferedData, n.failed = !0, n.timedOut = !!u, n.isCanceled = l, n.killed = f && !u, n;
+  }, "makeError");
+  Bn.exports = Aa;
+});
+
+// ../node_modules/execa/lib/stdio.js
+var Ln = p((Pf, Ot) => {
+  "use strict";
+  var ke = ["stdin", "stdout", "stderr"], Ra = /* @__PURE__ */ o((e) => ke.some((t) => e[t] !== void 0), "hasAlias"), Mn = /* @__PURE__ */ o(
+  (e) => {
+    if (!e)
+      return;
+    let { stdio: t } = e;
+    if (t === void 0)
+      return ke.map((n) => e[n]);
+    if (Ra(e))
+      throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${ke.map((n) => `\`${n}\``).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 r = Math.max(t.length, ke.length);
+    return Array.from({ length: r }, (n, i) => t[i]);
+  }, "normalizeStdio");
+  Ot.exports = Mn;
+  Ot.exports.node = (e) => {
+    let t = Mn(e);
+    return t === "ipc" ? "ipc" : t === void 0 || typeof t == "string" ? [t, t, t, "ipc"] : t.includes("ipc") ? t : [...t, "ipc"];
+  };
+});
+
+// ../node_modules/signal-exit/signals.js
+var Fn = p((Tf, Ie) => {
+  Ie.exports = [
+    "SIGABRT",
+    "SIGALRM",
+    "SIGHUP",
+    "SIGINT",
+    "SIGTERM"
+  ];
+  process.platform !== "win32" && Ie.exports.push(
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+  process.platform === "linux" && Ie.exports.push(
+    "SIGIO",
+    "SIGPOLL",
+    "SIGPWR",
+    "SIGSTKFLT",
+    "SIGUNUSED"
+  );
+});
+
+// ../node_modules/signal-exit/index.js
+var Hn = p((kf, z) => {
+  var w = global.process, j = /* @__PURE__ */ o(function(e) {
+    return e && typeof e == "object" && typeof e.removeListener == "function" && typeof e.emit == "function" && typeof e.reallyExit == "func\
+tion" && typeof e.listeners == "function" && typeof e.kill == "function" && typeof e.pid == "number" && typeof e.on == "function";
+  }, "processOk");
+  j(w) ? (Un = require("assert"), H = Fn(), $n = /^win/i.test(w.platform), ne = require("events"), typeof ne != "function" && (ne = ne.EventEmitter),
+  w.__signal_exit_emitter__ ? P = w.__signal_exit_emitter__ : (P = w.__signal_exit_emitter__ = new ne(), P.count = 0, P.emitted = {}), P.infinite ||
+  (P.setMaxListeners(1 / 0), P.infinite = !0), z.exports = function(e, t) {
+    if (!j(global.process))
+      return function() {
+      };
+    Un.equal(typeof e, "function", "a callback must be provided for exit handler"), V === !1 && At();
+    var r = "exit";
+    t && t.alwaysLast && (r = "afterexit");
+    var n = /* @__PURE__ */ o(function() {
+      P.removeListener(r, e), P.listeners("exit").length === 0 && P.listeners("afterexit").length === 0 && Ce();
+    }, "remove");
+    return P.on(r, e), n;
+  }, Ce = /* @__PURE__ */ o(function() {
+    !V || !j(global.process) || (V = !1, H.forEach(function(t) {
+      try {
+        w.removeListener(t, Oe[t]);
+      } catch {
+      }
+    }), w.emit = Ae, w.reallyExit = Rt, P.count -= 1);
+  }, "unload"), z.exports.unload = Ce, N = /* @__PURE__ */ o(function(t, r, n) {
+    P.emitted[t] || (P.emitted[t] = !0, P.emit(t, r, n));
+  }, "emit"), Oe = {}, H.forEach(function(e) {
+    Oe[e] = /* @__PURE__ */ o(function() {
+      if (j(global.process)) {
+        var r = w.listeners(e);
+        r.length === P.count && (Ce(), N("exit", null, e), N("afterexit", null, e), $n && e === "SIGHUP" && (e = "SIGINT"), w.kill(w.pid, e));
+      }
+    }, "listener");
+  }), z.exports.signals = function() {
+    return H;
+  }, V = !1, At = /* @__PURE__ */ o(function() {
+    V || !j(global.process) || (V = !0, P.count += 1, H = H.filter(function(t) {
+      try {
+        return w.on(t, Oe[t]), !0;
+      } catch {
+        return !1;
+      }
+    }), w.emit = Wn, w.reallyExit = qn);
+  }, "load"), z.exports.load = At, Rt = w.reallyExit, qn = /* @__PURE__ */ o(function(t) {
+    j(global.process) && (w.exitCode = t || /* istanbul ignore next */
+    0, N("exit", w.exitCode, null), N("afterexit", w.exitCode, null), Rt.call(w, w.exitCode));
+  }, "processReallyExit"), Ae = w.emit, Wn = /* @__PURE__ */ o(function(t, r) {
+    if (t === "exit" && j(global.process)) {
+      r !== void 0 && (w.exitCode = r);
+      var n = Ae.apply(this, arguments);
+      return N("exit", w.exitCode, null), N("afterexit", w.exitCode, null), n;
+    } else
+      return Ae.apply(this, arguments);
+  }, "processEmit")) : z.exports = function() {
+    return function() {
+    };
+  };
+  var Un, H, $n, ne, P, Ce, N, Oe, V, At, Rt, qn, Ae, Wn;
+});
+
+// ../node_modules/execa/lib/kill.js
+var zn = p((Cf, Vn) => {
+  "use strict";
+  var _a = require("os"), Ga = Hn(), ja = 1e3 * 5, Na = /* @__PURE__ */ o((e, t = "SIGTERM", r = {}) => {
+    let n = e(t);
+    return Ba(e, t, r, n), n;
+  }, "spawnedKill"), Ba = /* @__PURE__ */ o((e, t, r, n) => {
+    if (!Da(t, r, n))
+      return;
+    let i = La(r), s = setTimeout(() => {
+      e("SIGKILL");
+    }, i);
+    s.unref && s.unref();
+  }, "setKillTimeout"), Da = /* @__PURE__ */ o((e, { forceKillAfterTimeout: t }, r) => Ma(e) && t !== !1 && r, "shouldForceKill"), Ma = /* @__PURE__ */ o(
+  (e) => e === _a.constants.signals.SIGTERM || typeof e == "string" && e.toUpperCase() === "SIGTERM", "isSigterm"), La = /* @__PURE__ */ o(({
+  forceKillAfterTimeout: e = !0 }) => {
+    if (e === !0)
+      return ja;
+    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"), Fa = /* @__PURE__ */ o((e, t) => {
+    e.kill() && (t.isCanceled = !0);
+  }, "spawnedCancel"), Ua = /* @__PURE__ */ o((e, t, r) => {
+    e.kill(t), r(Object.assign(new Error("Timed out"), { timedOut: !0, signal: t }));
+  }, "timeoutKill"), $a = /* @__PURE__ */ o((e, { timeout: t, killSignal: r = "SIGTERM" }, n) => {
+    if (t === 0 || t === void 0)
+      return n;
+    let i, s = new Promise((c, u) => {
+      i = setTimeout(() => {
+        Ua(e, r, u);
+      }, t);
+    }), a = n.finally(() => {
+      clearTimeout(i);
+    });
+    return Promise.race([s, a]);
+  }, "setupTimeout"), qa = /* @__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"), Wa = /* @__PURE__ */ o(async (e, { cleanup: t, detached: r }, n) => {
+    if (!t || r)
+      return n;
+    let i = Ga(() => {
+      e.kill();
+    });
+    return n.finally(() => {
+      i();
+    });
+  }, "setExitHandler");
+  Vn.exports = {
+    spawnedKill: Na,
+    spawnedCancel: Fa,
+    setupTimeout: $a,
+    validateTimeout: qa,
+    setExitHandler: Wa
+  };
+});
+
+// ../node_modules/is-stream/index.js
+var Kn = p((Af, Jn) => {
+  "use strict";
+  var C = /* @__PURE__ */ o((e) => e !== null && typeof e == "object" && typeof e.pipe == "function", "isStream");
+  C.writable = (e) => C(e) && e.writable !== !1 && typeof e._write == "function" && typeof e._writableState == "object";
+  C.readable = (e) => C(e) && e.readable !== !1 && typeof e._read == "function" && typeof e._readableState == "object";
+  C.duplex = (e) => C.writable(e) && C.readable(e);
+  C.transform = (e) => C.duplex(e) && typeof e._transform == "function";
+  Jn.exports = C;
+});
+
+// ../node_modules/get-stream/buffer-stream.js
+var Xn = p((_f, Yn) => {
+  "use strict";
+  var { PassThrough: Ha } = require("stream");
+  Yn.exports = (e) => {
+    e = { ...e };
+    let { array: t } = e, { encoding: r } = e, n = r === "buffer", i = !1;
+    t ? i = !(r || n) : r = r || "utf8", n && (r = null);
+    let s = new Ha({ objectMode: i });
+    r && s.setEncoding(r);
+    let a = 0, c = [];
+    return s.on("data", (u) => {
+      c.push(u), i ? a = c.length : a += u.length;
+    }), s.getBufferedValue = () => t ? c : n ? Buffer.concat(c, a) : c.join(""), s.getBufferedLength = () => a, s;
+  };
+});
+
+// ../node_modules/get-stream/index.js
+var Qn = p((Gf, oe) => {
+  "use strict";
+  var { constants: Va } = require("buffer"), za = require("stream"), { promisify: Ja } = require("util"), Ka = Xn(), Ya = Ja(za.pipeline), Re = class extends Error {
+    static {
+      o(this, "MaxBufferError");
+    }
+    constructor() {
+      super("maxBuffer exceeded"), this.name = "MaxBufferError";
+    }
+  };
+  async function _t(e, t) {
+    if (!e)
+      throw new Error("Expected a stream");
+    t = {
+      maxBuffer: 1 / 0,
+      ...t
+    };
+    let { maxBuffer: r } = t, n = Ka(t);
+    return await new Promise((i, s) => {
+      let a = /* @__PURE__ */ o((c) => {
+        c && n.getBufferedLength() <= Va.MAX_LENGTH && (c.bufferedData = n.getBufferedValue()), s(c);
+      }, "rejectPromise");
+      (async () => {
+        try {
+          await Ya(e, n), i();
+        } catch (c) {
+          a(c);
+        }
+      })(), n.on("data", () => {
+        n.getBufferedLength() > r && a(new Re());
+      });
+    }), n.getBufferedValue();
+  }
+  o(_t, "getStream");
+  oe.exports = _t;
+  oe.exports.buffer = (e, t) => _t(e, { ...t, encoding: "buffer" });
+  oe.exports.array = (e, t) => _t(e, { ...t, array: !0 });
+  oe.exports.MaxBufferError = Re;
+});
+
+// ../node_modules/merge-stream/index.js
+var Gt = p((Nf, Zn) => {
+  "use strict";
+  var { PassThrough: Xa } = require("stream");
+  Zn.exports = function() {
+    var e = [], t = new Xa({ objectMode: !0 });
+    return t.setMaxListeners(0), t.add = r, t.isEmpty = n, t.on("unpipe", i), Array.prototype.slice.call(arguments).forEach(r), t;
+    function r(s) {
+      return Array.isArray(s) ? (s.forEach(r), 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(r, "add");
+    function n() {
+      return e.length == 0;
+    }
+    o(n, "isEmpty");
+    function i(s) {
+      e = e.filter(function(a) {
+        return a !== s;
+      }), !e.length && t.readable && t.end();
+    }
+    o(i, "remove");
+  };
+});
+
+// ../node_modules/execa/lib/stream.js
+var no = p((Df, ro) => {
+  "use strict";
+  var to = Kn(), eo = Qn(), Qa = Gt(), Za = /* @__PURE__ */ o((e, t) => {
+    t === void 0 || e.stdin === void 0 || (to(t) ? t.pipe(e.stdin) : e.stdin.end(t));
+  }, "handleInput"), ec = /* @__PURE__ */ o((e, { all: t }) => {
+    if (!t || !e.stdout && !e.stderr)
+      return;
+    let r = Qa();
+    return e.stdout && r.add(e.stdout), e.stderr && r.add(e.stderr), r;
+  }, "makeAllStream"), jt = /* @__PURE__ */ o(async (e, t) => {
+    if (e) {
+      e.destroy();
+      try {
+        return await t;
+      } catch (r) {
+        return r.bufferedData;
+      }
+    }
+  }, "getBufferedData"), Nt = /* @__PURE__ */ o((e, { encoding: t, buffer: r, maxBuffer: n }) => {
+    if (!(!e || !r))
+      return t ? eo(e, { encoding: t, maxBuffer: n }) : eo.buffer(e, { maxBuffer: n });
+  }, "getStreamPromise"), tc = /* @__PURE__ */ o(async ({ stdout: e, stderr: t, all: r }, { encoding: n, buffer: i, maxBuffer: s }, a) => {
+    let c = Nt(e, { encoding: n, buffer: i, maxBuffer: s }), u = Nt(t, { encoding: n, buffer: i, maxBuffer: s }), l = Nt(r, { encoding: n, buffer: i,
+    maxBuffer: s * 2 });
+    try {
+      return await Promise.all([a, c, u, l]);
+    } catch (f) {
+      return Promise.all([
+        { error: f, signal: f.signal, timedOut: f.timedOut },
+        jt(e, c),
+        jt(t, u),
+        jt(r, l)
+      ]);
+    }
+  }, "getSpawnedResult"), rc = /* @__PURE__ */ o(({ input: e }) => {
+    if (to(e))
+      throw new TypeError("The `input` option cannot be a stream in sync mode");
+  }, "validateInputSync");
+  ro.exports = {
+    handleInput: Za,
+    makeAllStream: ec,
+    getSpawnedResult: tc,
+    validateInputSync: rc
+  };
+});
+
+// ../node_modules/execa/lib/promise.js
+var io = p((Lf, oo) => {
+  "use strict";
+  var nc = (async () => {
+  })().constructor.prototype, oc = ["then", "catch", "finally"].map((e) => [
+    e,
+    Reflect.getOwnPropertyDescriptor(nc, e)
+  ]), ic = /* @__PURE__ */ o((e, t) => {
+    for (let [r, n] of oc) {
+      let i = typeof t == "function" ? (...s) => Reflect.apply(n.value, t(), s) : n.value.bind(t);
+      Reflect.defineProperty(e, r, { ...n, value: i });
+    }
+    return e;
+  }, "mergePromise"), sc = /* @__PURE__ */ o((e) => new Promise((t, r) => {
+    e.on("exit", (n, i) => {
+      t({ exitCode: n, signal: i });
+    }), e.on("error", (n) => {
+      r(n);
+    }), e.stdin && e.stdin.on("error", (n) => {
+      r(n);
+    });
+  }), "getSpawnedPromise");
+  oo.exports = {
+    mergePromise: ic,
+    getSpawnedPromise: sc
+  };
+});
+
+// ../node_modules/execa/lib/command.js
+var co = p((Uf, ao) => {
+  "use strict";
+  var so = /* @__PURE__ */ o((e, t = []) => Array.isArray(t) ? [e, ...t] : [e], "normalizeArgs"), ac = /^[\w.-]+$/, cc = /"/g, uc = /* @__PURE__ */ o(
+  (e) => typeof e != "string" || ac.test(e) ? e : `"${e.replace(cc, '\\"')}"`, "escapeArg"), lc = /* @__PURE__ */ o((e, t) => so(e, t).join(
+  " "), "joinCommand"), fc = /* @__PURE__ */ o((e, t) => so(e, t).map((r) => uc(r)).join(" "), "getEscapedCommand"), pc = / +/g, dc = /* @__PURE__ */ o(
+  (e) => {
+    let t = [];
+    for (let r of e.trim().split(pc)) {
+      let n = t[t.length - 1];
+      n && n.endsWith("\\") ? t[t.length - 1] = `${n.slice(0, -1)} ${r}` : t.push(r);
+    }
+    return t;
+  }, "parseCommand");
+  ao.exports = {
+    joinCommand: lc,
+    getEscapedCommand: fc,
+    parseCommand: dc
+  };
+});
+
+// ../node_modules/execa/index.js
+var yo = p((qf, J) => {
+  "use strict";
+  var mc = require("path"), Bt = require("child_process"), hc = kt(), yc = vn(), gc = Tn(), bc = On(), _e = Dn(), lo = Ln(), { spawnedKill: xc,
+  spawnedCancel: Sc, setupTimeout: wc, validateTimeout: vc, setExitHandler: Pc } = zn(), { handleInput: Ec, getSpawnedResult: Tc, makeAllStream: kc,
+  validateInputSync: Ic } = no(), { mergePromise: uo, getSpawnedPromise: Cc } = io(), { joinCommand: fo, parseCommand: po, getEscapedCommand: mo } = co(),
+  Oc = 1e3 * 1e3 * 100, Ac = /* @__PURE__ */ o(({ env: e, extendEnv: t, preferLocal: r, localDir: n, execPath: i }) => {
+    let s = t ? { ...process.env, ...e } : e;
+    return r ? gc.env({ env: s, cwd: n, execPath: i }) : s;
+  }, "getEnv"), ho = /* @__PURE__ */ o((e, t, r = {}) => {
+    let n = hc._parse(e, t, r);
+    return e = n.command, t = n.args, r = n.options, r = {
+      maxBuffer: Oc,
+      buffer: !0,
+      stripFinalNewline: !0,
+      extendEnv: !0,
+      preferLocal: !1,
+      localDir: r.cwd || process.cwd(),
+      execPath: process.execPath,
+      encoding: "utf8",
+      reject: !0,
+      cleanup: !0,
+      all: !1,
+      windowsHide: !0,
+      ...r
+    }, r.env = Ac(r), r.stdio = lo(r), process.platform === "win32" && mc.basename(e, ".exe") === "cmd" && t.unshift("/q"), { file: e, args: t,
+    options: r, parsed: n };
+  }, "handleArguments"), ie = /* @__PURE__ */ o((e, t, r) => typeof t != "string" && !Buffer.isBuffer(t) ? r === void 0 ? void 0 : "" : e.stripFinalNewline ?
+  yc(t) : t, "handleOutput"), Ge = /* @__PURE__ */ o((e, t, r) => {
+    let n = ho(e, t, r), i = fo(e, t), s = mo(e, t);
+    vc(n.options);
+    let a;
+    try {
+      a = Bt.spawn(n.file, n.args, n.options);
+    } catch (m) {
+      let y = new Bt.ChildProcess(), h = Promise.reject(_e({
+        error: m,
+        stdout: "",
+        stderr: "",
+        all: "",
+        command: i,
+        escapedCommand: s,
+        parsed: n,
+        timedOut: !1,
+        isCanceled: !1,
+        killed: !1
+      }));
+      return uo(y, h);
+    }
+    let c = Cc(a), u = wc(a, n.options, c), l = Pc(a, n.options, u), f = { isCanceled: !1 };
+    a.kill = xc.bind(null, a.kill.bind(a)), a.cancel = Sc.bind(null, a, f);
+    let g = bc(/* @__PURE__ */ o(async () => {
+      let [{ error: m, exitCode: y, signal: h, timedOut: S }, k, E, O] = await Tc(a, n.options, l), _ = ie(n.options, k), G = ie(n.options, E),
+      d = ie(n.options, O);
+      if (m || y !== 0 || h !== null) {
+        let v = _e({
+          error: m,
+          exitCode: y,
+          signal: h,
+          stdout: _,
+          stderr: G,
+          all: d,
+          command: i,
+          escapedCommand: s,
+          parsed: n,
+          timedOut: S,
+          isCanceled: f.isCanceled,
+          killed: a.killed
+        });
+        if (!n.options.reject)
+          return v;
+        throw v;
+      }
+      return {
+        command: i,
+        escapedCommand: s,
+        exitCode: 0,
+        stdout: _,
+        stderr: G,
+        all: d,
+        failed: !1,
+        timedOut: !1,
+        isCanceled: !1,
+        killed: !1
+      };
+    }, "handlePromise"));
+    return Ec(a, n.options.input), a.all = kc(a, n.options), uo(a, g);
+  }, "execa");
+  J.exports = Ge;
+  J.exports.sync = (e, t, r) => {
+    let n = ho(e, t, r), i = fo(e, t), s = mo(e, t);
+    Ic(n.options);
+    let a;
+    try {
+      a = Bt.spawnSync(n.file, n.args, n.options);
+    } catch (l) {
+      throw _e({
+        error: l,
+        stdout: "",
+        stderr: "",
+        all: "",
+        command: i,
+        escapedCommand: s,
+        parsed: n,
+        timedOut: !1,
+        isCanceled: !1,
+        killed: !1
+      });
+    }
+    let c = ie(n.options, a.stdout, a.error), u = ie(n.options, a.stderr, a.error);
+    if (a.error || a.status !== 0 || a.signal !== null) {
+      let l = _e({
+        stdout: c,
+        stderr: u,
+        error: a.error,
+        signal: a.signal,
+        exitCode: a.status,
+        command: i,
+        escapedCommand: s,
+        parsed: n,
+        timedOut: a.error && a.error.code === "ETIMEDOUT",
+        isCanceled: !1,
+        killed: a.signal !== null
+      });
+      if (!n.options.reject)
+        return l;
+      throw l;
+    }
+    return {
+      command: i,
+      escapedCommand: s,
+      exitCode: 0,
+      stdout: c,
+      stderr: u,
+      failed: !1,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    };
+  };
+  J.exports.command = (e, t) => {
+    let [r, ...n] = po(e);
+    return Ge(r, n, t);
+  };
+  J.exports.commandSync = (e, t) => {
+    let [r, ...n] = po(e);
+    return Ge.sync(r, n, t);
+  };
+  J.exports.node = (e, t, r = {}) => {
+    t && !Array.isArray(t) && typeof t == "object" && (r = t, t = []);
+    let n = lo.node(r), i = process.execArgv.filter((c) => !c.startsWith("--inspect")), {
+      nodePath: s = process.execPath,
+      nodeOptions: a = i
+    } = r;
+    return Ge(
+      s,
+      [
+        ...a,
+        e,
+        ...Array.isArray(t) ? t : []
+      ],
+      {
+        ...r,
+        stdin: void 0,
+        stdout: void 0,
+        stderr: void 0,
+        stdio: n,
+        shell: !1
+      }
+    );
+  };
+});
+
+// ../node_modules/detect-package-manager/dist/index.js
+var So = p((xo) => {
+  var Rc = Object.create, Be = Object.defineProperty, _c = Object.getOwnPropertyDescriptor, Gc = Object.getOwnPropertyNames, jc = Object.getPrototypeOf,
+  Nc = Object.prototype.hasOwnProperty, go = /* @__PURE__ */ o((e) => Be(e, "__esModule", { value: !0 }), "__markAsModule"), Bc = /* @__PURE__ */ o(
+  (e, t) => {
+    go(e);
+    for (var r in t)
+      Be(e, r, { get: t[r], enumerable: !0 });
+  }, "__export"), Dc = /* @__PURE__ */ o((e, t, r) => {
+    if (t && typeof t == "object" || typeof t == "function")
+      for (let n of Gc(t))
+        !Nc.call(e, n) && n !== "default" && Be(e, n, { get: /* @__PURE__ */ o(() => t[n], "get"), enumerable: !(r = _c(t, n)) || r.enumerable });
+    return e;
+  }, "__reExport"), Mt = /* @__PURE__ */ o((e) => Dc(go(Be(e != null ? Rc(jc(e)) : {}, "default", e && e.__esModule && "default" in e ? { get: /* @__PURE__ */ o(
+  () => e.default, "get"), enumerable: !0 } : { value: e, enumerable: !0 })), e), "__toModule");
+  Bc(xo, {
+    clearCache: /* @__PURE__ */ o(() => $c, "clearCache"),
+    detect: /* @__PURE__ */ o(() => Fc, "detect"),
+    getNpmVersion: /* @__PURE__ */ o(() => Uc, "getNpmVersion")
+  });
+  var Mc = Mt(require("fs")), je = Mt(require("path")), bo = Mt(yo());
+  async function Ne(e) {
+    try {
+      return await Mc.promises.access(e), !0;
+    } catch {
+      return !1;
+    }
+  }
+  o(Ne, "pathExists");
+  var B = /* @__PURE__ */ new Map();
+  function Dt(e) {
+    let t = `has_global_${e}`;
+    return B.has(t) ? Promise.resolve(B.get(t)) : (0, bo.default)(e, ["--version"]).then((r) => /^\d+.\d+.\d+$/.test(r.stdout)).then((r) => (B.
+    set(t, r), r)).catch(() => !1);
+  }
+  o(Dt, "hasGlobalInstallation");
+  function Lc(e = ".") {
+    let t = `lockfile_${e}`;
+    return B.has(t) ? Promise.resolve(B.get(t)) : Promise.all([
+      Ne((0, je.resolve)(e, "yarn.lock")),
+      Ne((0, je.resolve)(e, "package-lock.json")),
+      Ne((0, je.resolve)(e, "pnpm-lock.yaml")),
+      Ne((0, je.resolve)(e, "bun.lockb"))
+    ]).then(([r, n, i, s]) => {
+      let a = null;
+      return r ? a = "yarn" : i ? a = "pnpm" : s ? a = "bun" : n && (a = "npm"), B.set(t, a), a;
+    });
+  }
+  o(Lc, "getTypeofLockFile");
+  var Fc = /* @__PURE__ */ o(async ({
+    cwd: e,
+    includeGlobalBun: t
+  } = {}) => {
+    let r = await Lc(e);
+    if (r)
+      return r;
+    let [n, i, s] = await Promise.all([
+      Dt("yarn"),
+      Dt("pnpm"),
+      t && Dt("bun")
+    ]);
+    return n ? "yarn" : i ? "pnpm" : s ? "bun" : "npm";
+  }, "detect");
+  function Uc(e) {
+    return (0, bo.default)(e || "npm", ["--version"]).then((t) => t.stdout);
+  }
+  o(Uc, "getNpmVersion");
+  function $c() {
+    return B.clear();
+  }
+  o($c, "clearCache");
+});
+
+// ../node_modules/walk-up-path/dist/cjs/index.js
+var vo = p((De) => {
+  "use strict";
+  Object.defineProperty(De, "__esModule", { value: !0 });
+  De.walkUp = void 0;
+  var wo = require("path"), qc = /* @__PURE__ */ o(function* (e) {
+    for (e = (0, wo.resolve)(e); e; ) {
+      yield e;
+      let t = (0, wo.dirname)(e);
+      if (t === e)
+        break;
+      e = t;
+    }
+  }, "walkUp");
+  De.walkUp = qc;
+});
+
+// ../node_modules/common-path-prefix/index.js
+var Gi = p((Wd, _i) => {
+  "use strict";
+  var { sep: zu } = require("path"), Ju = /* @__PURE__ */ o((e) => {
+    for (let t of e) {
+      let r = /(\/|\\)/.exec(t);
+      if (r !== null) return r[0];
+    }
+    return zu;
+  }, "determineSeparator");
+  _i.exports = /* @__PURE__ */ o(function(t, r = Ju(t)) {
+    let [n = "", ...i] = t;
+    if (n === "" || i.length === 0) return "";
+    let s = n.split(r), a = s.length;
+    for (let u of i) {
+      let l = u.split(r);
+      for (let f = 0; f < a; f++)
+        l[f] !== s[f] && (a = f);
+      if (a === 0) return "";
+    }
+    let c = s.slice(0, a).join(r);
+    return c.endsWith(r) ? c : c + r;
+  }, "commonPathPrefix");
+});
+
+// ../node_modules/fetch-retry/index.js
+var ds = p((Wh, ps) => {
+  "use strict";
+  ps.exports = function(e, t) {
+    if (t = t || {}, typeof e != "function")
+      throw new R("fetch must be a function");
+    if (typeof t != "object")
+      throw new R("defaults must be an object");
+    if (t.retries !== void 0 && !at(t.retries))
+      throw new R("retries must be a positive integer");
+    if (t.retryDelay !== void 0 && !at(t.retryDelay) && typeof t.retryDelay != "function")
+      throw new R("retryDelay must be a positive integer or a function returning a positive integer");
+    if (t.retryOn !== void 0 && !Array.isArray(t.retryOn) && typeof t.retryOn != "function")
+      throw new R("retryOn property expects an array or function");
+    var r = {
+      retries: 3,
+      retryDelay: 1e3,
+      retryOn: []
+    };
+    return t = Object.assign(r, t), /* @__PURE__ */ o(function(i, s) {
+      var a = t.retries, c = t.retryDelay, u = t.retryOn;
+      if (s && s.retries !== void 0)
+        if (at(s.retries))
+          a = s.retries;
+        else
+          throw new R("retries must be a positive integer");
+      if (s && s.retryDelay !== void 0)
+        if (at(s.retryDelay) || typeof s.retryDelay == "function")
+          c = s.retryDelay;
+        else
+          throw new R("retryDelay must be a positive integer or a function returning a positive integer");
+      if (s && s.retryOn)
+        if (Array.isArray(s.retryOn) || typeof s.retryOn == "function")
+          u = s.retryOn;
+        else
+          throw new R("retryOn property expects an array or function");
+      return new Promise(function(l, f) {
+        var x = /* @__PURE__ */ o(function(m) {
+          var y = typeof Request < "u" && i instanceof Request ? i.clone() : i;
+          e(y, s).then(function(h) {
+            if (Array.isArray(u) && u.indexOf(h.status) === -1)
+              l(h);
+            else if (typeof u == "function")
+              try {
+                return Promise.resolve(u(m, null, h)).then(function(S) {
+                  S ? g(m, null, h) : l(h);
+                }).catch(f);
+              } catch (S) {
+                f(S);
+              }
+            else
+              m < a ? g(m, null, h) : l(h);
+          }).catch(function(h) {
+            if (typeof u == "function")
+              try {
+                Promise.resolve(u(m, h, null)).then(function(S) {
+                  S ? g(m, h, null) : f(h);
+                }).catch(function(S) {
+                  f(S);
+                });
+              } catch (S) {
+                f(S);
+              }
+            else m < a ? g(m, h, null) : f(h);
+          });
+        }, "wrappedFetch");
+        function g(m, y, h) {
+          var S = typeof c == "function" ? c(m, y, h) : c;
+          setTimeout(function() {
+            x(++m);
+          }, S);
+        }
+        o(g, "retry"), x(0);
+      });
+    }, "fetchRetry");
+  };
+  function at(e) {
+    return Number.isInteger(e) && e >= 0;
+  }
+  o(at, "isPositiveInteger");
+  function R(e) {
+    this.name = "ArgumentError", this.message = e;
+  }
+  o(R, "ArgumentError");
+});
+
+// src/telemetry/index.ts
+var Il = {};
+Gs(Il, {
+  addToGlobalContext: () => ks,
+  cleanPaths: () => F,
+  computeStorybookMetadata: () => fs,
+  getPrecedingUpgrade: () => vs,
+  getStorybookMetadata: () => Sr,
+  isExampleStoryId: () => Tl,
+  metaFrameworks: () => br,
+  oneWayHash: () => ct,
+  removeAnsiEscapeCodes: () => mt,
+  sanitizeAddonName: () => xr,
+  sanitizeError: () => ee,
+  telemetry: () => kl
+});
+module.exports = js(Il);
+var kr = require("storybook/internal/node-logger");
+
+// src/telemetry/notify.ts
+var dt = require("storybook/internal/common"), Se = b(Ar(), 1);
+var Rr = "telemetry-notification-date", L = console, _r = /* @__PURE__ */ o(async () => {
+  await dt.cache.get(Rr, null) || (dt.cache.set(Rr, Date.now()), L.log(), L.log(
+    `${Se.default.magenta(
+      Se.default.bold("attention")
+    )} => Storybook now collects completely anonymous telemetry regarding usage.`
+  ), L.log("This information is used to shape Storybook's roadmap and prioritize features."), L.log(
+    "You can learn more, including how to opt-out if you'd not like to participate in this anonymous program, by visiting the following URL:"
+  ), L.log(Se.default.cyan("https://storybook.js.org/telemetry")), L.log());
+}, "notify");
+
+// src/telemetry/sanitize.ts
+var ht = b(require("node:path"), 1);
+function Gr(e) {
+  return e.replace(/[-[/{}()*+?.\\^$|]/g, "\\$&");
+}
+o(Gr, "regexpEscape");
+function mt(e = "") {
+  return e.replace(/\u001B\[[0-9;]*m/g, "");
+}
+o(mt, "removeAnsiEscapeCodes");
+function F(e, t = ht.default.sep) {
+  if (!e)
+    return e;
+  let r = process.cwd().split(t);
+  for (; r.length > 1; ) {
+    let n = r.join(t), i = new RegExp(Gr(n), "gi");
+    e = e.replace(i, "$SNIP");
+    let s = r.join(t + t), a = new RegExp(Gr(s), "gi");
+    e = e.replace(a, "$SNIP"), r.pop();
+  }
+  return e;
+}
+o(F, "cleanPaths");
+function ee(e, t = ht.default.sep) {
+  try {
+    e = {
+      ...JSON.parse(JSON.stringify(e)),
+      message: mt(e.message),
+      stack: mt(e.stack),
+      cause: e.cause,
+      name: e.name
+    };
+    let r = F(JSON.stringify(e), t);
+    return JSON.parse(r);
+  } catch (r) {
+    return `Sanitization error: ${r?.message}`;
+  }
+}
+o(ee, "sanitizeError");
+
+// src/telemetry/storybook-metadata.ts
+var us = require("node:path"), A = require("storybook/internal/common"), ls = require("storybook/internal/csf-tools"), st = b(So(), 1);
+
+// ../node_modules/fd-package-json/dist/esm/main.js
+var Po = b(vo(), 1), Eo = require("node:path"), Me = require("node:fs/promises"), To = require("node:fs");
+async function Wc(e) {
+  try {
+    return (await (0, Me.stat)(e)).isFile();
+  } catch {
+    return !1;
+  }
+}
+o(Wc, "fileExists");
+async function Lt(e) {
+  for (let t of (0, Po.walkUp)(e)) {
+    let r = (0, Eo.resolve)(t, "package.json");
+    if (await Wc(r))
+      return r;
+  }
+  return null;
+}
+o(Lt, "findPackagePath");
+async function ko(e) {
+  let t = await Lt(e);
+  if (!t)
+    return null;
+  try {
+    let r = await (0, Me.readFile)(t, { encoding: "utf8" });
+    return JSON.parse(r);
+  } catch {
+    return null;
+  }
+}
+o(ko, "findPackage");
+
+// src/telemetry/get-application-file-count.ts
+var Ki = require("node:path");
+
+// src/telemetry/exec-command-count-lines.ts
+var Ai = require("node:readline");
+
+// node_modules/execa/index.js
+var Pi = require("node:buffer"), Ei = b(require("node:path"), 1), Qe = b(require("node:child_process"), 1), ue = b(require("node:process"), 1),
+Ti = b(kt(), 1);
+
+// ../node_modules/strip-final-newline/index.js
+function Ft(e) {
+  let t = typeof e == "string" ? `
+` : 10, r = typeof e == "string" ? "\r" : 13;
+  return e[e.length - 1] === t && (e = e.slice(0, -1)), e[e.length - 1] === r && (e = e.slice(0, -1)), e;
+}
+o(Ft, "stripFinalNewline");
+
+// node_modules/npm-run-path/index.js
+var se = b(require("node:process"), 1), K = b(require("node:path"), 1), Io = b(require("node:url"), 1);
+
+// node_modules/path-key/index.js
+function Le(e = {}) {
+  let {
+    env: t = process.env,
+    platform: r = process.platform
+  } = e;
+  return r !== "win32" ? "PATH" : Object.keys(t).reverse().find((n) => n.toUpperCase() === "PATH") || "Path";
+}
+o(Le, "pathKey");
+
+// node_modules/npm-run-path/index.js
+function Hc(e = {}) {
+  let {
+    cwd: t = se.default.cwd(),
+    path: r = se.default.env[Le()],
+    execPath: n = se.default.execPath
+  } = e, i, s = t instanceof URL ? Io.default.fileURLToPath(t) : t, a = K.default.resolve(s), c = [];
+  for (; i !== a; )
+    c.push(K.default.join(a, "node_modules/.bin")), i = a, a = K.default.resolve(a, "..");
+  return c.push(K.default.resolve(s, n, "..")), [...c, r].join(K.default.delimiter);
+}
+o(Hc, "npmRunPath");
+function Co({ env: e = se.default.env, ...t } = {}) {
+  e = { ...e };
+  let r = Le({ env: e });
+  return t.path = e[r], e[r] = Hc(t), e;
+}
+o(Co, "npmRunPathEnv");
+
+// node_modules/mimic-fn/index.js
+var Vc = /* @__PURE__ */ o((e, t, r, n) => {
+  if (r === "length" || r === "prototype" || r === "arguments" || r === "caller")
+    return;
+  let i = Object.getOwnPropertyDescriptor(e, r), s = Object.getOwnPropertyDescriptor(t, r);
+  !zc(i, s) && n || Object.defineProperty(e, r, s);
+}, "copyProperty"), zc = /* @__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"), Jc = /* @__PURE__ */ o((e, t) => {
+  let r = Object.getPrototypeOf(t);
+  r !== Object.getPrototypeOf(e) && Object.setPrototypeOf(e, r);
+}, "changePrototype"), Kc = /* @__PURE__ */ o((e, t) => `/* Wrapped ${e}*/
+${t}`, "wrappedToString"), Yc = Object.getOwnPropertyDescriptor(Function.prototype, "toString"), Xc = Object.getOwnPropertyDescriptor(Function.
+prototype.toString, "name"), Qc = /* @__PURE__ */ o((e, t, r) => {
+  let n = r === "" ? "" : `with ${r.trim()}() `, i = Kc.bind(null, n, t.toString());
+  Object.defineProperty(i, "name", Xc), Object.defineProperty(e, "toString", { ...Yc, value: i });
+}, "changeToString");
+function Ut(e, t, { ignoreNonConfigurable: r = !1 } = {}) {
+  let { name: n } = e;
+  for (let i of Reflect.ownKeys(t))
+    Vc(e, t, i, r);
+  return Jc(e, t), Qc(e, t, n), e;
+}
+o(Ut, "mimicFunction");
+
+// node_modules/onetime/index.js
+var Fe = /* @__PURE__ */ new WeakMap(), Oo = /* @__PURE__ */ o((e, t = {}) => {
+  if (typeof e != "function")
+    throw new TypeError("Expected a function");
+  let r, n = 0, i = e.displayName || e.name || "<anonymous>", s = /* @__PURE__ */ o(function(...a) {
+    if (Fe.set(s, ++n), n === 1)
+      r = e.apply(this, a), e = null;
+    else if (t.throw === !0)
+      throw new Error(`Function \`${i}\` can only be called once`);
+    return r;
+  }, "onetime");
+  return Ut(s, e), Fe.set(s, n), s;
+}, "onetime");
+Oo.callCount = (e) => {
+  if (!Fe.has(e))
+    throw new Error(`The given function \`${e.name}\` is not wrapped by the \`onetime\` package`);
+  return Fe.get(e);
+};
+var Ao = Oo;
+
+// node_modules/execa/lib/error.js
+var Do = b(require("node:process"), 1);
+
+// node_modules/human-signals/build/src/main.js
+var No = require("node:os");
+
+// node_modules/human-signals/build/src/realtime.js
+var Ro = /* @__PURE__ */ o(() => {
+  let e = $t - _o + 1;
+  return Array.from({ length: e }, Zc);
+}, "getRealtimeSignals"), Zc = /* @__PURE__ */ o((e, t) => ({
+  name: `SIGRT${t + 1}`,
+  number: _o + t,
+  action: "terminate",
+  description: "Application-specific signal (realtime)",
+  standard: "posix"
+}), "getRealtimeSignal"), _o = 34, $t = 64;
+
+// node_modules/human-signals/build/src/signals.js
+var jo = require("node:os");
+
+// node_modules/human-signals/build/src/core.js
+var Go = [
+  {
+    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 qt = /* @__PURE__ */ o(() => {
+  let e = Ro();
+  return [...Go, ...e].map(eu);
+}, "getSignals"), eu = /* @__PURE__ */ o(({
+  name: e,
+  number: t,
+  description: r,
+  action: n,
+  forced: i = !1,
+  standard: s
+}) => {
+  let {
+    signals: { [e]: a }
+  } = jo.constants, c = a !== void 0;
+  return { name: e, number: c ? a : t, description: r, supported: c, action: n, forced: i, standard: s };
+}, "normalizeSignal");
+
+// node_modules/human-signals/build/src/main.js
+var tu = /* @__PURE__ */ o(() => {
+  let e = qt();
+  return Object.fromEntries(e.map(ru));
+}, "getSignalsByName"), ru = /* @__PURE__ */ o(({
+  name: e,
+  number: t,
+  description: r,
+  supported: n,
+  action: i,
+  forced: s,
+  standard: a
+}) => [e, { name: e, number: t, description: r, supported: n, action: i, forced: s, standard: a }], "getSignalByName"), Bo = tu(), nu = /* @__PURE__ */ o(
+() => {
+  let e = qt(), t = $t + 1, r = Array.from(
+    { length: t },
+    (n, i) => ou(i, e)
+  );
+  return Object.assign({}, ...r);
+}, "getSignalsByNumber"), ou = /* @__PURE__ */ o((e, t) => {
+  let r = iu(e, t);
+  if (r === void 0)
+    return {};
+  let { name: n, description: i, supported: s, action: a, forced: c, standard: u } = r;
+  return {
+    [e]: {
+      name: n,
+      number: e,
+      description: i,
+      supported: s,
+      action: a,
+      forced: c,
+      standard: u
+    }
+  };
+}, "getSignalByNumber"), iu = /* @__PURE__ */ o((e, t) => {
+  let r = t.find(({ name: n }) => No.constants.signals[n] === e);
+  return r !== void 0 ? r : t.find((n) => n.number === e);
+}, "findSignalByNumber"), bp = nu();
+
+// node_modules/execa/lib/error.js
+var su = /* @__PURE__ */ o(({ timedOut: e, timeout: t, errorCode: r, signal: n, signalDescription: i, exitCode: s, isCanceled: a }) => e ? `\
+timed out after ${t} milliseconds` : a ? "was canceled" : r !== void 0 ? `failed with ${r}` : n !== void 0 ? `was killed with ${n} (${i})` :
+s !== void 0 ? `failed with exit code ${s}` : "failed", "getErrorPrefix"), ae = /* @__PURE__ */ o(({
+  stdout: e,
+  stderr: t,
+  all: r,
+  error: n,
+  signal: i,
+  exitCode: s,
+  command: a,
+  escapedCommand: c,
+  timedOut: u,
+  isCanceled: l,
+  killed: f,
+  parsed: { options: { timeout: x, cwd: g = Do.default.cwd() } }
+}) => {
+  s = s === null ? void 0 : s, i = i === null ? void 0 : i;
+  let m = i === void 0 ? void 0 : Bo[i].description, y = n && n.code, S = `Command ${su({ timedOut: u, timeout: x, errorCode: y, signal: i, signalDescription: m,
+  exitCode: s, isCanceled: l })}: ${a}`, k = Object.prototype.toString.call(n) === "[object Error]", E = k ? `${S}
+${n.message}` : S, O = [E, t, e].filter(Boolean).join(`
+`);
+  return k ? (n.originalMessage = n.message, n.message = O) : n = new Error(O), n.shortMessage = E, n.command = a, n.escapedCommand = c, n.exitCode =
+  s, n.signal = i, n.signalDescription = m, n.stdout = e, n.stderr = t, n.cwd = g, r !== void 0 && (n.all = r), "bufferedData" in n && delete n.
+  bufferedData, n.failed = !0, n.timedOut = !!u, n.isCanceled = l, n.killed = f && !u, n;
+}, "makeError");
+
+// node_modules/execa/lib/stdio.js
+var Ue = ["stdin", "stdout", "stderr"], au = /* @__PURE__ */ o((e) => Ue.some((t) => e[t] !== void 0), "hasAlias"), Mo = /* @__PURE__ */ o((e) => {
+  if (!e)
+    return;
+  let { stdio: t } = e;
+  if (t === void 0)
+    return Ue.map((n) => e[n]);
+  if (au(e))
+    throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${Ue.map((n) => `\`${n}\``).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 r = Math.max(t.length, Ue.length);
+  return Array.from({ length: r }, (n, i) => t[i]);
+}, "normalizeStdio");
+
+// node_modules/execa/lib/kill.js
+var Fo = b(require("node:os"), 1);
+
+// node_modules/signal-exit/dist/mjs/signals.js
+var D = [];
+D.push("SIGHUP", "SIGINT", "SIGTERM");
+process.platform !== "win32" && D.push(
+  "SIGALRM",
+  "SIGABRT",
+  "SIGVTALRM",
+  "SIGXCPU",
+  "SIGXFSZ",
+  "SIGUSR2",
+  "SIGTRAP",
+  "SIGSYS",
+  "SIGQUIT",
+  "SIGIOT"
+  // should detect profiler and enable/disable accordingly.
+  // see #21
+  // 'SIGPROF'
+);
+process.platform === "linux" && D.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+
+// node_modules/signal-exit/dist/mjs/index.js
+var $e = /* @__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 == "f\
+unction", "processOk"), Wt = Symbol.for("signal-exit emitter"), Ht = globalThis, cu = Object.defineProperty.bind(Object), Vt = class {
+  static {
+    o(this, "Emitter");
+  }
+  emitted = {
+    afterExit: !1,
+    exit: !1
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (Ht[Wt])
+      return Ht[Wt];
+    cu(Ht, Wt, {
+      value: this,
+      writable: !1,
+      enumerable: !1,
+      configurable: !1
+    });
+  }
+  on(t, r) {
+    this.listeners[t].push(r);
+  }
+  removeListener(t, r) {
+    let n = this.listeners[t], i = n.indexOf(r);
+    i !== -1 && (i === 0 && n.length === 1 ? n.length = 0 : n.splice(i, 1));
+  }
+  emit(t, r, n) {
+    if (this.emitted[t])
+      return !1;
+    this.emitted[t] = !0;
+    let i = !1;
+    for (let s of this.listeners[t])
+      i = s(r, n) === !0 || i;
+    return t === "exit" && (i = this.emit("afterExit", r, n) || i), i;
+  }
+}, qe = class {
+  static {
+    o(this, "SignalExitBase");
+  }
+}, uu = /* @__PURE__ */ o((e) => ({
+  onExit(t, r) {
+    return e.onExit(t, r);
+  },
+  load() {
+    return e.load();
+  },
+  unload() {
+    return e.unload();
+  }
+}), "signalExitWrap"), zt = class extends qe {
+  static {
+    o(this, "SignalExitFallback");
+  }
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+}, Jt = class extends qe {
+  static {
+    o(this, "SignalExit");
+  }
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #s = Kt.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #t = new Vt();
+  #e;
+  #o;
+  #i;
+  #n = {};
+  #r = !1;
+  constructor(t) {
+    super(), this.#e = t, this.#n = {};
+    for (let r of D)
+      this.#n[r] = () => {
+        let n = this.#e.listeners(r), { 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), n.length === i) {
+          this.unload();
+          let a = this.#t.emit("exit", null, r), c = r === "SIGHUP" ? this.#s : r;
+          a || t.kill(t.pid, c);
+        }
+      };
+    this.#i = t.reallyExit, this.#o = t.emit;
+  }
+  onExit(t, r) {
+    if (!$e(this.#e))
+      return () => {
+      };
+    this.#r === !1 && this.load();
+    let n = r?.alwaysLast ? "afterExit" : "exit";
+    return this.#t.on(n, t), () => {
+      this.#t.removeListener(n, t), this.#t.listeners.exit.length === 0 && this.#t.listeners.afterExit.length === 0 && this.unload();
+    };
+  }
+  load() {
+    if (!this.#r) {
+      this.#r = !0, this.#t.count += 1;
+      for (let t of D)
+        try {
+          let r = this.#n[t];
+          r && this.#e.on(t, r);
+        } catch {
+        }
+      this.#e.emit = (t, ...r) => this.#c(t, ...r), this.#e.reallyExit = (t) => this.#a(t);
+    }
+  }
+  unload() {
+    this.#r && (this.#r = !1, D.forEach((t) => {
+      let r = this.#n[t];
+      if (!r)
+        throw new Error("Listener not defined for signal: " + t);
+      try {
+        this.#e.removeListener(t, r);
+      } catch {
+      }
+    }), this.#e.emit = this.#o, this.#e.reallyExit = this.#i, this.#t.count -= 1);
+  }
+  #a(t) {
+    return $e(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, ...r) {
+    let n = this.#o;
+    if (t === "exit" && $e(this.#e)) {
+      typeof r[0] == "number" && (this.#e.exitCode = r[0]);
+      let i = n.call(this.#e, t, ...r);
+      return this.#t.emit("exit", this.#e.exitCode, null), i;
+    } else
+      return n.call(this.#e, t, ...r);
+  }
+}, Kt = 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: Lo,
+  /**
+   * 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: Cp,
+  /**
+   * 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: Op
+} = uu($e(Kt) ? new Jt(Kt) : new zt());
+
+// node_modules/execa/lib/kill.js
+var lu = 1e3 * 5, Uo = /* @__PURE__ */ o((e, t = "SIGTERM", r = {}) => {
+  let n = e(t);
+  return fu(e, t, r, n), n;
+}, "spawnedKill"), fu = /* @__PURE__ */ o((e, t, r, n) => {
+  if (!pu(t, r, n))
+    return;
+  let i = mu(r), s = setTimeout(() => {
+    e("SIGKILL");
+  }, i);
+  s.unref && s.unref();
+}, "setKillTimeout"), pu = /* @__PURE__ */ o((e, { forceKillAfterTimeout: t }, r) => du(e) && t !== !1 && r, "shouldForceKill"), du = /* @__PURE__ */ o(
+(e) => e === Fo.default.constants.signals.SIGTERM || typeof e == "string" && e.toUpperCase() === "SIGTERM", "isSigterm"), mu = /* @__PURE__ */ o(
+({ forceKillAfterTimeout: e = !0 }) => {
+  if (e === !0)
+    return lu;
+  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"), $o = /* @__PURE__ */ o((e, t) => {
+  e.kill() && (t.isCanceled = !0);
+}, "spawnedCancel"), hu = /* @__PURE__ */ o((e, t, r) => {
+  e.kill(t), r(Object.assign(new Error("Timed out"), { timedOut: !0, signal: t }));
+}, "timeoutKill"), qo = /* @__PURE__ */ o((e, { timeout: t, killSignal: r = "SIGTERM" }, n) => {
+  if (t === 0 || t === void 0)
+    return n;
+  let i, s = new Promise((c, u) => {
+    i = setTimeout(() => {
+      hu(e, r, u);
+    }, t);
+  }), a = n.finally(() => {
+    clearTimeout(i);
+  });
+  return Promise.race([s, a]);
+}, "setupTimeout"), Wo = /* @__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"), Ho = /* @__PURE__ */ o(async (e, { cleanup: t, detached: r }, n) => {
+  if (!t || r)
+    return n;
+  let i = Lo(() => {
+    e.kill();
+  });
+  return n.finally(() => {
+    i();
+  });
+}, "setExitHandler");
+
+// node_modules/execa/lib/pipe.js
+var Vo = require("node:fs"), zo = require("node:child_process");
+
+// node_modules/is-stream/index.js
+function We(e) {
+  return e !== null && typeof e == "object" && typeof e.pipe == "function";
+}
+o(We, "isStream");
+function Yt(e) {
+  return We(e) && e.writable !== !1 && typeof e._write == "function" && typeof e._writableState == "object";
+}
+o(Yt, "isWritableStream");
+
+// node_modules/execa/lib/pipe.js
+var yu = /* @__PURE__ */ o((e) => e instanceof zo.ChildProcess && typeof e.then == "function", "isExecaChildProcess"), Xt = /* @__PURE__ */ o(
+(e, t, r) => {
+  if (typeof r == "string")
+    return e[t].pipe((0, Vo.createWriteStream)(r)), e;
+  if (Yt(r))
+    return e[t].pipe(r), e;
+  if (!yu(r))
+    throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
+  if (!Yt(r.stdin))
+    throw new TypeError("The target child process's stdin must be available.");
+  return e[t].pipe(r.stdin), r;
+}, "pipeToTarget"), Jo = /* @__PURE__ */ o((e) => {
+  e.stdout !== null && (e.pipeStdout = Xt.bind(void 0, e, "stdout")), e.stderr !== null && (e.pipeStderr = Xt.bind(void 0, e, "stderr")), e.
+  all !== void 0 && (e.pipeAll = Xt.bind(void 0, e, "all"));
+}, "addPipeMethods");
+
+// node_modules/execa/lib/stream.js
+var Ye = require("node:fs"), oi = require("node:timers/promises");
+
+// node_modules/get-stream/source/contents.js
+var ce = /* @__PURE__ */ o(async (e, { init: t, convertChunk: r, getSize: n, truncateChunk: i, addChunk: s, getFinalChunk: a, finalize: c }, {
+maxBuffer: u = Number.POSITIVE_INFINITY } = {}) => {
+  if (!bu(e))
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+  let l = t();
+  l.length = 0;
+  try {
+    for await (let f of e) {
+      let x = xu(f), g = r[x](f, l);
+      Xo({ convertedChunk: g, state: l, getSize: n, truncateChunk: i, addChunk: s, maxBuffer: u });
+    }
+    return gu({ state: l, convertChunk: r, getSize: n, truncateChunk: i, addChunk: s, getFinalChunk: a, maxBuffer: u }), c(l);
+  } catch (f) {
+    throw f.bufferedData = c(l), f;
+  }
+}, "getStreamContents"), gu = /* @__PURE__ */ o(({ state: e, getSize: t, truncateChunk: r, addChunk: n, getFinalChunk: i, maxBuffer: s }) => {
+  let a = i(e);
+  a !== void 0 && Xo({ convertedChunk: a, state: e, getSize: t, truncateChunk: r, addChunk: n, maxBuffer: s });
+}, "appendFinalChunk"), Xo = /* @__PURE__ */ o(({ convertedChunk: e, state: t, getSize: r, truncateChunk: n, addChunk: i, maxBuffer: s }) => {
+  let a = r(e), c = t.length + a;
+  if (c <= s) {
+    Ko(e, t, i, c);
+    return;
+  }
+  let u = n(e, s - t.length);
+  throw u !== void 0 && Ko(u, t, i, s), new He();
+}, "appendChunk"), Ko = /* @__PURE__ */ o((e, t, r, n) => {
+  t.contents = r(e, t, n), t.length = n;
+}, "addNewChunk"), bu = /* @__PURE__ */ o((e) => typeof e == "object" && e !== null && typeof e[Symbol.asyncIterator] == "function", "isAsyn\
+cIterable"), xu = /* @__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 r = Yo.call(e);
+  return r === "[object ArrayBuffer]" ? "arrayBuffer" : r === "[object DataView]" ? "dataView" : Number.isInteger(e.byteLength) && Number.isInteger(
+  e.byteOffset) && Yo.call(e.buffer) === "[object ArrayBuffer]" ? "typedArray" : "others";
+}, "getChunkType"), { toString: Yo } = Object.prototype, He = class extends Error {
+  static {
+    o(this, "MaxBufferError");
+  }
+  name = "MaxBufferError";
+  constructor() {
+    super("maxBuffer exceeded");
+  }
+};
+
+// node_modules/get-stream/source/utils.js
+var Qt = /* @__PURE__ */ o((e) => e, "identity"), Zt = /* @__PURE__ */ o(() => {
+}, "noop"), er = /* @__PURE__ */ o(({ contents: e }) => e, "getContentsProp"), Ve = /* @__PURE__ */ o((e) => {
+  throw new Error(`Streams in object mode are not supported: ${String(e)}`);
+}, "throwObjectStream"), ze = /* @__PURE__ */ o((e) => e.length, "getLengthProp");
+
+// node_modules/get-stream/source/array-buffer.js
+async function tr(e, t) {
+  return ce(e, Cu, t);
+}
+o(tr, "getStreamAsArrayBuffer");
+var Su = /* @__PURE__ */ o(() => ({ contents: new ArrayBuffer(0) }), "initArrayBuffer"), wu = /* @__PURE__ */ o((e) => vu.encode(e), "useTex\
+tEncoder"), vu = new TextEncoder(), Qo = /* @__PURE__ */ o((e) => new Uint8Array(e), "useUint8Array"), Zo = /* @__PURE__ */ o((e) => new Uint8Array(
+e.buffer, e.byteOffset, e.byteLength), "useUint8ArrayWithOffset"), Pu = /* @__PURE__ */ o((e, t) => e.slice(0, t), "truncateArrayBufferChunk"),
+Eu = /* @__PURE__ */ o((e, { contents: t, length: r }, n) => {
+  let i = ri() ? ku(t, n) : Tu(t, n);
+  return new Uint8Array(i).set(e, r), i;
+}, "addArrayBufferChunk"), Tu = /* @__PURE__ */ o((e, t) => {
+  if (t <= e.byteLength)
+    return e;
+  let r = new ArrayBuffer(ti(t));
+  return new Uint8Array(r).set(new Uint8Array(e), 0), r;
+}, "resizeArrayBufferSlow"), ku = /* @__PURE__ */ o((e, t) => {
+  if (t <= e.maxByteLength)
+    return e.resize(t), e;
+  let r = new ArrayBuffer(t, { maxByteLength: ti(t) });
+  return new Uint8Array(r).set(new Uint8Array(e), 0), r;
+}, "resizeArrayBuffer"), ti = /* @__PURE__ */ o((e) => ei ** Math.ceil(Math.log(e) / Math.log(ei)), "getNewContentsLength"), ei = 2, Iu = /* @__PURE__ */ o(
+({ contents: e, length: t }) => ri() ? e : e.slice(0, t), "finalizeArrayBuffer"), ri = /* @__PURE__ */ o(() => "resize" in ArrayBuffer.prototype,
+"hasArrayBufferResize"), Cu = {
+  init: Su,
+  convertChunk: {
+    string: wu,
+    buffer: Qo,
+    arrayBuffer: Qo,
+    dataView: Zo,
+    typedArray: Zo,
+    others: Ve
+  },
+  getSize: ze,
+  truncateChunk: Pu,
+  addChunk: Eu,
+  getFinalChunk: Zt,
+  finalize: Iu
+};
+
+// node_modules/get-stream/source/buffer.js
+async function Je(e, t) {
+  if (!("Buffer" in globalThis))
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  try {
+    return ni(await tr(e, t));
+  } catch (r) {
+    throw r.bufferedData !== void 0 && (r.bufferedData = ni(r.bufferedData)), r;
+  }
+}
+o(Je, "getStreamAsBuffer");
+var ni = /* @__PURE__ */ o((e) => globalThis.Buffer.from(e), "arrayBufferToNodeBuffer");
+
+// node_modules/get-stream/source/string.js
+async function rr(e, t) {
+  return ce(e, Gu, t);
+}
+o(rr, "getStreamAsString");
+var Ou = /* @__PURE__ */ o(() => ({ contents: "", textDecoder: new TextDecoder() }), "initString"), Ke = /* @__PURE__ */ o((e, { textDecoder: t }) => t.
+decode(e, { stream: !0 }), "useTextDecoder"), Au = /* @__PURE__ */ o((e, { contents: t }) => t + e, "addStringChunk"), Ru = /* @__PURE__ */ o(
+(e, t) => e.slice(0, t), "truncateStringChunk"), _u = /* @__PURE__ */ o(({ textDecoder: e }) => {
+  let t = e.decode();
+  return t === "" ? void 0 : t;
+}, "getFinalStringChunk"), Gu = {
+  init: Ou,
+  convertChunk: {
+    string: Qt,
+    buffer: Ke,
+    arrayBuffer: Ke,
+    dataView: Ke,
+    typedArray: Ke,
+    others: Ve
+  },
+  getSize: ze,
+  truncateChunk: Ru,
+  addChunk: Au,
+  getFinalChunk: _u,
+  finalize: er
+};
+
+// node_modules/execa/lib/stream.js
+var ii = b(Gt(), 1);
+var si = /* @__PURE__ */ o((e) => {
+  if (e !== void 0)
+    throw new TypeError("The `input` and `inputFile` options cannot be both set.");
+}, "validateInputOptions"), ju = /* @__PURE__ */ o(({ input: e, inputFile: t }) => typeof t != "string" ? e : (si(e), (0, Ye.readFileSync)(t)),
+"getInputSync"), ai = /* @__PURE__ */ o((e) => {
+  let t = ju(e);
+  if (We(t))
+    throw new TypeError("The `input` option cannot be a stream in sync mode");
+  return t;
+}, "handleInputSync"), Nu = /* @__PURE__ */ o(({ input: e, inputFile: t }) => typeof t != "string" ? e : (si(e), (0, Ye.createReadStream)(t)),
+"getInput"), ci = /* @__PURE__ */ o((e, t) => {
+  let r = Nu(t);
+  r !== void 0 && (We(r) ? r.pipe(e.stdin) : e.stdin.end(r));
+}, "handleInput"), ui = /* @__PURE__ */ o((e, { all: t }) => {
+  if (!t || !e.stdout && !e.stderr)
+    return;
+  let r = (0, ii.default)();
+  return e.stdout && r.add(e.stdout), e.stderr && r.add(e.stderr), r;
+}, "makeAllStream"), nr = /* @__PURE__ */ o(async (e, t) => {
+  if (!(!e || t === void 0)) {
+    await (0, oi.setTimeout)(0), e.destroy();
+    try {
+      return await t;
+    } catch (r) {
+      return r.bufferedData;
+    }
+  }
+}, "getBufferedData"), or = /* @__PURE__ */ o((e, { encoding: t, buffer: r, maxBuffer: n }) => {
+  if (!(!e || !r))
+    return t === "utf8" || t === "utf-8" ? rr(e, { maxBuffer: n }) : t === null || t === "buffer" ? Je(e, { maxBuffer: n }) : Bu(e, n, t);
+}, "getStreamPromise"), Bu = /* @__PURE__ */ o(async (e, t, r) => (await Je(e, { maxBuffer: t })).toString(r), "applyEncoding"), li = /* @__PURE__ */ o(
+async ({ stdout: e, stderr: t, all: r }, { encoding: n, buffer: i, maxBuffer: s }, a) => {
+  let c = or(e, { encoding: n, buffer: i, maxBuffer: s }), u = or(t, { encoding: n, buffer: i, maxBuffer: s }), l = or(r, { encoding: n, buffer: i,
+  maxBuffer: s * 2 });
+  try {
+    return await Promise.all([a, c, u, l]);
+  } catch (f) {
+    return Promise.all([
+      { error: f, signal: f.signal, timedOut: f.timedOut },
+      nr(e, c),
+      nr(t, u),
+      nr(r, l)
+    ]);
+  }
+}, "getSpawnedResult");
+
+// node_modules/execa/lib/promise.js
+var Du = (async () => {
+})().constructor.prototype, Mu = ["then", "catch", "finally"].map((e) => [
+  e,
+  Reflect.getOwnPropertyDescriptor(Du, e)
+]), ir = /* @__PURE__ */ o((e, t) => {
+  for (let [r, n] of Mu) {
+    let i = typeof t == "function" ? (...s) => Reflect.apply(n.value, t(), s) : n.value.bind(t);
+    Reflect.defineProperty(e, r, { ...n, value: i });
+  }
+}, "mergePromise"), fi = /* @__PURE__ */ o((e) => new Promise((t, r) => {
+  e.on("exit", (n, i) => {
+    t({ exitCode: n, signal: i });
+  }), e.on("error", (n) => {
+    r(n);
+  }), e.stdin && e.stdin.on("error", (n) => {
+    r(n);
+  });
+}), "getSpawnedPromise");
+
+// node_modules/execa/lib/command.js
+var mi = require("node:buffer"), hi = require("node:child_process");
+var yi = /* @__PURE__ */ o((e, t = []) => Array.isArray(t) ? [e, ...t] : [e], "normalizeArgs"), Lu = /^[\w.-]+$/, Fu = /* @__PURE__ */ o((e) => typeof e !=
+"string" || Lu.test(e) ? e : `"${e.replaceAll('"', '\\"')}"`, "escapeArg"), sr = /* @__PURE__ */ o((e, t) => yi(e, t).join(" "), "joinComman\
+d"), ar = /* @__PURE__ */ o((e, t) => yi(e, t).map((r) => Fu(r)).join(" "), "getEscapedCommand"), gi = / +/g, bi = /* @__PURE__ */ o((e) => {
+  let t = [];
+  for (let r of e.trim().split(gi)) {
+    let n = t.at(-1);
+    n && n.endsWith("\\") ? t[t.length - 1] = `${n.slice(0, -1)} ${r}` : t.push(r);
+  }
+  return t;
+}, "parseCommand"), pi = /* @__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 hi.ChildProcess) && "stdout" in e) {
+    let r = typeof e.stdout;
+    if (r === "string")
+      return e.stdout;
+    if (mi.Buffer.isBuffer(e.stdout))
+      return e.stdout.toString();
+    throw new TypeError(`Unexpected "${r}" stdout in template expression`);
+  }
+  throw new TypeError(`Unexpected "${t}" in template expression`);
+}, "parseExpression"), di = /* @__PURE__ */ o((e, t, r) => r || e.length === 0 || t.length === 0 ? [...e, ...t] : [
+  ...e.slice(0, -1),
+  `${e.at(-1)}${t[0]}`,
+  ...t.slice(1)
+], "concatTokens"), Uu = /* @__PURE__ */ o(({ templates: e, expressions: t, tokens: r, index: n, template: i }) => {
+  let s = i ?? e.raw[n], a = s.split(gi).filter(Boolean), c = di(
+    r,
+    a,
+    s.startsWith(" ")
+  );
+  if (n === t.length)
+    return c;
+  let u = t[n], l = Array.isArray(u) ? u.map((f) => pi(f)) : [pi(u)];
+  return di(
+    c,
+    l,
+    s.endsWith(" ")
+  );
+}, "parseTemplate"), cr = /* @__PURE__ */ o((e, t) => {
+  let r = [];
+  for (let [n, i] of e.entries())
+    r = Uu({ templates: e, expressions: t, tokens: r, index: n, template: i });
+  return r;
+}, "parseTemplates");
+
+// node_modules/execa/lib/verbose.js
+var xi = require("node:util"), Si = b(require("node:process"), 1);
+var wi = (0, xi.debuglog)("execa").enabled, Xe = /* @__PURE__ */ o((e, t) => String(e).padStart(t, "0"), "padField"), $u = /* @__PURE__ */ o(
+() => {
+  let e = /* @__PURE__ */ new Date();
+  return `${Xe(e.getHours(), 2)}:${Xe(e.getMinutes(), 2)}:${Xe(e.getSeconds(), 2)}.${Xe(e.getMilliseconds(), 3)}`;
+}, "getTimestamp"), ur = /* @__PURE__ */ o((e, { verbose: t }) => {
+  t && Si.default.stderr.write(`[${$u()}] ${e}
+`);
+}, "logCommand");
+
+// node_modules/execa/index.js
+var qu = 1e3 * 1e3 * 100, Wu = /* @__PURE__ */ o(({ env: e, extendEnv: t, preferLocal: r, localDir: n, execPath: i }) => {
+  let s = t ? { ...ue.default.env, ...e } : e;
+  return r ? Co({ env: s, cwd: n, execPath: i }) : s;
+}, "getEnv"), ki = /* @__PURE__ */ o((e, t, r = {}) => {
+  let n = Ti.default._parse(e, t, r);
+  return e = n.command, t = n.args, r = n.options, r = {
+    maxBuffer: qu,
+    buffer: !0,
+    stripFinalNewline: !0,
+    extendEnv: !0,
+    preferLocal: !1,
+    localDir: r.cwd || ue.default.cwd(),
+    execPath: ue.default.execPath,
+    encoding: "utf8",
+    reject: !0,
+    cleanup: !0,
+    all: !1,
+    windowsHide: !0,
+    verbose: wi,
+    ...r
+  }, r.env = Wu(r), r.stdio = Mo(r), ue.default.platform === "win32" && Ei.default.basename(e, ".exe") === "cmd" && t.unshift("/q"), { file: e,
+  args: t, options: r, parsed: n };
+}, "handleArguments"), le = /* @__PURE__ */ o((e, t, r) => typeof t != "string" && !Pi.Buffer.isBuffer(t) ? r === void 0 ? void 0 : "" : e.stripFinalNewline ?
+Ft(t) : t, "handleOutput");
+function Ii(e, t, r) {
+  let n = ki(e, t, r), i = sr(e, t), s = ar(e, t);
+  ur(s, n.options), Wo(n.options);
+  let a;
+  try {
+    a = Qe.default.spawn(n.file, n.args, n.options);
+  } catch (m) {
+    let y = new Qe.default.ChildProcess(), h = Promise.reject(ae({
+      error: m,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command: i,
+      escapedCommand: s,
+      parsed: n,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    }));
+    return ir(y, h), y;
+  }
+  let c = fi(a), u = qo(a, n.options, c), l = Ho(a, n.options, u), f = { isCanceled: !1 };
+  a.kill = Uo.bind(null, a.kill.bind(a)), a.cancel = $o.bind(null, a, f);
+  let g = Ao(/* @__PURE__ */ o(async () => {
+    let [{ error: m, exitCode: y, signal: h, timedOut: S }, k, E, O] = await li(a, n.options, l), _ = le(n.options, k), G = le(n.options, E),
+    d = le(n.options, O);
+    if (m || y !== 0 || h !== null) {
+      let v = ae({
+        error: m,
+        exitCode: y,
+        signal: h,
+        stdout: _,
+        stderr: G,
+        all: d,
+        command: i,
+        escapedCommand: s,
+        parsed: n,
+        timedOut: S,
+        isCanceled: f.isCanceled || (n.options.signal ? n.options.signal.aborted : !1),
+        killed: a.killed
+      });
+      if (!n.options.reject)
+        return v;
+      throw v;
+    }
+    return {
+      command: i,
+      escapedCommand: s,
+      exitCode: 0,
+      stdout: _,
+      stderr: G,
+      all: d,
+      failed: !1,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    };
+  }, "handlePromise"));
+  return ci(a, n.options), a.all = ui(a, n.options), Jo(a), ir(a, g), a;
+}
+o(Ii, "execa");
+function Hu(e, t, r) {
+  let n = ki(e, t, r), i = sr(e, t), s = ar(e, t);
+  ur(s, n.options);
+  let a = ai(n.options), c;
+  try {
+    c = Qe.default.spawnSync(n.file, n.args, { ...n.options, input: a });
+  } catch (f) {
+    throw ae({
+      error: f,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command: i,
+      escapedCommand: s,
+      parsed: n,
+      timedOut: !1,
+      isCanceled: !1,
+      killed: !1
+    });
+  }
+  let u = le(n.options, c.stdout, c.error), l = le(n.options, c.stderr, c.error);
+  if (c.error || c.status !== 0 || c.signal !== null) {
+    let f = ae({
+      stdout: u,
+      stderr: l,
+      error: c.error,
+      signal: c.signal,
+      exitCode: c.status,
+      command: i,
+      escapedCommand: s,
+      parsed: n,
+      timedOut: c.error && c.error.code === "ETIMEDOUT",
+      isCanceled: !1,
+      killed: c.signal !== null
+    });
+    if (!n.options.reject)
+      return f;
+    throw f;
+  }
+  return {
+    command: i,
+    escapedCommand: s,
+    exitCode: 0,
+    stdout: u,
+    stderr: l,
+    failed: !1,
+    timedOut: !1,
+    isCanceled: !1,
+    killed: !1
+  };
+}
+o(Hu, "execaSync");
+var Vu = /* @__PURE__ */ o(({ input: e, inputFile: t, stdio: r }) => e === void 0 && t === void 0 && r === void 0 ? { stdin: "inherit" } : {},
+"normalizeScriptStdin"), vi = /* @__PURE__ */ o((e = {}) => ({
+  preferLocal: !0,
+  ...Vu(e),
+  ...e
+}), "normalizeScriptOptions");
+function Ci(e) {
+  function t(r, ...n) {
+    if (!Array.isArray(r))
+      return Ci({ ...e, ...r });
+    let [i, ...s] = cr(r, n);
+    return Ii(i, s, vi(e));
+  }
+  return o(t, "$"), t.sync = (r, ...n) => {
+    if (!Array.isArray(r))
+      throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
+    let [i, ...s] = cr(r, n);
+    return Hu(i, s, vi(e));
+  }, t;
+}
+o(Ci, "create$");
+var jd = Ci();
+function Oi(e, t) {
+  let [r, ...n] = bi(e);
+  return Ii(r, n, t);
+}
+o(Oi, "execaCommand");
+
+// src/telemetry/exec-command-count-lines.ts
+async function Ze(e, t) {
+  let r = Oi(e, { shell: !0, buffer: !1, ...t });
+  if (!r.stdout)
+    throw new Error("Unexpected missing stdout");
+  let n = 0, i = (0, Ai.createInterface)(r.stdout);
+  return i.on("line", () => {
+    n += 1;
+  }), await r, i.close(), n;
+}
+o(Ze, "execCommandCountLines");
+
+// ../node_modules/slash/index.js
+function lr(e) {
+  return e.startsWith("\\\\?\\") ? e : e.replace(/\\/g, "/");
+}
+o(lr, "slash");
+
+// src/common/utils/file-cache.ts
+var fe = require("node:crypto"), T = require("node:fs"), I = require("node:fs/promises"), Ri = require("node:os"), Y = require("node:path");
+var et = class {
+  static {
+    o(this, "FileSystemCache");
+  }
+  constructor(t = {}) {
+    this.prefix = (t.ns || t.prefix || "") + "-", this.hash_alg = t.hash_alg || "md5", this.cache_dir = t.basePath || (0, Y.join)((0, Ri.tmpdir)(),
+    (0, fe.randomBytes)(15).toString("base64").replace(/\//g, "-")), this.ttl = t.ttl || 0, (0, fe.createHash)(this.hash_alg), (0, T.mkdirSync)(
+    this.cache_dir, { recursive: !0 });
+  }
+  generateHash(t) {
+    return (0, Y.join)(this.cache_dir, this.prefix + (0, fe.createHash)(this.hash_alg).update(t).digest("hex"));
+  }
+  isExpired(t, r) {
+    return t.ttl != null && r > t.ttl;
+  }
+  parseCacheData(t, r) {
+    let n = JSON.parse(t);
+    return this.isExpired(n, Date.now()) ? r : n.content;
+  }
+  parseSetData(t, r, n = {}) {
+    let i = n.ttl ?? this.ttl;
+    return JSON.stringify({ key: t, content: r, ...i && { ttl: Date.now() + i * 1e3 } });
+  }
+  async get(t, r) {
+    try {
+      let n = await (0, I.readFile)(this.generateHash(t), "utf8");
+      return this.parseCacheData(n, r);
+    } catch {
+      return r;
+    }
+  }
+  getSync(t, r) {
+    try {
+      let n = (0, T.readFileSync)(this.generateHash(t), "utf8");
+      return this.parseCacheData(n, r);
+    } catch {
+      return r;
+    }
+  }
+  async set(t, r, n = {}) {
+    let i = typeof n == "number" ? { ttl: n } : n;
+    (0, T.mkdirSync)(this.cache_dir, { recursive: !0 }), await (0, I.writeFile)(this.generateHash(t), this.parseSetData(t, r, i), {
+      encoding: i.encoding || "utf8"
+    });
+  }
+  setSync(t, r, n = {}) {
+    let i = typeof n == "number" ? { ttl: n } : n;
+    (0, T.mkdirSync)(this.cache_dir, { recursive: !0 }), (0, T.writeFileSync)(this.generateHash(t), this.parseSetData(t, r, i), {
+      encoding: i.encoding || "utf8"
+    });
+  }
+  async setMany(t, r) {
+    await Promise.all(t.map((n) => this.set(n.key, n.content ?? n.value, r)));
+  }
+  setManySync(t, r) {
+    t.forEach((n) => this.setSync(n.key, n.content ?? n.value, r));
+  }
+  async remove(t) {
+    await (0, I.rm)(this.generateHash(t), { force: !0 });
+  }
+  removeSync(t) {
+    (0, T.rmSync)(this.generateHash(t), { force: !0 });
+  }
+  async clear() {
+    let t = await (0, I.readdir)(this.cache_dir);
+    await Promise.all(
+      t.filter((r) => r.startsWith(this.prefix)).map((r) => (0, I.rm)((0, Y.join)(this.cache_dir, r), { force: !0 }))
+    );
+  }
+  clearSync() {
+    (0, T.readdirSync)(this.cache_dir).filter((t) => t.startsWith(this.prefix)).forEach((t) => (0, T.rmSync)((0, Y.join)(this.cache_dir, t),
+    { force: !0 }));
+  }
+  async getAll() {
+    let t = Date.now(), r = await (0, I.readdir)(this.cache_dir);
+    return (await Promise.all(
+      r.filter((i) => i.startsWith(this.prefix)).map((i) => (0, I.readFile)((0, Y.join)(this.cache_dir, i), "utf8"))
+    )).map((i) => JSON.parse(i)).filter((i) => i.content && !this.isExpired(i, t));
+  }
+  async load() {
+    return {
+      files: (await this.getAll()).map((r) => ({
+        path: this.generateHash(r.key),
+        value: r.content,
+        key: r.key
+      }))
+    };
+  }
+};
+function fr(e) {
+  return new et(e);
+}
+o(fr, "createFileSystemCache");
+
+// src/common/utils/resolve-path-in-sb-cache.ts
+var hr = require("node:path");
+
+// ../node_modules/find-cache-dir/index.js
+var Hi = b(require("node:process"), 1), X = b(require("node:path"), 1), de = b(require("node:fs"), 1), Vi = b(Gi(), 1);
+
+// ../node_modules/pkg-dir/index.js
+var Ui = b(require("node:path"), 1);
+
+// ../node_modules/pkg-dir/node_modules/find-up/index.js
+var pe = b(require("node:path"), 1), Li = require("node:url");
+
+// ../node_modules/locate-path/index.js
+var ji = b(require("node:process"), 1), Ni = b(require("node:path"), 1), tt = b(require("node:fs"), 1), Bi = require("node:url");
+var Di = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function Ku(e) {
+  if (!Object.hasOwnProperty.call(Di, e))
+    throw new Error(`Invalid type specified: ${e}`);
+}
+o(Ku, "checkType");
+var Yu = /* @__PURE__ */ o((e, t) => t[Di[e]](), "matchType"), Xu = /* @__PURE__ */ o((e) => e instanceof URL ? (0, Bi.fileURLToPath)(e) : e,
+"toPath");
+function pr(e, {
+  cwd: t = ji.default.cwd(),
+  type: r = "file",
+  allowSymlinks: n = !0
+} = {}) {
+  Ku(r), t = Xu(t);
+  let i = n ? tt.default.statSync : tt.default.lstatSync;
+  for (let s of e)
+    try {
+      let a = i(Ni.default.resolve(t, s), {
+        throwIfNoEntry: !1
+      });
+      if (!a)
+        continue;
+      if (Yu(r, a))
+        return s;
+    } catch {
+    }
+}
+o(pr, "locatePathSync");
+
+// ../node_modules/pkg-dir/node_modules/path-exists/index.js
+var Mi = b(require("node:fs"), 1);
+
+// ../node_modules/pkg-dir/node_modules/find-up/index.js
+var Qu = /* @__PURE__ */ o((e) => e instanceof URL ? (0, Li.fileURLToPath)(e) : e, "toPath"), Zu = Symbol("findUpStop");
+function el(e, t = {}) {
+  let r = pe.default.resolve(Qu(t.cwd) || ""), { root: n } = pe.default.parse(r), i = t.stopAt || n, s = t.limit || Number.POSITIVE_INFINITY,
+  a = [e].flat(), c = /* @__PURE__ */ o((l) => {
+    if (typeof e != "function")
+      return pr(a, l);
+    let f = e(l.cwd);
+    return typeof f == "string" ? pr([f], l) : f;
+  }, "runMatcher"), u = [];
+  for (; ; ) {
+    let l = c({ ...t, cwd: r });
+    if (l === Zu || (l && u.push(pe.default.resolve(r, l)), r === i || u.length >= s))
+      break;
+    r = pe.default.dirname(r);
+  }
+  return u;
+}
+o(el, "findUpMultipleSync");
+function Fi(e, t = {}) {
+  return el(e, { ...t, limit: 1 })[0];
+}
+o(Fi, "findUpSync");
+
+// ../node_modules/pkg-dir/index.js
+function $i({ cwd: e } = {}) {
+  let t = Fi("package.json", { cwd: e });
+  return t && Ui.default.dirname(t);
+}
+o($i, "packageDirectorySync");
+
+// ../node_modules/find-cache-dir/index.js
+var { env: dr, cwd: tl } = Hi.default, qi = /* @__PURE__ */ o((e) => {
+  try {
+    return de.default.accessSync(e, de.default.constants.W_OK), !0;
+  } catch {
+    return !1;
+  }
+}, "isWritable");
+function Wi(e, t) {
+  return t.create && de.default.mkdirSync(e, { recursive: !0 }), e;
+}
+o(Wi, "useDirectory");
+function rl(e) {
+  let t = X.default.join(e, "node_modules");
+  if (!(!qi(t) && (de.default.existsSync(t) || !qi(X.default.join(e)))))
+    return t;
+}
+o(rl, "getNodeModuleDirectory");
+function mr(e = {}) {
+  if (dr.CACHE_DIR && !["true", "false", "1", "0"].includes(dr.CACHE_DIR))
+    return Wi(X.default.join(dr.CACHE_DIR, e.name), e);
+  let { cwd: t = tl(), files: r } = e;
+  if (r) {
+    if (!Array.isArray(r))
+      throw new TypeError(`Expected \`files\` option to be an array, got \`${typeof r}\`.`);
+    t = (0, Vi.default)(r.map((i) => X.default.resolve(t, i)));
+  }
+  if (t = $i({ cwd: t }), !(!t || !rl(t)))
+    return Wi(X.default.join(t, "node_modules", ".cache", e.name), e);
+}
+o(mr, "findCacheDirectory");
+
+// src/common/utils/resolve-path-in-sb-cache.ts
+function zi(e, t = "default") {
+  let r = mr({ name: "storybook" });
+  return r ||= (0, hr.join)(process.cwd(), "node_modules", ".cache", "storybook"), (0, hr.join)(r, t, e);
+}
+o(zi, "resolvePathInStorybookCache");
+
+// src/telemetry/run-telemetry-operation.ts
+var Ji = fr({
+  basePath: zi("telemetry"),
+  ns: "storybook",
+  ttl: 24 * 60 * 60 * 1e3
+  // 24h
+}), rt = /* @__PURE__ */ o(async (e, t) => {
+  let r = await Ji.get(e);
+  return r === void 0 && (r = await t(), r !== void 0 && await Ji.set(e, r)), r;
+}, "runTelemetryOperation");
+
+// src/telemetry/get-application-file-count.ts
+var nl = ["page", "screen"], ol = ["js", "jsx", "ts", "tsx"], il = /* @__PURE__ */ o(async (e) => {
+  let r = nl.flatMap((n) => [
+    n,
+    [n[0].toUpperCase(), ...n.slice(1)].join("")
+  ]).flatMap(
+    (n) => ol.map((i) => `"${e}${Ki.sep}*${n}*.${i}"`)
+  );
+  try {
+    let n = `git ls-files -- ${r.join(" ")}`;
+    return await Ze(n);
+  } catch {
+    return;
+  }
+}, "getApplicationFilesCountUncached"), Yi = /* @__PURE__ */ o(async (e) => rt(
+  "applicationFiles",
+  async () => il(e)
+), "getApplicationFileCount");
+
+// src/telemetry/get-chromatic-version.ts
+function Xi(e) {
+  let t = e.dependencies?.chromatic || e.devDependencies?.chromatic || e.peerDependencies?.chromatic;
+  return t || (e.scripts && Object.values(e.scripts).find((r) => r?.match(/chromatic/)) ? "latest" : void 0);
+}
+o(Xi, "getChromaticVersionSpecifier");
+
+// src/telemetry/get-framework-info.ts
+var ts = require("node:path"), rs = require("storybook/internal/common");
+
+// src/telemetry/package-json.ts
+var Qi = require("node:fs/promises"), Zi = require("node:path");
+var yr = /* @__PURE__ */ o(async (e) => {
+  let t = Object.keys(e);
+  return Promise.all(t.map(nt));
+}, "getActualPackageVersions"), nt = /* @__PURE__ */ o(async (e) => {
+  try {
+    let t = await gr(e);
+    return {
+      name: e,
+      version: t.version
+    };
+  } catch {
+    return { name: e, version: null };
+  }
+}, "getActualPackageVersion"), gr = /* @__PURE__ */ o(async (e) => {
+  let t = require.resolve((0, Zi.join)(e, "package.json"), {
+    paths: [process.cwd()]
+  });
+  return JSON.parse(await (0, Qi.readFile)(t, { encoding: "utf8" }));
+}, "getActualPackageJson");
+
+// src/telemetry/get-framework-info.ts
+var sl = [
+  "html",
+  "react",
+  "svelte",
+  "vue3",
+  "preact",
+  "server",
+  "vue",
+  "web-components",
+  "angular",
+  "ember"
+], al = ["builder-webpack5", "builder-vite"];
+function es(e, t) {
+  let { name: r = "", version: n, dependencies: i, devDependencies: s, peerDependencies: a } = e, c = {
+    // We include the framework itself because it may be a renderer too (e.g. angular)
+    [r]: n,
+    ...i,
+    ...s,
+    ...a
+  };
+  return t.map((u) => `@storybook/${u}`).find((u) => c[u]);
+}
+o(es, "findMatchingPackage");
+var cl = /* @__PURE__ */ o((e) => {
+  let t = (0, ts.normalize)(e).replace(new RegExp(/\\/, "g"), "/");
+  return Object.keys(rs.frameworkPackages).find((n) => t.endsWith(n)) || F(e).replace(/.*node_modules[\\/]/, "");
+}, "getFrameworkPackageName");
+async function ns(e) {
+  if (!e?.framework)
+    return {};
+  let t = typeof e.framework == "string" ? e.framework : e.framework?.name;
+  if (!t)
+    return {};
+  let r = await gr(t);
+  if (!r)
+    return {};
+  let n = es(r, al), i = es(r, sl), s = cl(t), a = typeof e.framework == "object" ? e.framework.options : {};
+  return {
+    framework: {
+      name: s,
+      options: a
+    },
+    builder: n,
+    renderer: i
+  };
+}
+o(ns, "getFrameworkInfo");
+
+// src/telemetry/get-has-router-package.ts
+var ul = /* @__PURE__ */ new Set([
+  "react-router",
+  "react-router-dom",
+  "remix",
+  "@tanstack/react-router",
+  "expo-router",
+  "@reach/router",
+  "react-easy-router",
+  "@remix-run/router",
+  "wouter",
+  "wouter-preact",
+  "preact-router",
+  "vue-router",
+  "unplugin-vue-router",
+  "@angular/router",
+  "@solidjs/router",
+  // metaframeworks that imply routing
+  "next",
+  "react-scripts",
+  "gatsby",
+  "nuxt",
+  "@sveltejs/kit"
+]);
+function os(e) {
+  return Object.keys(e?.dependencies ?? {}).some(
+    (t) => ul.has(t)
+  );
+}
+o(os, "getHasRouterPackage");
+
+// src/telemetry/get-monorepo-type.ts
+var me = require("node:fs"), ot = require("node:path"), ss = require("storybook/internal/common");
+var is = {
+  Nx: "nx.json",
+  Turborepo: "turbo.json",
+  Lerna: "lerna.json",
+  Rush: "rush.json",
+  Lage: "lage.config.json"
+}, as = /* @__PURE__ */ o(() => {
+  let e = (0, ss.getProjectRoot)();
+  if (!e)
+    return;
+  let r = Object.keys(is).find((i) => {
+    let s = (0, ot.join)(e, is[i]);
+    return (0, me.existsSync)(s);
+  });
+  if (r)
+    return r;
+  if (!(0, me.existsSync)((0, ot.join)(e, "package.json")))
+    return;
+  if (JSON.parse(
+    (0, me.readFileSync)((0, ot.join)(e, "package.json"), { encoding: "utf8" })
+  )?.workspaces)
+    return "Workspaces";
+}, "getMonorepoType");
+
+// src/telemetry/get-portable-stories-usage.ts
+var ll = /* @__PURE__ */ o(async (e) => {
+  try {
+    let t = "git grep -l composeStor" + (e ? ` -- ${e}` : "");
+    return await Ze(t);
+  } catch (t) {
+    return t.exitCode === 1 ? 0 : void 0;
+  }
+}, "getPortableStoriesFileCountUncached"), cs = /* @__PURE__ */ o(async (e) => rt(
+  "portableStories",
+  async () => ll(e)
+), "getPortableStoriesFileCount");
+
+// src/telemetry/storybook-metadata.ts
+var br = {
+  next: "Next",
+  "react-scripts": "CRA",
+  gatsby: "Gatsby",
+  "@nuxtjs/storybook": "nuxt",
+  "@nrwl/storybook": "nx",
+  "@vue/cli-service": "vue-cli",
+  "@sveltejs/kit": "sveltekit"
+}, xr = /* @__PURE__ */ o((e) => F(e).replace(/\/dist\/.*/, "").replace(/\.[mc]?[tj]?s[x]?$/, "").replace(/\/register$/, "").replace(/\/manager$/,
+"").replace(/\/preset$/, ""), "sanitizeAddonName"), fs = /* @__PURE__ */ o(async ({
+  packageJsonPath: e,
+  packageJson: t,
+  mainConfig: r
+}) => {
+  let n = {
+    generatedAt: (/* @__PURE__ */ new Date()).getTime(),
+    hasCustomBabel: !1,
+    hasCustomWebpack: !1,
+    hasStaticDirs: !1,
+    hasStorybookEslint: !1,
+    refCount: 0
+  }, i = {
+    ...t?.dependencies,
+    ...t?.devDependencies,
+    ...t?.peerDependencies
+  }, s = Object.keys(i).find((d) => !!br[d]);
+  if (s) {
+    let { version: d } = await nt(s);
+    n.metaFramework = {
+      name: br[s],
+      packageName: s,
+      version: d
+    };
+  }
+  let a = [
+    "playwright",
+    "vitest",
+    "jest",
+    "cypress",
+    "nightwatch",
+    "webdriver",
+    "@web/test-runner",
+    "puppeteer",
+    "karma",
+    "jasmine",
+    "chai",
+    "testing-library",
+    "@ngneat/spectator",
+    "wdio",
+    "msw",
+    "miragejs",
+    "sinon"
+  ], c = Object.keys(i).filter(
+    (d) => a.find((v) => d.includes(v))
+  );
+  n.testPackages = Object.fromEntries(
+    await Promise.all(
+      c.map(async (d) => [d, (await nt(d))?.version])
+    )
+  ), n.hasRouterPackage = os(t);
+  let u = as();
+  u && (n.monorepo = u);
+  try {
+    let d = await (0, st.detect)({ cwd: (0, A.getProjectRoot)() }), v = await (0, st.getNpmVersion)(d);
+    n.packageManager = {
+      type: d,
+      version: v
+    };
+  } catch {
+  }
+  n.hasCustomBabel = !!r.babel, n.hasCustomWebpack = !!r.webpackFinal, n.hasStaticDirs = !!r.staticDirs, typeof r.typescript == "object" && (n.
+  typescriptOptions = r.typescript);
+  let l = await ns(r);
+  typeof r.refs == "object" && (n.refCount = Object.keys(r.refs).length), typeof r.features == "object" && (n.features = r.features);
+  let f = {};
+  r.addons && r.addons.forEach((d) => {
+    let v, ge;
+    typeof d == "string" ? v = xr(d) : (d.name.includes("addon-essentials") && (ge = d.options), v = xr(d.name)), f[v] = {
+      options: ge,
+      version: void 0
+    };
+  });
+  let x = Xi(t);
+  x && (f.chromatic = {
+    version: void 0,
+    versionSpecifier: x,
+    options: void 0
+  }), (await yr(f)).forEach(({ name: d, version: v }) => {
+    f[d].version = v;
+  });
+  let m = Object.keys(f), y = Object.keys(i).filter((d) => d.includes("storybook") && !m.includes(d)).reduce((d, v) => ({
+    ...d,
+    [v]: { version: void 0 }
+  }), {});
+  (await yr(y)).forEach(({ name: d, version: v }) => {
+    y[d].version = v;
+  });
+  let S = i.typescript ? "typescript" : "javascript", k = !!i["eslint-plugin-storybook"], E = (0, A.getStorybookInfo)(t);
+  try {
+    let { previewConfig: d } = E;
+    if (d) {
+      let v = await (0, ls.readConfig)(d), ge = !!(v.getFieldNode(["globals"]) || v.getFieldNode(["globalTypes"]));
+      n.preview = { ...n.preview, usesGlobals: ge };
+    }
+  } catch {
+  }
+  let O = y[E.frameworkPackage]?.version, _ = await cs(), G = await Yi((0, us.dirname)(e));
+  return {
+    ...n,
+    ...l,
+    portableStoriesFileCount: _,
+    applicationFileCount: G,
+    storybookVersion: O,
+    storybookVersionSpecifier: E.version,
+    language: S,
+    storybookPackages: y,
+    addons: f,
+    hasStorybookEslint: k
+  };
+}, "computeStorybookMetadata");
+async function fl() {
+  let e = await Lt(process.cwd());
+  return e ? {
+    packageJsonPath: e,
+    packageJson: await ko(e) || {}
+  } : {
+    packageJsonPath: process.cwd(),
+    packageJson: {}
+  };
+}
+o(fl, "getPackageJsonDetails");
+var it, Sr = /* @__PURE__ */ o(async (e) => {
+  if (it)
+    return it;
+  let { packageJson: t, packageJsonPath: r } = await fl(), n = (e || (0, A.getStorybookConfiguration)(
+    String(t?.scripts?.storybook || ""),
+    "-c",
+    "--config-dir"
+  )) ?? ".storybook", i = await (0, A.loadMainConfig)({ configDir: n });
+  return it = await fs({ mainConfig: i, packageJson: t, packageJsonPath: r }), it;
+}, "getStorybookMetadata");
+
+// src/telemetry/telemetry.ts
+var Es = b(require("node:os"), 1), Ts = b(ds(), 1);
+
+// ../node_modules/nanoid/index.js
+var wr = require("crypto");
+
+// ../node_modules/nanoid/url-alphabet/index.js
+var ms = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../node_modules/nanoid/index.js
+var pl = 128, M, Q, dl = /* @__PURE__ */ o((e) => {
+  !M || M.length < e ? (M = Buffer.allocUnsafe(e * pl), (0, wr.randomFillSync)(M), Q = 0) : Q + e > M.length && ((0, wr.randomFillSync)(M), Q =
+  0), Q += e;
+}, "fillPool");
+var he = /* @__PURE__ */ o((e = 21) => {
+  dl(e -= 0);
+  let t = "";
+  for (let r = Q - e; r < Q; r++)
+    t += ms[M[r] & 63];
+  return t;
+}, "nanoid");
+
+// src/telemetry/anonymous-id.ts
+var ys = require("node:path"), gs = require("storybook/internal/common"), bs = require("child_process");
+
+// src/telemetry/one-way-hash.ts
+var hs = require("crypto");
+var ct = /* @__PURE__ */ o((e) => {
+  let t = (0, hs.createHash)("sha256");
+  return t.update("storybook-telemetry-salt"), t.update(e), t.digest("hex");
+}, "oneWayHash");
+
+// src/telemetry/anonymous-id.ts
+function ml(e) {
+  let n = e.trim().replace(/#.*$/, "").replace(/^.*@/, "").replace(/^.*\/\//, "");
+  return (n.endsWith(".git") ? n : `${n}.git`).replace(":", "/");
+}
+o(ml, "normalizeGitUrl");
+function hl(e, t) {
+  return `${ml(e)}${lr(t)}`;
+}
+o(hl, "unhashedProjectId");
+var ut, xs = /* @__PURE__ */ o(() => {
+  if (ut)
+    return ut;
+  try {
+    let e = (0, gs.getProjectRoot)(), t = (0, ys.relative)(e, process.cwd()), r = (0, bs.execSync)("git config --local --get remote.origin.u\
+rl", {
+      timeout: 1e3,
+      stdio: "pipe"
+    });
+    ut = ct(hl(String(r), t));
+  } catch {
+  }
+  return ut;
+}, "getAnonymousProjectId");
+
+// src/telemetry/event-cache.ts
+var lt = require("storybook/internal/common");
+var vr = Promise.resolve(), yl = /* @__PURE__ */ o(async (e, t) => {
+  let r = await lt.cache.get("lastEvents") || {};
+  r[e] = { body: t, timestamp: Date.now() }, await lt.cache.set("lastEvents", r);
+}, "setHelper"), ws = /* @__PURE__ */ o(async (e, t) => (await vr, vr = yl(e, t), vr), "set");
+var gl = /* @__PURE__ */ o((e) => {
+  let { body: t, timestamp: r } = e;
+  return {
+    timestamp: r,
+    eventType: t?.eventType,
+    eventId: t?.eventId,
+    sessionId: t?.sessionId
+  };
+}, "upgradeFields"), bl = ["init", "upgrade"], xl = ["build", "dev", "error"], Ss = /* @__PURE__ */ o((e, t) => {
+  let r = t.map((n) => e?.[n]).filter(Boolean).sort((n, i) => i.timestamp - n.timestamp);
+  return r.length > 0 ? r[0] : void 0;
+}, "lastEvent"), vs = /* @__PURE__ */ o(async (e = void 0) => {
+  let t = e || await lt.cache.get("lastEvents") || {}, r = Ss(t, bl), n = Ss(t, xl);
+  if (r)
+    return !n?.timestamp || r.timestamp > n.timestamp ? gl(r) : void 0;
+}, "getPrecedingUpgrade");
+
+// src/telemetry/fetch.ts
+var Ps = global.fetch;
+
+// src/telemetry/session-id.ts
+var Pr = require("storybook/internal/common");
+var Sl = 1e3 * 60 * 60 * 2, ye;
+var Er = /* @__PURE__ */ o(async () => {
+  let e = Date.now();
+  if (!ye) {
+    let t = await Pr.cache.get("session");
+    t && t.lastUsed >= e - Sl ? ye = t.id : ye = he();
+  }
+  return await Pr.cache.set("session", { id: ye, lastUsed: e }), ye;
+}, "getSessionId");
+
+// src/telemetry/telemetry.ts
+var wl = (0, Ts.default)(Ps), vl = process.env.STORYBOOK_TELEMETRY_URL || "https://storybook.js.org/event-log", ft = [], ks = /* @__PURE__ */ o(
+(e, t) => {
+  Tr[e] = t;
+}, "addToGlobalContext"), Pl = /* @__PURE__ */ o(() => {
+  try {
+    let e = Es.platform();
+    return e === "win32" ? "Windows" : e === "darwin" ? "macOS" : e === "linux" ? "Linux" : `Other: ${e}`;
+  } catch {
+    return "Unknown";
+  }
+}, "getOperatingSystem"), Tr = {
+  inCI: !!process.env.CI,
+  isTTY: process.stdout.isTTY,
+  platform: Pl(),
+  nodeVersion: process.versions.node
+}, El = /* @__PURE__ */ o(async (e, t, r) => {
+  let { eventType: n, payload: i, metadata: s, ...a } = e, c = await Er(), u = he(), l = { ...a, eventType: n, eventId: u, sessionId: c, metadata: s,
+  payload: i, context: t };
+  return wl(vl, {
+    method: "post",
+    body: JSON.stringify(l),
+    headers: { "Content-Type": "application/json" },
+    retries: 3,
+    retryOn: [503, 504],
+    retryDelay: /* @__PURE__ */ o((f) => 2 ** f * (typeof r?.retryDelay == "number" && !Number.isNaN(r?.retryDelay) ? r.retryDelay : 1e3), "\
+retryDelay")
+  });
+}, "prepareRequest");
+async function Is(e, t = { retryDelay: 1e3, immediate: !1 }) {
+  let { eventType: r, payload: n, metadata: i, ...s } = e, a = t.stripMetadata ? Tr : {
+    ...Tr,
+    anonymousId: xs()
+  }, c;
+  try {
+    c = El(e, a, t), ft.push(c), t.immediate ? await Promise.all(ft) : await c;
+    let u = await Er(), l = he(), f = { ...s, eventType: r, eventId: l, sessionId: u, metadata: i, payload: n, context: a };
+    await ws(r, f);
+  } catch {
+  } finally {
+    ft = ft.filter((u) => u !== c);
+  }
+}
+o(Is, "sendTelemetry");
+
+// src/telemetry/index.ts
+var Tl = /* @__PURE__ */ o((e) => e.startsWith("example-button--") || e.startsWith("example-header--") || e.startsWith("example-page--"), "i\
+sExampleStoryId"), kl = /* @__PURE__ */ o(async (e, t = {}, r = {}) => {
+  e !== "boot" && r.notify !== !1 && await _r();
+  let n = {
+    eventType: e,
+    payload: t
+  };
+  try {
+    r?.stripMetadata || (n.metadata = await Sr(r?.configDir));
+  } catch (i) {
+    n.payload.metadataErrorMessage = ee(i).message, r?.enableCrashReports && (n.payload.metadataError = ee(i));
+  } finally {
+    let { error: i } = n.payload;
+    i && (n.payload.error = ee(i)), (!n.payload.error || r?.enableCrashReports) && (process.env?.STORYBOOK_TELEMETRY_DEBUG && (kr.logger.info(
+    `
+[telemetry]`), kr.logger.info(JSON.stringify(n, null, 2))), await Is(n, r));
+  }
+}, "telemetry");