@vercel/build-utils 8.4.2 → 8.4.4

package/dist/index.js

@@ -85,9 +85,9 @@ var require_isarray = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/stream.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/stream.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/stream.js"(exports2, module2) {
     module2.exports = require("stream");
   }
 });
@@ -266,9 +266,9 @@ var require_inherits = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/BufferList.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/BufferList.js
 var require_BufferList = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports2, module2) {
     "use strict";
     function _classCallCheck(instance, Constructor) {
       if (!(instance instanceof Constructor)) {
@@ -331,8 +331,6 @@ var require_BufferList = __commonJS({
       BufferList.prototype.concat = function concat(n) {
         if (this.length === 0)
           return Buffer2.alloc(0);
-        if (this.length === 1)
-          return this.head.data;
         var ret = Buffer2.allocUnsafe(n >>> 0);
         var p = this.head;
         var i = 0;
@@ -354,9 +352,9 @@ var require_BufferList = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/destroy.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/destroy.js
 var require_destroy = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
     function destroy(err, cb) {
@@ -366,8 +364,13 @@ var require_destroy = __commonJS({
       if (readableDestroyed || writableDestroyed) {
         if (cb) {
           cb(err);
-        } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
-          pna.nextTick(emitErrorNT, this, err);
+        } else if (err) {
+          if (!this._writableState) {
+            pna.nextTick(emitErrorNT, this, err);
+          } else if (!this._writableState.errorEmitted) {
+            this._writableState.errorEmitted = true;
+            pna.nextTick(emitErrorNT, this, err);
+          }
         }
         return this;
       }
@@ -379,9 +382,11 @@ var require_destroy = __commonJS({
       }
       this._destroy(err || null, function(err2) {
         if (!cb && err2) {
-          pna.nextTick(emitErrorNT, _this, err2);
-          if (_this._writableState) {
+          if (!_this._writableState) {
+            pna.nextTick(emitErrorNT, _this, err2);
+          } else if (!_this._writableState.errorEmitted) {
             _this._writableState.errorEmitted = true;
+            pna.nextTick(emitErrorNT, _this, err2);
           }
         } else if (cb) {
           cb(err2);
@@ -400,12 +405,14 @@ var require_destroy = __commonJS({
         this._writableState.destroyed = false;
         this._writableState.ended = false;
         this._writableState.ending = false;
+        this._writableState.finalCalled = false;
+        this._writableState.prefinished = false;
         this._writableState.finished = false;
         this._writableState.errorEmitted = false;
       }
     }
-    function emitErrorNT(self, err) {
-      self.emit("error", err);
+    function emitErrorNT(self2, err) {
+      self2.emit("error", err);
     }
     module2.exports = {
       destroy,
@@ -421,9 +428,9 @@ var require_node = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_writable.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_writable.js
 var require_stream_writable = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
     module2.exports = Writable;
@@ -445,7 +452,7 @@ var require_stream_writable = __commonJS({
     };
     var Stream = require_stream();
     var Buffer2 = require_safe_buffer().Buffer;
-    var OurUint8Array = global.Uint8Array || function() {
+    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
       return Buffer2.from(chunk);
@@ -612,7 +619,7 @@ var require_stream_writable = __commonJS({
       var state = this._writableState;
       if (state.corked) {
         state.corked--;
-        if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest)
+        if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest)
           clearBuffer(this, state);
       }
     };
@@ -803,7 +810,7 @@ var require_stream_writable = __commonJS({
         state.corked = 1;
         this.uncork();
       }
-      if (!state.ending && !state.finished)
+      if (!state.ending)
         endWritable(this, state, cb);
     };
     function needFinish(state) {
@@ -864,11 +871,7 @@ var require_stream_writable = __commonJS({
         cb(err);
         entry = entry.next;
       }
-      if (state.corkedRequestsFree) {
-        state.corkedRequestsFree.next = corkReq;
-      } else {
-        state.corkedRequestsFree = corkReq;
-      }
+      state.corkedRequestsFree.next = corkReq;
     }
     Object.defineProperty(Writable.prototype, "destroyed", {
       get: function() {
@@ -893,9 +896,9 @@ var require_stream_writable = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_duplex.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_duplex.js
 var require_stream_duplex = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_duplex.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_duplex.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
     var objectKeys = Object.keys || function(obj) {
@@ -950,8 +953,8 @@ var require_stream_duplex = __commonJS({
         return;
       pna.nextTick(onEndNT, this);
     }
-    function onEndNT(self) {
-      self.end();
+    function onEndNT(self2) {
+      self2.end();
     }
     Object.defineProperty(Duplex.prototype, "destroyed", {
       get: function() {
@@ -1102,14 +1105,14 @@ var require_string_decoder = __commonJS({
         return 4;
       return byte >> 6 === 2 ? -1 : -2;
     }
-    function utf8CheckIncomplete(self, buf, i) {
+    function utf8CheckIncomplete(self2, buf, i) {
       var j = buf.length - 1;
       if (j < i)
         return 0;
       var nb = utf8CheckByte(buf[j]);
       if (nb >= 0) {
         if (nb > 0)
-          self.lastNeed = nb - 1;
+          self2.lastNeed = nb - 1;
         return nb;
       }
       if (--j < i || nb === -2)
@@ -1117,7 +1120,7 @@ var require_string_decoder = __commonJS({
       nb = utf8CheckByte(buf[j]);
       if (nb >= 0) {
         if (nb > 0)
-          self.lastNeed = nb - 2;
+          self2.lastNeed = nb - 2;
         return nb;
       }
       if (--j < i || nb === -2)
@@ -1128,25 +1131,25 @@ var require_string_decoder = __commonJS({
           if (nb === 2)
             nb = 0;
           else
-            self.lastNeed = nb - 3;
+            self2.lastNeed = nb - 3;
         }
         return nb;
       }
       return 0;
     }
-    function utf8CheckExtraBytes(self, buf, p) {
+    function utf8CheckExtraBytes(self2, buf, p) {
       if ((buf[0] & 192) !== 128) {
-        self.lastNeed = 0;
+        self2.lastNeed = 0;
         return "\uFFFD";
       }
-      if (self.lastNeed > 1 && buf.length > 1) {
+      if (self2.lastNeed > 1 && buf.length > 1) {
         if ((buf[1] & 192) !== 128) {
-          self.lastNeed = 1;
+          self2.lastNeed = 1;
           return "\uFFFD";
         }
-        if (self.lastNeed > 2 && buf.length > 2) {
+        if (self2.lastNeed > 2 && buf.length > 2) {
           if ((buf[2] & 192) !== 128) {
-            self.lastNeed = 2;
+            self2.lastNeed = 2;
             return "\uFFFD";
           }
         }
@@ -1236,9 +1239,9 @@ var require_string_decoder = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_readable.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_readable.js
 var require_stream_readable = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
     module2.exports = Readable;
@@ -1251,7 +1254,7 @@ var require_stream_readable = __commonJS({
     };
     var Stream = require_stream();
     var Buffer2 = require_safe_buffer().Buffer;
-    var OurUint8Array = global.Uint8Array || function() {
+    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
       return Buffer2.from(chunk);
@@ -1666,8 +1669,8 @@ var require_stream_readable = __commonJS({
         var ret = dest.write(chunk);
         if (false === ret && !increasedAwaitDrain) {
           if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
-            debug2("false write response, pause", src._readableState.awaitDrain);
-            src._readableState.awaitDrain++;
+            debug2("false write response, pause", state.awaitDrain);
+            state.awaitDrain++;
             increasedAwaitDrain = true;
           }
           src.pause();
@@ -1739,7 +1742,7 @@ var require_stream_readable = __commonJS({
         state.pipesCount = 0;
         state.flowing = false;
         for (var i = 0; i < len; i++) {
-          dests[i].emit("unpipe", this, unpipeInfo);
+          dests[i].emit("unpipe", this, { hasUnpiped: false });
         }
         return this;
       }
@@ -1773,9 +1776,9 @@ var require_stream_readable = __commonJS({
       return res;
     };
     Readable.prototype.addListener = Readable.prototype.on;
-    function nReadingNextTick(self) {
+    function nReadingNextTick(self2) {
       debug2("readable nexttick read 0");
-      self.read(0);
+      self2.read(0);
     }
     Readable.prototype.resume = function() {
       var state = this._readableState;
@@ -1994,9 +1997,9 @@ var require_stream_readable = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_transform.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_transform.js
 var require_stream_transform = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
     "use strict";
     module2.exports = Transform;
     var Duplex = require_stream_duplex();
@@ -2101,9 +2104,9 @@ var require_stream_transform = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_passthrough.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_passthrough.js
 var require_stream_passthrough = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
     "use strict";
     module2.exports = PassThrough;
     var Transform = require_stream_transform();
@@ -2121,9 +2124,9 @@ var require_stream_passthrough = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/readable.js
+// ../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/readable.js
 var require_readable = __commonJS({
-  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/readable.js"(exports2, module2) {
+  "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/readable.js"(exports2, module2) {
     var Stream = require("stream");
     if (process.env.READABLE_STREAM === "disable" && Stream) {
       module2.exports = Stream;
@@ -2190,18 +2193,18 @@ var require_from2 = __commonJS({
         this._callback = check;
         this.destroyed = false;
         Readable.call(this, override || opts);
-        var self = this;
+        var self2 = this;
         var hwm = this._readableState.highWaterMark;
         function check(err, data) {
-          if (self.destroyed)
+          if (self2.destroyed)
             return;
           if (err)
-            return self.destroy(err);
+            return self2.destroy(err);
           if (data === null)
-            return self.push(null);
-          self._reading = false;
-          if (self.push(data))
-            self._read(hwm);
+            return self2.push(null);
+          self2._reading = false;
+          if (self2.push(data))
+            self2._read(hwm);
         }
       }
       Class.prototype._from = read || noop;
@@ -2215,11 +2218,11 @@ var require_from2 = __commonJS({
         if (this.destroyed)
           return;
         this.destroyed = true;
-        var self = this;
+        var self2 = this;
         process.nextTick(function() {
           if (err)
-            self.emit("error", err);
-          self.emit("close");
+            self2.emit("error", err);
+          self2.emit("close");
         });
       };
       return Class;
@@ -2700,7 +2703,7 @@ var require_legacy_streams = __commonJS({
         if (!(this instanceof ReadStream))
           return new ReadStream(path7, options);
         Stream.call(this);
-        var self = this;
+        var self2 = this;
         this.path = path7;
         this.fd = null;
         this.readable = true;
@@ -2732,19 +2735,19 @@ var require_legacy_streams = __commonJS({
         }
         if (this.fd !== null) {
           process.nextTick(function() {
-            self._read();
+            self2._read();
           });
           return;
         }
         fs5.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
-            self.emit("error", err);
-            self.readable = false;
+            self2.emit("error", err);
+            self2.readable = false;
             return;
           }
-          self.fd = fd;
-          self.emit("open", fd);
-          self._read();
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2._read();
         });
       }
       function WriteStream(path7, options) {
@@ -4827,140 +4830,1760 @@ var require_move_sync = __commonJS({
         return moveAcrossDevice(src, dest, overwrite);
       }
     }
-    function moveAcrossDevice(src, dest, overwrite) {
-      const opts = {
-        overwrite,
-        errorOnExist: true
-      };
-      copySync(src, dest, opts);
-      return removeSync(src);
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module2.exports = moveSync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/index.js
+var require_move_sync2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require_graceful_fs();
+    var path7 = require("path");
+    var copy = require_copy2().copy;
+    var remove2 = require_remove().remove;
+    var mkdirp3 = require_mkdirs().mkdirp;
+    var pathExists = require_path_exists().pathExists;
+    var stat = require_stat();
+    function move(src, dest, opts, cb) {
+      if (typeof opts === "function") {
+        cb = opts;
+        opts = {};
+      }
+      const overwrite = opts.overwrite || opts.clobber || false;
+      stat.checkPaths(src, dest, "move", opts, (err, stats) => {
+        if (err)
+          return cb(err);
+        const { srcStat, isChangingCase = false } = stats;
+        stat.checkParentPaths(src, srcStat, dest, "move", (err2) => {
+          if (err2)
+            return cb(err2);
+          if (isParentRoot(dest))
+            return doRename(src, dest, overwrite, isChangingCase, cb);
+          mkdirp3(path7.dirname(dest), (err3) => {
+            if (err3)
+              return cb(err3);
+            return doRename(src, dest, overwrite, isChangingCase, cb);
+          });
+        });
+      });
+    }
+    function isParentRoot(dest) {
+      const parent = path7.dirname(dest);
+      const parsedPath = path7.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase, cb) {
+      if (isChangingCase)
+        return rename2(src, dest, overwrite, cb);
+      if (overwrite) {
+        return remove2(dest, (err) => {
+          if (err)
+            return cb(err);
+          return rename2(src, dest, overwrite, cb);
+        });
+      }
+      pathExists(dest, (err, destExists) => {
+        if (err)
+          return cb(err);
+        if (destExists)
+          return cb(new Error("dest already exists."));
+        return rename2(src, dest, overwrite, cb);
+      });
+    }
+    function rename2(src, dest, overwrite, cb) {
+      fs5.rename(src, dest, (err) => {
+        if (!err)
+          return cb();
+        if (err.code !== "EXDEV")
+          return cb(err);
+        return moveAcrossDevice(src, dest, overwrite, cb);
+      });
+    }
+    function moveAcrossDevice(src, dest, overwrite, cb) {
+      const opts = {
+        overwrite,
+        errorOnExist: true
+      };
+      copy(src, dest, opts, (err) => {
+        if (err)
+          return cb(err);
+        return remove2(src, cb);
+      });
+    }
+    module2.exports = move;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    module2.exports = {
+      move: u(require_move())
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy_sync2(),
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move_sync2(),
+      ...require_move2(),
+      ...require_output(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/stream.js
+var require_stream2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/stream.js"(exports2, module2) {
+    module2.exports = require("stream");
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/BufferList.js
+var require_BufferList2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports2, module2) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var Buffer2 = require_safe_buffer().Buffer;
+    var util = require("util");
+    function copyBuffer(src, target, offset) {
+      src.copy(target, offset);
+    }
+    module2.exports = function() {
+      function BufferList() {
+        _classCallCheck(this, BufferList);
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
+      }
+      BufferList.prototype.push = function push(v) {
+        var entry = { data: v, next: null };
+        if (this.length > 0)
+          this.tail.next = entry;
+        else
+          this.head = entry;
+        this.tail = entry;
+        ++this.length;
+      };
+      BufferList.prototype.unshift = function unshift(v) {
+        var entry = { data: v, next: this.head };
+        if (this.length === 0)
+          this.tail = entry;
+        this.head = entry;
+        ++this.length;
+      };
+      BufferList.prototype.shift = function shift() {
+        if (this.length === 0)
+          return;
+        var ret = this.head.data;
+        if (this.length === 1)
+          this.head = this.tail = null;
+        else
+          this.head = this.head.next;
+        --this.length;
+        return ret;
+      };
+      BufferList.prototype.clear = function clear() {
+        this.head = this.tail = null;
+        this.length = 0;
+      };
+      BufferList.prototype.join = function join3(s) {
+        if (this.length === 0)
+          return "";
+        var p = this.head;
+        var ret = "" + p.data;
+        while (p = p.next) {
+          ret += s + p.data;
+        }
+        return ret;
+      };
+      BufferList.prototype.concat = function concat(n) {
+        if (this.length === 0)
+          return Buffer2.alloc(0);
+        if (this.length === 1)
+          return this.head.data;
+        var ret = Buffer2.allocUnsafe(n >>> 0);
+        var p = this.head;
+        var i = 0;
+        while (p) {
+          copyBuffer(p.data, ret, i);
+          i += p.data.length;
+          p = p.next;
+        }
+        return ret;
+      };
+      return BufferList;
+    }();
+    if (util && util.inspect && util.inspect.custom) {
+      module2.exports.prototype[util.inspect.custom] = function() {
+        var obj = util.inspect({ length: this.length });
+        return this.constructor.name + " " + obj;
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/destroy.js
+var require_destroy2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {
+    "use strict";
+    var pna = require_process_nextick_args();
+    function destroy(err, cb) {
+      var _this = this;
+      var readableDestroyed = this._readableState && this._readableState.destroyed;
+      var writableDestroyed = this._writableState && this._writableState.destroyed;
+      if (readableDestroyed || writableDestroyed) {
+        if (cb) {
+          cb(err);
+        } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+          pna.nextTick(emitErrorNT, this, err);
+        }
+        return this;
+      }
+      if (this._readableState) {
+        this._readableState.destroyed = true;
+      }
+      if (this._writableState) {
+        this._writableState.destroyed = true;
+      }
+      this._destroy(err || null, function(err2) {
+        if (!cb && err2) {
+          pna.nextTick(emitErrorNT, _this, err2);
+          if (_this._writableState) {
+            _this._writableState.errorEmitted = true;
+          }
+        } else if (cb) {
+          cb(err2);
+        }
+      });
+      return this;
+    }
+    function undestroy() {
+      if (this._readableState) {
+        this._readableState.destroyed = false;
+        this._readableState.reading = false;
+        this._readableState.ended = false;
+        this._readableState.endEmitted = false;
+      }
+      if (this._writableState) {
+        this._writableState.destroyed = false;
+        this._writableState.ended = false;
+        this._writableState.ending = false;
+        this._writableState.finished = false;
+        this._writableState.errorEmitted = false;
+      }
+    }
+    function emitErrorNT(self2, err) {
+      self2.emit("error", err);
+    }
+    module2.exports = {
+      destroy,
+      undestroy
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_writable.js
+var require_stream_writable2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
+    "use strict";
+    var pna = require_process_nextick_args();
+    module2.exports = Writable;
+    function CorkedRequest(state) {
+      var _this = this;
+      this.next = null;
+      this.entry = null;
+      this.finish = function() {
+        onCorkedFinish(_this, state);
+      };
+    }
+    var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+    var Duplex;
+    Writable.WritableState = WritableState;
+    var util = Object.create(require_util());
+    util.inherits = require_inherits();
+    var internalUtil = {
+      deprecate: require_node()
+    };
+    var Stream = require_stream2();
+    var Buffer2 = require_safe_buffer().Buffer;
+    var OurUint8Array = global.Uint8Array || function() {
+    };
+    function _uint8ArrayToBuffer(chunk) {
+      return Buffer2.from(chunk);
+    }
+    function _isUint8Array(obj) {
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+    }
+    var destroyImpl = require_destroy2();
+    util.inherits(Writable, Stream);
+    function nop() {
+    }
+    function WritableState(options, stream) {
+      Duplex = Duplex || require_stream_duplex2();
+      options = options || {};
+      var isDuplex = stream instanceof Duplex;
+      this.objectMode = !!options.objectMode;
+      if (isDuplex)
+        this.objectMode = this.objectMode || !!options.writableObjectMode;
+      var hwm = options.highWaterMark;
+      var writableHwm = options.writableHighWaterMark;
+      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+      if (hwm || hwm === 0)
+        this.highWaterMark = hwm;
+      else if (isDuplex && (writableHwm || writableHwm === 0))
+        this.highWaterMark = writableHwm;
+      else
+        this.highWaterMark = defaultHwm;
+      this.highWaterMark = Math.floor(this.highWaterMark);
+      this.finalCalled = false;
+      this.needDrain = false;
+      this.ending = false;
+      this.ended = false;
+      this.finished = false;
+      this.destroyed = false;
+      var noDecode = options.decodeStrings === false;
+      this.decodeStrings = !noDecode;
+      this.defaultEncoding = options.defaultEncoding || "utf8";
+      this.length = 0;
+      this.writing = false;
+      this.corked = 0;
+      this.sync = true;
+      this.bufferProcessing = false;
+      this.onwrite = function(er) {
+        onwrite(stream, er);
+      };
+      this.writecb = null;
+      this.writelen = 0;
+      this.bufferedRequest = null;
+      this.lastBufferedRequest = null;
+      this.pendingcb = 0;
+      this.prefinished = false;
+      this.errorEmitted = false;
+      this.bufferedRequestCount = 0;
+      this.corkedRequestsFree = new CorkedRequest(this);
+    }
+    WritableState.prototype.getBuffer = function getBuffer() {
+      var current = this.bufferedRequest;
+      var out = [];
+      while (current) {
+        out.push(current);
+        current = current.next;
+      }
+      return out;
+    };
+    (function() {
+      try {
+        Object.defineProperty(WritableState.prototype, "buffer", {
+          get: internalUtil.deprecate(function() {
+            return this.getBuffer();
+          }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+        });
+      } catch (_) {
+      }
+    })();
+    var realHasInstance;
+    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+      realHasInstance = Function.prototype[Symbol.hasInstance];
+      Object.defineProperty(Writable, Symbol.hasInstance, {
+        value: function(object) {
+          if (realHasInstance.call(this, object))
+            return true;
+          if (this !== Writable)
+            return false;
+          return object && object._writableState instanceof WritableState;
+        }
+      });
+    } else {
+      realHasInstance = function(object) {
+        return object instanceof this;
+      };
+    }
+    function Writable(options) {
+      Duplex = Duplex || require_stream_duplex2();
+      if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+        return new Writable(options);
+      }
+      this._writableState = new WritableState(options, this);
+      this.writable = true;
+      if (options) {
+        if (typeof options.write === "function")
+          this._write = options.write;
+        if (typeof options.writev === "function")
+          this._writev = options.writev;
+        if (typeof options.destroy === "function")
+          this._destroy = options.destroy;
+        if (typeof options.final === "function")
+          this._final = options.final;
+      }
+      Stream.call(this);
+    }
+    Writable.prototype.pipe = function() {
+      this.emit("error", new Error("Cannot pipe, not readable"));
+    };
+    function writeAfterEnd(stream, cb) {
+      var er = new Error("write after end");
+      stream.emit("error", er);
+      pna.nextTick(cb, er);
+    }
+    function validChunk(stream, state, chunk, cb) {
+      var valid = true;
+      var er = false;
+      if (chunk === null) {
+        er = new TypeError("May not write null values to stream");
+      } else if (typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
+        er = new TypeError("Invalid non-string/buffer chunk");
+      }
+      if (er) {
+        stream.emit("error", er);
+        pna.nextTick(cb, er);
+        valid = false;
+      }
+      return valid;
+    }
+    Writable.prototype.write = function(chunk, encoding, cb) {
+      var state = this._writableState;
+      var ret = false;
+      var isBuf = !state.objectMode && _isUint8Array(chunk);
+      if (isBuf && !Buffer2.isBuffer(chunk)) {
+        chunk = _uint8ArrayToBuffer(chunk);
+      }
+      if (typeof encoding === "function") {
+        cb = encoding;
+        encoding = null;
+      }
+      if (isBuf)
+        encoding = "buffer";
+      else if (!encoding)
+        encoding = state.defaultEncoding;
+      if (typeof cb !== "function")
+        cb = nop;
+      if (state.ended)
+        writeAfterEnd(this, cb);
+      else if (isBuf || validChunk(this, state, chunk, cb)) {
+        state.pendingcb++;
+        ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+      }
+      return ret;
+    };
+    Writable.prototype.cork = function() {
+      var state = this._writableState;
+      state.corked++;
+    };
+    Writable.prototype.uncork = function() {
+      var state = this._writableState;
+      if (state.corked) {
+        state.corked--;
+        if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest)
+          clearBuffer(this, state);
+      }
+    };
+    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+      if (typeof encoding === "string")
+        encoding = encoding.toLowerCase();
+      if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))
+        throw new TypeError("Unknown encoding: " + encoding);
+      this._writableState.defaultEncoding = encoding;
+      return this;
+    };
+    function decodeChunk(state, chunk, encoding) {
+      if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
+        chunk = Buffer2.from(chunk, encoding);
+      }
+      return chunk;
+    }
+    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function() {
+        return this._writableState.highWaterMark;
+      }
+    });
+    function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+      if (!isBuf) {
+        var newChunk = decodeChunk(state, chunk, encoding);
+        if (chunk !== newChunk) {
+          isBuf = true;
+          encoding = "buffer";
+          chunk = newChunk;
+        }
+      }
+      var len = state.objectMode ? 1 : chunk.length;
+      state.length += len;
+      var ret = state.length < state.highWaterMark;
+      if (!ret)
+        state.needDrain = true;
+      if (state.writing || state.corked) {
+        var last = state.lastBufferedRequest;
+        state.lastBufferedRequest = {
+          chunk,
+          encoding,
+          isBuf,
+          callback: cb,
+          next: null
+        };
+        if (last) {
+          last.next = state.lastBufferedRequest;
+        } else {
+          state.bufferedRequest = state.lastBufferedRequest;
+        }
+        state.bufferedRequestCount += 1;
+      } else {
+        doWrite(stream, state, false, len, chunk, encoding, cb);
+      }
+      return ret;
+    }
+    function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+      state.writelen = len;
+      state.writecb = cb;
+      state.writing = true;
+      state.sync = true;
+      if (writev)
+        stream._writev(chunk, state.onwrite);
+      else
+        stream._write(chunk, encoding, state.onwrite);
+      state.sync = false;
+    }
+    function onwriteError(stream, state, sync, er, cb) {
+      --state.pendingcb;
+      if (sync) {
+        pna.nextTick(cb, er);
+        pna.nextTick(finishMaybe, stream, state);
+        stream._writableState.errorEmitted = true;
+        stream.emit("error", er);
+      } else {
+        cb(er);
+        stream._writableState.errorEmitted = true;
+        stream.emit("error", er);
+        finishMaybe(stream, state);
+      }
+    }
+    function onwriteStateUpdate(state) {
+      state.writing = false;
+      state.writecb = null;
+      state.length -= state.writelen;
+      state.writelen = 0;
+    }
+    function onwrite(stream, er) {
+      var state = stream._writableState;
+      var sync = state.sync;
+      var cb = state.writecb;
+      onwriteStateUpdate(state);
+      if (er)
+        onwriteError(stream, state, sync, er, cb);
+      else {
+        var finished = needFinish(state);
+        if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+          clearBuffer(stream, state);
+        }
+        if (sync) {
+          asyncWrite(afterWrite, stream, state, finished, cb);
+        } else {
+          afterWrite(stream, state, finished, cb);
+        }
+      }
+    }
+    function afterWrite(stream, state, finished, cb) {
+      if (!finished)
+        onwriteDrain(stream, state);
+      state.pendingcb--;
+      cb();
+      finishMaybe(stream, state);
+    }
+    function onwriteDrain(stream, state) {
+      if (state.length === 0 && state.needDrain) {
+        state.needDrain = false;
+        stream.emit("drain");
+      }
+    }
+    function clearBuffer(stream, state) {
+      state.bufferProcessing = true;
+      var entry = state.bufferedRequest;
+      if (stream._writev && entry && entry.next) {
+        var l = state.bufferedRequestCount;
+        var buffer = new Array(l);
+        var holder = state.corkedRequestsFree;
+        holder.entry = entry;
+        var count = 0;
+        var allBuffers = true;
+        while (entry) {
+          buffer[count] = entry;
+          if (!entry.isBuf)
+            allBuffers = false;
+          entry = entry.next;
+          count += 1;
+        }
+        buffer.allBuffers = allBuffers;
+        doWrite(stream, state, true, state.length, buffer, "", holder.finish);
+        state.pendingcb++;
+        state.lastBufferedRequest = null;
+        if (holder.next) {
+          state.corkedRequestsFree = holder.next;
+          holder.next = null;
+        } else {
+          state.corkedRequestsFree = new CorkedRequest(state);
+        }
+        state.bufferedRequestCount = 0;
+      } else {
+        while (entry) {
+          var chunk = entry.chunk;
+          var encoding = entry.encoding;
+          var cb = entry.callback;
+          var len = state.objectMode ? 1 : chunk.length;
+          doWrite(stream, state, false, len, chunk, encoding, cb);
+          entry = entry.next;
+          state.bufferedRequestCount--;
+          if (state.writing) {
+            break;
+          }
+        }
+        if (entry === null)
+          state.lastBufferedRequest = null;
+      }
+      state.bufferedRequest = entry;
+      state.bufferProcessing = false;
+    }
+    Writable.prototype._write = function(chunk, encoding, cb) {
+      cb(new Error("_write() is not implemented"));
+    };
+    Writable.prototype._writev = null;
+    Writable.prototype.end = function(chunk, encoding, cb) {
+      var state = this._writableState;
+      if (typeof chunk === "function") {
+        cb = chunk;
+        chunk = null;
+        encoding = null;
+      } else if (typeof encoding === "function") {
+        cb = encoding;
+        encoding = null;
+      }
+      if (chunk !== null && chunk !== void 0)
+        this.write(chunk, encoding);
+      if (state.corked) {
+        state.corked = 1;
+        this.uncork();
+      }
+      if (!state.ending && !state.finished)
+        endWritable(this, state, cb);
+    };
+    function needFinish(state) {
+      return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+    }
+    function callFinal(stream, state) {
+      stream._final(function(err) {
+        state.pendingcb--;
+        if (err) {
+          stream.emit("error", err);
+        }
+        state.prefinished = true;
+        stream.emit("prefinish");
+        finishMaybe(stream, state);
+      });
+    }
+    function prefinish(stream, state) {
+      if (!state.prefinished && !state.finalCalled) {
+        if (typeof stream._final === "function") {
+          state.pendingcb++;
+          state.finalCalled = true;
+          pna.nextTick(callFinal, stream, state);
+        } else {
+          state.prefinished = true;
+          stream.emit("prefinish");
+        }
+      }
+    }
+    function finishMaybe(stream, state) {
+      var need = needFinish(state);
+      if (need) {
+        prefinish(stream, state);
+        if (state.pendingcb === 0) {
+          state.finished = true;
+          stream.emit("finish");
+        }
+      }
+      return need;
+    }
+    function endWritable(stream, state, cb) {
+      state.ending = true;
+      finishMaybe(stream, state);
+      if (cb) {
+        if (state.finished)
+          pna.nextTick(cb);
+        else
+          stream.once("finish", cb);
+      }
+      state.ended = true;
+      stream.writable = false;
+    }
+    function onCorkedFinish(corkReq, state, err) {
+      var entry = corkReq.entry;
+      corkReq.entry = null;
+      while (entry) {
+        var cb = entry.callback;
+        state.pendingcb--;
+        cb(err);
+        entry = entry.next;
+      }
+      if (state.corkedRequestsFree) {
+        state.corkedRequestsFree.next = corkReq;
+      } else {
+        state.corkedRequestsFree = corkReq;
+      }
+    }
+    Object.defineProperty(Writable.prototype, "destroyed", {
+      get: function() {
+        if (this._writableState === void 0) {
+          return false;
+        }
+        return this._writableState.destroyed;
+      },
+      set: function(value) {
+        if (!this._writableState) {
+          return;
+        }
+        this._writableState.destroyed = value;
+      }
+    });
+    Writable.prototype.destroy = destroyImpl.destroy;
+    Writable.prototype._undestroy = destroyImpl.undestroy;
+    Writable.prototype._destroy = function(err, cb) {
+      this.end();
+      cb(err);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_duplex.js
+var require_stream_duplex2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_duplex.js"(exports2, module2) {
+    "use strict";
+    var pna = require_process_nextick_args();
+    var objectKeys = Object.keys || function(obj) {
+      var keys2 = [];
+      for (var key in obj) {
+        keys2.push(key);
+      }
+      return keys2;
+    };
+    module2.exports = Duplex;
+    var util = Object.create(require_util());
+    util.inherits = require_inherits();
+    var Readable = require_stream_readable2();
+    var Writable = require_stream_writable2();
+    util.inherits(Duplex, Readable);
+    {
+      keys = objectKeys(Writable.prototype);
+      for (v = 0; v < keys.length; v++) {
+        method = keys[v];
+        if (!Duplex.prototype[method])
+          Duplex.prototype[method] = Writable.prototype[method];
+      }
+    }
+    var keys;
+    var method;
+    var v;
+    function Duplex(options) {
+      if (!(this instanceof Duplex))
+        return new Duplex(options);
+      Readable.call(this, options);
+      Writable.call(this, options);
+      if (options && options.readable === false)
+        this.readable = false;
+      if (options && options.writable === false)
+        this.writable = false;
+      this.allowHalfOpen = true;
+      if (options && options.allowHalfOpen === false)
+        this.allowHalfOpen = false;
+      this.once("end", onend);
+    }
+    Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function() {
+        return this._writableState.highWaterMark;
+      }
+    });
+    function onend() {
+      if (this.allowHalfOpen || this._writableState.ended)
+        return;
+      pna.nextTick(onEndNT, this);
+    }
+    function onEndNT(self2) {
+      self2.end();
+    }
+    Object.defineProperty(Duplex.prototype, "destroyed", {
+      get: function() {
+        if (this._readableState === void 0 || this._writableState === void 0) {
+          return false;
+        }
+        return this._readableState.destroyed && this._writableState.destroyed;
+      },
+      set: function(value) {
+        if (this._readableState === void 0 || this._writableState === void 0) {
+          return;
+        }
+        this._readableState.destroyed = value;
+        this._writableState.destroyed = value;
+      }
+    });
+    Duplex.prototype._destroy = function(err, cb) {
+      this.push(null);
+      this.end();
+      pna.nextTick(cb, err);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_readable.js
+var require_stream_readable2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
+    "use strict";
+    var pna = require_process_nextick_args();
+    module2.exports = Readable;
+    var isArray = require_isarray();
+    var Duplex;
+    Readable.ReadableState = ReadableState;
+    var EE = require("events").EventEmitter;
+    var EElistenerCount = function(emitter, type) {
+      return emitter.listeners(type).length;
+    };
+    var Stream = require_stream2();
+    var Buffer2 = require_safe_buffer().Buffer;
+    var OurUint8Array = global.Uint8Array || function() {
+    };
+    function _uint8ArrayToBuffer(chunk) {
+      return Buffer2.from(chunk);
+    }
+    function _isUint8Array(obj) {
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+    }
+    var util = Object.create(require_util());
+    util.inherits = require_inherits();
+    var debugUtil = require("util");
+    var debug2 = void 0;
+    if (debugUtil && debugUtil.debuglog) {
+      debug2 = debugUtil.debuglog("stream");
+    } else {
+      debug2 = function() {
+      };
+    }
+    var BufferList = require_BufferList2();
+    var destroyImpl = require_destroy2();
+    var StringDecoder;
+    util.inherits(Readable, Stream);
+    var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
+    function prependListener(emitter, event, fn) {
+      if (typeof emitter.prependListener === "function")
+        return emitter.prependListener(event, fn);
+      if (!emitter._events || !emitter._events[event])
+        emitter.on(event, fn);
+      else if (isArray(emitter._events[event]))
+        emitter._events[event].unshift(fn);
+      else
+        emitter._events[event] = [fn, emitter._events[event]];
+    }
+    function ReadableState(options, stream) {
+      Duplex = Duplex || require_stream_duplex2();
+      options = options || {};
+      var isDuplex = stream instanceof Duplex;
+      this.objectMode = !!options.objectMode;
+      if (isDuplex)
+        this.objectMode = this.objectMode || !!options.readableObjectMode;
+      var hwm = options.highWaterMark;
+      var readableHwm = options.readableHighWaterMark;
+      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+      if (hwm || hwm === 0)
+        this.highWaterMark = hwm;
+      else if (isDuplex && (readableHwm || readableHwm === 0))
+        this.highWaterMark = readableHwm;
+      else
+        this.highWaterMark = defaultHwm;
+      this.highWaterMark = Math.floor(this.highWaterMark);
+      this.buffer = new BufferList();
+      this.length = 0;
+      this.pipes = null;
+      this.pipesCount = 0;
+      this.flowing = null;
+      this.ended = false;
+      this.endEmitted = false;
+      this.reading = false;
+      this.sync = true;
+      this.needReadable = false;
+      this.emittedReadable = false;
+      this.readableListening = false;
+      this.resumeScheduled = false;
+      this.destroyed = false;
+      this.defaultEncoding = options.defaultEncoding || "utf8";
+      this.awaitDrain = 0;
+      this.readingMore = false;
+      this.decoder = null;
+      this.encoding = null;
+      if (options.encoding) {
+        if (!StringDecoder)
+          StringDecoder = require_string_decoder().StringDecoder;
+        this.decoder = new StringDecoder(options.encoding);
+        this.encoding = options.encoding;
+      }
+    }
+    function Readable(options) {
+      Duplex = Duplex || require_stream_duplex2();
+      if (!(this instanceof Readable))
+        return new Readable(options);
+      this._readableState = new ReadableState(options, this);
+      this.readable = true;
+      if (options) {
+        if (typeof options.read === "function")
+          this._read = options.read;
+        if (typeof options.destroy === "function")
+          this._destroy = options.destroy;
+      }
+      Stream.call(this);
+    }
+    Object.defineProperty(Readable.prototype, "destroyed", {
+      get: function() {
+        if (this._readableState === void 0) {
+          return false;
+        }
+        return this._readableState.destroyed;
+      },
+      set: function(value) {
+        if (!this._readableState) {
+          return;
+        }
+        this._readableState.destroyed = value;
+      }
+    });
+    Readable.prototype.destroy = destroyImpl.destroy;
+    Readable.prototype._undestroy = destroyImpl.undestroy;
+    Readable.prototype._destroy = function(err, cb) {
+      this.push(null);
+      cb(err);
+    };
+    Readable.prototype.push = function(chunk, encoding) {
+      var state = this._readableState;
+      var skipChunkCheck;
+      if (!state.objectMode) {
+        if (typeof chunk === "string") {
+          encoding = encoding || state.defaultEncoding;
+          if (encoding !== state.encoding) {
+            chunk = Buffer2.from(chunk, encoding);
+            encoding = "";
+          }
+          skipChunkCheck = true;
+        }
+      } else {
+        skipChunkCheck = true;
+      }
+      return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+    };
+    Readable.prototype.unshift = function(chunk) {
+      return readableAddChunk(this, chunk, null, true, false);
+    };
+    function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+      var state = stream._readableState;
+      if (chunk === null) {
+        state.reading = false;
+        onEofChunk(stream, state);
+      } else {
+        var er;
+        if (!skipChunkCheck)
+          er = chunkInvalid(state, chunk);
+        if (er) {
+          stream.emit("error", er);
+        } else if (state.objectMode || chunk && chunk.length > 0) {
+          if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
+            chunk = _uint8ArrayToBuffer(chunk);
+          }
+          if (addToFront) {
+            if (state.endEmitted)
+              stream.emit("error", new Error("stream.unshift() after end event"));
+            else
+              addChunk(stream, state, chunk, true);
+          } else if (state.ended) {
+            stream.emit("error", new Error("stream.push() after EOF"));
+          } else {
+            state.reading = false;
+            if (state.decoder && !encoding) {
+              chunk = state.decoder.write(chunk);
+              if (state.objectMode || chunk.length !== 0)
+                addChunk(stream, state, chunk, false);
+              else
+                maybeReadMore(stream, state);
+            } else {
+              addChunk(stream, state, chunk, false);
+            }
+          }
+        } else if (!addToFront) {
+          state.reading = false;
+        }
+      }
+      return needMoreData(state);
+    }
+    function addChunk(stream, state, chunk, addToFront) {
+      if (state.flowing && state.length === 0 && !state.sync) {
+        stream.emit("data", chunk);
+        stream.read(0);
+      } else {
+        state.length += state.objectMode ? 1 : chunk.length;
+        if (addToFront)
+          state.buffer.unshift(chunk);
+        else
+          state.buffer.push(chunk);
+        if (state.needReadable)
+          emitReadable(stream);
+      }
+      maybeReadMore(stream, state);
+    }
+    function chunkInvalid(state, chunk) {
+      var er;
+      if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
+        er = new TypeError("Invalid non-string/buffer chunk");
+      }
+      return er;
+    }
+    function needMoreData(state) {
+      return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+    }
+    Readable.prototype.isPaused = function() {
+      return this._readableState.flowing === false;
+    };
+    Readable.prototype.setEncoding = function(enc) {
+      if (!StringDecoder)
+        StringDecoder = require_string_decoder().StringDecoder;
+      this._readableState.decoder = new StringDecoder(enc);
+      this._readableState.encoding = enc;
+      return this;
+    };
+    var MAX_HWM = 8388608;
+    function computeNewHighWaterMark(n) {
+      if (n >= MAX_HWM) {
+        n = MAX_HWM;
+      } else {
+        n--;
+        n |= n >>> 1;
+        n |= n >>> 2;
+        n |= n >>> 4;
+        n |= n >>> 8;
+        n |= n >>> 16;
+        n++;
+      }
+      return n;
+    }
+    function howMuchToRead(n, state) {
+      if (n <= 0 || state.length === 0 && state.ended)
+        return 0;
+      if (state.objectMode)
+        return 1;
+      if (n !== n) {
+        if (state.flowing && state.length)
+          return state.buffer.head.data.length;
+        else
+          return state.length;
+      }
+      if (n > state.highWaterMark)
+        state.highWaterMark = computeNewHighWaterMark(n);
+      if (n <= state.length)
+        return n;
+      if (!state.ended) {
+        state.needReadable = true;
+        return 0;
+      }
+      return state.length;
+    }
+    Readable.prototype.read = function(n) {
+      debug2("read", n);
+      n = parseInt(n, 10);
+      var state = this._readableState;
+      var nOrig = n;
+      if (n !== 0)
+        state.emittedReadable = false;
+      if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+        debug2("read: emitReadable", state.length, state.ended);
+        if (state.length === 0 && state.ended)
+          endReadable(this);
+        else
+          emitReadable(this);
+        return null;
+      }
+      n = howMuchToRead(n, state);
+      if (n === 0 && state.ended) {
+        if (state.length === 0)
+          endReadable(this);
+        return null;
+      }
+      var doRead = state.needReadable;
+      debug2("need readable", doRead);
+      if (state.length === 0 || state.length - n < state.highWaterMark) {
+        doRead = true;
+        debug2("length less than watermark", doRead);
+      }
+      if (state.ended || state.reading) {
+        doRead = false;
+        debug2("reading or ended", doRead);
+      } else if (doRead) {
+        debug2("do read");
+        state.reading = true;
+        state.sync = true;
+        if (state.length === 0)
+          state.needReadable = true;
+        this._read(state.highWaterMark);
+        state.sync = false;
+        if (!state.reading)
+          n = howMuchToRead(nOrig, state);
+      }
+      var ret;
+      if (n > 0)
+        ret = fromList(n, state);
+      else
+        ret = null;
+      if (ret === null) {
+        state.needReadable = true;
+        n = 0;
+      } else {
+        state.length -= n;
+      }
+      if (state.length === 0) {
+        if (!state.ended)
+          state.needReadable = true;
+        if (nOrig !== n && state.ended)
+          endReadable(this);
+      }
+      if (ret !== null)
+        this.emit("data", ret);
+      return ret;
+    };
+    function onEofChunk(stream, state) {
+      if (state.ended)
+        return;
+      if (state.decoder) {
+        var chunk = state.decoder.end();
+        if (chunk && chunk.length) {
+          state.buffer.push(chunk);
+          state.length += state.objectMode ? 1 : chunk.length;
+        }
+      }
+      state.ended = true;
+      emitReadable(stream);
+    }
+    function emitReadable(stream) {
+      var state = stream._readableState;
+      state.needReadable = false;
+      if (!state.emittedReadable) {
+        debug2("emitReadable", state.flowing);
+        state.emittedReadable = true;
+        if (state.sync)
+          pna.nextTick(emitReadable_, stream);
+        else
+          emitReadable_(stream);
+      }
+    }
+    function emitReadable_(stream) {
+      debug2("emit readable");
+      stream.emit("readable");
+      flow(stream);
+    }
+    function maybeReadMore(stream, state) {
+      if (!state.readingMore) {
+        state.readingMore = true;
+        pna.nextTick(maybeReadMore_, stream, state);
+      }
+    }
+    function maybeReadMore_(stream, state) {
+      var len = state.length;
+      while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+        debug2("maybeReadMore read 0");
+        stream.read(0);
+        if (len === state.length)
+          break;
+        else
+          len = state.length;
+      }
+      state.readingMore = false;
+    }
+    Readable.prototype._read = function(n) {
+      this.emit("error", new Error("_read() is not implemented"));
+    };
+    Readable.prototype.pipe = function(dest, pipeOpts) {
+      var src = this;
+      var state = this._readableState;
+      switch (state.pipesCount) {
+        case 0:
+          state.pipes = dest;
+          break;
+        case 1:
+          state.pipes = [state.pipes, dest];
+          break;
+        default:
+          state.pipes.push(dest);
+          break;
+      }
+      state.pipesCount += 1;
+      debug2("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
+      var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+      var endFn = doEnd ? onend : unpipe;
+      if (state.endEmitted)
+        pna.nextTick(endFn);
+      else
+        src.once("end", endFn);
+      dest.on("unpipe", onunpipe);
+      function onunpipe(readable, unpipeInfo) {
+        debug2("onunpipe");
+        if (readable === src) {
+          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+            unpipeInfo.hasUnpiped = true;
+            cleanup();
+          }
+        }
+      }
+      function onend() {
+        debug2("onend");
+        dest.end();
+      }
+      var ondrain = pipeOnDrain(src);
+      dest.on("drain", ondrain);
+      var cleanedUp = false;
+      function cleanup() {
+        debug2("cleanup");
+        dest.removeListener("close", onclose);
+        dest.removeListener("finish", onfinish);
+        dest.removeListener("drain", ondrain);
+        dest.removeListener("error", onerror);
+        dest.removeListener("unpipe", onunpipe);
+        src.removeListener("end", onend);
+        src.removeListener("end", unpipe);
+        src.removeListener("data", ondata);
+        cleanedUp = true;
+        if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
+          ondrain();
+      }
+      var increasedAwaitDrain = false;
+      src.on("data", ondata);
+      function ondata(chunk) {
+        debug2("ondata");
+        increasedAwaitDrain = false;
+        var ret = dest.write(chunk);
+        if (false === ret && !increasedAwaitDrain) {
+          if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+            debug2("false write response, pause", src._readableState.awaitDrain);
+            src._readableState.awaitDrain++;
+            increasedAwaitDrain = true;
+          }
+          src.pause();
+        }
+      }
+      function onerror(er) {
+        debug2("onerror", er);
+        unpipe();
+        dest.removeListener("error", onerror);
+        if (EElistenerCount(dest, "error") === 0)
+          dest.emit("error", er);
+      }
+      prependListener(dest, "error", onerror);
+      function onclose() {
+        dest.removeListener("finish", onfinish);
+        unpipe();
+      }
+      dest.once("close", onclose);
+      function onfinish() {
+        debug2("onfinish");
+        dest.removeListener("close", onclose);
+        unpipe();
+      }
+      dest.once("finish", onfinish);
+      function unpipe() {
+        debug2("unpipe");
+        src.unpipe(dest);
+      }
+      dest.emit("pipe", src);
+      if (!state.flowing) {
+        debug2("pipe resume");
+        src.resume();
+      }
+      return dest;
+    };
+    function pipeOnDrain(src) {
+      return function() {
+        var state = src._readableState;
+        debug2("pipeOnDrain", state.awaitDrain);
+        if (state.awaitDrain)
+          state.awaitDrain--;
+        if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
+          state.flowing = true;
+          flow(src);
+        }
+      };
+    }
+    Readable.prototype.unpipe = function(dest) {
+      var state = this._readableState;
+      var unpipeInfo = { hasUnpiped: false };
+      if (state.pipesCount === 0)
+        return this;
+      if (state.pipesCount === 1) {
+        if (dest && dest !== state.pipes)
+          return this;
+        if (!dest)
+          dest = state.pipes;
+        state.pipes = null;
+        state.pipesCount = 0;
+        state.flowing = false;
+        if (dest)
+          dest.emit("unpipe", this, unpipeInfo);
+        return this;
+      }
+      if (!dest) {
+        var dests = state.pipes;
+        var len = state.pipesCount;
+        state.pipes = null;
+        state.pipesCount = 0;
+        state.flowing = false;
+        for (var i = 0; i < len; i++) {
+          dests[i].emit("unpipe", this, unpipeInfo);
+        }
+        return this;
+      }
+      var index = indexOf(state.pipes, dest);
+      if (index === -1)
+        return this;
+      state.pipes.splice(index, 1);
+      state.pipesCount -= 1;
+      if (state.pipesCount === 1)
+        state.pipes = state.pipes[0];
+      dest.emit("unpipe", this, unpipeInfo);
+      return this;
+    };
+    Readable.prototype.on = function(ev, fn) {
+      var res = Stream.prototype.on.call(this, ev, fn);
+      if (ev === "data") {
+        if (this._readableState.flowing !== false)
+          this.resume();
+      } else if (ev === "readable") {
+        var state = this._readableState;
+        if (!state.endEmitted && !state.readableListening) {
+          state.readableListening = state.needReadable = true;
+          state.emittedReadable = false;
+          if (!state.reading) {
+            pna.nextTick(nReadingNextTick, this);
+          } else if (state.length) {
+            emitReadable(this);
+          }
+        }
+      }
+      return res;
+    };
+    Readable.prototype.addListener = Readable.prototype.on;
+    function nReadingNextTick(self2) {
+      debug2("readable nexttick read 0");
+      self2.read(0);
+    }
+    Readable.prototype.resume = function() {
+      var state = this._readableState;
+      if (!state.flowing) {
+        debug2("resume");
+        state.flowing = true;
+        resume(this, state);
+      }
+      return this;
+    };
+    function resume(stream, state) {
+      if (!state.resumeScheduled) {
+        state.resumeScheduled = true;
+        pna.nextTick(resume_, stream, state);
+      }
+    }
+    function resume_(stream, state) {
+      if (!state.reading) {
+        debug2("resume read 0");
+        stream.read(0);
+      }
+      state.resumeScheduled = false;
+      state.awaitDrain = 0;
+      stream.emit("resume");
+      flow(stream);
+      if (state.flowing && !state.reading)
+        stream.read(0);
+    }
+    Readable.prototype.pause = function() {
+      debug2("call pause flowing=%j", this._readableState.flowing);
+      if (false !== this._readableState.flowing) {
+        debug2("pause");
+        this._readableState.flowing = false;
+        this.emit("pause");
+      }
+      return this;
+    };
+    function flow(stream) {
+      var state = stream._readableState;
+      debug2("flow", state.flowing);
+      while (state.flowing && stream.read() !== null) {
+      }
+    }
+    Readable.prototype.wrap = function(stream) {
+      var _this = this;
+      var state = this._readableState;
+      var paused = false;
+      stream.on("end", function() {
+        debug2("wrapped end");
+        if (state.decoder && !state.ended) {
+          var chunk = state.decoder.end();
+          if (chunk && chunk.length)
+            _this.push(chunk);
+        }
+        _this.push(null);
+      });
+      stream.on("data", function(chunk) {
+        debug2("wrapped data");
+        if (state.decoder)
+          chunk = state.decoder.write(chunk);
+        if (state.objectMode && (chunk === null || chunk === void 0))
+          return;
+        else if (!state.objectMode && (!chunk || !chunk.length))
+          return;
+        var ret = _this.push(chunk);
+        if (!ret) {
+          paused = true;
+          stream.pause();
+        }
+      });
+      for (var i in stream) {
+        if (this[i] === void 0 && typeof stream[i] === "function") {
+          this[i] = function(method) {
+            return function() {
+              return stream[method].apply(stream, arguments);
+            };
+          }(i);
+        }
+      }
+      for (var n = 0; n < kProxyEvents.length; n++) {
+        stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+      }
+      this._read = function(n2) {
+        debug2("wrapped _read", n2);
+        if (paused) {
+          paused = false;
+          stream.resume();
+        }
+      };
+      return this;
+    };
+    Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function() {
+        return this._readableState.highWaterMark;
+      }
+    });
+    Readable._fromList = fromList;
+    function fromList(n, state) {
+      if (state.length === 0)
+        return null;
+      var ret;
+      if (state.objectMode)
+        ret = state.buffer.shift();
+      else if (!n || n >= state.length) {
+        if (state.decoder)
+          ret = state.buffer.join("");
+        else if (state.buffer.length === 1)
+          ret = state.buffer.head.data;
+        else
+          ret = state.buffer.concat(state.length);
+        state.buffer.clear();
+      } else {
+        ret = fromListPartial(n, state.buffer, state.decoder);
+      }
+      return ret;
+    }
+    function fromListPartial(n, list, hasStrings) {
+      var ret;
+      if (n < list.head.data.length) {
+        ret = list.head.data.slice(0, n);
+        list.head.data = list.head.data.slice(n);
+      } else if (n === list.head.data.length) {
+        ret = list.shift();
+      } else {
+        ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+      }
+      return ret;
+    }
+    function copyFromBufferString(n, list) {
+      var p = list.head;
+      var c = 1;
+      var ret = p.data;
+      n -= ret.length;
+      while (p = p.next) {
+        var str = p.data;
+        var nb = n > str.length ? str.length : n;
+        if (nb === str.length)
+          ret += str;
+        else
+          ret += str.slice(0, n);
+        n -= nb;
+        if (n === 0) {
+          if (nb === str.length) {
+            ++c;
+            if (p.next)
+              list.head = p.next;
+            else
+              list.head = list.tail = null;
+          } else {
+            list.head = p;
+            p.data = str.slice(nb);
+          }
+          break;
+        }
+        ++c;
+      }
+      list.length -= c;
+      return ret;
+    }
+    function copyFromBuffer(n, list) {
+      var ret = Buffer2.allocUnsafe(n);
+      var p = list.head;
+      var c = 1;
+      p.data.copy(ret);
+      n -= p.data.length;
+      while (p = p.next) {
+        var buf = p.data;
+        var nb = n > buf.length ? buf.length : n;
+        buf.copy(ret, ret.length - n, 0, nb);
+        n -= nb;
+        if (n === 0) {
+          if (nb === buf.length) {
+            ++c;
+            if (p.next)
+              list.head = p.next;
+            else
+              list.head = list.tail = null;
+          } else {
+            list.head = p;
+            p.data = buf.slice(nb);
+          }
+          break;
+        }
+        ++c;
+      }
+      list.length -= c;
+      return ret;
+    }
+    function endReadable(stream) {
+      var state = stream._readableState;
+      if (state.length > 0)
+        throw new Error('"endReadable()" called on non-empty stream');
+      if (!state.endEmitted) {
+        state.ended = true;
+        pna.nextTick(endReadableNT, state, stream);
+      }
+    }
+    function endReadableNT(state, stream) {
+      if (!state.endEmitted && state.length === 0) {
+        state.endEmitted = true;
+        stream.readable = false;
+        stream.emit("end");
+      }
+    }
+    function indexOf(xs, x) {
+      for (var i = 0, l = xs.length; i < l; i++) {
+        if (xs[i] === x)
+          return i;
+      }
+      return -1;
     }
-    module2.exports = moveSync;
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/index.js
-var require_move_sync2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move-sync/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      moveSync: require_move_sync()
-    };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js
-var require_move = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_transform.js
+var require_stream_transform2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    var path7 = require("path");
-    var copy = require_copy2().copy;
-    var remove2 = require_remove().remove;
-    var mkdirp3 = require_mkdirs().mkdirp;
-    var pathExists = require_path_exists().pathExists;
-    var stat = require_stat();
-    function move(src, dest, opts, cb) {
-      if (typeof opts === "function") {
-        cb = opts;
-        opts = {};
+    module2.exports = Transform;
+    var Duplex = require_stream_duplex2();
+    var util = Object.create(require_util());
+    util.inherits = require_inherits();
+    util.inherits(Transform, Duplex);
+    function afterTransform(er, data) {
+      var ts = this._transformState;
+      ts.transforming = false;
+      var cb = ts.writecb;
+      if (!cb) {
+        return this.emit("error", new Error("write callback called multiple times"));
+      }
+      ts.writechunk = null;
+      ts.writecb = null;
+      if (data != null)
+        this.push(data);
+      cb(er);
+      var rs = this._readableState;
+      rs.reading = false;
+      if (rs.needReadable || rs.length < rs.highWaterMark) {
+        this._read(rs.highWaterMark);
       }
-      const overwrite = opts.overwrite || opts.clobber || false;
-      stat.checkPaths(src, dest, "move", opts, (err, stats) => {
-        if (err)
-          return cb(err);
-        const { srcStat, isChangingCase = false } = stats;
-        stat.checkParentPaths(src, srcStat, dest, "move", (err2) => {
-          if (err2)
-            return cb(err2);
-          if (isParentRoot(dest))
-            return doRename(src, dest, overwrite, isChangingCase, cb);
-          mkdirp3(path7.dirname(dest), (err3) => {
-            if (err3)
-              return cb(err3);
-            return doRename(src, dest, overwrite, isChangingCase, cb);
-          });
-        });
-      });
     }
-    function isParentRoot(dest) {
-      const parent = path7.dirname(dest);
-      const parsedPath = path7.parse(parent);
-      return parsedPath.root === parent;
+    function Transform(options) {
+      if (!(this instanceof Transform))
+        return new Transform(options);
+      Duplex.call(this, options);
+      this._transformState = {
+        afterTransform: afterTransform.bind(this),
+        needTransform: false,
+        transforming: false,
+        writecb: null,
+        writechunk: null,
+        writeencoding: null
+      };
+      this._readableState.needReadable = true;
+      this._readableState.sync = false;
+      if (options) {
+        if (typeof options.transform === "function")
+          this._transform = options.transform;
+        if (typeof options.flush === "function")
+          this._flush = options.flush;
+      }
+      this.on("prefinish", prefinish);
     }
-    function doRename(src, dest, overwrite, isChangingCase, cb) {
-      if (isChangingCase)
-        return rename2(src, dest, overwrite, cb);
-      if (overwrite) {
-        return remove2(dest, (err) => {
-          if (err)
-            return cb(err);
-          return rename2(src, dest, overwrite, cb);
+    function prefinish() {
+      var _this = this;
+      if (typeof this._flush === "function") {
+        this._flush(function(er, data) {
+          done(_this, er, data);
         });
+      } else {
+        done(this, null, null);
       }
-      pathExists(dest, (err, destExists) => {
-        if (err)
-          return cb(err);
-        if (destExists)
-          return cb(new Error("dest already exists."));
-        return rename2(src, dest, overwrite, cb);
-      });
-    }
-    function rename2(src, dest, overwrite, cb) {
-      fs5.rename(src, dest, (err) => {
-        if (!err)
-          return cb();
-        if (err.code !== "EXDEV")
-          return cb(err);
-        return moveAcrossDevice(src, dest, overwrite, cb);
-      });
     }
-    function moveAcrossDevice(src, dest, overwrite, cb) {
-      const opts = {
-        overwrite,
-        errorOnExist: true
-      };
-      copy(src, dest, opts, (err) => {
-        if (err)
-          return cb(err);
-        return remove2(src, cb);
+    Transform.prototype.push = function(chunk, encoding) {
+      this._transformState.needTransform = false;
+      return Duplex.prototype.push.call(this, chunk, encoding);
+    };
+    Transform.prototype._transform = function(chunk, encoding, cb) {
+      throw new Error("_transform() is not implemented");
+    };
+    Transform.prototype._write = function(chunk, encoding, cb) {
+      var ts = this._transformState;
+      ts.writecb = cb;
+      ts.writechunk = chunk;
+      ts.writeencoding = encoding;
+      if (!ts.transforming) {
+        var rs = this._readableState;
+        if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark)
+          this._read(rs.highWaterMark);
+      }
+    };
+    Transform.prototype._read = function(n) {
+      var ts = this._transformState;
+      if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+        ts.transforming = true;
+        this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+      } else {
+        ts.needTransform = true;
+      }
+    };
+    Transform.prototype._destroy = function(err, cb) {
+      var _this2 = this;
+      Duplex.prototype._destroy.call(this, err, function(err2) {
+        cb(err2);
+        _this2.emit("close");
       });
+    };
+    function done(stream, er, data) {
+      if (er)
+        return stream.emit("error", er);
+      if (data != null)
+        stream.push(data);
+      if (stream._writableState.length)
+        throw new Error("Calling transform done when ws.length != 0");
+      if (stream._transformState.transforming)
+        throw new Error("Calling transform done when still transforming");
+      return stream.push(null);
     }
-    module2.exports = move;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/index.js
-var require_move2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_passthrough.js
+var require_stream_passthrough2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    module2.exports = {
-      move: u(require_move())
+    module2.exports = PassThrough;
+    var Transform = require_stream_transform2();
+    var util = Object.create(require_util());
+    util.inherits = require_inherits();
+    util.inherits(PassThrough, Transform);
+    function PassThrough(options) {
+      if (!(this instanceof PassThrough))
+        return new PassThrough(options);
+      Transform.call(this, options);
+    }
+    PassThrough.prototype._transform = function(chunk, encoding, cb) {
+      cb(null, chunk);
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/index.js
-var require_lib = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@10.0.0/node_modules/fs-extra/lib/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      // Export promiseified graceful-fs:
-      ...require_fs(),
-      // Export extra methods:
-      ...require_copy_sync2(),
-      ...require_copy2(),
-      ...require_empty(),
-      ...require_ensure(),
-      ...require_json(),
-      ...require_mkdirs(),
-      ...require_move_sync2(),
-      ...require_move2(),
-      ...require_output(),
-      ...require_path_exists(),
-      ...require_remove()
-    };
+// ../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/readable.js
+var require_readable2 = __commonJS({
+  "../../node_modules/.pnpm/readable-stream@2.3.7/node_modules/readable-stream/readable.js"(exports2, module2) {
+    var Stream = require("stream");
+    if (process.env.READABLE_STREAM === "disable" && Stream) {
+      module2.exports = Stream;
+      exports2 = module2.exports = Stream.Readable;
+      exports2.Readable = Stream.Readable;
+      exports2.Writable = Stream.Writable;
+      exports2.Duplex = Stream.Duplex;
+      exports2.Transform = Stream.Transform;
+      exports2.PassThrough = Stream.PassThrough;
+      exports2.Stream = Stream;
+    } else {
+      exports2 = module2.exports = require_stream_readable2();
+      exports2.Stream = Stream || exports2;
+      exports2.Readable = exports2;
+      exports2.Writable = require_stream_writable2();
+      exports2.Duplex = require_stream_duplex2();
+      exports2.Transform = require_stream_transform2();
+      exports2.PassThrough = require_stream_passthrough2();
+    }
   }
 });
 
@@ -4969,28 +6592,28 @@ var require_multistream = __commonJS({
   "../../node_modules/.pnpm/multistream@2.1.1/node_modules/multistream/index.js"(exports2, module2) {
     module2.exports = MultiStream;
     var inherits = require_inherits();
-    var stream = require_readable();
+    var stream = require_readable2();
     inherits(MultiStream, stream.Readable);
     function MultiStream(streams, opts) {
-      var self = this;
-      if (!(self instanceof MultiStream))
+      var self2 = this;
+      if (!(self2 instanceof MultiStream))
         return new MultiStream(streams, opts);
-      stream.Readable.call(self, opts);
-      self.destroyed = false;
-      self._drained = false;
-      self._forwarding = false;
-      self._current = null;
-      self._toStreams2 = opts && opts.objectMode ? toStreams2Obj : toStreams2Buf;
+      stream.Readable.call(self2, opts);
+      self2.destroyed = false;
+      self2._drained = false;
+      self2._forwarding = false;
+      self2._current = null;
+      self2._toStreams2 = opts && opts.objectMode ? toStreams2Obj : toStreams2Buf;
       if (typeof streams === "function") {
-        self._queue = streams;
+        self2._queue = streams;
       } else {
-        self._queue = streams.map(self._toStreams2);
-        self._queue.forEach(function(stream2) {
+        self2._queue = streams.map(self2._toStreams2);
+        self2._queue.forEach(function(stream2) {
           if (typeof stream2 !== "function")
-            self._attachErrorListener(stream2);
+            self2._attachErrorListener(stream2);
         });
       }
-      self._next();
+      self2._next();
     }
     MultiStream.obj = function(streams) {
       return new MultiStream(streams, { objectMode: true, highWaterMark: 16 });
@@ -5026,61 +6649,61 @@ var require_multistream = __commonJS({
       this.emit("close");
     };
     MultiStream.prototype._next = function() {
-      var self = this;
-      self._current = null;
-      if (typeof self._queue === "function") {
-        self._queue(function(err, stream3) {
+      var self2 = this;
+      self2._current = null;
+      if (typeof self2._queue === "function") {
+        self2._queue(function(err, stream3) {
           if (err)
-            return self.destroy(err);
-          stream3 = self._toStreams2(stream3);
-          self._attachErrorListener(stream3);
-          self._gotNextStream(stream3);
+            return self2.destroy(err);
+          stream3 = self2._toStreams2(stream3);
+          self2._attachErrorListener(stream3);
+          self2._gotNextStream(stream3);
         });
       } else {
-        var stream2 = self._queue.shift();
+        var stream2 = self2._queue.shift();
         if (typeof stream2 === "function") {
-          stream2 = self._toStreams2(stream2());
-          self._attachErrorListener(stream2);
+          stream2 = self2._toStreams2(stream2());
+          self2._attachErrorListener(stream2);
         }
-        self._gotNextStream(stream2);
+        self2._gotNextStream(stream2);
       }
     };
     MultiStream.prototype._gotNextStream = function(stream2) {
-      var self = this;
+      var self2 = this;
       if (!stream2) {
-        self.push(null);
-        self.destroy();
+        self2.push(null);
+        self2.destroy();
         return;
       }
-      self._current = stream2;
-      self._forward();
+      self2._current = stream2;
+      self2._forward();
       stream2.on("readable", onReadable);
       stream2.once("end", onEnd);
       stream2.once("close", onClose);
       function onReadable() {
-        self._forward();
+        self2._forward();
       }
       function onClose() {
         if (!stream2._readableState.ended) {
-          self.destroy();
+          self2.destroy();
         }
       }
       function onEnd() {
-        self._current = null;
+        self2._current = null;
         stream2.removeListener("readable", onReadable);
         stream2.removeListener("end", onEnd);
         stream2.removeListener("close", onClose);
-        self._next();
+        self2._next();
       }
     };
     MultiStream.prototype._attachErrorListener = function(stream2) {
-      var self = this;
+      var self2 = this;
       if (!stream2)
         return;
       stream2.once("error", onError);
       function onError(err) {
         stream2.removeListener("error", onError);
-        self.destroy(err);
+        self2.destroy(err);
       }
     };
     function toStreams2Obj(s) {
@@ -8432,18 +10055,18 @@ var require_retry_operation = __commonJS({
           return false;
         }
       }
-      var self = this;
+      var self2 = this;
       var timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
+        self2._attempts++;
+        if (self2._operationTimeoutCb) {
+          self2._timeout = setTimeout(function() {
+            self2._operationTimeoutCb(self2._attempts);
+          }, self2._operationTimeout);
+          if (self2._options.unref) {
+            self2._timeout.unref();
           }
         }
-        self._fn(self._attempts);
+        self2._fn(self2._attempts);
       }, timeout);
       if (this._options.unref) {
         timer.unref();
@@ -8460,11 +10083,11 @@ var require_retry_operation = __commonJS({
           this._operationTimeoutCb = timeoutOps.cb;
         }
       }
-      var self = this;
+      var self2 = this;
       if (this._operationTimeoutCb) {
         this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
+          self2._operationTimeoutCb();
+        }, self2._operationTimeout);
       }
       this._operationStart = (/* @__PURE__ */ new Date()).getTime();
       this._fn(this._attempts);
@@ -8970,17 +10593,17 @@ var require_yazl = __commonJS({
       this.forceZip64Eocd = false;
     }
     ZipFile2.prototype.addFile = function(realPath, metadataPath, options) {
-      var self = this;
+      var self2 = this;
       metadataPath = validateMetadataPath(metadataPath, false);
       if (options == null)
         options = {};
       var entry = new Entry(metadataPath, false, options);
-      self.entries.push(entry);
+      self2.entries.push(entry);
       fs5.stat(realPath, function(err, stats) {
         if (err)
-          return self.emit("error", err);
+          return self2.emit("error", err);
         if (!stats.isFile())
-          return self.emit("error", new Error("not a file: " + realPath));
+          return self2.emit("error", new Error("not a file: " + realPath));
         entry.uncompressedSize = stats.size;
         if (options.mtime == null)
           entry.setLastModDate(stats.mtime);
@@ -8990,28 +10613,28 @@ var require_yazl = __commonJS({
           var readStream = fs5.createReadStream(realPath);
           entry.state = Entry.FILE_DATA_IN_PROGRESS;
           readStream.on("error", function(err2) {
-            self.emit("error", err2);
+            self2.emit("error", err2);
           });
-          pumpFileDataReadStream(self, entry, readStream);
+          pumpFileDataReadStream(self2, entry, readStream);
         });
-        pumpEntries(self);
+        pumpEntries(self2);
       });
     };
     ZipFile2.prototype.addReadStream = function(readStream, metadataPath, options) {
-      var self = this;
+      var self2 = this;
       metadataPath = validateMetadataPath(metadataPath, false);
       if (options == null)
         options = {};
       var entry = new Entry(metadataPath, false, options);
-      self.entries.push(entry);
+      self2.entries.push(entry);
       entry.setFileDataPumpFunction(function() {
         entry.state = Entry.FILE_DATA_IN_PROGRESS;
-        pumpFileDataReadStream(self, entry, readStream);
+        pumpFileDataReadStream(self2, entry, readStream);
       });
-      pumpEntries(self);
+      pumpEntries(self2);
     };
     ZipFile2.prototype.addBuffer = function(buffer, metadataPath, options) {
-      var self = this;
+      var self2 = this;
       metadataPath = validateMetadataPath(metadataPath, false);
       if (buffer.length > 1073741823)
         throw new Error("buffer too large: " + buffer.length + " > 1073741823");
@@ -9023,7 +10646,7 @@ var require_yazl = __commonJS({
       entry.uncompressedSize = buffer.length;
       entry.crc32 = crc32.unsigned(buffer);
       entry.crcAndFileSizeKnown = true;
-      self.entries.push(entry);
+      self2.entries.push(entry);
       if (!entry.compress) {
         setCompressedBuffer(buffer);
       } else {
@@ -9034,18 +10657,18 @@ var require_yazl = __commonJS({
       function setCompressedBuffer(compressedBuffer) {
         entry.compressedSize = compressedBuffer.length;
         entry.setFileDataPumpFunction(function() {
-          writeToOutputStream(self, compressedBuffer);
-          writeToOutputStream(self, entry.getDataDescriptor());
+          writeToOutputStream(self2, compressedBuffer);
+          writeToOutputStream(self2, entry.getDataDescriptor());
           entry.state = Entry.FILE_DATA_DONE;
           setImmediate(function() {
-            pumpEntries(self);
+            pumpEntries(self2);
           });
         });
-        pumpEntries(self);
+        pumpEntries(self2);
       }
     };
     ZipFile2.prototype.addEmptyDirectory = function(metadataPath, options) {
-      var self = this;
+      var self2 = this;
       metadataPath = validateMetadataPath(metadataPath, true);
       if (options == null)
         options = {};
@@ -9054,13 +10677,13 @@ var require_yazl = __commonJS({
       if (options.compress != null)
         throw new Error("options.compress not allowed");
       var entry = new Entry(metadataPath, true, options);
-      self.entries.push(entry);
+      self2.entries.push(entry);
       entry.setFileDataPumpFunction(function() {
-        writeToOutputStream(self, entry.getDataDescriptor());
+        writeToOutputStream(self2, entry.getDataDescriptor());
         entry.state = Entry.FILE_DATA_DONE;
-        pumpEntries(self);
+        pumpEntries(self2);
       });
-      pumpEntries(self);
+      pumpEntries(self2);
     };
     var eocdrSignatureBuffer = bufferFrom([80, 75, 5, 6]);
     ZipFile2.prototype.end = function(options, finalSizeCallback) {
@@ -9090,45 +10713,45 @@ var require_yazl = __commonJS({
       }
       pumpEntries(this);
     };
-    function writeToOutputStream(self, buffer) {
-      self.outputStream.write(buffer);
-      self.outputStreamCursor += buffer.length;
+    function writeToOutputStream(self2, buffer) {
+      self2.outputStream.write(buffer);
+      self2.outputStreamCursor += buffer.length;
     }
-    function pumpFileDataReadStream(self, entry, readStream) {
+    function pumpFileDataReadStream(self2, entry, readStream) {
       var crc32Watcher = new Crc32Watcher();
       var uncompressedSizeCounter = new ByteCounter();
       var compressor = entry.compress ? new zlib.DeflateRaw() : new PassThrough();
       var compressedSizeCounter = new ByteCounter();
-      readStream.pipe(crc32Watcher).pipe(uncompressedSizeCounter).pipe(compressor).pipe(compressedSizeCounter).pipe(self.outputStream, { end: false });
+      readStream.pipe(crc32Watcher).pipe(uncompressedSizeCounter).pipe(compressor).pipe(compressedSizeCounter).pipe(self2.outputStream, { end: false });
       compressedSizeCounter.on("end", function() {
         entry.crc32 = crc32Watcher.crc32;
         if (entry.uncompressedSize == null) {
           entry.uncompressedSize = uncompressedSizeCounter.byteCount;
         } else {
           if (entry.uncompressedSize !== uncompressedSizeCounter.byteCount)
-            return self.emit("error", new Error("file data stream has unexpected number of bytes"));
+            return self2.emit("error", new Error("file data stream has unexpected number of bytes"));
         }
         entry.compressedSize = compressedSizeCounter.byteCount;
-        self.outputStreamCursor += entry.compressedSize;
-        writeToOutputStream(self, entry.getDataDescriptor());
+        self2.outputStreamCursor += entry.compressedSize;
+        writeToOutputStream(self2, entry.getDataDescriptor());
         entry.state = Entry.FILE_DATA_DONE;
-        pumpEntries(self);
+        pumpEntries(self2);
       });
     }
-    function pumpEntries(self) {
-      if (self.allDone)
+    function pumpEntries(self2) {
+      if (self2.allDone)
         return;
-      if (self.ended && self.finalSizeCallback != null) {
-        var finalSize = calculateFinalSize(self);
+      if (self2.ended && self2.finalSizeCallback != null) {
+        var finalSize = calculateFinalSize(self2);
         if (finalSize != null) {
-          self.finalSizeCallback(finalSize);
-          self.finalSizeCallback = null;
+          self2.finalSizeCallback(finalSize);
+          self2.finalSizeCallback = null;
         }
       }
       var entry = getFirstNotDoneEntry();
       function getFirstNotDoneEntry() {
-        for (var i = 0; i < self.entries.length; i++) {
-          var entry2 = self.entries[i];
+        for (var i = 0; i < self2.entries.length; i++) {
+          var entry2 = self2.entries[i];
           if (entry2.state < Entry.FILE_DATA_DONE)
             return entry2;
         }
@@ -9139,28 +10762,28 @@ var require_yazl = __commonJS({
           return;
         if (entry.state === Entry.FILE_DATA_IN_PROGRESS)
           return;
-        entry.relativeOffsetOfLocalHeader = self.outputStreamCursor;
+        entry.relativeOffsetOfLocalHeader = self2.outputStreamCursor;
         var localFileHeader = entry.getLocalFileHeader();
-        writeToOutputStream(self, localFileHeader);
+        writeToOutputStream(self2, localFileHeader);
         entry.doFileDataPump();
       } else {
-        if (self.ended) {
-          self.offsetOfStartOfCentralDirectory = self.outputStreamCursor;
-          self.entries.forEach(function(entry2) {
+        if (self2.ended) {
+          self2.offsetOfStartOfCentralDirectory = self2.outputStreamCursor;
+          self2.entries.forEach(function(entry2) {
             var centralDirectoryRecord = entry2.getCentralDirectoryRecord();
-            writeToOutputStream(self, centralDirectoryRecord);
+            writeToOutputStream(self2, centralDirectoryRecord);
           });
-          writeToOutputStream(self, getEndOfCentralDirectoryRecord(self));
-          self.outputStream.end();
-          self.allDone = true;
+          writeToOutputStream(self2, getEndOfCentralDirectoryRecord(self2));
+          self2.outputStream.end();
+          self2.allDone = true;
         }
       }
     }
-    function calculateFinalSize(self) {
+    function calculateFinalSize(self2) {
       var pretendOutputCursor = 0;
       var centralDirectorySize = 0;
-      for (var i = 0; i < self.entries.length; i++) {
-        var entry = self.entries[i];
+      for (var i = 0; i < self2.entries.length; i++) {
+        var entry = self2.entries[i];
         if (entry.compress)
           return -1;
         if (entry.state >= Entry.READY_TO_PUMP_FILE_DATA) {
@@ -9187,30 +10810,30 @@ var require_yazl = __commonJS({
         }
       }
       var endOfCentralDirectorySize = 0;
-      if (self.forceZip64Eocd || self.entries.length >= 65535 || centralDirectorySize >= 65535 || pretendOutputCursor >= 4294967295) {
+      if (self2.forceZip64Eocd || self2.entries.length >= 65535 || centralDirectorySize >= 65535 || pretendOutputCursor >= 4294967295) {
         endOfCentralDirectorySize += ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE;
       }
-      endOfCentralDirectorySize += END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self.comment.length;
+      endOfCentralDirectorySize += END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self2.comment.length;
       return pretendOutputCursor + centralDirectorySize + endOfCentralDirectorySize;
     }
     var ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 56;
     var ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE = 20;
     var END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 22;
-    function getEndOfCentralDirectoryRecord(self, actuallyJustTellMeHowLongItWouldBe) {
+    function getEndOfCentralDirectoryRecord(self2, actuallyJustTellMeHowLongItWouldBe) {
       var needZip64Format = false;
-      var normalEntriesLength = self.entries.length;
-      if (self.forceZip64Eocd || self.entries.length >= 65535) {
+      var normalEntriesLength = self2.entries.length;
+      if (self2.forceZip64Eocd || self2.entries.length >= 65535) {
         normalEntriesLength = 65535;
         needZip64Format = true;
       }
-      var sizeOfCentralDirectory = self.outputStreamCursor - self.offsetOfStartOfCentralDirectory;
+      var sizeOfCentralDirectory = self2.outputStreamCursor - self2.offsetOfStartOfCentralDirectory;
       var normalSizeOfCentralDirectory = sizeOfCentralDirectory;
-      if (self.forceZip64Eocd || sizeOfCentralDirectory >= 4294967295) {
+      if (self2.forceZip64Eocd || sizeOfCentralDirectory >= 4294967295) {
         normalSizeOfCentralDirectory = 4294967295;
         needZip64Format = true;
       }
-      var normalOffsetOfStartOfCentralDirectory = self.offsetOfStartOfCentralDirectory;
-      if (self.forceZip64Eocd || self.offsetOfStartOfCentralDirectory >= 4294967295) {
+      var normalOffsetOfStartOfCentralDirectory = self2.offsetOfStartOfCentralDirectory;
+      if (self2.forceZip64Eocd || self2.offsetOfStartOfCentralDirectory >= 4294967295) {
         normalOffsetOfStartOfCentralDirectory = 4294967295;
         needZip64Format = true;
       }
@@ -9221,7 +10844,7 @@ var require_yazl = __commonJS({
           return END_OF_CENTRAL_DIRECTORY_RECORD_SIZE;
         }
       }
-      var eocdrBuffer = bufferAlloc(END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self.comment.length);
+      var eocdrBuffer = bufferAlloc(END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self2.comment.length);
       eocdrBuffer.writeUInt32LE(101010256, 0);
       eocdrBuffer.writeUInt16LE(0, 4);
       eocdrBuffer.writeUInt16LE(0, 6);
@@ -9229,8 +10852,8 @@ var require_yazl = __commonJS({
       eocdrBuffer.writeUInt16LE(normalEntriesLength, 10);
       eocdrBuffer.writeUInt32LE(normalSizeOfCentralDirectory, 12);
       eocdrBuffer.writeUInt32LE(normalOffsetOfStartOfCentralDirectory, 16);
-      eocdrBuffer.writeUInt16LE(self.comment.length, 20);
-      self.comment.copy(eocdrBuffer, 22);
+      eocdrBuffer.writeUInt16LE(self2.comment.length, 20);
+      self2.comment.copy(eocdrBuffer, 22);
       if (!needZip64Format)
         return eocdrBuffer;
       var zip64EocdrBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE);
@@ -9240,14 +10863,14 @@ var require_yazl = __commonJS({
       zip64EocdrBuffer.writeUInt16LE(VERSION_NEEDED_TO_EXTRACT_ZIP64, 14);
       zip64EocdrBuffer.writeUInt32LE(0, 16);
       zip64EocdrBuffer.writeUInt32LE(0, 20);
-      writeUInt64LE(zip64EocdrBuffer, self.entries.length, 24);
-      writeUInt64LE(zip64EocdrBuffer, self.entries.length, 32);
+      writeUInt64LE(zip64EocdrBuffer, self2.entries.length, 24);
+      writeUInt64LE(zip64EocdrBuffer, self2.entries.length, 32);
       writeUInt64LE(zip64EocdrBuffer, sizeOfCentralDirectory, 40);
-      writeUInt64LE(zip64EocdrBuffer, self.offsetOfStartOfCentralDirectory, 48);
+      writeUInt64LE(zip64EocdrBuffer, self2.offsetOfStartOfCentralDirectory, 48);
       var zip64EocdlBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE);
       zip64EocdlBuffer.writeUInt32LE(117853008, 0);
       zip64EocdlBuffer.writeUInt32LE(0, 4);
-      writeUInt64LE(zip64EocdlBuffer, self.outputStreamCursor, 8);
+      writeUInt64LE(zip64EocdlBuffer, self2.outputStreamCursor, 8);
       zip64EocdlBuffer.writeUInt32LE(1, 16);
       return Buffer.concat([
         zip64EocdrBuffer,
@@ -10017,7 +11640,7 @@ var require_minimatch = __commonJS({
       var reClassStart = -1;
       var classStart = -1;
       var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
-      var self = this;
+      var self2 = this;
       function clearStateChar() {
         if (stateChar) {
           switch (stateChar) {
@@ -10033,7 +11656,7 @@ var require_minimatch = __commonJS({
               re += "\\" + stateChar;
               break;
           }
-          self.debug("clearStateChar %j %j", stateChar, re);
+          self2.debug("clearStateChar %j %j", stateChar, re);
           stateChar = false;
         }
       }
@@ -10065,7 +11688,7 @@ var require_minimatch = __commonJS({
               re += c;
               continue;
             }
-            self.debug("call clearStateChar %j", stateChar);
+            self2.debug("call clearStateChar %j", stateChar);
             clearStateChar();
             stateChar = c;
             if (options.noext)
@@ -11552,12 +13175,12 @@ var require_common = __commonJS({
     function alphasort(a, b) {
       return a.localeCompare(b, "en");
     }
-    function setupIgnores(self, options) {
-      self.ignore = options.ignore || [];
-      if (!Array.isArray(self.ignore))
-        self.ignore = [self.ignore];
-      if (self.ignore.length) {
-        self.ignore = self.ignore.map(ignoreMap);
+    function setupIgnores(self2, options) {
+      self2.ignore = options.ignore || [];
+      if (!Array.isArray(self2.ignore))
+        self2.ignore = [self2.ignore];
+      if (self2.ignore.length) {
+        self2.ignore = self2.ignore.map(ignoreMap);
       }
     }
     function ignoreMap(pattern) {
@@ -11571,7 +13194,7 @@ var require_common = __commonJS({
         gmatcher
       };
     }
-    function setopts(self, pattern, options) {
+    function setopts(self2, pattern, options) {
       if (!options)
         options = {};
       if (options.matchBase && -1 === pattern.indexOf("/")) {
@@ -11580,62 +13203,62 @@ var require_common = __commonJS({
         }
         pattern = "**/" + pattern;
       }
-      self.silent = !!options.silent;
-      self.pattern = pattern;
-      self.strict = options.strict !== false;
-      self.realpath = !!options.realpath;
-      self.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
-      self.follow = !!options.follow;
-      self.dot = !!options.dot;
-      self.mark = !!options.mark;
-      self.nodir = !!options.nodir;
-      if (self.nodir)
-        self.mark = true;
-      self.sync = !!options.sync;
-      self.nounique = !!options.nounique;
-      self.nonull = !!options.nonull;
-      self.nosort = !!options.nosort;
-      self.nocase = !!options.nocase;
-      self.stat = !!options.stat;
-      self.noprocess = !!options.noprocess;
-      self.absolute = !!options.absolute;
-      self.fs = options.fs || fs5;
-      self.maxLength = options.maxLength || Infinity;
-      self.cache = options.cache || /* @__PURE__ */ Object.create(null);
-      self.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
-      self.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
-      setupIgnores(self, options);
-      self.changedCwd = false;
+      self2.silent = !!options.silent;
+      self2.pattern = pattern;
+      self2.strict = options.strict !== false;
+      self2.realpath = !!options.realpath;
+      self2.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
+      self2.follow = !!options.follow;
+      self2.dot = !!options.dot;
+      self2.mark = !!options.mark;
+      self2.nodir = !!options.nodir;
+      if (self2.nodir)
+        self2.mark = true;
+      self2.sync = !!options.sync;
+      self2.nounique = !!options.nounique;
+      self2.nonull = !!options.nonull;
+      self2.nosort = !!options.nosort;
+      self2.nocase = !!options.nocase;
+      self2.stat = !!options.stat;
+      self2.noprocess = !!options.noprocess;
+      self2.absolute = !!options.absolute;
+      self2.fs = options.fs || fs5;
+      self2.maxLength = options.maxLength || Infinity;
+      self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
+      self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
+      self2.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
+      setupIgnores(self2, options);
+      self2.changedCwd = false;
       var cwd = process.cwd();
       if (!ownProp(options, "cwd"))
-        self.cwd = path7.resolve(cwd);
+        self2.cwd = path7.resolve(cwd);
       else {
-        self.cwd = path7.resolve(options.cwd);
-        self.changedCwd = self.cwd !== cwd;
+        self2.cwd = path7.resolve(options.cwd);
+        self2.changedCwd = self2.cwd !== cwd;
       }
-      self.root = options.root || path7.resolve(self.cwd, "/");
-      self.root = path7.resolve(self.root);
-      self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
-      self.nomount = !!options.nomount;
+      self2.root = options.root || path7.resolve(self2.cwd, "/");
+      self2.root = path7.resolve(self2.root);
+      self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
+      self2.nomount = !!options.nomount;
       if (process.platform === "win32") {
-        self.root = self.root.replace(/\\/g, "/");
-        self.cwd = self.cwd.replace(/\\/g, "/");
-        self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+        self2.root = self2.root.replace(/\\/g, "/");
+        self2.cwd = self2.cwd.replace(/\\/g, "/");
+        self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
       }
       options.nonegate = true;
       options.nocomment = true;
       options.allowWindowsEscape = true;
-      self.minimatch = new Minimatch(pattern, options);
-      self.options = self.minimatch.options;
+      self2.minimatch = new Minimatch(pattern, options);
+      self2.options = self2.minimatch.options;
     }
-    function finish(self) {
-      var nou = self.nounique;
+    function finish(self2) {
+      var nou = self2.nounique;
       var all = nou ? [] : /* @__PURE__ */ Object.create(null);
-      for (var i = 0, l = self.matches.length; i < l; i++) {
-        var matches = self.matches[i];
+      for (var i = 0, l = self2.matches.length; i < l; i++) {
+        var matches = self2.matches[i];
         if (!matches || Object.keys(matches).length === 0) {
-          if (self.nonull) {
-            var literal = self.minimatch.globSet[i];
+          if (self2.nonull) {
+            var literal = self2.minimatch.globSet[i];
             if (nou)
               all.push(literal);
             else
@@ -11653,31 +13276,31 @@ var require_common = __commonJS({
       }
       if (!nou)
         all = Object.keys(all);
-      if (!self.nosort)
+      if (!self2.nosort)
         all = all.sort(alphasort);
-      if (self.mark) {
+      if (self2.mark) {
         for (var i = 0; i < all.length; i++) {
-          all[i] = self._mark(all[i]);
+          all[i] = self2._mark(all[i]);
         }
-        if (self.nodir) {
+        if (self2.nodir) {
           all = all.filter(function(e) {
             var notDir = !/\/$/.test(e);
-            var c = self.cache[e] || self.cache[makeAbs(self, e)];
+            var c = self2.cache[e] || self2.cache[makeAbs(self2, e)];
             if (notDir && c)
               notDir = c !== "DIR" && !Array.isArray(c);
             return notDir;
           });
         }
       }
-      if (self.ignore.length)
+      if (self2.ignore.length)
         all = all.filter(function(m2) {
-          return !isIgnored(self, m2);
+          return !isIgnored(self2, m2);
         });
-      self.found = all;
+      self2.found = all;
     }
-    function mark(self, p) {
-      var abs = makeAbs(self, p);
-      var c = self.cache[abs];
+    function mark(self2, p) {
+      var abs = makeAbs(self2, p);
+      var c = self2.cache[abs];
       var m = p;
       if (c) {
         var isDir = c === "DIR" || Array.isArray(c);
@@ -11687,21 +13310,21 @@ var require_common = __commonJS({
         else if (!isDir && slash)
           m = m.slice(0, -1);
         if (m !== p) {
-          var mabs = makeAbs(self, m);
-          self.statCache[mabs] = self.statCache[abs];
-          self.cache[mabs] = self.cache[abs];
+          var mabs = makeAbs(self2, m);
+          self2.statCache[mabs] = self2.statCache[abs];
+          self2.cache[mabs] = self2.cache[abs];
         }
       }
       return m;
     }
-    function makeAbs(self, f) {
+    function makeAbs(self2, f) {
       var abs = f;
       if (f.charAt(0) === "/") {
-        abs = path7.join(self.root, f);
+        abs = path7.join(self2.root, f);
       } else if (isAbsolute(f) || f === "") {
         abs = f;
-      } else if (self.changedCwd) {
-        abs = path7.resolve(self.cwd, f);
+      } else if (self2.changedCwd) {
+        abs = path7.resolve(self2.cwd, f);
       } else {
         abs = path7.resolve(f);
       }
@@ -11709,17 +13332,17 @@ var require_common = __commonJS({
         abs = abs.replace(/\\/g, "/");
       return abs;
     }
-    function isIgnored(self, path8) {
-      if (!self.ignore.length)
+    function isIgnored(self2, path8) {
+      if (!self2.ignore.length)
         return false;
-      return self.ignore.some(function(item) {
+      return self2.ignore.some(function(item) {
         return item.matcher.match(path8) || !!(item.gmatcher && item.gmatcher.match(path8));
       });
     }
-    function childrenIgnored(self, path8) {
-      if (!self.ignore.length)
+    function childrenIgnored(self2, path8) {
+      if (!self2.ignore.length)
         return false;
-      return self.ignore.some(function(item) {
+      return self2.ignore.some(function(item) {
         return !!(item.gmatcher && item.gmatcher.match(path8));
       });
     }
@@ -11769,17 +13392,17 @@ var require_sync = __commonJS({
     GlobSync.prototype._finish = function() {
       assert7.ok(this instanceof GlobSync);
       if (this.realpath) {
-        var self = this;
+        var self2 = this;
         this.matches.forEach(function(matchset, index) {
-          var set = self.matches[index] = /* @__PURE__ */ Object.create(null);
+          var set = self2.matches[index] = /* @__PURE__ */ Object.create(null);
           for (var p in matchset) {
             try {
-              p = self._makeAbs(p);
-              var real = rp.realpathSync(p, self.realpathCache);
+              p = self2._makeAbs(p);
+              var real = rp.realpathSync(p, self2.realpathCache);
               set[real] = true;
             } catch (er) {
               if (er.syscall === "stat")
-                set[self._makeAbs(p)] = true;
+                set[self2._makeAbs(p)] = true;
               else
                 throw er;
             }
@@ -12212,7 +13835,7 @@ var require_glob = __commonJS({
           cb(null, matches);
         });
       }
-      var self = this;
+      var self2 = this;
       this._processing = 0;
       this._emitQueue = [];
       this._processQueue = [];
@@ -12227,14 +13850,14 @@ var require_glob = __commonJS({
       }
       sync = false;
       function done() {
-        --self._processing;
-        if (self._processing <= 0) {
+        --self2._processing;
+        if (self2._processing <= 0) {
           if (sync) {
             process.nextTick(function() {
-              self._finish();
+              self2._finish();
             });
           } else {
-            self._finish();
+            self2._finish();
           }
         }
       }
@@ -12255,12 +13878,12 @@ var require_glob = __commonJS({
       var n = this.matches.length;
       if (n === 0)
         return this._finish();
-      var self = this;
+      var self2 = this;
       for (var i = 0; i < this.matches.length; i++)
         this._realpathSet(i, next);
       function next() {
         if (--n === 0)
-          self._finish();
+          self2._finish();
       }
     };
     Glob.prototype._realpathSet = function(index, cb) {
@@ -12268,22 +13891,22 @@ var require_glob = __commonJS({
       if (!matchset)
         return cb();
       var found = Object.keys(matchset);
-      var self = this;
+      var self2 = this;
       var n = found.length;
       if (n === 0)
         return cb();
       var set = this.matches[index] = /* @__PURE__ */ Object.create(null);
       found.forEach(function(p, i) {
-        p = self._makeAbs(p);
-        rp.realpath(p, self.realpathCache, function(er, real) {
+        p = self2._makeAbs(p);
+        rp.realpath(p, self2.realpathCache, function(er, real) {
           if (!er)
             set[real] = true;
           else if (er.syscall === "stat")
             set[p] = true;
           else
-            self.emit("error", er);
+            self2.emit("error", er);
           if (--n === 0) {
-            self.matches[index] = set;
+            self2.matches[index] = set;
             cb();
           }
         });
@@ -12376,9 +13999,9 @@ var require_glob = __commonJS({
         this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
     };
     Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
-      var self = this;
+      var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+        return self2._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
       });
     };
     Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
@@ -12470,20 +14093,20 @@ var require_glob = __commonJS({
       if (this.follow)
         return this._readdir(abs, false, cb);
       var lstatkey = "lstat\0" + abs;
-      var self = this;
+      var self2 = this;
       var lstatcb = inflight(lstatkey, lstatcb_);
       if (lstatcb)
-        self.fs.lstat(abs, lstatcb);
+        self2.fs.lstat(abs, lstatcb);
       function lstatcb_(er, lstat2) {
         if (er && er.code === "ENOENT")
           return cb();
         var isSym = lstat2 && lstat2.isSymbolicLink();
-        self.symlinks[abs] = isSym;
+        self2.symlinks[abs] = isSym;
         if (!isSym && lstat2 && !lstat2.isDirectory()) {
-          self.cache[abs] = "FILE";
+          self2.cache[abs] = "FILE";
           cb();
         } else
-          self._readdir(abs, false, cb);
+          self2._readdir(abs, false, cb);
       }
     };
     Glob.prototype._readdir = function(abs, inGlobStar, cb) {
@@ -12501,15 +14124,15 @@ var require_glob = __commonJS({
         if (Array.isArray(c))
           return cb(null, c);
       }
-      var self = this;
-      self.fs.readdir(abs, readdirCb(this, abs, cb));
+      var self2 = this;
+      self2.fs.readdir(abs, readdirCb(this, abs, cb));
     };
-    function readdirCb(self, abs, cb) {
+    function readdirCb(self2, abs, cb) {
       return function(er, entries) {
         if (er)
-          self._readdirError(abs, er, cb);
+          self2._readdirError(abs, er, cb);
         else
-          self._readdirEntries(abs, entries, cb);
+          self2._readdirEntries(abs, entries, cb);
       };
     }
     Glob.prototype._readdirEntries = function(abs, entries, cb) {
@@ -12563,9 +14186,9 @@ var require_glob = __commonJS({
       return cb();
     };
     Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
-      var self = this;
+      var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+        self2._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
       });
     };
     Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
@@ -12591,9 +14214,9 @@ var require_glob = __commonJS({
       cb();
     };
     Glob.prototype._processSimple = function(prefix, index, cb) {
-      var self = this;
+      var self2 = this;
       this._stat(prefix, function(er, exists) {
-        self._processSimple2(prefix, index, er, exists, cb);
+        self2._processSimple2(prefix, index, er, exists, cb);
       });
     };
     Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
@@ -12643,20 +14266,20 @@ var require_glob = __commonJS({
             return cb(null, type, stat);
         }
       }
-      var self = this;
+      var self2 = this;
       var statcb = inflight("stat\0" + abs, lstatcb_);
       if (statcb)
-        self.fs.lstat(abs, statcb);
+        self2.fs.lstat(abs, statcb);
       function lstatcb_(er, lstat2) {
         if (lstat2 && lstat2.isSymbolicLink()) {
-          return self.fs.stat(abs, function(er2, stat2) {
+          return self2.fs.stat(abs, function(er2, stat2) {
             if (er2)
-              self._stat2(f, abs, null, lstat2, cb);
+              self2._stat2(f, abs, null, lstat2, cb);
             else
-              self._stat2(f, abs, er2, stat2, cb);
+              self2._stat2(f, abs, er2, stat2, cb);
           });
         } else {
-          self._stat2(f, abs, er, lstat2, cb);
+          self2._stat2(f, abs, er, lstat2, cb);
         }
       }
     };
@@ -21400,7 +23023,8 @@ var Prerender = class {
     passQuery,
     sourcePath,
     experimentalBypassFor,
-    experimentalStreamingLambdaPath
+    experimentalStreamingLambdaPath,
+    chain
   }) {
     this.type = "Prerender";
     this.expiration = expiration;
@@ -21492,6 +23116,26 @@ var Prerender = class {
       }
       this.experimentalStreamingLambdaPath = experimentalStreamingLambdaPath;
     }
+    if (chain !== void 0) {
+      if (typeof chain !== "object") {
+        throw new Error(
+          "The `chain` argument for `Prerender` must be an object."
+        );
+      }
+      if (!chain.headers || typeof chain.headers !== "object" || Object.entries(chain.headers).some(
+        ([key, value]) => typeof key !== "string" || typeof value !== "string"
+      )) {
+        throw new Error(
+          `The \`chain.headers\` argument for \`Prerender\` must be an object with string key/values`
+        );
+      }
+      if (!chain.outputPath || typeof chain.outputPath !== "string") {
+        throw new Error(
+          "The `chain.outputPath` argument for `Prerender` must be a string."
+        );
+      }
+      this.chain = chain;
+    }
   }
 };
 
@@ -21648,6 +23292,12 @@ var NODE_VERSIONS = [
   }
 ];
 function getOptions() {
+  if (process.env.VERCEL_ALLOW_NODEJS22 === "1") {
+    return [
+      { major: 22, range: "22.x", runtime: "nodejs22.x" },
+      ...NODE_VERSIONS
+    ];
+  }
   return NODE_VERSIONS;
 }
 function isNodeVersionAvailable(version) {