npm-pkg-lint 2.0.0 → 2.0.2

package/dist/index.js

@@ -60,6 +60,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return __privateGet(obj, member, getter);
   }
 });
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // node_modules/argparse/lib/sub.js
 var require_sub = __commonJS({
@@ -2453,12 +2457,12 @@ var require_argparse = __commonJS({
         this._positionals = this.add_argument_group("positional arguments");
         this._optionals = this.add_argument_group("optional arguments");
         this._subparsers = void 0;
-        function identity(string) {
+        function identity2(string) {
           return string;
         }
-        this.register("type", void 0, identity);
-        this.register("type", null, identity);
-        this.register("type", "auto", identity);
+        this.register("type", void 0, identity2);
+        this.register("type", null, identity2);
+        this.register("type", "auto", identity2);
         this.register("type", "int", function(x) {
           let result = Number(x);
           if (!Number.isInteger(result)) {
@@ -7886,9 +7890,9 @@ var require_read_entry = __commonJS({
         }
         return super.write(data.slice(0, r));
       }
-      [SLURP](ex, global2) {
+      [SLURP](ex, global3) {
         for (const k in ex) {
-          if (ex[k] !== null && ex[k] !== void 0 && !(global2 && k === "path")) {
+          if (ex[k] !== null && ex[k] !== void 0 && !(global3 && k === "path")) {
             this[k] = k === "path" || k === "linkpath" ? normPath(ex[k]) : ex[k];
           }
         }
@@ -8126,9 +8130,9 @@ var require_header = __commonJS({
           this.nullBlock = true;
         }
       }
-      [SLURP](ex, global2) {
+      [SLURP](ex, global3) {
         for (const k in ex) {
-          if (ex[k] !== null && ex[k] !== void 0 && !(global2 && k === "path")) {
+          if (ex[k] !== null && ex[k] !== void 0 && !(global3 && k === "path")) {
             this[k] = ex[k];
           }
         }
@@ -8261,7 +8265,7 @@ var require_pax = __commonJS({
     var Header = require_header();
     var path7 = __require("path");
     var Pax = class {
-      constructor(obj, global2) {
+      constructor(obj, global3) {
         this.atime = obj.atime || null;
         this.charset = obj.charset || null;
         this.comment = obj.comment || null;
@@ -8277,7 +8281,7 @@ var require_pax = __commonJS({
         this.dev = obj.dev || null;
         this.ino = obj.ino || null;
         this.nlink = obj.nlink || null;
-        this.global = global2 || false;
+        this.global = global3 || false;
       }
       encode() {
         const body = this.encodeBody();
@@ -10089,7 +10093,7 @@ var require_parse = __commonJS({
     var SAW_NULL_BLOCK = Symbol("sawNullBlock");
     var SAW_EOF = Symbol("sawEOF");
     var CLOSESTREAM = Symbol("closeStream");
-    var noop = (_) => true;
+    var noop2 = (_) => true;
     module.exports = warner(class Parser extends EE {
       constructor(opt) {
         opt = opt || {};
@@ -10112,7 +10116,7 @@ var require_parse = __commonJS({
         }
         this.strict = !!opt.strict;
         this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
-        this.filter = typeof opt.filter === "function" ? opt.filter : noop;
+        this.filter = typeof opt.filter === "function" ? opt.filter : noop2;
         this.writable = true;
         this.readable = false;
         this[QUEUE] = new Yallist();
@@ -14924,302 +14928,6 @@ var require_cross_spawn = __commonJS({
   }
 });
 
-// node_modules/signal-exit/signals.js
-var require_signals = __commonJS({
-  "node_modules/signal-exit/signals.js"(exports, module) {
-    module.exports = [
-      "SIGABRT",
-      "SIGALRM",
-      "SIGHUP",
-      "SIGINT",
-      "SIGTERM"
-    ];
-    if (process.platform !== "win32") {
-      module.exports.push(
-        "SIGVTALRM",
-        "SIGXCPU",
-        "SIGXFSZ",
-        "SIGUSR2",
-        "SIGTRAP",
-        "SIGSYS",
-        "SIGQUIT",
-        "SIGIOT"
-        // should detect profiler and enable/disable accordingly.
-        // see #21
-        // 'SIGPROF'
-      );
-    }
-    if (process.platform === "linux") {
-      module.exports.push(
-        "SIGIO",
-        "SIGPOLL",
-        "SIGPWR",
-        "SIGSTKFLT",
-        "SIGUNUSED"
-      );
-    }
-  }
-});
-
-// node_modules/signal-exit/index.js
-var require_signal_exit = __commonJS({
-  "node_modules/signal-exit/index.js"(exports, module) {
-    var process7 = global.process;
-    var processOk = function(process8) {
-      return process8 && typeof process8 === "object" && typeof process8.removeListener === "function" && typeof process8.emit === "function" && typeof process8.reallyExit === "function" && typeof process8.listeners === "function" && typeof process8.kill === "function" && typeof process8.pid === "number" && typeof process8.on === "function";
-    };
-    if (!processOk(process7)) {
-      module.exports = function() {
-        return function() {
-        };
-      };
-    } else {
-      assert = __require("assert");
-      signals = require_signals();
-      isWin = /^win/i.test(process7.platform);
-      EE = __require("events");
-      if (typeof EE !== "function") {
-        EE = EE.EventEmitter;
-      }
-      if (process7.__signal_exit_emitter__) {
-        emitter = process7.__signal_exit_emitter__;
-      } else {
-        emitter = process7.__signal_exit_emitter__ = new EE();
-        emitter.count = 0;
-        emitter.emitted = {};
-      }
-      if (!emitter.infinite) {
-        emitter.setMaxListeners(Infinity);
-        emitter.infinite = true;
-      }
-      module.exports = function(cb, opts) {
-        if (!processOk(global.process)) {
-          return function() {
-          };
-        }
-        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
-        if (loaded === false) {
-          load();
-        }
-        var ev = "exit";
-        if (opts && opts.alwaysLast) {
-          ev = "afterexit";
-        }
-        var remove = function() {
-          emitter.removeListener(ev, cb);
-          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
-            unload();
-          }
-        };
-        emitter.on(ev, cb);
-        return remove;
-      };
-      unload = function unload2() {
-        if (!loaded || !processOk(global.process)) {
-          return;
-        }
-        loaded = false;
-        signals.forEach(function(sig) {
-          try {
-            process7.removeListener(sig, sigListeners[sig]);
-          } catch (er) {
-          }
-        });
-        process7.emit = originalProcessEmit;
-        process7.reallyExit = originalProcessReallyExit;
-        emitter.count -= 1;
-      };
-      module.exports.unload = unload;
-      emit = function emit2(event, code, signal) {
-        if (emitter.emitted[event]) {
-          return;
-        }
-        emitter.emitted[event] = true;
-        emitter.emit(event, code, signal);
-      };
-      sigListeners = {};
-      signals.forEach(function(sig) {
-        sigListeners[sig] = function listener() {
-          if (!processOk(global.process)) {
-            return;
-          }
-          var listeners = process7.listeners(sig);
-          if (listeners.length === emitter.count) {
-            unload();
-            emit("exit", null, sig);
-            emit("afterexit", null, sig);
-            if (isWin && sig === "SIGHUP") {
-              sig = "SIGINT";
-            }
-            process7.kill(process7.pid, sig);
-          }
-        };
-      });
-      module.exports.signals = function() {
-        return signals;
-      };
-      loaded = false;
-      load = function load2() {
-        if (loaded || !processOk(global.process)) {
-          return;
-        }
-        loaded = true;
-        emitter.count += 1;
-        signals = signals.filter(function(sig) {
-          try {
-            process7.on(sig, sigListeners[sig]);
-            return true;
-          } catch (er) {
-            return false;
-          }
-        });
-        process7.emit = processEmit;
-        process7.reallyExit = processReallyExit;
-      };
-      module.exports.load = load;
-      originalProcessReallyExit = process7.reallyExit;
-      processReallyExit = function processReallyExit2(code) {
-        if (!processOk(global.process)) {
-          return;
-        }
-        process7.exitCode = code || /* istanbul ignore next */
-        0;
-        emit("exit", process7.exitCode, null);
-        emit("afterexit", process7.exitCode, null);
-        originalProcessReallyExit.call(process7, process7.exitCode);
-      };
-      originalProcessEmit = process7.emit;
-      processEmit = function processEmit2(ev, arg) {
-        if (ev === "exit" && processOk(global.process)) {
-          if (arg !== void 0) {
-            process7.exitCode = arg;
-          }
-          var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process7.exitCode, null);
-          emit("afterexit", process7.exitCode, null);
-          return ret;
-        } else {
-          return originalProcessEmit.apply(this, arguments);
-        }
-      };
-    }
-    var assert;
-    var signals;
-    var isWin;
-    var EE;
-    var emitter;
-    var unload;
-    var emit;
-    var sigListeners;
-    var loaded;
-    var load;
-    var originalProcessReallyExit;
-    var processReallyExit;
-    var originalProcessEmit;
-    var processEmit;
-  }
-});
-
-// node_modules/get-stream/buffer-stream.js
-var require_buffer_stream = __commonJS({
-  "node_modules/get-stream/buffer-stream.js"(exports, module) {
-    "use strict";
-    var { PassThrough: PassThroughStream } = __require("stream");
-    module.exports = (options) => {
-      options = { ...options };
-      const { array } = options;
-      let { encoding } = options;
-      const isBuffer = encoding === "buffer";
-      let objectMode = false;
-      if (array) {
-        objectMode = !(encoding || isBuffer);
-      } else {
-        encoding = encoding || "utf8";
-      }
-      if (isBuffer) {
-        encoding = null;
-      }
-      const stream = new PassThroughStream({ objectMode });
-      if (encoding) {
-        stream.setEncoding(encoding);
-      }
-      let length = 0;
-      const chunks = [];
-      stream.on("data", (chunk) => {
-        chunks.push(chunk);
-        if (objectMode) {
-          length = chunks.length;
-        } else {
-          length += chunk.length;
-        }
-      });
-      stream.getBufferedValue = () => {
-        if (array) {
-          return chunks;
-        }
-        return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
-      };
-      stream.getBufferedLength = () => length;
-      return stream;
-    };
-  }
-});
-
-// node_modules/get-stream/index.js
-var require_get_stream = __commonJS({
-  "node_modules/get-stream/index.js"(exports, module) {
-    "use strict";
-    var { constants: BufferConstants } = __require("buffer");
-    var stream = __require("stream");
-    var { promisify } = __require("util");
-    var bufferStream = require_buffer_stream();
-    var streamPipelinePromisified = promisify(stream.pipeline);
-    var MaxBufferError = class extends Error {
-      constructor() {
-        super("maxBuffer exceeded");
-        this.name = "MaxBufferError";
-      }
-    };
-    async function getStream2(inputStream, options) {
-      if (!inputStream) {
-        throw new Error("Expected a stream");
-      }
-      options = {
-        maxBuffer: Infinity,
-        ...options
-      };
-      const { maxBuffer } = options;
-      const stream2 = bufferStream(options);
-      await new Promise((resolve, reject) => {
-        const rejectPromise = (error) => {
-          if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-            error.bufferedData = stream2.getBufferedValue();
-          }
-          reject(error);
-        };
-        (async () => {
-          try {
-            await streamPipelinePromisified(inputStream, stream2);
-            resolve();
-          } catch (error) {
-            rejectPromise(error);
-          }
-        })();
-        stream2.on("data", () => {
-          if (stream2.getBufferedLength() > maxBuffer) {
-            rejectPromise(new MaxBufferError());
-          }
-        });
-      });
-      return stream2.getBufferedValue();
-    }
-    module.exports = getStream2;
-    module.exports.buffer = (stream2, options) => getStream2(stream2, { ...options, encoding: "buffer" });
-    module.exports.array = (stream2, options) => getStream2(stream2, { ...options, array: true });
-    module.exports.MaxBufferError = MaxBufferError;
-  }
-});
-
 // node_modules/merge-stream/index.js
 var require_merge_stream = __commonJS({
   "node_modules/merge-stream/index.js"(exports, module) {
@@ -15689,7 +15397,7 @@ function stylish(results) {
     fixableWarningCount += result.fixableWarningCount;
     const rows = messages.map((message) => {
       let messageType;
-      if (message.fatal || message.severity === 2) {
+      if (Boolean(message.fatal) || message.severity === 2) {
         messageType = red2("error");
         summaryColor = red2;
       } else {
@@ -15697,8 +15405,8 @@ function stylish(results) {
       }
       return [
         "",
-        message.line || 0,
-        message.column || 0,
+        message.line ?? 0,
+        message.column ?? 0,
         messageType,
         message.message.replace(/([^ ])\.$/u, "$1"),
         message.ruleId ? dim2(message.ruleId) : ""
@@ -16368,7 +16076,7 @@ var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 import { Buffer as Buffer3 } from "buffer";
 import path4 from "path";
 import childProcess from "child_process";
-import process6 from "process";
+import process7 from "process";
 
 // node_modules/execa/node_modules/strip-final-newline/index.js
 function stripFinalNewline(input) {
@@ -16803,8 +16511,8 @@ var SIGNALS = [
 // node_modules/execa/node_modules/human-signals/build/src/signals.js
 var getSignals = () => {
   const realtimeSignals = getRealtimeSignals();
-  const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
-  return signals;
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+  return signals2;
 };
 var normalizeSignal = ({
   name,
@@ -16824,8 +16532,8 @@ var normalizeSignal = ({
 
 // node_modules/execa/node_modules/human-signals/build/src/main.js
 var getSignalsByName = () => {
-  const signals = getSignals();
-  return Object.fromEntries(signals.map(getSignalByName));
+  const signals2 = getSignals();
+  return Object.fromEntries(signals2.map(getSignalByName));
 };
 var getSignalByName = ({
   name,
@@ -16838,13 +16546,16 @@ var getSignalByName = ({
 }) => [name, { name, number, description, supported, action, forced, standard }];
 var signalsByName = getSignalsByName();
 var getSignalsByNumber = () => {
-  const signals = getSignals();
+  const signals2 = getSignals();
   const length = SIGRTMAX + 1;
-  const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
+  const signalsA = Array.from(
+    { length },
+    (value, number) => getSignalByNumber(number, signals2)
+  );
   return Object.assign({}, ...signalsA);
 };
-var getSignalByNumber = (number, signals) => {
-  const signal = findSignalByNumber(number, signals);
+var getSignalByNumber = (number, signals2) => {
+  const signal = findSignalByNumber(number, signals2);
   if (signal === void 0) {
     return {};
   }
@@ -16861,12 +16572,12 @@ var getSignalByNumber = (number, signals) => {
     }
   };
 };
-var findSignalByNumber = (number, signals) => {
-  const signal = signals.find(({ name }) => constants2.signals[name] === number);
+var findSignalByNumber = (number, signals2) => {
+  const signal = signals2.find(({ name }) => constants2.signals[name] === number);
   if (signal !== void 0) {
     return signal;
   }
-  return signals.find((signalA) => signalA.number === number);
+  return signals2.find((signalA) => signalA.number === number);
 };
 var signalsByNumber = getSignalsByNumber();
 
@@ -16966,8 +16677,272 @@ var normalizeStdio = (options) => {
 };
 
 // node_modules/execa/lib/kill.js
-var import_signal_exit = __toESM(require_signal_exit(), 1);
 import os from "os";
+
+// node_modules/execa/node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// node_modules/execa/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process8) => !!process8 && typeof process8 === "object" && typeof process8.removeListener === "function" && typeof process8.emit === "function" && typeof process8.reallyExit === "function" && typeof process8.listeners === "function" && typeof process8.kill === "function" && typeof process8.pid === "number" && typeof process8.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global2 = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global2[kExitEmitter]) {
+      return global2[kExitEmitter];
+    }
+    ObjectDefineProperty(global2, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+};
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+var SignalExitFallback = class extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+};
+var _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _processReallyExit, processReallyExit_fn, _processEmit, processEmit_fn;
+var SignalExit = class extends SignalExitBase {
+  constructor(process8) {
+    super();
+    __privateAdd(this, _processReallyExit);
+    __privateAdd(this, _processEmit);
+    // "SIGHUP" throws an `ENOSYS` error on Windows,
+    // so use a supported signal instead
+    /* c8 ignore start */
+    __privateAdd(this, _hupSig, process5.platform === "win32" ? "SIGINT" : "SIGHUP");
+    /* c8 ignore stop */
+    __privateAdd(this, _emitter, new Emitter());
+    __privateAdd(this, _process, void 0);
+    __privateAdd(this, _originalProcessEmit, void 0);
+    __privateAdd(this, _originalProcessReallyExit, void 0);
+    __privateAdd(this, _sigListeners, {});
+    __privateAdd(this, _loaded, false);
+    __privateSet(this, _process, process8);
+    __privateSet(this, _sigListeners, {});
+    for (const sig of signals) {
+      __privateGet(this, _sigListeners)[sig] = () => {
+        const listeners = __privateGet(this, _process).listeners(sig);
+        let { count } = __privateGet(this, _emitter);
+        const p = process8;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = __privateGet(this, _emitter).emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? __privateGet(this, _hupSig) : sig;
+          if (!ret)
+            process8.kill(process8.pid, s);
+        }
+      };
+    }
+    __privateSet(this, _originalProcessReallyExit, process8.reallyExit);
+    __privateSet(this, _originalProcessEmit, process8.emit);
+  }
+  onExit(cb, opts) {
+    if (!processOk(__privateGet(this, _process))) {
+      return () => {
+      };
+    }
+    if (__privateGet(this, _loaded) === false) {
+      this.load();
+    }
+    const ev = (opts == null ? void 0 : opts.alwaysLast) ? "afterExit" : "exit";
+    __privateGet(this, _emitter).on(ev, cb);
+    return () => {
+      __privateGet(this, _emitter).removeListener(ev, cb);
+      if (__privateGet(this, _emitter).listeners["exit"].length === 0 && __privateGet(this, _emitter).listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (__privateGet(this, _loaded)) {
+      return;
+    }
+    __privateSet(this, _loaded, true);
+    __privateGet(this, _emitter).count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = __privateGet(this, _sigListeners)[sig];
+        if (fn)
+          __privateGet(this, _process).on(sig, fn);
+      } catch (_) {
+      }
+    }
+    __privateGet(this, _process).emit = (ev, ...a) => {
+      return __privateMethod(this, _processEmit, processEmit_fn).call(this, ev, ...a);
+    };
+    __privateGet(this, _process).reallyExit = (code) => {
+      return __privateMethod(this, _processReallyExit, processReallyExit_fn).call(this, code);
+    };
+  }
+  unload() {
+    if (!__privateGet(this, _loaded)) {
+      return;
+    }
+    __privateSet(this, _loaded, false);
+    signals.forEach((sig) => {
+      const listener = __privateGet(this, _sigListeners)[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        __privateGet(this, _process).removeListener(sig, listener);
+      } catch (_) {
+      }
+    });
+    __privateGet(this, _process).emit = __privateGet(this, _originalProcessEmit);
+    __privateGet(this, _process).reallyExit = __privateGet(this, _originalProcessReallyExit);
+    __privateGet(this, _emitter).count -= 1;
+  }
+};
+_hupSig = new WeakMap();
+_emitter = new WeakMap();
+_process = new WeakMap();
+_originalProcessEmit = new WeakMap();
+_originalProcessReallyExit = new WeakMap();
+_sigListeners = new WeakMap();
+_loaded = new WeakMap();
+_processReallyExit = new WeakSet();
+processReallyExit_fn = function(code) {
+  if (!processOk(__privateGet(this, _process))) {
+    return 0;
+  }
+  __privateGet(this, _process).exitCode = code || 0;
+  __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
+  return __privateGet(this, _originalProcessReallyExit).call(__privateGet(this, _process), __privateGet(this, _process).exitCode);
+};
+_processEmit = new WeakSet();
+processEmit_fn = function(ev, ...args) {
+  const og = __privateGet(this, _originalProcessEmit);
+  if (ev === "exit" && processOk(__privateGet(this, _process))) {
+    if (typeof args[0] === "number") {
+      __privateGet(this, _process).exitCode = args[0];
+    }
+    const ret = og.call(__privateGet(this, _process), ev, ...args);
+    __privateGet(this, _emitter).emit("exit", __privateGet(this, _process).exitCode, null);
+    return ret;
+  } else {
+    return og.call(__privateGet(this, _process), ev, ...args);
+  }
+};
+var process5 = globalThis.process;
+var {
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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
+} = signalExitWrap(processOk(process5) ? new SignalExit(process5) : new SignalExitFallback());
+
+// node_modules/execa/lib/kill.js
 var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
 var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
   const killResult = kill(signal);
@@ -17031,7 +17006,7 @@ var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
   if (!cleanup || detached) {
     return timedPromise;
   }
-  const removeExitHandler = (0, import_signal_exit.default)(() => {
+  const removeExitHandler = onExit(() => {
     spawned.kill();
   });
   return timedPromise.finally(() => {
@@ -17085,7 +17060,192 @@ var addPipeMethods = (spawned) => {
 
 // node_modules/execa/lib/stream.js
 import { createReadStream, readFileSync } from "fs";
-var import_get_stream = __toESM(require_get_stream(), 1);
+import { setTimeout as setTimeout2 } from "timers/promises";
+
+// node_modules/execa/node_modules/get-stream/source/contents.js
+var getStreamContents = async (stream, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+  if (!isAsyncIterable(stream)) {
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+  }
+  const state = init2();
+  state.length = 0;
+  try {
+    for await (const chunk of stream) {
+      const chunkType = getChunkType(chunk);
+      const convertedChunk = convertChunk[chunkType](chunk, state);
+      appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+    }
+    appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
+    return finalize(state);
+  } catch (error) {
+    error.bufferedData = finalize(state);
+    throw error;
+  }
+};
+var appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+  const convertedChunk = getFinalChunk(state);
+  if (convertedChunk !== void 0) {
+    appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+  }
+};
+var appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+  const chunkSize = getSize(convertedChunk);
+  const newLength = state.length + chunkSize;
+  if (newLength <= maxBuffer) {
+    addNewChunk(convertedChunk, state, addChunk, newLength);
+    return;
+  }
+  const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+  if (truncatedChunk !== void 0) {
+    addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
+  }
+  throw new MaxBufferError();
+};
+var addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+  state.contents = addChunk(convertedChunk, state, newLength);
+  state.length = newLength;
+};
+var isAsyncIterable = (stream) => typeof stream === "object" && stream !== null && typeof stream[Symbol.asyncIterator] === "function";
+var getChunkType = (chunk) => {
+  var _a;
+  const typeOfChunk = typeof chunk;
+  if (typeOfChunk === "string") {
+    return "string";
+  }
+  if (typeOfChunk !== "object" || chunk === null) {
+    return "others";
+  }
+  if ((_a = globalThis.Buffer) == null ? void 0 : _a.isBuffer(chunk)) {
+    return "buffer";
+  }
+  const prototypeName = objectToString.call(chunk);
+  if (prototypeName === "[object ArrayBuffer]") {
+    return "arrayBuffer";
+  }
+  if (prototypeName === "[object DataView]") {
+    return "dataView";
+  }
+  if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]") {
+    return "typedArray";
+  }
+  return "others";
+};
+var { toString: objectToString } = Object.prototype;
+var MaxBufferError = class extends Error {
+  name = "MaxBufferError";
+  constructor() {
+    super("maxBuffer exceeded");
+  }
+};
+
+// node_modules/execa/node_modules/get-stream/source/utils.js
+var identity = (value) => value;
+var noop = () => void 0;
+var getContentsProp = ({ contents }) => contents;
+var throwObjectStream = (chunk) => {
+  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+};
+var getLengthProp = (convertedChunk) => convertedChunk.length;
+
+// node_modules/execa/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream, options) {
+  return getStreamContents(stream, arrayBufferMethods, options);
+}
+var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+var useTextEncoder = (chunk) => textEncoder.encode(chunk);
+var textEncoder = new TextEncoder();
+var useUint8Array = (chunk) => new Uint8Array(chunk);
+var useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+var truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+  const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+  new Uint8Array(newContents).set(convertedChunk, previousLength);
+  return newContents;
+};
+var resizeArrayBufferSlow = (contents, length) => {
+  if (length <= contents.byteLength) {
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var resizeArrayBuffer = (contents, length) => {
+  if (length <= contents.maxByteLength) {
+    contents.resize(length);
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+var SCALE_FACTOR = 2;
+var finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+var hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+var arrayBufferMethods = {
+  init: initArrayBuffer,
+  convertChunk: {
+    string: useTextEncoder,
+    buffer: useUint8Array,
+    arrayBuffer: useUint8Array,
+    dataView: useUint8ArrayWithOffset,
+    typedArray: useUint8ArrayWithOffset,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateArrayBufferChunk,
+  addChunk: addArrayBufferChunk,
+  getFinalChunk: noop,
+  finalize: finalizeArrayBuffer
+};
+
+// node_modules/execa/node_modules/get-stream/source/buffer.js
+async function getStreamAsBuffer(stream, options) {
+  if (!("Buffer" in globalThis)) {
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  }
+  try {
+    return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options));
+  } catch (error) {
+    if (error.bufferedData !== void 0) {
+      error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData);
+    }
+    throw error;
+  }
+}
+var arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+
+// node_modules/execa/node_modules/get-stream/source/string.js
+async function getStreamAsString(stream, options) {
+  return getStreamContents(stream, stringMethods, options);
+}
+var initString = () => ({ contents: "", textDecoder: new TextDecoder() });
+var useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true });
+var addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
+var truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var getFinalStringChunk = ({ textDecoder }) => {
+  const finalChunk = textDecoder.decode();
+  return finalChunk === "" ? void 0 : finalChunk;
+};
+var stringMethods = {
+  init: initString,
+  convertChunk: {
+    string: identity,
+    buffer: useTextDecoder,
+    arrayBuffer: useTextDecoder,
+    dataView: useTextDecoder,
+    typedArray: useTextDecoder,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateStringChunk,
+  addChunk: addStringChunk,
+  getFinalChunk: getFinalStringChunk,
+  finalize: getContentsProp
+};
+
+// node_modules/execa/lib/stream.js
 var import_merge_stream = __toESM(require_merge_stream(), 1);
 var validateInputOptions = (input) => {
   if (input !== void 0) {
@@ -17141,6 +17301,7 @@ var getBufferedData = async (stream, streamPromise) => {
   if (!stream || streamPromise === void 0) {
     return;
   }
+  await setTimeout2(0);
   stream.destroy();
   try {
     return await streamPromise;
@@ -17152,10 +17313,17 @@ var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
   if (!stream || !buffer) {
     return;
   }
-  if (encoding) {
-    return (0, import_get_stream.default)(stream, { encoding, maxBuffer });
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return getStreamAsString(stream, { maxBuffer });
   }
-  return import_get_stream.default.buffer(stream, { maxBuffer });
+  if (encoding === null || encoding === "buffer") {
+    return getStreamAsBuffer(stream, { maxBuffer });
+  }
+  return applyEncoding(stream, maxBuffer, encoding);
+};
+var applyEncoding = async (stream, maxBuffer, encoding) => {
+  const buffer = await getStreamAsBuffer(stream, { maxBuffer });
+  return buffer.toString(encoding);
 };
 var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
   const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
@@ -17210,12 +17378,11 @@ var normalizeArgs = (file, args = []) => {
   return [file, ...args];
 };
 var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-var DOUBLE_QUOTES_REGEXP = /"/g;
 var escapeArg = (arg) => {
   if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
     return arg;
   }
-  return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+  return `"${arg.replaceAll('"', '\\"')}"`;
 };
 var joinCommand = (file, args) => normalizeArgs(file, args).join(" ");
 var getEscapedCommand = (file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
@@ -17242,7 +17409,7 @@ var parseExpression = (expression) => {
 };
 var concatTokens = (tokens, nextTokens, isNew) => isNew || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
   ...tokens.slice(0, -1),
-  `${tokens[tokens.length - 1]}${nextTokens[0]}`,
+  `${tokens.at(-1)}${nextTokens[0]}`,
   ...nextTokens.slice(1)
 ];
 var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
@@ -17274,7 +17441,7 @@ var parseTemplates = (templates, expressions) => {
 
 // node_modules/execa/lib/verbose.js
 import { debuglog } from "util";
-import process5 from "process";
+import process6 from "process";
 var verboseDefault = debuglog("execa").enabled;
 var padField = (field, padding) => String(field).padStart(padding, "0");
 var getTimestamp = () => {
@@ -17285,14 +17452,14 @@ var logCommand = (escapedCommand, { verbose }) => {
   if (!verbose) {
     return;
   }
-  process5.stderr.write(`[${getTimestamp()}] ${escapedCommand}
+  process6.stderr.write(`[${getTimestamp()}] ${escapedCommand}
 `);
 };
 
 // node_modules/execa/index.js
 var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
 var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
-  const env = extendEnv ? { ...process6.env, ...envOption } : envOption;
+  const env = extendEnv ? { ...process7.env, ...envOption } : envOption;
   if (preferLocal) {
     return npmRunPathEnv({ env, cwd: localDir, execPath });
   }
@@ -17309,8 +17476,8 @@ var handleArguments = (file, args, options = {}) => {
     stripFinalNewline: true,
     extendEnv: true,
     preferLocal: false,
-    localDir: options.cwd || process6.cwd(),
-    execPath: process6.execPath,
+    localDir: options.cwd || process7.cwd(),
+    execPath: process7.execPath,
     encoding: "utf8",
     reject: true,
     cleanup: true,
@@ -17321,7 +17488,7 @@ var handleArguments = (file, args, options = {}) => {
   };
   options.env = getEnv(options);
   options.stdio = normalizeStdio(options);
-  if (process6.platform === "win32" && path4.basename(file, ".exe") === "cmd") {
+  if (process7.platform === "win32" && path4.basename(file, ".exe") === "cmd") {
     args.unshift("/q");
   }
   return { file, args, options, parsed };