@apps-in-toss/plugins 0.0.26 → 0.0.27

package/dist/index.js

@@ -108,7 +108,7 @@ var require_fd_slicer = __commonJS({
   "../../.yarn/cache/yauzl-npm-3.2.0-b1af038bc6-7b40b3dc46.zip/node_modules/yauzl/fd-slicer.js"(exports) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -133,7 +133,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs6.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs7.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -142,7 +142,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs6.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs7.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -163,7 +163,7 @@ var require_fd_slicer = __commonJS({
       if (self2.refCount > 0) return;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.autoClose) {
-        fs6.close(self2.fd, onCloseDone);
+        fs7.close(self2.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -200,7 +200,7 @@ var require_fd_slicer = __commonJS({
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
         var buffer = Buffer.allocUnsafe(toRead);
-        fs6.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        fs7.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
           if (err) {
             self2.destroy(err);
           } else if (bytesRead === 0) {
@@ -247,7 +247,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
-        fs6.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        fs7.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
           if (err2) {
             self2.destroy();
             cb();
@@ -689,7 +689,7 @@ var require_yauzl = __commonJS({
   "../../.yarn/cache/yauzl-npm-3.2.0-b1af038bc6-7b40b3dc46.zip/node_modules/yauzl/index.js"(exports) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -710,7 +710,7 @@ var require_yauzl = __commonJS({
     exports.Entry = Entry;
     exports.LocalFileHeader = LocalFileHeader;
     exports.RandomAccessReader = RandomAccessReader;
-    function open(path7, options2, callback) {
+    function open(path8, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -722,10 +722,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs6.open(path7, "r", function(err, fd) {
+      fs7.open(path8, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs6.close(fd, defaultCallback);
+          if (err2) fs7.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -742,7 +742,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs6.fstat(fd, function(err, stats) {
+      fs7.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -1735,8 +1735,8 @@ var require_minimatch = __commonJS({
       return new Minimatch(pattern, options2).match(p);
     };
     module.exports = minimatch;
-    var path7 = require_path();
-    minimatch.sep = path7.sep;
+    var path8 = require_path();
+    minimatch.sep = path8.sep;
     var GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     var expand = require_brace_expansion();
@@ -2245,8 +2245,8 @@ var require_minimatch = __commonJS({
         if (this.empty) return f === "";
         if (f === "/" && partial) return true;
         const options2 = this.options;
-        if (path7.sep !== "/") {
-          f = f.split(path7.sep).join("/");
+        if (path8.sep !== "/") {
+          f = f.split(path8.sep).join("/");
         }
         f = f.split(slashSplit);
         this.debug(this.pattern, "split", f);
@@ -2286,13 +2286,13 @@ var require_readdir_glob = __commonJS({
     "use strict";
     init_esm_shims();
     module.exports = readdirGlob;
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var { EventEmitter } = __require("events");
     var { Minimatch } = require_minimatch();
     var { resolve } = __require("path");
     function readdir(dir2, strict) {
       return new Promise((resolve2, reject2) => {
-        fs6.readdir(dir2, { withFileTypes: true }, (err, files) => {
+        fs7.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -2325,7 +2325,7 @@ var require_readdir_glob = __commonJS({
     }
     function stat(file, followSymlinks) {
       return new Promise((resolve2, reject2) => {
-        const statFunc = followSymlinks ? fs6.stat : fs6.lstat;
+        const statFunc = followSymlinks ? fs7.stat : fs7.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -2346,8 +2346,8 @@ var require_readdir_glob = __commonJS({
         });
       });
     }
-    async function* exploreWalkAsync(dir2, path7, followSymlinks, useStat, shouldSkip, strict) {
-      let files = await readdir(path7 + dir2, strict);
+    async function* exploreWalkAsync(dir2, path8, followSymlinks, useStat, shouldSkip, strict) {
+      let files = await readdir(path8 + dir2, strict);
       for (const file of files) {
         let name = file.name;
         if (name === void 0) {
@@ -2356,7 +2356,7 @@ var require_readdir_glob = __commonJS({
         }
         const filename = dir2 + "/" + name;
         const relative = filename.slice(1);
-        const absolute = path7 + "/" + relative;
+        const absolute = path8 + "/" + relative;
         let stats = null;
         if (useStat || followSymlinks) {
           stats = await stat(absolute, followSymlinks);
@@ -2370,15 +2370,15 @@ var require_readdir_glob = __commonJS({
         if (stats.isDirectory()) {
           if (!shouldSkip(relative)) {
             yield { relative, absolute, stats };
-            yield* exploreWalkAsync(filename, path7, followSymlinks, useStat, shouldSkip, false);
+            yield* exploreWalkAsync(filename, path8, followSymlinks, useStat, shouldSkip, false);
           }
         } else {
           yield { relative, absolute, stats };
         }
       }
     }
-    async function* explore(path7, followSymlinks, useStat, shouldSkip) {
-      yield* exploreWalkAsync("", path7, followSymlinks, useStat, shouldSkip, true);
+    async function* explore(path8, followSymlinks, useStat, shouldSkip) {
+      yield* exploreWalkAsync("", path8, followSymlinks, useStat, shouldSkip, true);
     }
     function readOptions(options2) {
       return {
@@ -4391,54 +4391,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs6) {
+    function patch(fs7) {
       if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs6);
-      }
-      if (!fs6.lutimes) {
-        patchLutimes(fs6);
-      }
-      fs6.chown = chownFix(fs6.chown);
-      fs6.fchown = chownFix(fs6.fchown);
-      fs6.lchown = chownFix(fs6.lchown);
-      fs6.chmod = chmodFix(fs6.chmod);
-      fs6.fchmod = chmodFix(fs6.fchmod);
-      fs6.lchmod = chmodFix(fs6.lchmod);
-      fs6.chownSync = chownFixSync(fs6.chownSync);
-      fs6.fchownSync = chownFixSync(fs6.fchownSync);
-      fs6.lchownSync = chownFixSync(fs6.lchownSync);
-      fs6.chmodSync = chmodFixSync(fs6.chmodSync);
-      fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
-      fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
-      fs6.stat = statFix(fs6.stat);
-      fs6.fstat = statFix(fs6.fstat);
-      fs6.lstat = statFix(fs6.lstat);
-      fs6.statSync = statFixSync(fs6.statSync);
-      fs6.fstatSync = statFixSync(fs6.fstatSync);
-      fs6.lstatSync = statFixSync(fs6.lstatSync);
-      if (fs6.chmod && !fs6.lchmod) {
-        fs6.lchmod = function(path7, mode, cb) {
+        patchLchmod(fs7);
+      }
+      if (!fs7.lutimes) {
+        patchLutimes(fs7);
+      }
+      fs7.chown = chownFix(fs7.chown);
+      fs7.fchown = chownFix(fs7.fchown);
+      fs7.lchown = chownFix(fs7.lchown);
+      fs7.chmod = chmodFix(fs7.chmod);
+      fs7.fchmod = chmodFix(fs7.fchmod);
+      fs7.lchmod = chmodFix(fs7.lchmod);
+      fs7.chownSync = chownFixSync(fs7.chownSync);
+      fs7.fchownSync = chownFixSync(fs7.fchownSync);
+      fs7.lchownSync = chownFixSync(fs7.lchownSync);
+      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
+      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
+      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
+      fs7.stat = statFix(fs7.stat);
+      fs7.fstat = statFix(fs7.fstat);
+      fs7.lstat = statFix(fs7.lstat);
+      fs7.statSync = statFixSync(fs7.statSync);
+      fs7.fstatSync = statFixSync(fs7.fstatSync);
+      fs7.lstatSync = statFixSync(fs7.lstatSync);
+      if (fs7.chmod && !fs7.lchmod) {
+        fs7.lchmod = function(path8, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs7.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path7, uid, gid, cb) {
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path8, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs7.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs6.stat(to, function(stater, st) {
+                  fs7.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -4454,9 +4454,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs6.rename);
+        }(fs7.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
+      fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4464,22 +4464,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs6.read);
-      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs7.read);
+      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4489,11 +4489,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs6.readSync);
-      function patchLchmod(fs7) {
-        fs7.lchmod = function(path7, mode, callback) {
-          fs7.open(
-            path7,
+      }(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path8, mode, callback) {
+          fs8.open(
+            path8,
             constants2.O_WRONLY | constants2.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -4501,80 +4501,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs7.fchmod(fd, mode, function(err2) {
-                fs7.close(fd, function(err22) {
+              fs8.fchmod(fd, mode, function(err2) {
+                fs8.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs7.lchmodSync = function(path7, mode) {
-          var fd = fs7.openSync(path7, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+        fs8.lchmodSync = function(path8, mode) {
+          var fd = fs8.openSync(path8, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs8.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs8.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path7, at, mt, cb) {
-            fs7.open(path7, constants2.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs8) {
+        if (constants2.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+          fs8.lutimes = function(path8, at, mt, cb) {
+            fs8.open(path8, constants2.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs7.futimes(fd, at, mt, function(er2) {
-                fs7.close(fd, function(er22) {
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path7, at, mt) {
-            var fd = fs7.openSync(path7, constants2.O_SYMLINK);
+          fs8.lutimesSync = function(path8, at, mt) {
+            var fd = fs8.openSync(path8, constants2.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs8.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs8.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs8.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs6, target, mode, function(er) {
+          return orig.call(fs7, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4584,7 +4584,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs6, target, mode);
+            return orig.call(fs7, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4593,7 +4593,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs6, target, uid, gid, function(er) {
+          return orig.call(fs7, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4603,7 +4603,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs6, target, uid, gid);
+            return orig.call(fs7, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4623,13 +4623,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options2 ? orig.call(fs6, target, options2, callback) : orig.call(fs6, target, callback);
+          return options2 ? orig.call(fs7, target, options2, callback) : orig.call(fs7, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options2) {
-          var stats = options2 ? orig.call(fs6, target, options2) : orig.call(fs6, target);
+          var stats = options2 ? orig.call(fs7, target, options2) : orig.call(fs7, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -4660,16 +4660,16 @@ var require_legacy_streams = __commonJS({
     init_esm_shims();
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs6) {
+    function legacy(fs7) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path7, options2) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path7, options2);
+      function ReadStream(path8, options2) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path8, options2);
         Stream.call(this);
         var self2 = this;
-        this.path = path7;
+        this.path = path8;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -4703,7 +4703,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -4714,10 +4714,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path7, options2) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path7, options2);
+      function WriteStream(path8, options2) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path8, options2);
         Stream.call(this);
-        this.path = path7;
+        this.path = path8;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -4742,7 +4742,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs6.open;
+          this._open = fs7.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -4780,7 +4780,7 @@ var require_graceful_fs = __commonJS({
   "../../.yarn/cache/graceful-fs-npm-4.2.11-b94d8104d4-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -4812,12 +4812,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs6[gracefulQueue]) {
+    if (!fs7[gracefulQueue]) {
       queue2 = global[gracefulQueue] || [];
-      publishQueue(fs6, queue2);
-      fs6.close = function(fs$close) {
+      publishQueue(fs7, queue2);
+      fs7.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+          return fs$close.call(fs7, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -4829,48 +4829,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs6.close);
-      fs6.closeSync = function(fs$closeSync) {
+      }(fs7.close);
+      fs7.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs7, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs6.closeSync);
+      }(fs7.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs6[gracefulQueue]);
-          __require("assert").equal(fs6[gracefulQueue].length, 0);
+          debug(fs7[gracefulQueue]);
+          __require("assert").equal(fs7[gracefulQueue].length, 0);
         });
       }
     }
     var queue2;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs6[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs6));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
-      module.exports = patch(fs6);
-      fs6.__patched = true;
-    }
-    function patch(fs7) {
-      polyfills(fs7);
-      fs7.gracefulify = patch;
-      fs7.createReadStream = createReadStream2;
-      fs7.createWriteStream = createWriteStream2;
-      var fs$readFile = fs7.readFile;
-      fs7.readFile = readFile2;
-      function readFile2(path7, options2, cb) {
+      publishQueue(global, fs7[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs7));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
+      module.exports = patch(fs7);
+      fs7.__patched = true;
+    }
+    function patch(fs8) {
+      polyfills(fs8);
+      fs8.gracefulify = patch;
+      fs8.createReadStream = createReadStream2;
+      fs8.createWriteStream = createWriteStream2;
+      var fs$readFile = fs8.readFile;
+      fs8.readFile = readFile3;
+      function readFile3(path8, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
-        return go$readFile(path7, options2, cb);
-        function go$readFile(path8, options3, cb2, startTime) {
-          return fs$readFile(path8, options3, function(err) {
+        return go$readFile(path8, options2, cb);
+        function go$readFile(path9, options3, cb2, startTime) {
+          return fs$readFile(path9, options3, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path8, options3, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path9, options3, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4878,16 +4878,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs7.writeFile;
-      fs7.writeFile = writeFile2;
-      function writeFile2(path7, data, options2, cb) {
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile2;
+      function writeFile2(path8, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
-        return go$writeFile(path7, data, options2, cb);
-        function go$writeFile(path8, data2, options3, cb2, startTime) {
-          return fs$writeFile(path8, data2, options3, function(err) {
+        return go$writeFile(path8, data, options2, cb);
+        function go$writeFile(path9, data2, options3, cb2, startTime) {
+          return fs$writeFile(path9, data2, options3, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path8, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path9, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4895,17 +4895,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs7.appendFile;
+      var fs$appendFile = fs8.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
-      function appendFile(path7, data, options2, cb) {
+        fs8.appendFile = appendFile;
+      function appendFile(path8, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
-        return go$appendFile(path7, data, options2, cb);
-        function go$appendFile(path8, data2, options3, cb2, startTime) {
-          return fs$appendFile(path8, data2, options3, function(err) {
+        return go$appendFile(path8, data, options2, cb);
+        function go$appendFile(path9, data2, options3, cb2, startTime) {
+          return fs$appendFile(path9, data2, options3, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path8, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path9, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4913,9 +4913,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs7.copyFile;
+      var fs$copyFile = fs8.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs8.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -4933,34 +4933,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs7.readdir;
-      fs7.readdir = readdir;
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path7, options2, cb) {
+      function readdir(path8, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path8, options3, cb2, startTime) {
-          return fs$readdir(path8, fs$readdirCallback(
-            path8,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options3, cb2, startTime) {
+          return fs$readdir(path9, fs$readdirCallback(
+            path9,
             options3,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path8, options3, cb2, startTime) {
-          return fs$readdir(path8, options3, fs$readdirCallback(
-            path8,
+        } : function go$readdir2(path9, options3, cb2, startTime) {
+          return fs$readdir(path9, options3, fs$readdirCallback(
+            path9,
             options3,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path7, options2, cb);
-        function fs$readdirCallback(path8, options3, cb2, startTime) {
+        return go$readdir(path8, options2, cb);
+        function fs$readdirCallback(path9, options3, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path8, options3, cb2],
+                [path9, options3, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -4975,21 +4975,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs7);
+        var legStreams = legacy(fs8);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs8.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs8.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs8, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -4999,7 +4999,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs8, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -5010,7 +5010,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs7, "FileReadStream", {
+      Object.defineProperty(fs8, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -5021,7 +5021,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs7, "FileWriteStream", {
+      Object.defineProperty(fs8, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5031,7 +5031,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path7, options2) {
+      function ReadStream(path8, options2) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -5051,7 +5051,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path7, options2) {
+      function WriteStream(path8, options2) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -5069,22 +5069,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream2(path7, options2) {
-        return new fs7.ReadStream(path7, options2);
+      function createReadStream2(path8, options2) {
+        return new fs8.ReadStream(path8, options2);
       }
-      function createWriteStream2(path7, options2) {
-        return new fs7.WriteStream(path7, options2);
+      function createWriteStream2(path8, options2) {
+        return new fs8.WriteStream(path8, options2);
       }
-      var fs$open = fs7.open;
-      fs7.open = open;
-      function open(path7, flags, mode, cb) {
+      var fs$open = fs8.open;
+      fs8.open = open;
+      function open(path8, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path7, flags, mode, cb);
-        function go$open(path8, flags2, mode2, cb2, startTime) {
-          return fs$open(path8, flags2, mode2, function(err, fd) {
+        return go$open(path8, flags, mode, cb);
+        function go$open(path9, flags2, mode2, cb2, startTime) {
+          return fs$open(path9, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path8, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5092,20 +5092,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs7;
+      return fs8;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs7[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs6[gracefulQueue].length; ++i) {
-        if (fs6[gracefulQueue][i].length > 2) {
-          fs6[gracefulQueue][i][3] = now;
-          fs6[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs7[gracefulQueue].length; ++i) {
+        if (fs7[gracefulQueue][i].length > 2) {
+          fs7[gracefulQueue][i][3] = now;
+          fs7[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -5113,9 +5113,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs6[gracefulQueue].length === 0)
+      if (fs7[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs7[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -5137,7 +5137,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs6[gracefulQueue].push(elem);
+          fs7[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5456,7 +5456,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join2(s) {
+      BufferList.prototype.join = function join3(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -7221,22 +7221,22 @@ var require_normalize_path = __commonJS({
   "../../.yarn/cache/normalize-path-npm-3.0.0-a747cc5237-e008c8142b.zip/node_modules/normalize-path/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    module.exports = function(path7, stripTrailing) {
-      if (typeof path7 !== "string") {
+    module.exports = function(path8, stripTrailing) {
+      if (typeof path8 !== "string") {
         throw new TypeError("expected path to be a string");
       }
-      if (path7 === "\\" || path7 === "/") return "/";
-      var len = path7.length;
-      if (len <= 1) return path7;
+      if (path8 === "\\" || path8 === "/") return "/";
+      var len = path8.length;
+      if (len <= 1) return path8;
       var prefix = "";
-      if (len > 4 && path7[3] === "\\") {
-        var ch = path7[2];
-        if ((ch === "?" || ch === ".") && path7.slice(0, 2) === "\\\\") {
-          path7 = path7.slice(2);
+      if (len > 4 && path8[3] === "\\") {
+        var ch = path8[2];
+        if ((ch === "?" || ch === ".") && path8.slice(0, 2) === "\\\\") {
+          path8 = path8.slice(2);
           prefix = "//";
         }
       }
-      var segs = path7.split(/[/\\]+/);
+      var segs = path8.split(/[/\\]+/);
       if (stripTrailing !== false && segs[segs.length - 1] === "") {
         segs.pop();
       }
@@ -15851,11 +15851,11 @@ var require_commonjs = __commonJS({
       return (f) => f.length === len && f !== "." && f !== "..";
     };
     var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    var path7 = {
+    var path8 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    exports.sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
+    exports.sep = defaultPlatform === "win32" ? path8.win32.sep : path8.posix.sep;
     exports.minimatch.sep = exports.sep;
     exports.GLOBSTAR = Symbol("globstar **");
     exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
@@ -19106,12 +19106,12 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path7) {
-        if (!path7) {
+      resolve(path8) {
+        if (!path8) {
           return this;
         }
-        const rootPath = this.getRootString(path7);
-        const dir2 = path7.substring(rootPath.length);
+        const rootPath = this.getRootString(path8);
+        const dir2 = path8.substring(rootPath.length);
         const dirParts = dir2.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -19864,8 +19864,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path7) {
-        return node_path_1.win32.parse(path7).root;
+      getRootString(path8) {
+        return node_path_1.win32.parse(path8).root;
       }
       /**
        * @internal
@@ -19912,8 +19912,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path7) {
-        return path7.startsWith("/") ? "/" : "";
+      getRootString(path8) {
+        return path8.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -19963,8 +19963,8 @@ var require_commonjs4 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs6);
+      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs7);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -20003,11 +20003,11 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path7 = this.cwd) {
-        if (typeof path7 === "string") {
-          path7 = this.cwd.resolve(path7);
+      depth(path8 = this.cwd) {
+        if (typeof path8 === "string") {
+          path8 = this.cwd.resolve(path8);
         }
-        return path7.depth();
+        return path8.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -20494,9 +20494,9 @@ var require_commonjs4 = __commonJS({
         process2();
         return results;
       }
-      chdir(path7 = this.cwd) {
+      chdir(path8 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path7 === "string" ? this.cwd.resolve(path7) : path7;
+        this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -20523,8 +20523,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -20553,8 +20553,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -20887,8 +20887,8 @@ var require_processor = __commonJS({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path7, n]) => [
-          path7,
+        return [...this.store.entries()].map(([path8, n]) => [
+          path8,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -21107,9 +21107,9 @@ var require_walker = __commonJS({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path7, opts) {
+      constructor(patterns, path8, opts) {
         this.patterns = patterns;
-        this.path = path7;
+        this.path = path8;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -21128,11 +21128,11 @@ var require_walker = __commonJS({
           });
         }
       }
-      #ignored(path7) {
-        return this.seen.has(path7) || !!this.#ignore?.ignored?.(path7);
+      #ignored(path8) {
+        return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
       }
-      #childrenIgnored(path7) {
-        return !!this.#ignore?.childrenIgnored?.(path7);
+      #childrenIgnored(path8) {
+        return !!this.#ignore?.childrenIgnored?.(path8);
       }
       // backpressure mechanism
       pause() {
@@ -21348,8 +21348,8 @@ var require_walker = __commonJS({
     exports.GlobUtil = GlobUtil;
     var GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path7, opts) {
-        super(patterns, path7, opts);
+      constructor(patterns, path8, opts) {
+        super(patterns, path8, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -21387,8 +21387,8 @@ var require_walker = __commonJS({
     exports.GlobWalker = GlobWalker;
     var GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path7, opts) {
-        super(patterns, path7, opts);
+      constructor(patterns, path8, opts) {
+        super(patterns, path8, opts);
         this.results = new minipass_1.Minipass({
           signal: this.signal,
           objectMode: true
@@ -21748,8 +21748,8 @@ var require_file = __commonJS({
   "../../.yarn/cache/archiver-utils-npm-5.0.2-c2e6f595a7-3782c5fa99.zip/node_modules/archiver-utils/file.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs6 = require_graceful_fs();
-    var path7 = __require("path");
+    var fs7 = require_graceful_fs();
+    var path8 = __require("path");
     var flatten = require_flatten();
     var difference = require_difference();
     var union = require_union();
@@ -21774,8 +21774,8 @@ var require_file = __commonJS({
       return result;
     };
     file.exists = function() {
-      var filepath = path7.join.apply(path7, arguments);
-      return fs6.existsSync(filepath);
+      var filepath = path8.join.apply(path8, arguments);
+      return fs7.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options2 = isPlainObject(args[0]) ? args.shift() : {};
@@ -21788,12 +21788,12 @@ var require_file = __commonJS({
       });
       if (options2.filter) {
         matches = matches.filter(function(filepath) {
-          filepath = path7.join(options2.cwd || "", filepath);
+          filepath = path8.join(options2.cwd || "", filepath);
           try {
             if (typeof options2.filter === "function") {
               return options2.filter(filepath);
             } else {
-              return fs6.statSync(filepath)[options2.filter]();
+              return fs7.statSync(filepath)[options2.filter]();
             }
           } catch (e) {
             return false;
@@ -21805,7 +21805,7 @@ var require_file = __commonJS({
     file.expandMapping = function(patterns, destBase, options2) {
       options2 = Object.assign({
         rename: function(destBase2, destPath) {
-          return path7.join(destBase2 || "", destPath);
+          return path8.join(destBase2 || "", destPath);
         }
       }, options2);
       var files = [];
@@ -21813,14 +21813,14 @@ var require_file = __commonJS({
       file.expand(options2, patterns).forEach(function(src) {
         var destPath = src;
         if (options2.flatten) {
-          destPath = path7.basename(destPath);
+          destPath = path8.basename(destPath);
         }
         if (options2.ext) {
           destPath = destPath.replace(/(\.[^\/]*)?$/, options2.ext);
         }
         var dest = options2.rename(destBase, destPath, options2);
         if (options2.cwd) {
-          src = path7.join(options2.cwd, src);
+          src = path8.join(options2.cwd, src);
         }
         dest = dest.replace(pathSeparatorRe, "/");
         src = src.replace(pathSeparatorRe, "/");
@@ -21903,11 +21903,11 @@ var require_archiver_utils = __commonJS({
   "../../.yarn/cache/archiver-utils-npm-5.0.2-c2e6f595a7-3782c5fa99.zip/node_modules/archiver-utils/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs6 = require_graceful_fs();
-    var path7 = __require("path");
+    var fs7 = require_graceful_fs();
+    var path8 = __require("path");
     var isStream = require_is_stream();
     var lazystream = require_lazystream();
-    var normalizePath = require_normalize_path();
+    var normalizePath2 = require_normalize_path();
     var defaults = require_defaults();
     var Stream = __require("stream").Stream;
     var PassThrough = require_ours().PassThrough;
@@ -21952,7 +21952,7 @@ var require_archiver_utils = __commonJS({
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs6.createReadStream(filepath);
+        return fs7.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -21966,13 +21966,13 @@ var require_archiver_utils = __commonJS({
       return source;
     };
     utils.sanitizePath = function(filepath) {
-      return normalizePath(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+      return normalizePath2(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
     };
     utils.trailingSlashIt = function(str) {
       return str.slice(-1) !== "/" ? str + "/" : str;
     };
     utils.unixifyPath = function(filepath) {
-      return normalizePath(filepath, false).replace(/^\w+:/, "");
+      return normalizePath2(filepath, false).replace(/^\w+:/, "");
     };
     utils.walkdir = function(dirpath, base, callback) {
       var results = [];
@@ -21980,7 +21980,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs6.readdir(dirpath, function(err, list) {
+      fs7.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -21992,11 +21992,11 @@ var require_archiver_utils = __commonJS({
           if (!file) {
             return callback(null, results);
           }
-          filepath = path7.join(dirpath, file);
-          fs6.stat(filepath, function(err2, stats) {
+          filepath = path8.join(dirpath, file);
+          fs7.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
-              relative: path7.relative(base, filepath).replace(/\\/g, "/"),
+              relative: path8.relative(base, filepath).replace(/\\/g, "/"),
               stats
             });
             if (stats && stats.isDirectory()) {
@@ -22059,10 +22059,10 @@ var require_core = __commonJS({
   "../../.yarn/cache/archiver-npm-7.0.1-dc24339f78-02afd87ca1.zip/node_modules/archiver/lib/core.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var glob = require_readdir_glob();
     var async = (init_async(), __toCommonJS(async_exports));
-    var path7 = __require("path");
+    var path8 = __require("path");
     var util = require_archiver_utils();
     var inherits = __require("util").inherits;
     var ArchiverError = require_error();
@@ -22123,7 +22123,7 @@ var require_core = __commonJS({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs6.Stats) {
+      if (data.stats && data.stats instanceof fs7.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -22294,7 +22294,7 @@ var require_core = __commonJS({
         callback();
         return;
       }
-      fs6.lstat(task.filepath, function(err, stats) {
+      fs7.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -22337,10 +22337,10 @@ var require_core = __commonJS({
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs6.readlinkSync(task.filepath);
-        var dirName = path7.dirname(task.filepath);
+        var linkPath = fs7.readlinkSync(task.filepath);
+        var dirName = path8.dirname(task.filepath);
         task.data.type = "symlink";
-        task.data.linkname = path7.relative(dirName, path7.resolve(dirName, linkPath));
+        task.data.linkname = path8.relative(dirName, path8.resolve(dirName, linkPath));
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else {
@@ -22885,7 +22885,7 @@ var require_zip_archive_entry = __commonJS({
     "use strict";
     init_esm_shims();
     var inherits = __require("util").inherits;
-    var normalizePath = require_normalize_path();
+    var normalizePath2 = require_normalize_path();
     var ArchiveEntry = require_archive_entry();
     var GeneralPurposeBit = require_general_purpose_bit();
     var UnixStat = require_unix_stat();
@@ -23009,7 +23009,7 @@ var require_zip_archive_entry = __commonJS({
       this.method = method;
     };
     ZipArchiveEntry.prototype.setName = function(name, prependSlash = false) {
-      name = normalizePath(name, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+      name = normalizePath2(name, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
       if (prependSlash) {
         name = `/${name}`;
       }
@@ -26528,11 +26528,11 @@ var require_validateReport = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports._validateReport = void 0;
     var _validateReport2 = (array) => {
-      const reportable = (path7) => {
+      const reportable = (path8) => {
         if (array.length === 0)
           return true;
         const last = array[array.length - 1].path;
-        return path7.length > last.length || last.substring(0, path7.length) !== path7;
+        return path8.length > last.length || last.substring(0, path8.length) !== path8;
       };
       return (exceptable, error) => {
         if (exceptable && reportable(error.path))
@@ -26549,14 +26549,15 @@ init_esm_shims();
 
 // src/appsInToss.ts
 init_esm_shims();
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 
-// ../../.yarn/cache/@react-native-bedrock-utils-npm-0.0.24-86d1e7a92c-ff04765188.zip/node_modules/@react-native-bedrock/utils/dist/index.js
+// ../../packages/utils/dist/index.js
 init_esm_shims();
 var import_yauzl = __toESM(require_yauzl(), 1);
 import fs from "fs";
 import path from "path";
+import os from "os";
 function getPackageRoot() {
   let cwd = process.cwd();
   const root = path.parse(cwd).root;
@@ -26601,6 +26602,13 @@ function readZipContent(zipPath, fileName) {
     });
   });
 }
+var win32Impl = {
+  normalizePath: (path22) => path22.replace(/\\/g, "/")
+};
+var posixImpl = {
+  normalizePath: (path22) => path22
+};
+var { normalizePath } = os.type() === "Windows_NT" ? win32Impl : posixImpl;
 
 // src/appsInToss.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -26610,26 +26618,102 @@ init_esm_shims();
 var REACT_NATIVE_VERSION = "0.72.6";
 var APP_MANIFEST_NAME = "app.json";
 
+// src/utils/collectDependencyVersions.ts
+init_esm_shims();
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import * as esbuild from "esbuild";
+async function collectDependencyVersions(rootDir) {
+  const packageJsonPath = path2.join(rootDir, "package.json");
+  const packageJson = JSON.parse(await fs2.readFile(packageJsonPath, "utf8"));
+  const [dependencies, devDependencies] = await Promise.all([
+    resolvePackageVersions(rootDir, Object.keys(packageJson.dependencies)),
+    resolvePackageVersions(rootDir, Object.keys(packageJson.devDependencies))
+  ]);
+  return { dependencies, devDependencies };
+}
+async function resolvePackageVersions(rootDir, packageNames) {
+  const results = {};
+  await esbuild.build({
+    stdin: { contents: createVirtualEntry(packageNames) },
+    bundle: true,
+    write: false,
+    logLevel: "silent",
+    plugins: [
+      {
+        name: "collect-package-version",
+        setup(build2) {
+          const RESOLVING = Symbol();
+          build2.onResolve({ filter: /.*/ }, async (args) => {
+            if (args.pluginData === RESOLVING) {
+              return null;
+            }
+            const resolveOptions = {
+              importer: args.importer,
+              kind: args.kind,
+              resolveDir: rootDir,
+              pluginData: RESOLVING
+            };
+            let result = await build2.resolve(path2.join(args.path, "package.json"), resolveOptions);
+            if (result.errors.length) {
+              result = await build2.resolve(args.path, resolveOptions);
+            }
+            if (result.errors.length) {
+              return result;
+            }
+            const packageName = args.path;
+            const packagePath = extractPackagePath(result.path, packageName);
+            if (packagePath) {
+              results[packageName] = await getPackageVersion(packagePath);
+            }
+            return result;
+          });
+          build2.onLoad({ filter: /.*/ }, () => ({ contents: "// empty source" }));
+        }
+      }
+    ]
+  });
+  return results;
+}
+function createVirtualEntry(packageNames) {
+  return packageNames.map((packageName) => `import '${packageName}';`).join("\n");
+}
+function extractPackagePath(path8, packageName) {
+  const normalizedPath = normalizePath(path8);
+  if (normalizedPath.endsWith("/package.json")) {
+    return normalizedPath.replace(/\/package\.json$/, "");
+  }
+  const match = normalizedPath.match(new RegExp(`(.*?node_modules/${packageName})/.*$`));
+  if (match) {
+    return match[1];
+  }
+  throw new Error(`Failed to extract path: ${packageName}`);
+}
+async function getPackageVersion(packagePath) {
+  const packageJson = JSON.parse(await fs2.readFile(path2.join(packagePath, "package.json"), "utf-8"));
+  return packageJson.version;
+}
+
 // src/utils/createArtifact.ts
 init_esm_shims();
-import path4 from "path";
+import path5 from "path";
 
 // src/utils/compressToZip.ts
 init_esm_shims();
 var import_archiver = __toESM(require_archiver(), 1);
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 async function compressToZip(config) {
   const { files, outfile } = config;
   return new Promise((resolve, reject2) => {
-    const outputStream = fs2.createWriteStream(outfile);
+    const outputStream = fs3.createWriteStream(outfile);
     const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
     outputStream.on("close", () => resolve(outfile));
     outputStream.on("error", (error) => reject2(error));
     archive.on("error", (error) => reject2(error)).pipe(outputStream);
     files.forEach(({ path: filePath, name }) => {
-      const fileName = name ?? path2.basename(filePath);
-      archive.append(fs2.createReadStream(filePath), { name: fileName });
+      const fileName = name ?? path3.basename(filePath);
+      archive.append(fs3.createReadStream(filePath), { name: fileName });
     });
     archive.finalize();
   });
@@ -26637,20 +26721,20 @@ async function compressToZip(config) {
 
 // src/utils/updateAppJsonMetadata.ts
 init_esm_shims();
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
 async function resolveAppManifestPath() {
   const cwd = getPackageRoot();
-  const appManifestPath = path3.join(cwd, ".bedrock", APP_MANIFEST_NAME);
-  await fs3.access(appManifestPath, fs3.constants.F_OK);
+  const appManifestPath = path4.join(cwd, ".bedrock", APP_MANIFEST_NAME);
+  await fs4.access(appManifestPath, fs4.constants.F_OK);
   return appManifestPath;
 }
 async function readAppJson(appJsonPath) {
-  const appJson = await fs3.readFile(appJsonPath, "utf8");
+  const appJson = await fs4.readFile(appJsonPath, "utf8");
   return JSON.parse(appJson);
 }
 async function writeAppJson(appJsonPath, content) {
-  await fs3.writeFile(appJsonPath, JSON.stringify(content));
+  await fs4.writeFile(appJsonPath, JSON.stringify(content));
 }
 async function updateAppJsonMetadata(metadata) {
   const appJsonPath = await resolveAppManifestPath();
@@ -26845,8 +26929,8 @@ async function validateZip(zipPath) {
 async function createArtifact(options2) {
   const { bundleFiles, outfile, appJsonPath, reactNativeVersion } = options2;
   const namedBundleFiles = bundleFiles.map((bundle) => {
-    const originalName = path4.basename(bundle.path);
-    const extension = path4.extname(originalName);
+    const originalName = path5.basename(bundle.path);
+    const extension = path5.extname(originalName);
     const runtime = reactNativeVersion.replace(new RegExp(/\./g), "_");
     return {
       path: bundle.path,
@@ -26857,7 +26941,8 @@ async function createArtifact(options2) {
   await updateAppJsonMetadata({
     runtimeVersion: reactNativeVersion,
     bundleFiles: namedBundleFiles.map(({ name }) => name),
-    deploymentId: options2.deploymentId
+    deploymentId: options2.deploymentId,
+    packageJson: options2.packageJson
   });
   await compressToZip({
     files: [{ path: appJsonPath, name: "app.json" }, ...namedBundleFiles, ...options2.additionalFilesToZip ?? []],
@@ -27248,17 +27333,17 @@ function generateDeploymentId() {
 
 // src/utils/setupRuntimeSetupScript.ts
 init_esm_shims();
-import fs4 from "node:fs";
-import path5 from "node:path";
+import fs5 from "node:fs";
+import path6 from "node:path";
 function setupRuntimeSetupScript(config) {
   const packageRoot = getPackageRoot();
-  const bedrockPath = path5.join(packageRoot, ".bedrock");
+  const bedrockPath = path6.join(packageRoot, ".bedrock");
   try {
-    fs4.accessSync(bedrockPath);
+    fs5.accessSync(bedrockPath);
   } catch {
-    fs4.mkdirSync(bedrockPath, { recursive: true });
+    fs5.mkdirSync(bedrockPath, { recursive: true });
   }
-  const envFilePath = path5.join(bedrockPath, ".apps-in-toss.env.js");
+  const envFilePath = path6.join(bedrockPath, ".apps-in-toss.env.js");
   const script = `
   (function (global) {
     global.__appsInToss = ${JSON.stringify({
@@ -27278,7 +27363,7 @@ function setupRuntimeSetupScript(config) {
       : this
   );
   `;
-  fs4.writeFileSync(envFilePath, script, "utf-8");
+  fs5.writeFileSync(envFilePath, script, "utf-8");
   return { contents: script, path: envFilePath };
 }
 
@@ -27290,9 +27375,11 @@ function appsInTossCreateArtifact(deploymentId) {
     build: {
       order: "post",
       handler: async ({ buildResults, appName, cwd }) => {
+        const { dependencies, devDependencies } = await collectDependencyVersions(cwd);
         const artifactOutfile = await createArtifact({
           reactNativeVersion: REACT_NATIVE_VERSION,
           deploymentId,
+          packageJson: { dependencies, devDependencies },
           bundleFiles: buildResults.map(({ outfile, sourcemapOutfile, platform }) => [
             {
               path: outfile,
@@ -27303,13 +27390,13 @@ function appsInTossCreateArtifact(deploymentId) {
               platform
             }
           ]).flat(),
-          outfile: path6.join(cwd, `${appName}.ait`),
-          appJsonPath: path6.join(packageRoot, ".bedrock", APP_MANIFEST_NAME)
+          outfile: path7.join(cwd, `${appName}.ait`),
+          appJsonPath: path7.join(packageRoot, ".bedrock", APP_MANIFEST_NAME)
         });
         if (!artifactOutfile) {
           throw new Error("\uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uC5D0 \uC2E4\uD328\uD588\uC5B4\uC694.");
         }
-        const filename = path6.basename(artifactOutfile);
+        const filename = path7.basename(artifactOutfile);
         console.log(`\u2705 ${import_picocolors.default.green(`${filename}`)} \uBE4C\uB4DC \uC644\uB8CC`);
       }
     }
@@ -27354,14 +27441,14 @@ function appsInTossDevServer(options2) {
 async function appsInTossAppJson(options2) {
   const packageRoot = getPackageRoot();
   const handleAppJson = async (appName) => {
-    const appJsonPath = path6.join(packageRoot, ".bedrock", APP_MANIFEST_NAME);
+    const appJsonPath = path7.join(packageRoot, ".bedrock", APP_MANIFEST_NAME);
     const appJsonObject = {
       appName,
       permissions: options2.permissions
     };
-    await fs5.promises.mkdir(path6.dirname(appJsonPath), { recursive: true });
+    await fs6.promises.mkdir(path7.dirname(appJsonPath), { recursive: true });
     try {
-      const existingAppJson = await fs5.promises.readFile(appJsonPath, "utf8");
+      const existingAppJson = await fs6.promises.readFile(appJsonPath, "utf8");
       const existingAppJsonObject = JSON.parse(existingAppJson);
       Object.assign(appJsonObject, existingAppJsonObject, {
         appName,
@@ -27369,7 +27456,7 @@ async function appsInTossAppJson(options2) {
       });
     } catch {
     }
-    await fs5.promises.writeFile(appJsonPath, JSON.stringify(appJsonObject, null, 2), "utf8");
+    await fs6.promises.writeFile(appJsonPath, JSON.stringify(appJsonObject, null, 2), "utf8");
   };
   return {
     name: "apps-in-toss:app-json",
@@ -27464,6 +27551,7 @@ export {
   appsInTossAppJson,
   appsInTossEsbuildConfig,
   appsInTossMetroConfig,
+  collectDependencyVersions,
   createArtifact,
   setupRuntimeSetupScript,
   validateAppManifest,