wxt 0.8.6 → 0.8.7

package/dist/index.cjs

@@ -695,10 +695,10 @@ var init_onetime = __esm({
   }
 });
 
-// node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/realtime.js
+// node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/realtime.js
 var getRealtimeSignals, getRealtimeSignal, SIGRTMIN, SIGRTMAX;
 var init_realtime = __esm({
-  "node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/realtime.js"() {
+  "node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/realtime.js"() {
     "use strict";
     getRealtimeSignals = () => {
       const length = SIGRTMAX - SIGRTMIN + 1;
@@ -716,10 +716,10 @@ var init_realtime = __esm({
   }
 });
 
-// node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/core.js
+// node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/core.js
 var SIGNALS;
 var init_core = __esm({
-  "node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/core.js"() {
+  "node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/core.js"() {
     "use strict";
     SIGNALS = [
       {
@@ -995,18 +995,18 @@ var init_core = __esm({
   }
 });
 
-// node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/signals.js
+// node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js
 var import_node_os, getSignals, normalizeSignal;
 var init_signals = __esm({
-  "node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/signals.js"() {
+  "node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js"() {
     "use strict";
     import_node_os = require("os");
     init_core();
     init_realtime();
     getSignals = () => {
       const realtimeSignals = getRealtimeSignals();
-      const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
-      return signals;
+      const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+      return signals2;
     };
     normalizeSignal = ({
       name,
@@ -1026,17 +1026,17 @@ var init_signals = __esm({
   }
 });
 
-// node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/main.js
+// node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js
 var import_node_os2, getSignalsByName, getSignalByName, signalsByName, getSignalsByNumber, getSignalByNumber, findSignalByNumber, signalsByNumber;
 var init_main = __esm({
-  "node_modules/.pnpm/human-signals@4.3.1/node_modules/human-signals/build/src/main.js"() {
+  "node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js"() {
     "use strict";
     import_node_os2 = require("os");
     init_realtime();
     init_signals();
     getSignalsByName = () => {
-      const signals = getSignals();
-      return Object.fromEntries(signals.map(getSignalByName));
+      const signals2 = getSignals();
+      return Object.fromEntries(signals2.map(getSignalByName));
     };
     getSignalByName = ({
       name,
@@ -1049,13 +1049,16 @@ var init_main = __esm({
     }) => [name, { name, number, description, supported, action, forced, standard }];
     signalsByName = getSignalsByName();
     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);
     };
-    getSignalByNumber = (number, signals) => {
-      const signal = findSignalByNumber(number, signals);
+    getSignalByNumber = (number, signals2) => {
+      const signal = findSignalByNumber(number, signals2);
       if (signal === void 0) {
         return {};
       }
@@ -1072,21 +1075,21 @@ var init_main = __esm({
         }
       };
     };
-    findSignalByNumber = (number, signals) => {
-      const signal = signals.find(({ name }) => import_node_os2.constants.signals[name] === number);
+    findSignalByNumber = (number, signals2) => {
+      const signal = signals2.find(({ name }) => import_node_os2.constants.signals[name] === number);
       if (signal !== void 0) {
         return signal;
       }
-      return signals.find((signalA) => signalA.number === number);
+      return signals2.find((signalA) => signalA.number === number);
     };
     signalsByNumber = getSignalsByNumber();
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/error.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js
 var import_node_process2, getErrorPrefix, makeError;
 var init_error = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/error.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js"() {
     "use strict";
     import_node_process2 = __toESM(require("process"), 1);
     init_main();
@@ -1162,10 +1165,10 @@ ${error.message}` : execaMessage;
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/stdio.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stdio.js
 var aliases, hasAlias, normalizeStdio, normalizeStdioNode;
 var init_stdio = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/stdio.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stdio.js"() {
     "use strict";
     aliases = ["stdin", "stdout", "stderr"];
     hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0);
@@ -1205,19 +1208,17 @@ var init_stdio = __esm({
   }
 });
 
-// node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
-var require_signals = __commonJS({
-  "node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module2) {
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals2 = __esm({
+  "node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js"() {
     "use strict";
-    module2.exports = [
-      "SIGABRT",
-      "SIGALRM",
-      "SIGHUP",
-      "SIGINT",
-      "SIGTERM"
-    ];
+    signals = [];
+    signals.push("SIGHUP", "SIGINT", "SIGTERM");
     if (process.platform !== "win32") {
-      module2.exports.push(
+      signals.push(
+        "SIGALRM",
+        "SIGABRT",
         "SIGVTALRM",
         "SIGXCPU",
         "SIGXFSZ",
@@ -1232,184 +1233,258 @@ var require_signals = __commonJS({
       );
     }
     if (process.platform === "linux") {
-      module2.exports.push(
-        "SIGIO",
-        "SIGPOLL",
-        "SIGPWR",
-        "SIGSTKFLT",
-        "SIGUNUSED"
-      );
+      signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
     }
   }
 });
 
-// node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
-var require_signal_exit = __commonJS({
-  "node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module2) {
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk, kExitEmitter, global2, ObjectDefineProperty, Emitter, SignalExitBase, signalExitWrap, SignalExitFallback, SignalExit, process4, onExit, load, unload;
+var init_mjs = __esm({
+  "node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js"() {
     "use strict";
-    var process6 = global.process;
-    var processOk = function(process7) {
-      return process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
+    init_signals2();
+    processOk = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
+    kExitEmitter = Symbol.for("signal-exit emitter");
+    global2 = globalThis;
+    ObjectDefineProperty = Object.defineProperty.bind(Object);
+    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;
+      }
     };
-    if (!processOk(process6)) {
-      module2.exports = function() {
-        return function() {
-        };
+    SignalExitBase = class {
+    };
+    signalExitWrap = (handler) => {
+      return {
+        onExit(cb, opts) {
+          return handler.onExit(cb, opts);
+        },
+        load() {
+          return handler.load();
+        },
+        unload() {
+          return handler.unload();
+        }
       };
-    } else {
-      assert = require("assert");
-      signals = require_signals();
-      isWin = /^win/i.test(process6.platform);
-      EE = require("events");
-      if (typeof EE !== "function") {
-        EE = EE.EventEmitter;
-      }
-      if (process6.__signal_exit_emitter__) {
-        emitter = process6.__signal_exit_emitter__;
-      } else {
-        emitter = process6.__signal_exit_emitter__ = new EE();
-        emitter.count = 0;
-        emitter.emitted = {};
+    };
+    SignalExitFallback = class extends SignalExitBase {
+      onExit() {
+        return () => {
+        };
       }
-      if (!emitter.infinite) {
-        emitter.setMaxListeners(Infinity);
-        emitter.infinite = true;
+      load() {
       }
-      module2.exports = function(cb, opts) {
-        if (!processOk(global.process)) {
-          return function() {
+      unload() {
+      }
+    };
+    SignalExit = class extends SignalExitBase {
+      // "SIGHUP" throws an `ENOSYS` error on Windows,
+      // so use a supported signal instead
+      /* c8 ignore start */
+      #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
+      /* c8 ignore stop */
+      #emitter = new Emitter();
+      #process;
+      #originalProcessEmit;
+      #originalProcessReallyExit;
+      #sigListeners = {};
+      #loaded = false;
+      constructor(process7) {
+        super();
+        this.#process = process7;
+        this.#sigListeners = {};
+        for (const sig of signals) {
+          this.#sigListeners[sig] = () => {
+            const listeners = this.#process.listeners(sig);
+            let { count } = this.#emitter;
+            const p = process7;
+            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 = this.#emitter.emit("exit", null, sig);
+              const s = sig === "SIGHUP" ? this.#hupSig : sig;
+              if (!ret)
+                process7.kill(process7.pid, s);
+            }
           };
         }
-        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
-        if (loaded === false) {
-          load();
+        this.#originalProcessReallyExit = process7.reallyExit;
+        this.#originalProcessEmit = process7.emit;
+      }
+      onExit(cb, opts) {
+        if (!processOk(this.#process)) {
+          return () => {
+          };
         }
-        var ev = "exit";
-        if (opts && opts.alwaysLast) {
-          ev = "afterexit";
+        if (this.#loaded === false) {
+          this.load();
         }
-        var remove = function() {
-          emitter.removeListener(ev, cb);
-          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
-            unload();
+        const ev = opts?.alwaysLast ? "afterExit" : "exit";
+        this.#emitter.on(ev, cb);
+        return () => {
+          this.#emitter.removeListener(ev, cb);
+          if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+            this.unload();
           }
         };
-        emitter.on(ev, cb);
-        return remove;
-      };
-      unload = function unload2() {
-        if (!loaded || !processOk(global.process)) {
+      }
+      load() {
+        if (this.#loaded) {
           return;
         }
-        loaded = false;
-        signals.forEach(function(sig) {
+        this.#loaded = true;
+        this.#emitter.count += 1;
+        for (const sig of signals) {
           try {
-            process6.removeListener(sig, sigListeners[sig]);
-          } catch (er) {
+            const fn = this.#sigListeners[sig];
+            if (fn)
+              this.#process.on(sig, fn);
+          } catch (_) {
           }
-        });
-        process6.emit = originalProcessEmit;
-        process6.reallyExit = originalProcessReallyExit;
-        emitter.count -= 1;
-      };
-      module2.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 = process6.listeners(sig);
-          if (listeners.length === emitter.count) {
-            unload();
-            emit("exit", null, sig);
-            emit("afterexit", null, sig);
-            if (isWin && sig === "SIGHUP") {
-              sig = "SIGINT";
-            }
-            process6.kill(process6.pid, sig);
-          }
+        this.#process.emit = (ev, ...a) => {
+          return this.#processEmit(ev, ...a);
         };
-      });
-      module2.exports.signals = function() {
-        return signals;
-      };
-      loaded = false;
-      load = function load2() {
-        if (loaded || !processOk(global.process)) {
+        this.#process.reallyExit = (code) => {
+          return this.#processReallyExit(code);
+        };
+      }
+      unload() {
+        if (!this.#loaded) {
           return;
         }
-        loaded = true;
-        emitter.count += 1;
-        signals = signals.filter(function(sig) {
+        this.#loaded = false;
+        signals.forEach((sig) => {
+          const listener = this.#sigListeners[sig];
+          if (!listener) {
+            throw new Error("Listener not defined for signal: " + sig);
+          }
           try {
-            process6.on(sig, sigListeners[sig]);
-            return true;
-          } catch (er) {
-            return false;
+            this.#process.removeListener(sig, listener);
+          } catch (_) {
           }
         });
-        process6.emit = processEmit;
-        process6.reallyExit = processReallyExit;
-      };
-      module2.exports.load = load;
-      originalProcessReallyExit = process6.reallyExit;
-      processReallyExit = function processReallyExit2(code) {
-        if (!processOk(global.process)) {
-          return;
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+      }
+      #processReallyExit(code) {
+        if (!processOk(this.#process)) {
+          return 0;
         }
-        process6.exitCode = code || /* istanbul ignore next */
-        0;
-        emit("exit", process6.exitCode, null);
-        emit("afterexit", process6.exitCode, null);
-        originalProcessReallyExit.call(process6, process6.exitCode);
-      };
-      originalProcessEmit = process6.emit;
-      processEmit = function processEmit2(ev, arg) {
-        if (ev === "exit" && processOk(global.process)) {
-          if (arg !== void 0) {
-            process6.exitCode = arg;
+        this.#process.exitCode = code || 0;
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+      }
+      #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === "exit" && processOk(this.#process)) {
+          if (typeof args[0] === "number") {
+            this.#process.exitCode = args[0];
           }
-          var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process6.exitCode, null);
-          emit("afterexit", process6.exitCode, null);
+          const ret = og.call(this.#process, ev, ...args);
+          this.#emitter.emit("exit", this.#process.exitCode, null);
           return ret;
         } else {
-          return originalProcessEmit.apply(this, arguments);
+          return og.call(this.#process, ev, ...args);
         }
-      };
-    }
-    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;
+      }
+    };
+    process4 = globalThis.process;
+    ({
+      onExit: (
+        /**
+         * 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: (
+        /**
+         * 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: (
+        /**
+         * 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(process4) ? new SignalExit(process4) : new SignalExitFallback()));
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/kill.js
-var import_node_os3, import_signal_exit, DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill, setKillTimeout, shouldForceKill, isSigterm, getForceKillAfterTimeout, spawnedCancel, timeoutKill, setupTimeout, validateTimeout, setExitHandler;
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js
+var import_node_os3, DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill, setKillTimeout, shouldForceKill, isSigterm, getForceKillAfterTimeout, spawnedCancel, timeoutKill, setupTimeout, validateTimeout, setExitHandler;
 var init_kill = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/kill.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js"() {
     "use strict";
     import_node_os3 = __toESM(require("os"), 1);
-    import_signal_exit = __toESM(require_signal_exit(), 1);
+    init_mjs();
     DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
     spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
       const killResult = kill(signal);
@@ -1473,7 +1548,7 @@ var init_kill = __esm({
       if (!cleanup || detached) {
         return timedPromise;
       }
-      const removeExitHandler = (0, import_signal_exit.default)(() => {
+      const removeExitHandler = onExit(() => {
         spawned.kill();
       });
       return timedPromise.finally(() => {
@@ -1496,10 +1571,10 @@ var init_is_stream = __esm({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/pipe.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js
 var import_node_fs, import_node_child_process, isExecaChildProcess, pipeToTarget, addPipeMethods;
 var init_pipe = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/pipe.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js"() {
     "use strict";
     import_node_fs = require("fs");
     import_node_child_process = require("child_process");
@@ -1537,103 +1612,241 @@ var init_pipe = __esm({
   }
 });
 
-// node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js
-var require_buffer_stream = __commonJS({
-  "node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js"(exports, module2) {
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js
+var getStreamContents, appendFinalChunk, appendChunk, addNewChunk, isAsyncIterable, getChunkType, objectToString, MaxBufferError;
+var init_contents = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js"() {
     "use strict";
-    var { PassThrough: PassThroughStream } = require("stream");
-    module2.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";
+    getStreamContents = async (stream, { init, 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.");
       }
-      if (isBuffer) {
-        encoding = null;
+      const state = init();
+      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;
       }
-      const stream = new PassThroughStream({ objectMode });
-      if (encoding) {
-        stream.setEncoding(encoding);
+    };
+    appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+      const convertedChunk = getFinalChunk(state);
+      if (convertedChunk !== void 0) {
+        appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+      }
+    };
+    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();
+    };
+    addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+      state.contents = addChunk(convertedChunk, state, newLength);
+      state.length = newLength;
+    };
+    isAsyncIterable = (stream) => typeof stream === "object" && stream !== null && typeof stream[Symbol.asyncIterator] === "function";
+    getChunkType = (chunk) => {
+      const typeOfChunk = typeof chunk;
+      if (typeOfChunk === "string") {
+        return "string";
+      }
+      if (typeOfChunk !== "object" || chunk === null) {
+        return "others";
+      }
+      if (globalThis.Buffer?.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";
+    };
+    ({ toString: objectToString } = Object.prototype);
+    MaxBufferError = class extends Error {
+      name = "MaxBufferError";
+      constructor() {
+        super("maxBuffer exceeded");
       }
-      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/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js
-var require_get_stream = __commonJS({
-  "node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js"(exports, module2) {
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js
+var identity, noop, getContentsProp, throwObjectStream, getLengthProp;
+var init_utils = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js"() {
     "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";
+    identity = (value) => value;
+    noop = () => void 0;
+    getContentsProp = ({ contents }) => contents;
+    throwObjectStream = (chunk) => {
+      throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+    };
+    getLengthProp = (convertedChunk) => convertedChunk.length;
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array.js
+var init_array = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array.js"() {
+    "use strict";
+    init_contents();
+    init_utils();
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream, options) {
+  return getStreamContents(stream, arrayBufferMethods, options);
+}
+var initArrayBuffer, useTextEncoder, textEncoder, useUint8Array, useUint8ArrayWithOffset, truncateArrayBufferChunk, addArrayBufferChunk, resizeArrayBufferSlow, resizeArrayBuffer, getNewContentsLength, SCALE_FACTOR, finalizeArrayBuffer, hasArrayBufferResize, arrayBufferMethods;
+var init_array_buffer = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js"() {
+    "use strict";
+    init_contents();
+    init_utils();
+    initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+    useTextEncoder = (chunk) => textEncoder.encode(chunk);
+    textEncoder = new TextEncoder();
+    useUint8Array = (chunk) => new Uint8Array(chunk);
+    useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+    addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+      const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+      new Uint8Array(newContents).set(convertedChunk, previousLength);
+      return newContents;
+    };
+    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;
     };
-    async function getStream2(inputStream, options) {
-      if (!inputStream) {
-        throw new Error("Expected a stream");
+    resizeArrayBuffer = (contents, length) => {
+      if (length <= contents.maxByteLength) {
+        contents.resize(length);
+        return contents;
       }
-      options = {
-        maxBuffer: Infinity,
-        ...options
-      };
-      const { maxBuffer } = options;
-      const stream2 = bufferStream(options);
-      await new Promise((resolve14, reject) => {
-        const rejectPromise = (error) => {
-          if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-            error.bufferedData = stream2.getBufferedValue();
-          }
-          reject(error);
-        };
-        (async () => {
-          try {
-            await streamPipelinePromisified(inputStream, stream2);
-            resolve14();
-          } catch (error) {
-            rejectPromise(error);
-          }
-        })();
-        stream2.on("data", () => {
-          if (stream2.getBufferedLength() > maxBuffer) {
-            rejectPromise(new MaxBufferError());
-          }
-        });
-      });
-      return stream2.getBufferedValue();
+      const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+      new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+      return arrayBuffer;
+    };
+    getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+    SCALE_FACTOR = 2;
+    finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+    hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+    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/.pnpm/get-stream@8.0.1/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);
     }
-    module2.exports = getStream2;
-    module2.exports.buffer = (stream2, options) => getStream2(stream2, { ...options, encoding: "buffer" });
-    module2.exports.array = (stream2, options) => getStream2(stream2, { ...options, array: true });
-    module2.exports.MaxBufferError = MaxBufferError;
+    throw error;
+  }
+}
+var arrayBufferToNodeBuffer;
+var init_buffer = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/buffer.js"() {
+    "use strict";
+    init_array_buffer();
+    arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js
+async function getStreamAsString(stream, options) {
+  return getStreamContents(stream, stringMethods, options);
+}
+var initString, useTextDecoder, addStringChunk, truncateStringChunk, getFinalStringChunk, stringMethods;
+var init_string = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js"() {
+    "use strict";
+    init_contents();
+    init_utils();
+    initString = () => ({ contents: "", textDecoder: new TextDecoder() });
+    useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true });
+    addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
+    truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+    getFinalStringChunk = ({ textDecoder }) => {
+      const finalChunk = textDecoder.decode();
+      return finalChunk === "" ? void 0 : finalChunk;
+    };
+    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/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/index.js
+var init_source = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/index.js"() {
+    "use strict";
+    init_array();
+    init_array_buffer();
+    init_buffer();
+    init_string();
+    init_contents();
   }
 });
 
@@ -1677,14 +1890,15 @@ var require_merge_stream = __commonJS({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/stream.js
-var import_node_fs2, import_get_stream, import_merge_stream, validateInputOptions, getInputSync, handleInputSync, getInput, handleInput, makeAllStream, getBufferedData, getStreamPromise, getSpawnedResult;
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js
+var import_node_fs2, import_promises, import_merge_stream, validateInputOptions, getInputSync, handleInputSync, getInput, handleInput, makeAllStream, getBufferedData, getStreamPromise, applyEncoding, getSpawnedResult;
 var init_stream = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/stream.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js"() {
     "use strict";
     import_node_fs2 = require("fs");
+    import_promises = require("timers/promises");
     init_is_stream();
-    import_get_stream = __toESM(require_get_stream(), 1);
+    init_source();
     import_merge_stream = __toESM(require_merge_stream(), 1);
     validateInputOptions = (input) => {
       if (input !== void 0) {
@@ -1740,6 +1954,7 @@ var init_stream = __esm({
       if (!stream || streamPromise === void 0) {
         return;
       }
+      await (0, import_promises.setTimeout)(0);
       stream.destroy();
       try {
         return await streamPromise;
@@ -1751,10 +1966,17 @@ var init_stream = __esm({
       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);
+    };
+    applyEncoding = async (stream, maxBuffer, encoding) => {
+      const buffer = await getStreamAsBuffer(stream, { maxBuffer });
+      return buffer.toString(encoding);
     };
     getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
       const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
@@ -1774,10 +1996,10 @@ var init_stream = __esm({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/promise.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/promise.js
 var nativePromisePrototype, descriptors, mergePromise, getSpawnedPromise;
 var init_promise = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/promise.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/promise.js"() {
     "use strict";
     nativePromisePrototype = (/* @__PURE__ */ (async () => {
     })()).constructor.prototype;
@@ -1807,10 +2029,10 @@ var init_promise = __esm({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/command.js
-var import_node_buffer, import_node_child_process2, normalizeArgs, NO_ESCAPE_REGEXP, DOUBLE_QUOTES_REGEXP, escapeArg, joinCommand, getEscapedCommand, SPACES_REGEXP, parseCommand, parseExpression, concatTokens, parseTemplate, parseTemplates;
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/command.js
+var import_node_buffer, import_node_child_process2, normalizeArgs, NO_ESCAPE_REGEXP, escapeArg, joinCommand, getEscapedCommand, SPACES_REGEXP, parseCommand, parseExpression, concatTokens, parseTemplate, parseTemplates;
 var init_command = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/command.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/command.js"() {
     "use strict";
     import_node_buffer = require("buffer");
     import_node_child_process2 = require("child_process");
@@ -1821,12 +2043,11 @@ var init_command = __esm({
       return [file, ...args];
     };
     NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-    DOUBLE_QUOTES_REGEXP = /"/g;
     escapeArg = (arg) => {
       if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
         return arg;
       }
-      return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+      return `"${arg.replaceAll('"', '\\"')}"`;
     };
     joinCommand = (file, args) => normalizeArgs(file, args).join(" ");
     getEscapedCommand = (file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" ");
@@ -1834,7 +2055,7 @@ var init_command = __esm({
     parseCommand = (command) => {
       const tokens = [];
       for (const token of command.trim().split(SPACES_REGEXP)) {
-        const previousToken = tokens[tokens.length - 1];
+        const previousToken = tokens.at(-1);
         if (previousToken && previousToken.endsWith("\\")) {
           tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
         } else {
@@ -1865,7 +2086,7 @@ var init_command = __esm({
     };
     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)
     ];
     parseTemplate = ({ templates, expressions, tokens, index, template }) => {
@@ -1897,10 +2118,10 @@ var init_command = __esm({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/verbose.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/verbose.js
 var import_node_util, import_node_process3, verboseDefault, padField, getTimestamp, logCommand;
 var init_verbose = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/lib/verbose.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/verbose.js"() {
     "use strict";
     import_node_util = require("util");
     import_node_process3 = __toESM(require("process"), 1);
@@ -1920,7 +2141,7 @@ var init_verbose = __esm({
   }
 });
 
-// node_modules/.pnpm/execa@7.2.0/node_modules/execa/index.js
+// node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js
 var execa_exports = {};
 __export(execa_exports, {
   $: () => $,
@@ -2118,7 +2339,7 @@ function execaNode(scriptPath, args, options = {}) {
 }
 var import_node_buffer2, import_node_path11, import_node_child_process3, import_node_process4, import_cross_spawn, DEFAULT_MAX_BUFFER, getEnv, handleArguments, handleOutput, normalizeScriptStdin, normalizeScriptOptions, $;
 var init_execa = __esm({
-  "node_modules/.pnpm/execa@7.2.0/node_modules/execa/index.js"() {
+  "node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js"() {
     "use strict";
     import_node_buffer2 = require("buffer");
     import_node_path11 = __toESM(require("path"), 1);
@@ -2729,8 +2950,8 @@ function globals(config) {
     name: "wxt:globals",
     config() {
       const define = {};
-      for (const global2 of getGlobals(config)) {
-        define[global2.name] = JSON.stringify(global2.value);
+      for (const global3 of getGlobals(config)) {
+        define[global3.name] = JSON.stringify(global3.value);
       }
       return {
         define
@@ -2835,8 +3056,8 @@ async function buildSingleEntrypoint(entrypoint, config) {
       "process.env.NODE_ENV": JSON.stringify(config.mode)
     }
   };
-  for (const global2 of getEntrypointGlobals(config, entrypoint.name)) {
-    libMode.define[global2.name] = JSON.stringify(global2.value);
+  for (const global3 of getEntrypointGlobals(config, entrypoint.name)) {
+    libMode.define[global3.name] = JSON.stringify(global3.value);
   }
   const entryConfig = vite2.mergeConfig(
     libMode,
@@ -2869,8 +3090,8 @@ async function buildMultipleEntrypoints(entrypoints, config) {
     },
     define: {}
   };
-  for (const global2 of getEntrypointGlobals(config, "html")) {
-    multiPage.define[global2.name] = JSON.stringify(global2.value);
+  for (const global3 of getEntrypointGlobals(config, "html")) {
+    multiPage.define[global3.name] = JSON.stringify(global3.value);
   }
   const entryConfig = vite2.mergeConfig(
     multiPage,
@@ -3387,7 +3608,7 @@ async function writePathsDeclarationFile(entrypoints, config) {
 import "wxt/browser";
 
 declare module "wxt/browser" {
-  type PublicPath =
+  export type PublicPath =
 {{ union }}
   export interface WxtRuntime extends Runtime.Static {
     getURL(path: PublicPath): string;
@@ -3462,7 +3683,7 @@ async function writeGlobalsDeclarationFile(config) {
       "// Generated by wxt",
       "export {}",
       "declare global {",
-      ...globals2.map((global2) => `  const ${global2.name}: ${global2.type};`),
+      ...globals2.map((global3) => `  const ${global3.name}: ${global3.type};`),
       "}"
     ].join("\n") + "\n"
   );
@@ -3964,7 +4185,7 @@ function getChunkSortWeight(filename) {
 var import_picocolors3 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.8.6";
+var version = "0.8.7";
 
 // src/core/utils/log/printHeader.ts
 var import_consola2 = require("consola");