@teams-max/mwsp 1.0.0

package/lib/internal/execa/index.js

@@ -0,0 +1,1579 @@
+// src/internal/execa/index.js
+module.exports = (() => {
+  var e = {
+    205: (e2, t2, r) => {
+      var n = r(223);
+      var o = function() {
+      };
+      var i = function(e3) {
+        return e3.setHeader && typeof e3.abort === "function";
+      };
+      var s = function(e3) {
+        return e3.stdio && Array.isArray(e3.stdio) && e3.stdio.length === 3;
+      };
+      var a = function(e3, t3, r2) {
+        if (typeof t3 === "function")
+          return a(e3, null, t3);
+        if (!t3)
+          t3 = {};
+        r2 = n(r2 || o);
+        var c = e3._writableState;
+        var u = e3._readableState;
+        var d = t3.readable || t3.readable !== false && e3.readable;
+        var l = t3.writable || t3.writable !== false && e3.writable;
+        var f = false;
+        var p = function() {
+          if (!e3.writable)
+            m();
+        };
+        var m = function() {
+          l = false;
+          if (!d)
+            r2.call(e3);
+        };
+        var x = function() {
+          d = false;
+          if (!l)
+            r2.call(e3);
+        };
+        var b = function(t4) {
+          r2.call(e3, t4 ? new Error("exited with error code: " + t4) : null);
+        };
+        var g = function(t4) {
+          r2.call(e3, t4);
+        };
+        var v = function() {
+          process.nextTick(y);
+        };
+        var y = function() {
+          if (f)
+            return;
+          if (d && !(u && u.ended && !u.destroyed))
+            return r2.call(e3, new Error("premature close"));
+          if (l && !(c && c.ended && !c.destroyed))
+            return r2.call(e3, new Error("premature close"));
+        };
+        var h = function() {
+          e3.req.on("finish", m);
+        };
+        if (i(e3)) {
+          e3.on("complete", m);
+          e3.on("abort", v);
+          if (e3.req)
+            h();
+          else
+            e3.on("request", h);
+        } else if (l && !c) {
+          e3.on("end", p);
+          e3.on("close", p);
+        }
+        if (s(e3))
+          e3.on("exit", b);
+        e3.on("end", x);
+        e3.on("finish", m);
+        if (t3.error !== false)
+          e3.on("error", g);
+        e3.on("close", v);
+        return function() {
+          f = true;
+          e3.removeListener("complete", m);
+          e3.removeListener("abort", v);
+          e3.removeListener("request", h);
+          if (e3.req)
+            e3.req.removeListener("finish", m);
+          e3.removeListener("end", p);
+          e3.removeListener("close", p);
+          e3.removeListener("finish", m);
+          e3.removeListener("exit", b);
+          e3.removeListener("end", x);
+          e3.removeListener("error", g);
+          e3.removeListener("close", v);
+        };
+      };
+      e2.exports = a;
+    },
+    447: (e2, t2, r) => {
+      "use strict";
+      const n = r(622);
+      const o = r(129);
+      const i = r(213);
+      const s = r(174);
+      const a = r(502);
+      const c = r(82);
+      const u = r(187);
+      const d = r(166);
+      const { spawnedKill: l, spawnedCancel: f, setupTimeout: p, setExitHandler: m } = r(819);
+      const {
+        handleInput: x,
+        getSpawnedResult: b,
+        makeAllStream: g,
+        validateInputSync: v
+      } = r(592);
+      const { mergePromise: y, getSpawnedPromise: h } = r(814);
+      const { joinCommand: S, parseCommand: w } = r(286);
+      const I = 1e3 * 1e3 * 100;
+      const G = ({ env: e3, extendEnv: t3, preferLocal: r2, localDir: n2, execPath: o2 }) => {
+        const i2 = t3 ? { ...process.env, ...e3 } : e3;
+        if (r2) {
+          return a.env({ env: i2, cwd: n2, execPath: o2 });
+        }
+        return i2;
+      };
+      const T = (e3, t3, r2 = {}) => {
+        const o2 = i._parse(e3, t3, r2);
+        e3 = o2.command;
+        t3 = o2.args;
+        r2 = o2.options;
+        r2 = {
+          maxBuffer: I,
+          buffer: true,
+          stripFinalNewline: true,
+          extendEnv: true,
+          preferLocal: false,
+          localDir: r2.cwd || process.cwd(),
+          execPath: process.execPath,
+          encoding: "utf8",
+          reject: true,
+          cleanup: true,
+          all: false,
+          windowsHide: true,
+          ...r2
+        };
+        r2.env = G(r2);
+        r2.stdio = d(r2);
+        if (process.platform === "win32" && n.basename(e3, ".exe") === "cmd") {
+          t3.unshift("/q");
+        }
+        return { file: e3, args: t3, options: r2, parsed: o2 };
+      };
+      const E = (e3, t3, r2) => {
+        if (typeof t3 !== "string" && !Buffer.isBuffer(t3)) {
+          return r2 === void 0 ? void 0 : "";
+        }
+        if (e3.stripFinalNewline) {
+          return s(t3);
+        }
+        return t3;
+      };
+      const C = (e3, t3, r2) => {
+        const n2 = T(e3, t3, r2);
+        const s2 = S(e3, t3);
+        let a2;
+        try {
+          a2 = o.spawn(n2.file, n2.args, n2.options);
+        } catch (e4) {
+          const t4 = new o.ChildProcess();
+          const r3 = Promise.reject(
+            u({
+              error: e4,
+              stdout: "",
+              stderr: "",
+              all: "",
+              command: s2,
+              parsed: n2,
+              timedOut: false,
+              isCanceled: false,
+              killed: false
+            })
+          );
+          return y(t4, r3);
+        }
+        const d2 = h(a2);
+        const v2 = p(a2, n2.options, d2);
+        const w2 = m(a2, n2.options, v2);
+        const I2 = { isCanceled: false };
+        a2.kill = l.bind(null, a2.kill.bind(a2));
+        a2.cancel = f.bind(null, a2, I2);
+        const G2 = async () => {
+          const [{ error: e4, exitCode: t4, signal: r3, timedOut: o2 }, i2, c2, d3] = await b(
+            a2,
+            n2.options,
+            w2
+          );
+          const l2 = E(n2.options, i2);
+          const f2 = E(n2.options, c2);
+          const p2 = E(n2.options, d3);
+          if (e4 || t4 !== 0 || r3 !== null) {
+            const i3 = u({
+              error: e4,
+              exitCode: t4,
+              signal: r3,
+              stdout: l2,
+              stderr: f2,
+              all: p2,
+              command: s2,
+              parsed: n2,
+              timedOut: o2,
+              isCanceled: I2.isCanceled,
+              killed: a2.killed
+            });
+            if (!n2.options.reject) {
+              return i3;
+            }
+            throw i3;
+          }
+          return {
+            command: s2,
+            exitCode: 0,
+            stdout: l2,
+            stderr: f2,
+            all: p2,
+            failed: false,
+            timedOut: false,
+            isCanceled: false,
+            killed: false
+          };
+        };
+        const C2 = c(G2);
+        i._enoent.hookChildProcess(a2, n2.parsed);
+        x(a2, n2.options.input);
+        a2.all = g(a2, n2.options);
+        return y(a2, C2);
+      };
+      e2.exports = C;
+      e2.exports.sync = (e3, t3, r2) => {
+        const n2 = T(e3, t3, r2);
+        const i2 = S(e3, t3);
+        v(n2.options);
+        let s2;
+        try {
+          s2 = o.spawnSync(n2.file, n2.args, n2.options);
+        } catch (e4) {
+          throw u({
+            error: e4,
+            stdout: "",
+            stderr: "",
+            all: "",
+            command: i2,
+            parsed: n2,
+            timedOut: false,
+            isCanceled: false,
+            killed: false
+          });
+        }
+        const a2 = E(n2.options, s2.stdout, s2.error);
+        const c2 = E(n2.options, s2.stderr, s2.error);
+        if (s2.error || s2.status !== 0 || s2.signal !== null) {
+          const e4 = u({
+            stdout: a2,
+            stderr: c2,
+            error: s2.error,
+            signal: s2.signal,
+            exitCode: s2.status,
+            command: i2,
+            parsed: n2,
+            timedOut: s2.error && s2.error.code === "ETIMEDOUT",
+            isCanceled: false,
+            killed: s2.signal !== null
+          });
+          if (!n2.options.reject) {
+            return e4;
+          }
+          throw e4;
+        }
+        return {
+          command: i2,
+          exitCode: 0,
+          stdout: a2,
+          stderr: c2,
+          failed: false,
+          timedOut: false,
+          isCanceled: false,
+          killed: false
+        };
+      };
+      e2.exports.command = (e3, t3) => {
+        const [r2, ...n2] = w(e3);
+        return C(r2, n2, t3);
+      };
+      e2.exports.commandSync = (e3, t3) => {
+        const [r2, ...n2] = w(e3);
+        return C.sync(r2, n2, t3);
+      };
+      e2.exports.node = (e3, t3, r2 = {}) => {
+        if (t3 && !Array.isArray(t3) && typeof t3 === "object") {
+          r2 = t3;
+          t3 = [];
+        }
+        const n2 = d.node(r2);
+        const { nodePath: o2 = process.execPath, nodeOptions: i2 = process.execArgv } = r2;
+        return C(o2, [...i2, e3, ...Array.isArray(t3) ? t3 : []], {
+          ...r2,
+          stdin: void 0,
+          stdout: void 0,
+          stderr: void 0,
+          stdio: n2,
+          shell: false
+        });
+      };
+    },
+    286: (e2) => {
+      "use strict";
+      const t2 = / +/g;
+      const r = (e3, t3 = []) => {
+        if (!Array.isArray(t3)) {
+          return e3;
+        }
+        return [e3, ...t3].join(" ");
+      };
+      const n = (e3, t3, r2) => {
+        if (r2 === 0) {
+          return [t3];
+        }
+        const n2 = e3[e3.length - 1];
+        if (n2.endsWith("\\")) {
+          return [...e3.slice(0, -1), `${n2.slice(0, -1)} ${t3}`];
+        }
+        return [...e3, t3];
+      };
+      const o = (e3) => {
+        return e3.trim().split(t2).reduce(n, []);
+      };
+      e2.exports = { joinCommand: r, parseCommand: o };
+    },
+    187: (e2, t2, r) => {
+      "use strict";
+      const { signalsByName: n } = r(779);
+      const o = ({
+        timedOut: e3,
+        timeout: t3,
+        errorCode: r2,
+        signal: n2,
+        signalDescription: o2,
+        exitCode: i2,
+        isCanceled: s
+      }) => {
+        if (e3) {
+          return `timed out after ${t3} milliseconds`;
+        }
+        if (s) {
+          return "was canceled";
+        }
+        if (r2 !== void 0) {
+          return `failed with ${r2}`;
+        }
+        if (n2 !== void 0) {
+          return `was killed with ${n2} (${o2})`;
+        }
+        if (i2 !== void 0) {
+          return `failed with exit code ${i2}`;
+        }
+        return "failed";
+      };
+      const i = ({
+        stdout: e3,
+        stderr: t3,
+        all: r2,
+        error: i2,
+        signal: s,
+        exitCode: a,
+        command: c,
+        timedOut: u,
+        isCanceled: d,
+        killed: l,
+        parsed: {
+          options: { timeout: f }
+        }
+      }) => {
+        a = a === null ? void 0 : a;
+        s = s === null ? void 0 : s;
+        const p = s === void 0 ? void 0 : n[s].description;
+        const m = i2 && i2.code;
+        const x = o({
+          timedOut: u,
+          timeout: f,
+          errorCode: m,
+          signal: s,
+          signalDescription: p,
+          exitCode: a,
+          isCanceled: d
+        });
+        const b = `Command ${x}: ${c}`;
+        const g = Object.prototype.toString.call(i2) === "[object Error]";
+        const v = g ? `${b}
+${i2.message}` : b;
+        const y = [v, t3, e3].filter(Boolean).join("\n");
+        if (g) {
+          i2.originalMessage = i2.message;
+          i2.message = y;
+        } else {
+          i2 = new Error(y);
+        }
+        i2.shortMessage = v;
+        i2.command = c;
+        i2.exitCode = a;
+        i2.signal = s;
+        i2.signalDescription = p;
+        i2.stdout = e3;
+        i2.stderr = t3;
+        if (r2 !== void 0) {
+          i2.all = r2;
+        }
+        if ("bufferedData" in i2) {
+          delete i2.bufferedData;
+        }
+        i2.failed = true;
+        i2.timedOut = Boolean(u);
+        i2.isCanceled = d;
+        i2.killed = l && !u;
+        return i2;
+      };
+      e2.exports = i;
+    },
+    819: (e2, t2, r) => {
+      "use strict";
+      const n = r(87);
+      const o = r(931);
+      const i = 1e3 * 5;
+      const s = (e3, t3 = "SIGTERM", r2 = {}) => {
+        const n2 = e3(t3);
+        a(e3, t3, r2, n2);
+        return n2;
+      };
+      const a = (e3, t3, r2, n2) => {
+        if (!c(t3, r2, n2)) {
+          return;
+        }
+        const o2 = d(r2);
+        const i2 = setTimeout(() => {
+          e3("SIGKILL");
+        }, o2);
+        if (i2.unref) {
+          i2.unref();
+        }
+      };
+      const c = (e3, { forceKillAfterTimeout: t3 }, r2) => {
+        return u(e3) && t3 !== false && r2;
+      };
+      const u = (e3) => {
+        return e3 === n.constants.signals.SIGTERM || typeof e3 === "string" && e3.toUpperCase() === "SIGTERM";
+      };
+      const d = ({ forceKillAfterTimeout: e3 = true }) => {
+        if (e3 === true) {
+          return i;
+        }
+        if (!Number.isFinite(e3) || e3 < 0) {
+          throw new TypeError(
+            `Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${e3}\` (${typeof e3})`
+          );
+        }
+        return e3;
+      };
+      const l = (e3, t3) => {
+        const r2 = e3.kill();
+        if (r2) {
+          t3.isCanceled = true;
+        }
+      };
+      const f = (e3, t3, r2) => {
+        e3.kill(t3);
+        r2(Object.assign(new Error("Timed out"), { timedOut: true, signal: t3 }));
+      };
+      const p = (e3, { timeout: t3, killSignal: r2 = "SIGTERM" }, n2) => {
+        if (t3 === 0 || t3 === void 0) {
+          return n2;
+        }
+        if (!Number.isFinite(t3) || t3 < 0) {
+          throw new TypeError(
+            `Expected the \`timeout\` option to be a non-negative integer, got \`${t3}\` (${typeof t3})`
+          );
+        }
+        let o2;
+        const i2 = new Promise((n3, i3) => {
+          o2 = setTimeout(() => {
+            f(e3, r2, i3);
+          }, t3);
+        });
+        const s2 = n2.finally(() => {
+          clearTimeout(o2);
+        });
+        return Promise.race([i2, s2]);
+      };
+      const m = async (e3, { cleanup: t3, detached: r2 }, n2) => {
+        if (!t3 || r2) {
+          return n2;
+        }
+        const i2 = o(() => {
+          e3.kill();
+        });
+        return n2.finally(() => {
+          i2();
+        });
+      };
+      e2.exports = { spawnedKill: s, spawnedCancel: l, setupTimeout: p, setExitHandler: m };
+    },
+    814: (e2) => {
+      "use strict";
+      const t2 = (async () => {
+      })().constructor.prototype;
+      const r = ["then", "catch", "finally"].map((e3) => [
+        e3,
+        Reflect.getOwnPropertyDescriptor(t2, e3)
+      ]);
+      const n = (e3, t3) => {
+        for (const [n2, o2] of r) {
+          const r2 = typeof t3 === "function" ? (...e4) => Reflect.apply(o2.value, t3(), e4) : o2.value.bind(t3);
+          Reflect.defineProperty(e3, n2, { ...o2, value: r2 });
+        }
+        return e3;
+      };
+      const o = (e3) => {
+        return new Promise((t3, r2) => {
+          e3.on("exit", (e4, r3) => {
+            t3({ exitCode: e4, signal: r3 });
+          });
+          e3.on("error", (e4) => {
+            r2(e4);
+          });
+          if (e3.stdin) {
+            e3.stdin.on("error", (e4) => {
+              r2(e4);
+            });
+          }
+        });
+      };
+      e2.exports = { mergePromise: n, getSpawnedPromise: o };
+    },
+    166: (e2) => {
+      "use strict";
+      const t2 = ["stdin", "stdout", "stderr"];
+      const r = (e3) => t2.some((t3) => e3[t3] !== void 0);
+      const n = (e3) => {
+        if (!e3) {
+          return;
+        }
+        const { stdio: n2 } = e3;
+        if (n2 === void 0) {
+          return t2.map((t3) => e3[t3]);
+        }
+        if (r(e3)) {
+          throw new Error(
+            `It's not possible to provide \`stdio\` in combination with one of ${t2.map((e4) => `\`${e4}\``).join(", ")}`
+          );
+        }
+        if (typeof n2 === "string") {
+          return n2;
+        }
+        if (!Array.isArray(n2)) {
+          throw new TypeError(
+            `Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof n2}\``
+          );
+        }
+        const o = Math.max(n2.length, t2.length);
+        return Array.from({ length: o }, (e4, t3) => n2[t3]);
+      };
+      e2.exports = n;
+      e2.exports.node = (e3) => {
+        const t3 = n(e3);
+        if (t3 === "ipc") {
+          return "ipc";
+        }
+        if (t3 === void 0 || typeof t3 === "string") {
+          return [t3, t3, t3, "ipc"];
+        }
+        if (t3.includes("ipc")) {
+          return t3;
+        }
+        return [...t3, "ipc"];
+      };
+    },
+    592: (e2, t2, r) => {
+      "use strict";
+      const n = r(554);
+      const o = r(766);
+      const i = r(583);
+      const s = (e3, t3) => {
+        if (t3 === void 0 || e3.stdin === void 0) {
+          return;
+        }
+        if (n(t3)) {
+          t3.pipe(e3.stdin);
+        } else {
+          e3.stdin.end(t3);
+        }
+      };
+      const a = (e3, { all: t3 }) => {
+        if (!t3 || !e3.stdout && !e3.stderr) {
+          return;
+        }
+        const r2 = i();
+        if (e3.stdout) {
+          r2.add(e3.stdout);
+        }
+        if (e3.stderr) {
+          r2.add(e3.stderr);
+        }
+        return r2;
+      };
+      const c = async (e3, t3) => {
+        if (!e3) {
+          return;
+        }
+        e3.destroy();
+        try {
+          return await t3;
+        } catch (e4) {
+          return e4.bufferedData;
+        }
+      };
+      const u = (e3, { encoding: t3, buffer: r2, maxBuffer: n2 }) => {
+        if (!e3 || !r2) {
+          return;
+        }
+        if (t3) {
+          return o(e3, { encoding: t3, maxBuffer: n2 });
+        }
+        return o.buffer(e3, { maxBuffer: n2 });
+      };
+      const d = async ({ stdout: e3, stderr: t3, all: r2 }, { encoding: n2, buffer: o2, maxBuffer: i2 }, s2) => {
+        const a2 = u(e3, { encoding: n2, buffer: o2, maxBuffer: i2 });
+        const d2 = u(t3, { encoding: n2, buffer: o2, maxBuffer: i2 });
+        const l2 = u(r2, { encoding: n2, buffer: o2, maxBuffer: i2 * 2 });
+        try {
+          return await Promise.all([s2, a2, d2, l2]);
+        } catch (n3) {
+          return Promise.all([
+            { error: n3, signal: n3.signal, timedOut: n3.timedOut },
+            c(e3, a2),
+            c(t3, d2),
+            c(r2, l2)
+          ]);
+        }
+      };
+      const l = ({ input: e3 }) => {
+        if (n(e3)) {
+          throw new TypeError("The `input` option cannot be a stream in sync mode");
+        }
+      };
+      e2.exports = { handleInput: s, makeAllStream: a, getSpawnedResult: d, validateInputSync: l };
+    },
+    585: (e2, t2, r) => {
+      "use strict";
+      const { PassThrough: n } = r(413);
+      e2.exports = (e3) => {
+        e3 = { ...e3 };
+        const { array: t3 } = e3;
+        let { encoding: r2 } = e3;
+        const o = r2 === "buffer";
+        let i = false;
+        if (t3) {
+          i = !(r2 || o);
+        } else {
+          r2 = r2 || "utf8";
+        }
+        if (o) {
+          r2 = null;
+        }
+        const s = new n({ objectMode: i });
+        if (r2) {
+          s.setEncoding(r2);
+        }
+        let a = 0;
+        const c = [];
+        s.on("data", (e4) => {
+          c.push(e4);
+          if (i) {
+            a = c.length;
+          } else {
+            a += e4.length;
+          }
+        });
+        s.getBufferedValue = () => {
+          if (t3) {
+            return c;
+          }
+          return o ? Buffer.concat(c, a) : c.join("");
+        };
+        s.getBufferedLength = () => a;
+        return s;
+      };
+    },
+    766: (e2, t2, r) => {
+      "use strict";
+      const { constants: n } = r(293);
+      const o = r(341);
+      const i = r(585);
+      class MaxBufferError extends Error {
+        constructor() {
+          super("maxBuffer exceeded");
+          this.name = "MaxBufferError";
+        }
+      }
+      async function getStream(e3, t3) {
+        if (!e3) {
+          return Promise.reject(new Error("Expected a stream"));
+        }
+        t3 = { maxBuffer: Infinity, ...t3 };
+        const { maxBuffer: r2 } = t3;
+        let s;
+        await new Promise((a, c) => {
+          const u = (e4) => {
+            if (e4 && s.getBufferedLength() <= n.MAX_LENGTH) {
+              e4.bufferedData = s.getBufferedValue();
+            }
+            c(e4);
+          };
+          s = o(e3, i(t3), (e4) => {
+            if (e4) {
+              u(e4);
+              return;
+            }
+            a();
+          });
+          s.on("data", () => {
+            if (s.getBufferedLength() > r2) {
+              u(new MaxBufferError());
+            }
+          });
+        });
+        return s.getBufferedValue();
+      }
+      e2.exports = getStream;
+      e2.exports.default = getStream;
+      e2.exports.buffer = (e3, t3) => getStream(e3, { ...t3, encoding: "buffer" });
+      e2.exports.array = (e3, t3) => getStream(e3, { ...t3, array: true });
+      e2.exports.MaxBufferError = MaxBufferError;
+    },
+    887: (e2, t2) => {
+      "use strict";
+      Object.defineProperty(t2, "__esModule", { value: true });
+      t2.SIGNALS = void 0;
+      const r = [
+        {
+          name: "SIGHUP",
+          number: 1,
+          action: "terminate",
+          description: "Terminal closed",
+          standard: "posix"
+        },
+        {
+          name: "SIGINT",
+          number: 2,
+          action: "terminate",
+          description: "User interruption with CTRL-C",
+          standard: "ansi"
+        },
+        {
+          name: "SIGQUIT",
+          number: 3,
+          action: "core",
+          description: "User interruption with CTRL-\\",
+          standard: "posix"
+        },
+        {
+          name: "SIGILL",
+          number: 4,
+          action: "core",
+          description: "Invalid machine instruction",
+          standard: "ansi"
+        },
+        {
+          name: "SIGTRAP",
+          number: 5,
+          action: "core",
+          description: "Debugger breakpoint",
+          standard: "posix"
+        },
+        { name: "SIGABRT", number: 6, action: "core", description: "Aborted", standard: "ansi" },
+        { name: "SIGIOT", number: 6, action: "core", description: "Aborted", standard: "bsd" },
+        {
+          name: "SIGBUS",
+          number: 7,
+          action: "core",
+          description: "Bus error due to misaligned, non-existing address or paging error",
+          standard: "bsd"
+        },
+        {
+          name: "SIGEMT",
+          number: 7,
+          action: "terminate",
+          description: "Command should be emulated but is not implemented",
+          standard: "other"
+        },
+        {
+          name: "SIGFPE",
+          number: 8,
+          action: "core",
+          description: "Floating point arithmetic error",
+          standard: "ansi"
+        },
+        {
+          name: "SIGKILL",
+          number: 9,
+          action: "terminate",
+          description: "Forced termination",
+          standard: "posix",
+          forced: true
+        },
+        {
+          name: "SIGUSR1",
+          number: 10,
+          action: "terminate",
+          description: "Application-specific signal",
+          standard: "posix"
+        },
+        {
+          name: "SIGSEGV",
+          number: 11,
+          action: "core",
+          description: "Segmentation fault",
+          standard: "ansi"
+        },
+        {
+          name: "SIGUSR2",
+          number: 12,
+          action: "terminate",
+          description: "Application-specific signal",
+          standard: "posix"
+        },
+        {
+          name: "SIGPIPE",
+          number: 13,
+          action: "terminate",
+          description: "Broken pipe or socket",
+          standard: "posix"
+        },
+        {
+          name: "SIGALRM",
+          number: 14,
+          action: "terminate",
+          description: "Timeout or timer",
+          standard: "posix"
+        },
+        {
+          name: "SIGTERM",
+          number: 15,
+          action: "terminate",
+          description: "Termination",
+          standard: "ansi"
+        },
+        {
+          name: "SIGSTKFLT",
+          number: 16,
+          action: "terminate",
+          description: "Stack is empty or overflowed",
+          standard: "other"
+        },
+        {
+          name: "SIGCHLD",
+          number: 17,
+          action: "ignore",
+          description: "Child process terminated, paused or unpaused",
+          standard: "posix"
+        },
+        {
+          name: "SIGCLD",
+          number: 17,
+          action: "ignore",
+          description: "Child process terminated, paused or unpaused",
+          standard: "other"
+        },
+        {
+          name: "SIGCONT",
+          number: 18,
+          action: "unpause",
+          description: "Unpaused",
+          standard: "posix",
+          forced: true
+        },
+        {
+          name: "SIGSTOP",
+          number: 19,
+          action: "pause",
+          description: "Paused",
+          standard: "posix",
+          forced: true
+        },
+        {
+          name: "SIGTSTP",
+          number: 20,
+          action: "pause",
+          description: 'Paused using CTRL-Z or "suspend"',
+          standard: "posix"
+        },
+        {
+          name: "SIGTTIN",
+          number: 21,
+          action: "pause",
+          description: "Background process cannot read terminal input",
+          standard: "posix"
+        },
+        {
+          name: "SIGBREAK",
+          number: 21,
+          action: "terminate",
+          description: "User interruption with CTRL-BREAK",
+          standard: "other"
+        },
+        {
+          name: "SIGTTOU",
+          number: 22,
+          action: "pause",
+          description: "Background process cannot write to terminal output",
+          standard: "posix"
+        },
+        {
+          name: "SIGURG",
+          number: 23,
+          action: "ignore",
+          description: "Socket received out-of-band data",
+          standard: "bsd"
+        },
+        {
+          name: "SIGXCPU",
+          number: 24,
+          action: "core",
+          description: "Process timed out",
+          standard: "bsd"
+        },
+        {
+          name: "SIGXFSZ",
+          number: 25,
+          action: "core",
+          description: "File too big",
+          standard: "bsd"
+        },
+        {
+          name: "SIGVTALRM",
+          number: 26,
+          action: "terminate",
+          description: "Timeout or timer",
+          standard: "bsd"
+        },
+        {
+          name: "SIGPROF",
+          number: 27,
+          action: "terminate",
+          description: "Timeout or timer",
+          standard: "bsd"
+        },
+        {
+          name: "SIGWINCH",
+          number: 28,
+          action: "ignore",
+          description: "Terminal window size changed",
+          standard: "bsd"
+        },
+        {
+          name: "SIGIO",
+          number: 29,
+          action: "terminate",
+          description: "I/O is available",
+          standard: "other"
+        },
+        {
+          name: "SIGPOLL",
+          number: 29,
+          action: "terminate",
+          description: "Watched event",
+          standard: "other"
+        },
+        {
+          name: "SIGINFO",
+          number: 29,
+          action: "ignore",
+          description: "Request for process information",
+          standard: "other"
+        },
+        {
+          name: "SIGPWR",
+          number: 30,
+          action: "terminate",
+          description: "Device running out of power",
+          standard: "systemv"
+        },
+        {
+          name: "SIGSYS",
+          number: 31,
+          action: "core",
+          description: "Invalid system call",
+          standard: "other"
+        },
+        {
+          name: "SIGUNUSED",
+          number: 31,
+          action: "terminate",
+          description: "Invalid system call",
+          standard: "other"
+        }
+      ];
+      t2.SIGNALS = r;
+    },
+    779: (e2, t2, r) => {
+      "use strict";
+      Object.defineProperty(t2, "__esModule", { value: true });
+      t2.signalsByNumber = t2.signalsByName = void 0;
+      var n = r(87);
+      var o = r(435);
+      var i = r(295);
+      const s = function() {
+        const e3 = (0, o.getSignals)();
+        return e3.reduce(a, {});
+      };
+      const a = function(e3, { name: t3, number: r2, description: n2, supported: o2, action: i2, forced: s2, standard: a2 }) {
+        return {
+          ...e3,
+          [t3]: {
+            name: t3,
+            number: r2,
+            description: n2,
+            supported: o2,
+            action: i2,
+            forced: s2,
+            standard: a2
+          }
+        };
+      };
+      const c = s();
+      t2.signalsByName = c;
+      const u = function() {
+        const e3 = (0, o.getSignals)();
+        const t3 = i.SIGRTMAX + 1;
+        const r2 = Array.from({ length: t3 }, (t4, r3) => d(r3, e3));
+        return Object.assign({}, ...r2);
+      };
+      const d = function(e3, t3) {
+        const r2 = l(e3, t3);
+        if (r2 === void 0) {
+          return {};
+        }
+        const { name: n2, description: o2, supported: i2, action: s2, forced: a2, standard: c2 } = r2;
+        return {
+          [e3]: {
+            name: n2,
+            number: e3,
+            description: o2,
+            supported: i2,
+            action: s2,
+            forced: a2,
+            standard: c2
+          }
+        };
+      };
+      const l = function(e3, t3) {
+        const r2 = t3.find(({ name: t4 }) => n.constants.signals[t4] === e3);
+        if (r2 !== void 0) {
+          return r2;
+        }
+        return t3.find((t4) => t4.number === e3);
+      };
+      const f = u();
+      t2.signalsByNumber = f;
+    },
+    295: (e2, t2) => {
+      "use strict";
+      Object.defineProperty(t2, "__esModule", { value: true });
+      t2.SIGRTMAX = t2.getRealtimeSignals = void 0;
+      const r = function() {
+        const e3 = i - o + 1;
+        return Array.from({ length: e3 }, n);
+      };
+      t2.getRealtimeSignals = r;
+      const n = function(e3, t3) {
+        return {
+          name: `SIGRT${t3 + 1}`,
+          number: o + t3,
+          action: "terminate",
+          description: "Application-specific signal (realtime)",
+          standard: "posix"
+        };
+      };
+      const o = 34;
+      const i = 64;
+      t2.SIGRTMAX = i;
+    },
+    435: (e2, t2, r) => {
+      "use strict";
+      Object.defineProperty(t2, "__esModule", { value: true });
+      t2.getSignals = void 0;
+      var n = r(87);
+      var o = r(887);
+      var i = r(295);
+      const s = function() {
+        const e3 = (0, i.getRealtimeSignals)();
+        const t3 = [...o.SIGNALS, ...e3].map(a);
+        return t3;
+      };
+      t2.getSignals = s;
+      const a = function({
+        name: e3,
+        number: t3,
+        description: r2,
+        action: o2,
+        forced: i2 = false,
+        standard: s2
+      }) {
+        const {
+          signals: { [e3]: a2 }
+        } = n.constants;
+        const c = a2 !== void 0;
+        const u = c ? a2 : t3;
+        return {
+          name: e3,
+          number: u,
+          description: r2,
+          supported: c,
+          action: o2,
+          forced: i2,
+          standard: s2
+        };
+      };
+    },
+    554: (e2) => {
+      "use strict";
+      const t2 = (e3) => e3 !== null && typeof e3 === "object" && typeof e3.pipe === "function";
+      t2.writable = (e3) => t2(e3) && e3.writable !== false && typeof e3._write === "function" && typeof e3._writableState === "object";
+      t2.readable = (e3) => t2(e3) && e3.readable !== false && typeof e3._read === "function" && typeof e3._readableState === "object";
+      t2.duplex = (e3) => t2.writable(e3) && t2.readable(e3);
+      t2.transform = (e3) => t2.duplex(e3) && typeof e3._transform === "function" && typeof e3._transformState === "object";
+      e2.exports = t2;
+    },
+    47: (e2) => {
+      "use strict";
+      const t2 = (e3, t3) => {
+        for (const r of Reflect.ownKeys(t3)) {
+          Object.defineProperty(e3, r, Object.getOwnPropertyDescriptor(t3, r));
+        }
+        return e3;
+      };
+      e2.exports = t2;
+      e2.exports.default = t2;
+    },
+    502: (e2, t2, r) => {
+      "use strict";
+      const n = r(622);
+      const o = r(278);
+      const i = (e3) => {
+        e3 = { cwd: process.cwd(), path: process.env[o()], execPath: process.execPath, ...e3 };
+        let t3;
+        let r2 = n.resolve(e3.cwd);
+        const i2 = [];
+        while (t3 !== r2) {
+          i2.push(n.join(r2, "node_modules/.bin"));
+          t3 = r2;
+          r2 = n.resolve(r2, "..");
+        }
+        const s = n.resolve(e3.cwd, e3.execPath, "..");
+        i2.push(s);
+        return i2.concat(e3.path).join(n.delimiter);
+      };
+      e2.exports = i;
+      e2.exports.default = i;
+      e2.exports.env = (t3) => {
+        t3 = { env: process.env, ...t3 };
+        const r2 = { ...t3.env };
+        const n2 = o({ env: r2 });
+        t3.path = r2[n2];
+        r2[n2] = e2.exports(t3);
+        return r2;
+      };
+    },
+    278: (e2) => {
+      "use strict";
+      const t2 = (e3 = {}) => {
+        const t3 = e3.env || process.env;
+        const r = e3.platform || process.platform;
+        if (r !== "win32") {
+          return "PATH";
+        }
+        return Object.keys(t3).reverse().find((e4) => e4.toUpperCase() === "PATH") || "Path";
+      };
+      e2.exports = t2;
+      e2.exports.default = t2;
+    },
+    223: (e2, t2, r) => {
+      var n = r(940);
+      e2.exports = n(once);
+      e2.exports.strict = n(onceStrict);
+      once.proto = once(function() {
+        Object.defineProperty(Function.prototype, "once", {
+          value: function() {
+            return once(this);
+          },
+          configurable: true
+        });
+        Object.defineProperty(Function.prototype, "onceStrict", {
+          value: function() {
+            return onceStrict(this);
+          },
+          configurable: true
+        });
+      });
+      function once(e3) {
+        var t3 = function() {
+          if (t3.called)
+            return t3.value;
+          t3.called = true;
+          return t3.value = e3.apply(this, arguments);
+        };
+        t3.called = false;
+        return t3;
+      }
+      function onceStrict(e3) {
+        var t3 = function() {
+          if (t3.called)
+            throw new Error(t3.onceError);
+          t3.called = true;
+          return t3.value = e3.apply(this, arguments);
+        };
+        var r2 = e3.name || "Function wrapped with `once`";
+        t3.onceError = r2 + " shouldn't be called more than once";
+        t3.called = false;
+        return t3;
+      }
+    },
+    82: (e2, t2, r) => {
+      "use strict";
+      const n = r(47);
+      const o = /* @__PURE__ */ new WeakMap();
+      const i = (e3, t3 = {}) => {
+        if (typeof e3 !== "function") {
+          throw new TypeError("Expected a function");
+        }
+        let r2;
+        let i2 = 0;
+        const s = e3.displayName || e3.name || "<anonymous>";
+        const a = function(...n2) {
+          o.set(a, ++i2);
+          if (i2 === 1) {
+            r2 = e3.apply(this, n2);
+            e3 = null;
+          } else if (t3.throw === true) {
+            throw new Error(`Function \`${s}\` can only be called once`);
+          }
+          return r2;
+        };
+        n(a, e3);
+        o.set(a, i2);
+        return a;
+      };
+      e2.exports = i;
+      e2.exports.default = i;
+      e2.exports.callCount = (e3) => {
+        if (!o.has(e3)) {
+          throw new Error(
+            `The given function \`${e3.name}\` is not wrapped by the \`onetime\` package`
+          );
+        }
+        return o.get(e3);
+      };
+    },
+    341: (e2, t2, r) => {
+      var n = r(223);
+      var o = r(205);
+      var i = r(747);
+      var s = function() {
+      };
+      var a = /^v?\.0/.test(process.version);
+      var c = function(e3) {
+        return typeof e3 === "function";
+      };
+      var u = function(e3) {
+        if (!a)
+          return false;
+        if (!i)
+          return false;
+        return (e3 instanceof (i.ReadStream || s) || e3 instanceof (i.WriteStream || s)) && c(e3.close);
+      };
+      var d = function(e3) {
+        return e3.setHeader && c(e3.abort);
+      };
+      var l = function(e3, t3, r2, i2) {
+        i2 = n(i2);
+        var a2 = false;
+        e3.on("close", function() {
+          a2 = true;
+        });
+        o(e3, { readable: t3, writable: r2 }, function(e4) {
+          if (e4)
+            return i2(e4);
+          a2 = true;
+          i2();
+        });
+        var l2 = false;
+        return function(t4) {
+          if (a2)
+            return;
+          if (l2)
+            return;
+          l2 = true;
+          if (u(e3))
+            return e3.close(s);
+          if (d(e3))
+            return e3.abort();
+          if (c(e3.destroy))
+            return e3.destroy();
+          i2(t4 || new Error("stream was destroyed"));
+        };
+      };
+      var f = function(e3) {
+        e3();
+      };
+      var p = function(e3, t3) {
+        return e3.pipe(t3);
+      };
+      var m = function() {
+        var e3 = Array.prototype.slice.call(arguments);
+        var t3 = c(e3[e3.length - 1] || s) && e3.pop() || s;
+        if (Array.isArray(e3[0]))
+          e3 = e3[0];
+        if (e3.length < 2)
+          throw new Error("pump requires two streams per minimum");
+        var r2;
+        var n2 = e3.map(function(o2, i2) {
+          var s2 = i2 < e3.length - 1;
+          var a2 = i2 > 0;
+          return l(o2, s2, a2, function(e4) {
+            if (!r2)
+              r2 = e4;
+            if (e4)
+              n2.forEach(f);
+            if (s2)
+              return;
+            n2.forEach(f);
+            t3(r2);
+          });
+        });
+        return e3.reduce(p);
+      };
+      e2.exports = m;
+    },
+    931: (e2, t2, r) => {
+      var n = r(357);
+      var o = r(710);
+      var i = /^win/i.test(process.platform);
+      var s = r(614);
+      if (typeof s !== "function") {
+        s = s.EventEmitter;
+      }
+      var a;
+      if (process.__signal_exit_emitter__) {
+        a = process.__signal_exit_emitter__;
+      } else {
+        a = process.__signal_exit_emitter__ = new s();
+        a.count = 0;
+        a.emitted = {};
+      }
+      if (!a.infinite) {
+        a.setMaxListeners(Infinity);
+        a.infinite = true;
+      }
+      e2.exports = function(e3, t3) {
+        n.equal(typeof e3, "function", "a callback must be provided for exit handler");
+        if (u === false) {
+          load();
+        }
+        var r2 = "exit";
+        if (t3 && t3.alwaysLast) {
+          r2 = "afterexit";
+        }
+        var o2 = function() {
+          a.removeListener(r2, e3);
+          if (a.listeners("exit").length === 0 && a.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        a.on(r2, e3);
+        return o2;
+      };
+      e2.exports.unload = unload;
+      function unload() {
+        if (!u) {
+          return;
+        }
+        u = false;
+        o.forEach(function(e3) {
+          try {
+            process.removeListener(e3, c[e3]);
+          } catch (e4) {
+          }
+        });
+        process.emit = l;
+        process.reallyExit = d;
+        a.count -= 1;
+      }
+      function emit(e3, t3, r2) {
+        if (a.emitted[e3]) {
+          return;
+        }
+        a.emitted[e3] = true;
+        a.emit(e3, t3, r2);
+      }
+      var c = {};
+      o.forEach(function(e3) {
+        c[e3] = function listener() {
+          var t3 = process.listeners(e3);
+          if (t3.length === a.count) {
+            unload();
+            emit("exit", null, e3);
+            emit("afterexit", null, e3);
+            if (i && e3 === "SIGHUP") {
+              e3 = "SIGINT";
+            }
+            process.kill(process.pid, e3);
+          }
+        };
+      });
+      e2.exports.signals = function() {
+        return o;
+      };
+      e2.exports.load = load;
+      var u = false;
+      function load() {
+        if (u) {
+          return;
+        }
+        u = true;
+        a.count += 1;
+        o = o.filter(function(e3) {
+          try {
+            process.on(e3, c[e3]);
+            return true;
+          } catch (e4) {
+            return false;
+          }
+        });
+        process.emit = processEmit;
+        process.reallyExit = processReallyExit;
+      }
+      var d = process.reallyExit;
+      function processReallyExit(e3) {
+        process.exitCode = e3 || 0;
+        emit("exit", process.exitCode, null);
+        emit("afterexit", process.exitCode, null);
+        d.call(process, process.exitCode);
+      }
+      var l = process.emit;
+      function processEmit(e3, t3) {
+        if (e3 === "exit") {
+          if (t3 !== void 0) {
+            process.exitCode = t3;
+          }
+          var r2 = l.apply(this, arguments);
+          emit("exit", process.exitCode, null);
+          emit("afterexit", process.exitCode, null);
+          return r2;
+        } else {
+          return l.apply(this, arguments);
+        }
+      }
+    },
+    710: (e2) => {
+      e2.exports = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
+      if (process.platform !== "win32") {
+        e2.exports.push(
+          "SIGVTALRM",
+          "SIGXCPU",
+          "SIGXFSZ",
+          "SIGUSR2",
+          "SIGTRAP",
+          "SIGSYS",
+          "SIGQUIT",
+          "SIGIOT"
+        );
+      }
+      if (process.platform === "linux") {
+        e2.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+      }
+    },
+    174: (e2) => {
+      "use strict";
+      e2.exports = (e3) => {
+        const t2 = typeof e3 === "string" ? "\n" : "\n".charCodeAt();
+        const r = typeof e3 === "string" ? "\r" : "\r".charCodeAt();
+        if (e3[e3.length - 1] === t2) {
+          e3 = e3.slice(0, e3.length - 1);
+        }
+        if (e3[e3.length - 1] === r) {
+          e3 = e3.slice(0, e3.length - 1);
+        }
+        return e3;
+      };
+    },
+    940: (e2) => {
+      e2.exports = wrappy;
+      function wrappy(e3, t2) {
+        if (e3 && t2)
+          return wrappy(e3)(t2);
+        if (typeof e3 !== "function")
+          throw new TypeError("need wrapper function");
+        Object.keys(e3).forEach(function(t3) {
+          wrapper[t3] = e3[t3];
+        });
+        return wrapper;
+        function wrapper() {
+          var t3 = new Array(arguments.length);
+          for (var r = 0; r < t3.length; r++) {
+            t3[r] = arguments[r];
+          }
+          var n = e3.apply(this, t3);
+          var o = t3[t3.length - 1];
+          if (typeof n === "function" && n !== o) {
+            Object.keys(o).forEach(function(e4) {
+              n[e4] = o[e4];
+            });
+          }
+          return n;
+        }
+      }
+    },
+    213: (e2) => {
+      "use strict";
+      e2.exports = require("../cross-spawn");
+    },
+    583: (e2) => {
+      "use strict";
+      e2.exports = require("../merge-stream");
+    },
+    357: (e2) => {
+      "use strict";
+      e2.exports = require("assert");
+    },
+    293: (e2) => {
+      "use strict";
+      e2.exports = require("buffer");
+    },
+    129: (e2) => {
+      "use strict";
+      e2.exports = require("child_process");
+    },
+    614: (e2) => {
+      "use strict";
+      e2.exports = require("events");
+    },
+    747: (e2) => {
+      "use strict";
+      e2.exports = require("fs");
+    },
+    87: (e2) => {
+      "use strict";
+      e2.exports = require("os");
+    },
+    622: (e2) => {
+      "use strict";
+      e2.exports = require("path");
+    },
+    413: (e2) => {
+      "use strict";
+      e2.exports = require("stream");
+    }
+  };
+  var t = {};
+  function __nccwpck_require__(r) {
+    if (t[r]) {
+      return t[r].exports;
+    }
+    var n = t[r] = { exports: {} };
+    var o = true;
+    try {
+      e[r](n, n.exports, __nccwpck_require__);
+      o = false;
+    } finally {
+      if (o)
+        delete t[r];
+    }
+    return n.exports;
+  }
+  __nccwpck_require__.ab = __dirname + "/";
+  return __nccwpck_require__(447);
+})();