@apps-in-toss/framework 0.0.0-dev.1741252452371 → 0.0.0-dev.1741346821380

package/dist/plugins/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -40,9 +39,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../.yarn/__virtual__/tsup-virtual-7254073ea3/0/cache/tsup-npm-8.3.5-ed25596739-7794953cbc.zip/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
   "../../.yarn/__virtual__/tsup-virtual-7254073ea3/0/cache/tsup-npm-8.3.5-ed25596739-7794953cbc.zip/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
   }
 });
 
@@ -354,8 +359,8 @@ var require_minimatch = __commonJS({
       return new Minimatch(pattern, options).match(p);
     };
     module.exports = minimatch;
-    var path14 = require_path();
-    minimatch.sep = path14.sep;
+    var path17 = require_path();
+    minimatch.sep = path17.sep;
     var GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     var expand = require_brace_expansion();
@@ -864,8 +869,8 @@ var require_minimatch = __commonJS({
         if (this.empty) return f === "";
         if (f === "/" && partial) return true;
         const options = this.options;
-        if (path14.sep !== "/") {
-          f = f.split(path14.sep).join("/");
+        if (path17.sep !== "/") {
+          f = f.split(path17.sep).join("/");
         }
         f = f.split(slashSplit);
         this.debug(this.pattern, "split", f);
@@ -905,13 +910,13 @@ var require_readdir_glob = __commonJS({
     "use strict";
     init_esm_shims();
     module.exports = readdirGlob;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var { EventEmitter: EventEmitter2 } = __require("events");
     var { Minimatch } = require_minimatch();
     var { resolve } = __require("path");
     function readdir(dir2, strict) {
       return new Promise((resolve2, reject2) => {
-        fs9.readdir(dir2, { withFileTypes: true }, (err, files) => {
+        fs10.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -944,7 +949,7 @@ var require_readdir_glob = __commonJS({
     }
     function stat(file, followSymlinks) {
       return new Promise((resolve2, reject2) => {
-        const statFunc = followSymlinks ? fs9.stat : fs9.lstat;
+        const statFunc = followSymlinks ? fs10.stat : fs10.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -965,8 +970,8 @@ var require_readdir_glob = __commonJS({
         });
       });
     }
-    async function* exploreWalkAsync(dir2, path14, followSymlinks, useStat, shouldSkip, strict) {
-      let files = await readdir(path14 + dir2, strict);
+    async function* exploreWalkAsync(dir2, path17, followSymlinks, useStat, shouldSkip, strict) {
+      let files = await readdir(path17 + dir2, strict);
       for (const file of files) {
         let name = file.name;
         if (name === void 0) {
@@ -975,7 +980,7 @@ var require_readdir_glob = __commonJS({
         }
         const filename = dir2 + "/" + name;
         const relative = filename.slice(1);
-        const absolute = path14 + "/" + relative;
+        const absolute = path17 + "/" + relative;
         let stats = null;
         if (useStat || followSymlinks) {
           stats = await stat(absolute, followSymlinks);
@@ -989,15 +994,15 @@ var require_readdir_glob = __commonJS({
         if (stats.isDirectory()) {
           if (!shouldSkip(relative)) {
             yield { relative, absolute, stats };
-            yield* exploreWalkAsync(filename, path14, followSymlinks, useStat, shouldSkip, false);
+            yield* exploreWalkAsync(filename, path17, followSymlinks, useStat, shouldSkip, false);
           }
         } else {
           yield { relative, absolute, stats };
         }
       }
     }
-    async function* explore(path14, followSymlinks, useStat, shouldSkip) {
-      yield* exploreWalkAsync("", path14, followSymlinks, useStat, shouldSkip, true);
+    async function* explore(path17, followSymlinks, useStat, shouldSkip) {
+      yield* exploreWalkAsync("", path17, followSymlinks, useStat, shouldSkip, true);
     }
     function readOptions(options) {
       return {
@@ -3010,54 +3015,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs9) {
+    function patch(fs10) {
       if (constants5.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs9);
-      }
-      if (!fs9.lutimes) {
-        patchLutimes(fs9);
-      }
-      fs9.chown = chownFix(fs9.chown);
-      fs9.fchown = chownFix(fs9.fchown);
-      fs9.lchown = chownFix(fs9.lchown);
-      fs9.chmod = chmodFix(fs9.chmod);
-      fs9.fchmod = chmodFix(fs9.fchmod);
-      fs9.lchmod = chmodFix(fs9.lchmod);
-      fs9.chownSync = chownFixSync(fs9.chownSync);
-      fs9.fchownSync = chownFixSync(fs9.fchownSync);
-      fs9.lchownSync = chownFixSync(fs9.lchownSync);
-      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
-      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
-      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
-      fs9.stat = statFix(fs9.stat);
-      fs9.fstat = statFix(fs9.fstat);
-      fs9.lstat = statFix(fs9.lstat);
-      fs9.statSync = statFixSync(fs9.statSync);
-      fs9.fstatSync = statFixSync(fs9.fstatSync);
-      fs9.lstatSync = statFixSync(fs9.lstatSync);
-      if (fs9.chmod && !fs9.lchmod) {
-        fs9.lchmod = function(path14, mode, cb) {
+        patchLchmod(fs10);
+      }
+      if (!fs10.lutimes) {
+        patchLutimes(fs10);
+      }
+      fs10.chown = chownFix(fs10.chown);
+      fs10.fchown = chownFix(fs10.fchown);
+      fs10.lchown = chownFix(fs10.lchown);
+      fs10.chmod = chmodFix(fs10.chmod);
+      fs10.fchmod = chmodFix(fs10.fchmod);
+      fs10.lchmod = chmodFix(fs10.lchmod);
+      fs10.chownSync = chownFixSync(fs10.chownSync);
+      fs10.fchownSync = chownFixSync(fs10.fchownSync);
+      fs10.lchownSync = chownFixSync(fs10.lchownSync);
+      fs10.chmodSync = chmodFixSync(fs10.chmodSync);
+      fs10.fchmodSync = chmodFixSync(fs10.fchmodSync);
+      fs10.lchmodSync = chmodFixSync(fs10.lchmodSync);
+      fs10.stat = statFix(fs10.stat);
+      fs10.fstat = statFix(fs10.fstat);
+      fs10.lstat = statFix(fs10.lstat);
+      fs10.statSync = statFixSync(fs10.statSync);
+      fs10.fstatSync = statFixSync(fs10.fstatSync);
+      fs10.lstatSync = statFixSync(fs10.lstatSync);
+      if (fs10.chmod && !fs10.lchmod) {
+        fs10.lchmod = function(path17, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs10.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path14, uid, gid, cb) {
+      if (fs10.chown && !fs10.lchown) {
+        fs10.lchown = function(path17, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs10.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs9.rename = typeof fs9.rename !== "function" ? fs9.rename : function(fs$rename) {
+        fs10.rename = typeof fs10.rename !== "function" ? fs10.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() {
-                  fs9.stat(to, function(stater, st) {
+                  fs10.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -3073,9 +3078,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs9.rename);
+        }(fs10.rename);
       }
-      fs9.read = typeof fs9.read !== "function" ? fs9.read : function(fs$read) {
+      fs10.read = typeof fs10.read !== "function" ? fs10.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -3083,22 +3088,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs9.read);
-      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs10.read);
+      fs10.readSync = typeof fs10.readSync !== "function" ? fs10.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs10, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -3108,11 +3113,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path14, mode, callback) {
-          fs10.open(
-            path14,
+      }(fs10.readSync);
+      function patchLchmod(fs11) {
+        fs11.lchmod = function(path17, mode, callback) {
+          fs11.open(
+            path17,
             constants5.O_WRONLY | constants5.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -3120,80 +3125,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs10.fchmod(fd, mode, function(err2) {
-                fs10.close(fd, function(err22) {
+              fs11.fchmod(fd, mode, function(err2) {
+                fs11.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs10.lchmodSync = function(path14, mode) {
-          var fd = fs10.openSync(path14, constants5.O_WRONLY | constants5.O_SYMLINK, mode);
+        fs11.lchmodSync = function(path17, mode) {
+          var fd = fs11.openSync(path17, constants5.O_WRONLY | constants5.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs10.fchmodSync(fd, mode);
+            ret = fs11.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs10.closeSync(fd);
+              fs11.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs10) {
-        if (constants5.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path14, at, mt, cb) {
-            fs10.open(path14, constants5.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs11) {
+        if (constants5.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
+          fs11.lutimes = function(path17, at, mt, cb) {
+            fs11.open(path17, constants5.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs10.futimes(fd, at, mt, function(er2) {
-                fs10.close(fd, function(er22) {
+              fs11.futimes(fd, at, mt, function(er2) {
+                fs11.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs10.lutimesSync = function(path14, at, mt) {
-            var fd = fs10.openSync(path14, constants5.O_SYMLINK);
+          fs11.lutimesSync = function(path17, at, mt) {
+            var fd = fs11.openSync(path17, constants5.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs10.futimesSync(fd, at, mt);
+              ret = fs11.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs10.closeSync(fd);
+                  fs11.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs10.closeSync(fd);
+                fs11.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs10.futimes) {
-          fs10.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs11.futimes) {
+          fs11.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs10.lutimesSync = function() {
+          fs11.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs9, target, mode, function(er) {
+          return orig.call(fs10, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3203,7 +3208,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs9, target, mode);
+            return orig.call(fs10, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3212,7 +3217,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs9, target, uid, gid, function(er) {
+          return orig.call(fs10, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -3222,7 +3227,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs9, target, uid, gid);
+            return orig.call(fs10, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -3242,13 +3247,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback);
+          return options ? orig.call(fs10, target, options, callback) : orig.call(fs10, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target);
+          var stats = options ? orig.call(fs10, target, options) : orig.call(fs10, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -3279,16 +3284,16 @@ var require_legacy_streams = __commonJS({
     init_esm_shims();
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs10) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path14, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
+      function ReadStream(path17, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path17, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path14;
+        this.path = path17;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -3322,7 +3327,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs10.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -3333,10 +3338,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path14, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
+      function WriteStream(path17, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path17, options);
         Stream.call(this);
-        this.path = path14;
+        this.path = path17;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -3361,7 +3366,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs9.open;
+          this._open = fs10.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3399,7 +3404,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 fs9 = __require("fs");
+    var fs10 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3431,12 +3436,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs9[gracefulQueue]) {
+    if (!fs10[gracefulQueue]) {
       queue2 = global[gracefulQueue] || [];
-      publishQueue(fs9, queue2);
-      fs9.close = function(fs$close) {
+      publishQueue(fs10, queue2);
+      fs10.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs9, fd, function(err) {
+          return fs$close.call(fs10, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3448,48 +3453,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs9.close);
-      fs9.closeSync = function(fs$closeSync) {
+      }(fs10.close);
+      fs10.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs9, arguments);
+          fs$closeSync.apply(fs10, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs9.closeSync);
+      }(fs10.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs9[gracefulQueue]);
-          __require("assert").equal(fs9[gracefulQueue].length, 0);
+          debug(fs10[gracefulQueue]);
+          __require("assert").equal(fs10[gracefulQueue].length, 0);
         });
       }
     }
     var queue2;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs9[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs9));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
-      module.exports = patch(fs9);
-      fs9.__patched = true;
-    }
-    function patch(fs10) {
-      polyfills(fs10);
-      fs10.gracefulify = patch;
-      fs10.createReadStream = createReadStream3;
-      fs10.createWriteStream = createWriteStream3;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile3;
-      function readFile3(path14, options, cb) {
+      publishQueue(global, fs10[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs10));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs10.__patched) {
+      module.exports = patch(fs10);
+      fs10.__patched = true;
+    }
+    function patch(fs11) {
+      polyfills(fs11);
+      fs11.gracefulify = patch;
+      fs11.createReadStream = createReadStream3;
+      fs11.createWriteStream = createWriteStream3;
+      var fs$readFile = fs11.readFile;
+      fs11.readFile = readFile2;
+      function readFile2(path17, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path14, options, cb);
-        function go$readFile(path15, options2, cb2, startTime) {
-          return fs$readFile(path15, options2, function(err) {
+        return go$readFile(path17, options, cb);
+        function go$readFile(path18, options2, cb2, startTime) {
+          return fs$readFile(path18, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path15, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path18, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3497,16 +3502,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile2;
-      function writeFile2(path14, data, options, cb) {
+      var fs$writeFile = fs11.writeFile;
+      fs11.writeFile = writeFile2;
+      function writeFile2(path17, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path14, data, options, cb);
-        function go$writeFile(path15, data2, options2, cb2, startTime) {
-          return fs$writeFile(path15, data2, options2, function(err) {
+        return go$writeFile(path17, data, options, cb);
+        function go$writeFile(path18, data2, options2, cb2, startTime) {
+          return fs$writeFile(path18, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path18, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3514,17 +3519,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs11.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
-      function appendFile(path14, data, options, cb) {
+        fs11.appendFile = appendFile;
+      function appendFile(path17, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path14, data, options, cb);
-        function go$appendFile(path15, data2, options2, cb2, startTime) {
-          return fs$appendFile(path15, data2, options2, function(err) {
+        return go$appendFile(path17, data, options, cb);
+        function go$appendFile(path18, data2, options2, cb2, startTime) {
+          return fs$appendFile(path18, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path18, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3532,9 +3537,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs10.copyFile;
+      var fs$copyFile = fs11.copyFile;
       if (fs$copyFile)
-        fs10.copyFile = copyFile;
+        fs11.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3552,34 +3557,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs10.readdir;
-      fs10.readdir = readdir;
+      var fs$readdir = fs11.readdir;
+      fs11.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path14, options, cb) {
+      function readdir(path17, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, fs$readdirCallback(
-            path15,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path18, options2, cb2, startTime) {
+          return fs$readdir(path18, fs$readdirCallback(
+            path18,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, options2, fs$readdirCallback(
-            path15,
+        } : function go$readdir2(path18, options2, cb2, startTime) {
+          return fs$readdir(path18, options2, fs$readdirCallback(
+            path18,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path14, options, cb);
-        function fs$readdirCallback(path15, options2, cb2, startTime) {
+        return go$readdir(path17, options, cb);
+        function fs$readdirCallback(path18, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path15, options2, cb2],
+                [path18, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -3594,21 +3599,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs10);
+        var legStreams = legacy(fs11);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs10.ReadStream;
+      var fs$ReadStream = fs11.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs10.WriteStream;
+      var fs$WriteStream = fs11.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs10, "ReadStream", {
+      Object.defineProperty(fs11, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -3618,7 +3623,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs11, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -3629,7 +3634,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs11, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -3640,7 +3645,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs11, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -3650,7 +3655,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path14, options) {
+      function ReadStream(path17, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -3670,7 +3675,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path14, options) {
+      function WriteStream(path17, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -3688,22 +3693,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream3(path14, options) {
-        return new fs10.ReadStream(path14, options);
+      function createReadStream3(path17, options) {
+        return new fs11.ReadStream(path17, options);
       }
-      function createWriteStream3(path14, options) {
-        return new fs10.WriteStream(path14, options);
+      function createWriteStream3(path17, options) {
+        return new fs11.WriteStream(path17, options);
       }
-      var fs$open = fs10.open;
-      fs10.open = open;
-      function open(path14, flags, mode, cb) {
+      var fs$open = fs11.open;
+      fs11.open = open;
+      function open(path17, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path14, flags, mode, cb);
-        function go$open(path15, flags2, mode2, cb2, startTime) {
-          return fs$open(path15, flags2, mode2, function(err, fd) {
+        return go$open(path17, flags, mode, cb);
+        function go$open(path18, flags2, mode2, cb2, startTime) {
+          return fs$open(path18, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path15, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path18, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3711,20 +3716,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs10;
+      return fs11;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs9[gracefulQueue].push(elem);
+      fs10[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i2 = 0; i2 < fs9[gracefulQueue].length; ++i2) {
-        if (fs9[gracefulQueue][i2].length > 2) {
-          fs9[gracefulQueue][i2][3] = now;
-          fs9[gracefulQueue][i2][4] = now;
+      for (var i2 = 0; i2 < fs10[gracefulQueue].length; ++i2) {
+        if (fs10[gracefulQueue][i2].length > 2) {
+          fs10[gracefulQueue][i2][3] = now;
+          fs10[gracefulQueue][i2][4] = now;
         }
       }
       retry2();
@@ -3732,9 +3737,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs9[gracefulQueue].length === 0)
+      if (fs10[gracefulQueue].length === 0)
         return;
-      var elem = fs9[gracefulQueue].shift();
+      var elem = fs10[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3756,7 +3761,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs9[gracefulQueue].push(elem);
+          fs10[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5840,22 +5845,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(path14, stripTrailing) {
-      if (typeof path14 !== "string") {
+    module.exports = function(path17, stripTrailing) {
+      if (typeof path17 !== "string") {
         throw new TypeError("expected path to be a string");
       }
-      if (path14 === "\\" || path14 === "/") return "/";
-      var len = path14.length;
-      if (len <= 1) return path14;
+      if (path17 === "\\" || path17 === "/") return "/";
+      var len = path17.length;
+      if (len <= 1) return path17;
       var prefix = "";
-      if (len > 4 && path14[3] === "\\") {
-        var ch = path14[2];
-        if ((ch === "?" || ch === ".") && path14.slice(0, 2) === "\\\\") {
-          path14 = path14.slice(2);
+      if (len > 4 && path17[3] === "\\") {
+        var ch = path17[2];
+        if ((ch === "?" || ch === ".") && path17.slice(0, 2) === "\\\\") {
+          path17 = path17.slice(2);
           prefix = "//";
         }
       }
-      var segs = path14.split(/[/\\]+/);
+      var segs = path17.split(/[/\\]+/);
       if (stripTrailing !== false && segs[segs.length - 1] === "") {
         segs.pop();
       }
@@ -7675,7 +7680,7 @@ var require_errors = __commonJS({
     var classRegExp = /^([A-Z][a-z0-9]*)+$/;
     var nodeInternalPrefix = "__node_internal_";
     var codes = {};
-    function assert3(value, message) {
+    function assert(value, message) {
       if (!value) {
         throw new codes.ERR_INTERNAL_ASSERTION(message);
       }
@@ -7691,7 +7696,7 @@ var require_errors = __commonJS({
     }
     function getMessage2(key, msg, args) {
       if (typeof msg === "function") {
-        assert3(
+        assert(
           msg.length <= args.length,
           // Default options do not count.
           `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`
@@ -7699,7 +7704,7 @@ var require_errors = __commonJS({
         return msg(...args);
       }
       const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;
-      assert3(
+      assert(
         expectedLength === args.length,
         `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
       );
@@ -7773,7 +7778,7 @@ var require_errors = __commonJS({
     E(
       "ERR_INVALID_ARG_TYPE",
       (name, expected, actual) => {
-        assert3(typeof name === "string", "'name' must be a string");
+        assert(typeof name === "string", "'name' must be a string");
         if (!Array.isArray(expected)) {
           expected = [expected];
         }
@@ -7788,13 +7793,13 @@ var require_errors = __commonJS({
         const instances = [];
         const other = [];
         for (const value of expected) {
-          assert3(typeof value === "string", "All expected entries have to be of type string");
+          assert(typeof value === "string", "All expected entries have to be of type string");
           if (kTypes.includes(value)) {
             types.push(value.toLowerCase());
           } else if (classRegExp.test(value)) {
             instances.push(value);
           } else {
-            assert3(value !== "object", 'The value "object" should be written as "Object"');
+            assert(value !== "object", 'The value "object" should be written as "Object"');
             other.push(value);
           }
         }
@@ -7907,7 +7912,7 @@ var require_errors = __commonJS({
     E(
       "ERR_MISSING_ARGS",
       (...args) => {
-        assert3(args.length > 0, "At least one arg needs to be specified");
+        assert(args.length > 0, "At least one arg needs to be specified");
         let msg;
         const len = args.length;
         args = (Array.isArray(args) ? args : [args]).map((a2) => `"${a2}"`).join(" or ");
@@ -7932,7 +7937,7 @@ var require_errors = __commonJS({
     E(
       "ERR_OUT_OF_RANGE",
       (str, range2, input) => {
-        assert3(range2, 'Missing "range" argument');
+        assert(range2, 'Missing "range" argument');
         let received;
         if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
           received = addNumericalSeparator(String(input));
@@ -8458,7 +8463,7 @@ var require_end_of_stream = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var { AbortError, codes } = require_errors();
     var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_PREMATURE_CLOSE } = codes;
     var { kEmptyObject, once: once10 } = require_util2();
@@ -8594,17 +8599,17 @@ var require_end_of_stream = __commonJS({
       }
       stream2.on("close", onclose);
       if (closed) {
-        process10.nextTick(onclose);
+        process11.nextTick(onclose);
       } else if (wState !== null && wState !== void 0 && wState.errorEmitted || rState !== null && rState !== void 0 && rState.errorEmitted) {
         if (!willEmitClose) {
-          process10.nextTick(onclosed);
+          process11.nextTick(onclosed);
         }
       } else if (!readable2 && (!willEmitClose || isReadable(stream2)) && (writableFinished || isWritable(stream2) === false)) {
-        process10.nextTick(onclosed);
+        process11.nextTick(onclosed);
       } else if (!writable2 && (!willEmitClose || isWritable(stream2)) && (readableFinished || isReadable(stream2) === false)) {
-        process10.nextTick(onclosed);
+        process11.nextTick(onclosed);
       } else if (rState && stream2.req && stream2.aborted) {
-        process10.nextTick(onclosed);
+        process11.nextTick(onclosed);
       }
       const cleanup = () => {
         callback = nop;
@@ -8632,7 +8637,7 @@ var require_end_of_stream = __commonJS({
           );
         };
         if (options.signal.aborted) {
-          process10.nextTick(abort);
+          process11.nextTick(abort);
         } else {
           addAbortListener3 = addAbortListener3 || require_util2().addAbortListener;
           const disposable = addAbortListener3(options.signal, abort);
@@ -8659,7 +8664,7 @@ var require_end_of_stream = __commonJS({
           );
         };
         if (options.signal.aborted) {
-          process10.nextTick(abort);
+          process11.nextTick(abort);
         } else {
           addAbortListener3 = addAbortListener3 || require_util2().addAbortListener;
           const disposable = addAbortListener3(options.signal, abort);
@@ -8672,7 +8677,7 @@ var require_end_of_stream = __commonJS({
       }
       const resolverFn = (...args) => {
         if (!isAborted) {
-          process10.nextTick(() => callback.apply(stream2, args));
+          process11.nextTick(() => callback.apply(stream2, args));
         }
       };
       PromisePrototypeThen(stream2[kIsClosedPromise].promise, resolverFn, resolverFn);
@@ -8711,7 +8716,7 @@ var require_destroy2 = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var {
       aggregateTwoErrors,
       codes: { ERR_MULTIPLE_CALLBACK },
@@ -8778,9 +8783,9 @@ var require_destroy2 = __commonJS({
           cb(err2);
         }
         if (err2) {
-          process10.nextTick(emitErrorCloseNT, self2, err2);
+          process11.nextTick(emitErrorCloseNT, self2, err2);
         } else {
-          process10.nextTick(emitCloseNT, self2);
+          process11.nextTick(emitCloseNT, self2);
         }
       }
       try {
@@ -8865,7 +8870,7 @@ var require_destroy2 = __commonJS({
           r.errored = err;
         }
         if (sync) {
-          process10.nextTick(emitErrorNT, stream2, err);
+          process11.nextTick(emitErrorNT, stream2, err);
         } else {
           emitErrorNT(stream2, err);
         }
@@ -8887,7 +8892,7 @@ var require_destroy2 = __commonJS({
       if (stream2.listenerCount(kConstruct) > 1) {
         return;
       }
-      process10.nextTick(constructNT, stream2);
+      process11.nextTick(constructNT, stream2);
     }
     function constructNT(stream2) {
       let called = false;
@@ -8911,15 +8916,15 @@ var require_destroy2 = __commonJS({
         } else if (err) {
           errorOrDestroy(stream2, err, true);
         } else {
-          process10.nextTick(emitConstructNT, stream2);
+          process11.nextTick(emitConstructNT, stream2);
         }
       }
       try {
         stream2._construct((err) => {
-          process10.nextTick(onConstruct, err);
+          process11.nextTick(onConstruct, err);
         });
       } catch (err) {
-        process10.nextTick(onConstruct, err);
+        process11.nextTick(onConstruct, err);
       }
     }
     function emitConstructNT(stream2) {
@@ -8933,7 +8938,7 @@ var require_destroy2 = __commonJS({
     }
     function emitErrorCloseLegacy(stream2, err) {
       stream2.emit("error", err);
-      process10.nextTick(emitCloseLegacy, stream2);
+      process11.nextTick(emitCloseLegacy, stream2);
     }
     function destroyer(stream2, err) {
       if (!stream2 || isDestroyed(stream2)) {
@@ -8954,9 +8959,9 @@ var require_destroy2 = __commonJS({
       } else if (typeof stream2.close === "function") {
         stream2.close();
       } else if (err) {
-        process10.nextTick(emitErrorCloseLegacy, stream2, err);
+        process11.nextTick(emitErrorCloseLegacy, stream2, err);
       } else {
-        process10.nextTick(emitCloseLegacy, stream2);
+        process11.nextTick(emitCloseLegacy, stream2);
       }
       if (!stream2.destroyed) {
         stream2[kIsDestroyed] = true;
@@ -9307,7 +9312,7 @@ var require_from = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/from.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require_primordials();
     var { Buffer: Buffer5 } = __require("buffer");
     var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_NULL_VALUES } = require_errors().codes;
@@ -9349,9 +9354,9 @@ var require_from = __commonJS({
       readable2._destroy = function(error, cb) {
         PromisePrototypeThen(
           close(error),
-          () => process10.nextTick(cb, error),
+          () => process11.nextTick(cb, error),
           // nextTick is here in case cb throws
-          (e) => process10.nextTick(cb, e || error)
+          (e) => process11.nextTick(cb, e || error)
         );
       };
       async function close(error) {
@@ -9403,7 +9408,7 @@ var require_readable2 = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/readable.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var {
       ArrayPrototypeIndexOf,
       NumberIsInteger,
@@ -9788,7 +9793,7 @@ var require_readable2 = __commonJS({
       if (!state.emittedReadable) {
         debug("emitReadable", state.flowing);
         state.emittedReadable = true;
-        process10.nextTick(emitReadable_, stream2);
+        process11.nextTick(emitReadable_, stream2);
       }
     }
     function emitReadable_(stream2) {
@@ -9804,7 +9809,7 @@ var require_readable2 = __commonJS({
     function maybeReadMore(stream2, state) {
       if (!state.readingMore && state.constructed) {
         state.readingMore = true;
-        process10.nextTick(maybeReadMore_, stream2, state);
+        process11.nextTick(maybeReadMore_, stream2, state);
       }
     }
     function maybeReadMore_(stream2, state) {
@@ -9831,9 +9836,9 @@ var require_readable2 = __commonJS({
       }
       state.pipes.push(dest);
       debug("pipe count=%d opts=%j", state.pipes.length, pipeOpts);
-      const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process10.stdout && dest !== process10.stderr;
+      const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process11.stdout && dest !== process11.stderr;
       const endFn = doEnd ? onend : unpipe;
-      if (state.endEmitted) process10.nextTick(endFn);
+      if (state.endEmitted) process11.nextTick(endFn);
       else src.once("end", endFn);
       dest.on("unpipe", onunpipe);
       function onunpipe(readable2, unpipeInfo) {
@@ -9983,7 +9988,7 @@ var require_readable2 = __commonJS({
           if (state.length) {
             emitReadable(this);
           } else if (!state.reading) {
-            process10.nextTick(nReadingNextTick, this);
+            process11.nextTick(nReadingNextTick, this);
           }
         }
       }
@@ -9993,7 +9998,7 @@ var require_readable2 = __commonJS({
     Readable4.prototype.removeListener = function(ev, fn) {
       const res = Stream.prototype.removeListener.call(this, ev, fn);
       if (ev === "readable") {
-        process10.nextTick(updateReadableListening, this);
+        process11.nextTick(updateReadableListening, this);
       }
       return res;
     };
@@ -10001,7 +10006,7 @@ var require_readable2 = __commonJS({
     Readable4.prototype.removeAllListeners = function(ev) {
       const res = Stream.prototype.removeAllListeners.apply(this, arguments);
       if (ev === "readable" || ev === void 0) {
-        process10.nextTick(updateReadableListening, this);
+        process11.nextTick(updateReadableListening, this);
       }
       return res;
     };
@@ -10033,7 +10038,7 @@ var require_readable2 = __commonJS({
     function resume(stream2, state) {
       if (!state.resumeScheduled) {
         state.resumeScheduled = true;
-        process10.nextTick(resume_, stream2, state);
+        process11.nextTick(resume_, stream2, state);
       }
     }
     function resume_(stream2, state) {
@@ -10310,7 +10315,7 @@ var require_readable2 = __commonJS({
       debug("endReadable", state.endEmitted);
       if (!state.endEmitted) {
         state.ended = true;
-        process10.nextTick(endReadableNT, state, stream2);
+        process11.nextTick(endReadableNT, state, stream2);
       }
     }
     function endReadableNT(state, stream2) {
@@ -10319,7 +10324,7 @@ var require_readable2 = __commonJS({
         state.endEmitted = true;
         stream2.emit("end");
         if (stream2.writable && stream2.allowHalfOpen === false) {
-          process10.nextTick(endWritableNT, stream2);
+          process11.nextTick(endWritableNT, stream2);
         } else if (state.autoDestroy) {
           const wState = stream2._writableState;
           const autoDestroy = !wState || wState.autoDestroy && // We don't expect the writable to ever 'finish'
@@ -10370,7 +10375,7 @@ var require_writable = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/writable.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var {
       ArrayPrototypeSlice,
       Error: Error2,
@@ -10523,7 +10528,7 @@ var require_writable = __commonJS({
         err = new ERR_STREAM_DESTROYED("write");
       }
       if (err) {
-        process10.nextTick(cb, err);
+        process11.nextTick(cb, err);
         errorOrDestroy(stream2, err, true);
         return err;
       }
@@ -10613,7 +10618,7 @@ var require_writable = __commonJS({
           stream2._readableState.errored = er;
         }
         if (sync) {
-          process10.nextTick(onwriteError, stream2, state, er, cb);
+          process11.nextTick(onwriteError, stream2, state, er, cb);
         } else {
           onwriteError(stream2, state, er, cb);
         }
@@ -10631,7 +10636,7 @@ var require_writable = __commonJS({
               stream: stream2,
               state
             };
-            process10.nextTick(afterWriteTick, state.afterWriteTickInfo);
+            process11.nextTick(afterWriteTick, state.afterWriteTickInfo);
           }
         } else {
           afterWrite(stream2, state, 1, cb);
@@ -10768,7 +10773,7 @@ var require_writable = __commonJS({
       }
       if (typeof cb === "function") {
         if (err || state.finished) {
-          process10.nextTick(cb, err);
+          process11.nextTick(cb, err);
         } else {
           state[kOnFinished].push(cb);
         }
@@ -10797,7 +10802,7 @@ var require_writable = __commonJS({
           state.prefinished = true;
           stream2.emit("prefinish");
           state.pendingcb++;
-          process10.nextTick(finish, stream2, state);
+          process11.nextTick(finish, stream2, state);
         }
       }
       state.sync = true;
@@ -10826,7 +10831,7 @@ var require_writable = __commonJS({
         if (state.pendingcb === 0) {
           if (sync) {
             state.pendingcb++;
-            process10.nextTick(
+            process11.nextTick(
               (stream3, state2) => {
                 if (needFinish(state2)) {
                   finish(stream3, state2);
@@ -10961,7 +10966,7 @@ var require_writable = __commonJS({
     Writable4.prototype.destroy = function(err, cb) {
       const state = this._writableState;
       if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) {
-        process10.nextTick(errorBuffer, state);
+        process11.nextTick(errorBuffer, state);
       }
       destroy.call(this, err, cb);
       return this;
@@ -10992,7 +10997,7 @@ var require_duplexify = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/duplexify.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var bufferModule = __require("buffer");
     var {
       isReadable,
@@ -11105,9 +11110,9 @@ var require_duplexify = __commonJS({
               final(async () => {
                 try {
                   await promise;
-                  process10.nextTick(cb, null);
+                  process11.nextTick(cb, null);
                 } catch (err) {
-                  process10.nextTick(cb, err);
+                  process11.nextTick(cb, err);
                 }
               });
             },
@@ -11186,7 +11191,7 @@ var require_duplexify = __commonJS({
             const _promise = promise;
             promise = null;
             const { chunk, done, cb } = await _promise;
-            process10.nextTick(cb);
+            process11.nextTick(cb);
             if (done) return;
             if (signal.aborted)
               throw new AbortError(void 0, {
@@ -11582,7 +11587,7 @@ var require_pipeline = __commonJS({
   "../../.yarn/cache/readable-stream-npm-4.5.2-2c754e52ef-a2c80e0e53.zip/node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var process10 = require_process();
+    var process11 = require_process();
     var { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator, SymbolDispose } = require_primordials();
     var eos = require_end_of_stream();
     var { once: once10 } = require_util2();
@@ -11784,7 +11789,7 @@ var require_pipeline = __commonJS({
           if (!error) {
             lastStreamCleanup.forEach((fn) => fn());
           }
-          process10.nextTick(callback, error, value);
+          process11.nextTick(callback, error, value);
         }
       }
       let ret;
@@ -11863,11 +11868,11 @@ var require_pipeline = __commonJS({
                   if (end) {
                     pt.end();
                   }
-                  process10.nextTick(finish);
+                  process11.nextTick(finish);
                 },
                 (err) => {
                   pt.destroy(err);
-                  process10.nextTick(finish, err);
+                  process11.nextTick(finish, err);
                 }
               );
             } else if (isIterable(ret, true)) {
@@ -11948,7 +11953,7 @@ var require_pipeline = __commonJS({
         }
       }
       if (signal !== null && signal !== void 0 && signal.aborted || outerSignal !== null && outerSignal !== void 0 && outerSignal.aborted) {
-        process10.nextTick(abort);
+        process11.nextTick(abort);
       }
       return ret;
     }
@@ -11969,7 +11974,7 @@ var require_pipeline = __commonJS({
         };
         var endFn = endFn2;
         if (isReadableFinished(src)) {
-          process10.nextTick(endFn2);
+          process11.nextTick(endFn2);
         } else {
           src.once("end", endFn2);
         }
@@ -14470,11 +14475,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 path14 = {
+    var path17 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    exports.sep = defaultPlatform === "win32" ? path14.win32.sep : path14.posix.sep;
+    exports.sep = defaultPlatform === "win32" ? path17.win32.sep : path17.posix.sep;
     exports.minimatch.sep = exports.sep;
     exports.GLOBSTAR = Symbol("globstar **");
     exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
@@ -17725,12 +17730,12 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path14) {
-        if (!path14) {
+      resolve(path17) {
+        if (!path17) {
           return this;
         }
-        const rootPath = this.getRootString(path14);
-        const dir2 = path14.substring(rootPath.length);
+        const rootPath = this.getRootString(path17);
+        const dir2 = path17.substring(rootPath.length);
         const dirParts = dir2.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -18483,8 +18488,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path14) {
-        return node_path_1.win32.parse(path14).root;
+      getRootString(path17) {
+        return node_path_1.win32.parse(path17).root;
       }
       /**
        * @internal
@@ -18531,8 +18536,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path14) {
-        return path14.startsWith("/") ? "/" : "";
+      getRootString(path17) {
+        return path17.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -18582,8 +18587,8 @@ var require_commonjs4 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs9 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs9);
+      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs10 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs10);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -18622,11 +18627,11 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path14 = this.cwd) {
-        if (typeof path14 === "string") {
-          path14 = this.cwd.resolve(path14);
+      depth(path17 = this.cwd) {
+        if (typeof path17 === "string") {
+          path17 = this.cwd.resolve(path17);
         }
-        return path14.depth();
+        return path17.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -19005,7 +19010,7 @@ var require_commonjs4 = __commonJS({
         const dirs = /* @__PURE__ */ new Set();
         const queue2 = [entry];
         let processing = 0;
-        const process10 = () => {
+        const process11 = () => {
           let paused = false;
           while (!paused) {
             const dir2 = queue2.shift();
@@ -19046,9 +19051,9 @@ var require_commonjs4 = __commonJS({
                 }
               }
               if (paused && !results.flowing) {
-                results.once("drain", process10);
+                results.once("drain", process11);
               } else if (!sync) {
-                process10();
+                process11();
               }
             };
             let sync = true;
@@ -19056,7 +19061,7 @@ var require_commonjs4 = __commonJS({
             sync = false;
           }
         };
-        process10();
+        process11();
         return results;
       }
       streamSync(entry = this.cwd, opts = {}) {
@@ -19074,7 +19079,7 @@ var require_commonjs4 = __commonJS({
         }
         const queue2 = [entry];
         let processing = 0;
-        const process10 = () => {
+        const process11 = () => {
           let paused = false;
           while (!paused) {
             const dir2 = queue2.shift();
@@ -19108,14 +19113,14 @@ var require_commonjs4 = __commonJS({
             }
           }
           if (paused && !results.flowing)
-            results.once("drain", process10);
+            results.once("drain", process11);
         };
-        process10();
+        process11();
         return results;
       }
-      chdir(path14 = this.cwd) {
+      chdir(path17 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path14 === "string" ? this.cwd.resolve(path14) : path14;
+        this.cwd = typeof path17 === "string" ? this.cwd.resolve(path17) : path17;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -19142,8 +19147,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs9) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+      newRoot(fs10) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -19172,8 +19177,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs9) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+      newRoot(fs10) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -19506,8 +19511,8 @@ var require_processor = __commonJS({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path14, n2]) => [
-          path14,
+        return [...this.store.entries()].map(([path17, n2]) => [
+          path17,
           !!(n2 & 2),
           !!(n2 & 1)
         ]);
@@ -19726,9 +19731,9 @@ var require_walker = __commonJS({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path14, opts) {
+      constructor(patterns, path17, opts) {
         this.patterns = patterns;
-        this.path = path14;
+        this.path = path17;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -19747,11 +19752,11 @@ var require_walker = __commonJS({
           });
         }
       }
-      #ignored(path14) {
-        return this.seen.has(path14) || !!this.#ignore?.ignored?.(path14);
+      #ignored(path17) {
+        return this.seen.has(path17) || !!this.#ignore?.ignored?.(path17);
       }
-      #childrenIgnored(path14) {
-        return !!this.#ignore?.childrenIgnored?.(path14);
+      #childrenIgnored(path17) {
+        return !!this.#ignore?.childrenIgnored?.(path17);
       }
       // backpressure mechanism
       pause() {
@@ -19967,8 +19972,8 @@ var require_walker = __commonJS({
     exports.GlobUtil = GlobUtil;
     var GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path14, opts) {
-        super(patterns, path14, opts);
+      constructor(patterns, path17, opts) {
+        super(patterns, path17, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -20006,8 +20011,8 @@ var require_walker = __commonJS({
     exports.GlobWalker = GlobWalker;
     var GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path14, opts) {
-        super(patterns, path14, opts);
+      constructor(patterns, path17, opts) {
+        super(patterns, path17, opts);
         this.results = new minipass_1.Minipass({
           signal: this.signal,
           objectMode: true
@@ -20367,8 +20372,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 fs9 = require_graceful_fs();
-    var path14 = __require("path");
+    var fs10 = require_graceful_fs();
+    var path17 = __require("path");
     var flatten = require_flatten();
     var difference = require_difference();
     var union = require_union();
@@ -20393,8 +20398,8 @@ var require_file = __commonJS({
       return result;
     };
     file.exists = function() {
-      var filepath = path14.join.apply(path14, arguments);
-      return fs9.existsSync(filepath);
+      var filepath = path17.join.apply(path17, arguments);
+      return fs10.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options = isPlainObject2(args[0]) ? args.shift() : {};
@@ -20407,12 +20412,12 @@ var require_file = __commonJS({
       });
       if (options.filter) {
         matches = matches.filter(function(filepath) {
-          filepath = path14.join(options.cwd || "", filepath);
+          filepath = path17.join(options.cwd || "", filepath);
           try {
             if (typeof options.filter === "function") {
               return options.filter(filepath);
             } else {
-              return fs9.statSync(filepath)[options.filter]();
+              return fs10.statSync(filepath)[options.filter]();
             }
           } catch (e) {
             return false;
@@ -20424,7 +20429,7 @@ var require_file = __commonJS({
     file.expandMapping = function(patterns, destBase, options) {
       options = Object.assign({
         rename: function(destBase2, destPath) {
-          return path14.join(destBase2 || "", destPath);
+          return path17.join(destBase2 || "", destPath);
         }
       }, options);
       var files = [];
@@ -20432,14 +20437,14 @@ var require_file = __commonJS({
       file.expand(options, patterns).forEach(function(src) {
         var destPath = src;
         if (options.flatten) {
-          destPath = path14.basename(destPath);
+          destPath = path17.basename(destPath);
         }
         if (options.ext) {
           destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
         }
         var dest = options.rename(destBase, destPath, options);
         if (options.cwd) {
-          src = path14.join(options.cwd, src);
+          src = path17.join(options.cwd, src);
         }
         dest = dest.replace(pathSeparatorRe, "/");
         src = src.replace(pathSeparatorRe, "/");
@@ -20522,8 +20527,8 @@ 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 fs9 = require_graceful_fs();
-    var path14 = __require("path");
+    var fs10 = require_graceful_fs();
+    var path17 = __require("path");
     var isStream2 = require_is_stream();
     var lazystream = require_lazystream();
     var normalizePath = require_normalize_path();
@@ -20571,7 +20576,7 @@ var require_archiver_utils = __commonJS({
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs9.createReadStream(filepath);
+        return fs10.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -20599,7 +20604,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs9.readdir(dirpath, function(err, list) {
+      fs10.readdir(dirpath, function(err, list) {
         var i2 = 0;
         var file;
         var filepath;
@@ -20611,11 +20616,11 @@ var require_archiver_utils = __commonJS({
           if (!file) {
             return callback(null, results);
           }
-          filepath = path14.join(dirpath, file);
-          fs9.stat(filepath, function(err2, stats) {
+          filepath = path17.join(dirpath, file);
+          fs10.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
-              relative: path14.relative(base, filepath).replace(/\\/g, "/"),
+              relative: path17.relative(base, filepath).replace(/\\/g, "/"),
               stats
             });
             if (stats && stats.isDirectory()) {
@@ -20678,10 +20683,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 fs9 = __require("fs");
+    var fs10 = __require("fs");
     var glob = require_readdir_glob();
     var async = (init_async(), __toCommonJS(async_exports));
-    var path14 = __require("path");
+    var path17 = __require("path");
     var util2 = require_archiver_utils();
     var inherits = __require("util").inherits;
     var ArchiverError = require_error();
@@ -20742,7 +20747,7 @@ var require_core = __commonJS({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs9.Stats) {
+      if (data.stats && data.stats instanceof fs10.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -20913,7 +20918,7 @@ var require_core = __commonJS({
         callback();
         return;
       }
-      fs9.lstat(task.filepath, function(err, stats) {
+      fs10.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -20956,10 +20961,10 @@ var require_core = __commonJS({
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs9.readlinkSync(task.filepath);
-        var dirName = path14.dirname(task.filepath);
+        var linkPath = fs10.readlinkSync(task.filepath);
+        var dirName = path17.dirname(task.filepath);
         task.data.type = "symlink";
-        task.data.linkname = path14.relative(dirName, path14.resolve(dirName, linkPath));
+        task.data.linkname = path17.relative(dirName, path17.resolve(dirName, linkPath));
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else {
@@ -22115,22 +22120,22 @@ var require_zip_archive_output_stream = __commonJS({
     };
     ZipArchiveOutputStream.prototype._smartStream = function(ae, callback) {
       var deflate = ae.getMethod() === constants5.METHOD_DEFLATED;
-      var process10 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
+      var process11 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
       var error = null;
       function handleStuff() {
-        var digest = process10.digest().readUInt32BE(0);
+        var digest = process11.digest().readUInt32BE(0);
         ae.setCrc(digest);
-        ae.setSize(process10.size());
-        ae.setCompressedSize(process10.size(true));
+        ae.setSize(process11.size());
+        ae.setCompressedSize(process11.size(true));
         this._afterAppend(ae);
         callback(error, ae);
       }
-      process10.once("end", handleStuff.bind(this));
-      process10.once("error", function(err) {
+      process11.once("end", handleStuff.bind(this));
+      process11.once("error", function(err) {
         error = err;
       });
-      process10.pipe(this, { end: false });
-      return process10;
+      process11.pipe(this, { end: false });
+      return process11;
     };
     ZipArchiveOutputStream.prototype._writeCentralDirectoryEnd = function() {
       var records = this._entries.length;
@@ -25133,8 +25138,8 @@ var require_windows = __commonJS({
     init_esm_shims();
     module.exports = isexe;
     isexe.sync = sync;
-    var fs9 = __require("fs");
-    function checkPathExt(path14, options) {
+    var fs10 = __require("fs");
+    function checkPathExt(path17, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -25145,25 +25150,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path14.substr(-p.length).toLowerCase() === p) {
+        if (p && path17.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path14, options) {
+    function checkStat(stat, path17, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path14, options);
+      return checkPathExt(path17, options);
     }
-    function isexe(path14, options, cb) {
-      fs9.stat(path14, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path14, options));
+    function isexe(path17, options, cb) {
+      fs10.stat(path17, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path17, options));
       });
     }
-    function sync(path14, options) {
-      return checkStat(fs9.statSync(path14), path14, options);
+    function sync(path17, options) {
+      return checkStat(fs10.statSync(path17), path17, options);
     }
   }
 });
@@ -25175,14 +25180,14 @@ var require_mode = __commonJS({
     init_esm_shims();
     module.exports = isexe;
     isexe.sync = sync;
-    var fs9 = __require("fs");
-    function isexe(path14, options, cb) {
-      fs9.stat(path14, function(er, stat) {
+    var fs10 = __require("fs");
+    function isexe(path17, options, cb) {
+      fs10.stat(path17, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path14, options) {
-      return checkStat(fs9.statSync(path14), options);
+    function sync(path17, options) {
+      return checkStat(fs10.statSync(path17), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -25208,7 +25213,7 @@ var require_isexe = __commonJS({
   "../../.yarn/cache/isexe-npm-2.0.0-ac27b2c17a-228cfa503f.zip/node_modules/isexe/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -25217,7 +25222,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path14, options, cb) {
+    function isexe(path17, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -25227,7 +25232,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject2) {
-          isexe(path14, options || {}, function(er, is) {
+          isexe(path17, options || {}, function(er, is) {
             if (er) {
               reject2(er);
             } else {
@@ -25236,7 +25241,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path14, options || {}, function(er, is) {
+      core(path17, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -25246,9 +25251,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path14, options) {
+    function sync(path17, options) {
       try {
-        return core.sync(path14, options || {});
+        return core.sync(path17, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -25266,7 +25271,7 @@ var require_which = __commonJS({
     "use strict";
     init_esm_shims();
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path14 = __require("path");
+    var path17 = __require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -25304,7 +25309,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject2(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path14.join(pathPart, cmd);
+        const pCmd = path17.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i2, 0));
       });
@@ -25331,7 +25336,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path14.join(pathPart, cmd);
+        const pCmd = path17.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -25381,7 +25386,7 @@ var require_resolveCommand = __commonJS({
   "../../.yarn/cache/cross-spawn-npm-7.0.3-68b62748dc-5738c31238.zip/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path14 = __require("path");
+    var path17 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -25399,7 +25404,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path14.delimiter : void 0
+          pathExt: withoutPathExt ? path17.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -25408,7 +25413,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path14.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path17.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -25465,12 +25470,12 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path14, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary2 = path14.split("/").pop();
-      if (binary2 === "env") {
+      const [path17, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path17.split("/").pop();
+      if (binary === "env") {
         return argument;
       }
-      return argument ? `${binary2} ${argument}` : binary2;
+      return argument ? `${binary} ${argument}` : binary;
     };
   }
 });
@@ -25480,16 +25485,16 @@ var require_readShebang = __commonJS({
   "../../.yarn/cache/cross-spawn-npm-7.0.3-68b62748dc-5738c31238.zip/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs9.openSync(command, "r");
-        fs9.readSync(fd, buffer, 0, size, 0);
-        fs9.closeSync(fd);
+        fd = fs10.openSync(command, "r");
+        fs10.readSync(fd, buffer, 0, size, 0);
+        fs10.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -25503,7 +25508,7 @@ var require_parse = __commonJS({
   "../../.yarn/cache/cross-spawn-npm-7.0.3-68b62748dc-5738c31238.zip/node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path14 = __require("path");
+    var path17 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape2();
     var readShebang = require_readShebang();
@@ -25528,7 +25533,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path14.normalize(parsed.command);
+        parsed.command = path17.normalize(parsed.command);
         parsed.command = escape.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -25646,8 +25651,8 @@ init_esm_shims();
 // src/plugins/appsInToss.ts
 init_esm_shims();
 var import_picocolors = __toESM(require_picocolors(), 1);
-import fs8 from "fs";
-import path13 from "path";
+import fs9 from "fs";
+import path16 from "path";
 
 // src/plugins/constants.ts
 init_esm_shims();
@@ -25655,14 +25660,14 @@ var APP_MANIFEST_NAME = "app.json";
 
 // src/plugins/utils/createArtifact.ts
 init_esm_shims();
-import fs6 from "fs/promises";
-import * as path11 from "path";
+import fs8 from "fs/promises";
+import * as path15 from "path";
 
 // src/plugins/utils/compressToZip.ts
 init_esm_shims();
 var import_archiver = __toESM(require_archiver(), 1);
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 async function compressToZip(config) {
   const { files, outfile } = config;
   return new Promise((resolve, reject2) => {
@@ -25672,7 +25677,7 @@ async function compressToZip(config) {
     outputStream.on("error", (error) => reject2(error));
     archive.on("error", (error) => reject2(error)).pipe(outputStream);
     files.forEach(({ path: filePath, name }) => {
-      const fileName = name ?? path.basename(filePath);
+      const fileName = name ?? path2.basename(filePath);
       archive.append(fs.createReadStream(filePath), { name: fileName });
     });
     archive.finalize();
@@ -25681,12 +25686,12 @@ async function compressToZip(config) {
 
 // src/plugins/utils/createCompressedBytecode.ts
 init_esm_shims();
+import path12 from "path";
 
 // src/plugins/utils/compileHbc.ts
 init_esm_shims();
-import assert from "assert";
-import os from "os";
-import path7 from "path";
+import fs4 from "fs";
+import path11 from "path";
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/index.js
 init_esm_shims();
@@ -25709,7 +25714,7 @@ init_esm_shims();
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/arguments/file-url.js
 init_esm_shims();
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var safeNormalizeFileUrl = (file, name) => {
   const fileString = normalizeFileUrl(normalizeDenoExecPath(file));
   if (typeof fileString !== "string") {
@@ -25719,7 +25724,7 @@ var safeNormalizeFileUrl = (file, name) => {
 };
 var normalizeDenoExecPath = (file) => isDenoExecPath(file) ? file.toString() : file;
 var isDenoExecPath = (file) => typeof file !== "string" && file && Object.getPrototypeOf(file) === String.prototype;
-var normalizeFileUrl = (file) => file instanceof URL ? fileURLToPath(file) : file;
+var normalizeFileUrl = (file) => file instanceof URL ? fileURLToPath2(file) : file;
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/methods/parameters.js
 var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
@@ -26570,13 +26575,13 @@ var handleCommand = (filePath, rawArguments, rawOptions) => {
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/arguments/options.js
 init_esm_shims();
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import path6 from "node:path";
+import path7 from "node:path";
 import process6 from "node:process";
 
 // ../../.yarn/cache/npm-run-path-npm-6.0.0-e1f8e169a9-b223c8a0dc.zip/node_modules/npm-run-path/index.js
 init_esm_shims();
 import process4 from "node:process";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // ../../.yarn/cache/path-key-npm-4.0.0-9f9fba604f-794efeef32.zip/node_modules/path-key/index.js
 init_esm_shims();
@@ -26595,21 +26600,21 @@ function pathKey(options = {}) {
 init_esm_shims();
 import { promisify } from "node:util";
 import { execFile as execFileCallback, execFileSync as execFileSyncOriginal } from "node:child_process";
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var execFileOriginal = promisify(execFileCallback);
 function toPath(urlOrPath) {
-  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+  return urlOrPath instanceof URL ? fileURLToPath3(urlOrPath) : urlOrPath;
 }
 function traversePathUp(startPath) {
   return {
     *[Symbol.iterator]() {
-      let currentPath = path2.resolve(toPath(startPath));
+      let currentPath = path3.resolve(toPath(startPath));
       let previousPath;
       while (previousPath !== currentPath) {
         yield currentPath;
         previousPath = currentPath;
-        currentPath = path2.resolve(currentPath, "..");
+        currentPath = path3.resolve(currentPath, "..");
       }
     }
   };
@@ -26624,27 +26629,27 @@ var npmRunPath = ({
   execPath: execPath2 = process4.execPath,
   addExecPath = true
 } = {}) => {
-  const cwdPath = path3.resolve(toPath(cwd));
+  const cwdPath = path4.resolve(toPath(cwd));
   const result = [];
-  const pathParts = pathOption.split(path3.delimiter);
+  const pathParts = pathOption.split(path4.delimiter);
   if (preferLocal) {
     applyPreferLocal(result, pathParts, cwdPath);
   }
   if (addExecPath) {
     applyExecPath(result, pathParts, execPath2, cwdPath);
   }
-  return pathOption === "" || pathOption === path3.delimiter ? `${result.join(path3.delimiter)}${pathOption}` : [...result, pathOption].join(path3.delimiter);
+  return pathOption === "" || pathOption === path4.delimiter ? `${result.join(path4.delimiter)}${pathOption}` : [...result, pathOption].join(path4.delimiter);
 };
 var applyPreferLocal = (result, pathParts, cwdPath) => {
   for (const directory of traversePathUp(cwdPath)) {
-    const pathPart = path3.join(directory, "node_modules/.bin");
+    const pathPart = path4.join(directory, "node_modules/.bin");
     if (!pathParts.includes(pathPart)) {
       result.push(pathPart);
     }
   }
 };
 var applyExecPath = (result, pathParts, execPath2, cwdPath) => {
-  const pathPart = path3.resolve(cwdPath, toPath(execPath2), "..");
+  const pathPart = path4.resolve(cwdPath, toPath(execPath2), "..");
   if (!pathParts.includes(pathPart)) {
     result.push(pathPart);
   }
@@ -27828,7 +27833,7 @@ var killAfterTimeout = async (subprocess, timeout2, context, { signal }) => {
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/methods/node.js
 init_esm_shims();
 import { execPath, execArgv } from "node:process";
-import path4 from "node:path";
+import path5 from "node:path";
 var mapNode = ({ options }) => {
   if (options.node === false) {
     throw new TypeError('The "node" option cannot be false with `execaNode()`.');
@@ -27847,7 +27852,7 @@ var handleNodeOption = (file, commandArguments, {
     throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
   }
   const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
-  const resolvedNodePath = path4.resolve(cwd, normalizedNodePath);
+  const resolvedNodePath = path5.resolve(cwd, normalizedNodePath);
   const newOptions = {
     ...options,
     nodePath: resolvedNodePath,
@@ -27857,7 +27862,7 @@ var handleNodeOption = (file, commandArguments, {
   if (!shouldHandleNode) {
     return [file, commandArguments, newOptions];
   }
-  if (path4.basename(file, ".exe") === "node") {
+  if (path5.basename(file, ".exe") === "node") {
     throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
   }
   return [
@@ -27950,11 +27955,11 @@ var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encodin
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/arguments/cwd.js
 init_esm_shims();
 import { statSync } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 import process5 from "node:process";
 var normalizeCwd = (cwd = getDefaultCwd()) => {
   const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
-  return path5.resolve(cwdString);
+  return path6.resolve(cwdString);
 };
 var getDefaultCwd = () => {
   try {
@@ -28001,7 +28006,7 @@ var normalizeOptions = (filePath, rawArguments, rawOptions) => {
   options.killSignal = normalizeKillSignal(options.killSignal);
   options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
   options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
-  if (process6.platform === "win32" && path6.basename(file, ".exe") === "cmd") {
+  if (process6.platform === "win32" && path7.basename(file, ".exe") === "cmd") {
     commandArguments.unshift("/q");
   }
   return { file, commandArguments, options };
@@ -29068,9 +29073,9 @@ var getTransformStreamType = (value, optionName) => {
   validateNonGeneratorType(value, optionName, "web TransformStream");
   return "webTransform";
 };
-var validateNonGeneratorType = ({ final, binary: binary2, objectMode }, optionName, typeName) => {
+var validateNonGeneratorType = ({ final, binary, objectMode }, optionName, typeName) => {
   checkUndefinedOption(final, `${optionName}.final`, typeName);
-  checkUndefinedOption(binary2, `${optionName}.binary`, typeName);
+  checkUndefinedOption(binary, `${optionName}.binary`, typeName);
   checkBooleanOption(objectMode, `${optionName}.objectMode`);
 };
 var checkUndefinedOption = (value, optionName, typeName) => {
@@ -29078,7 +29083,7 @@ var checkUndefinedOption = (value, optionName, typeName) => {
     throw new TypeError(`The \`${optionName}\` option can only be defined when using a generator, not a ${typeName}.`);
   }
 };
-var getGeneratorObjectType = ({ transform: transform2, final, binary: binary2, objectMode }, optionName) => {
+var getGeneratorObjectType = ({ transform: transform2, final, binary, objectMode }, optionName) => {
   if (transform2 !== void 0 && !isGenerator(transform2)) {
     throw new TypeError(`The \`${optionName}.transform\` option must be a generator, a Duplex stream or a web TransformStream.`);
   }
@@ -29091,7 +29096,7 @@ var getGeneratorObjectType = ({ transform: transform2, final, binary: binary2, o
   if (final !== void 0 && !isGenerator(final)) {
     throw new TypeError(`The \`${optionName}.final\` option must be a generator.`);
   }
-  checkBooleanOption(binary2, `${optionName}.binary`);
+  checkBooleanOption(binary, `${optionName}.binary`);
   checkBooleanOption(objectMode, `${optionName}.objectMode`);
   return isAsyncGenerator2(transform2) || isAsyncGenerator2(final) ? "asyncGenerator" : "generator";
 };
@@ -29239,14 +29244,14 @@ var normalizeGenerator = ({ stdioItem, stdioItem: { value }, index: index2, newT
     preserveNewlines = false,
     objectMode
   } = isPlainObject(value) ? value : { transform: value };
-  const binary2 = binaryOption || BINARY_ENCODINGS.has(encoding);
+  const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { writableObjectMode, readableObjectMode } = getTransformObjectModes(objectMode, index2, newTransforms, direction);
   return {
     ...stdioItem,
     value: {
       transform: transform2,
       final,
-      binary: binary2,
+      binary,
       preserveNewlines,
       writableObjectMode,
       readableObjectMode
@@ -29750,7 +29755,7 @@ import { Transform, getDefaultHighWaterMark } from "node:stream";
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/transform/split.js
 init_esm_shims();
-var getSplitLinesGenerator = (binary2, preserveNewlines, skipped, state) => binary2 || skipped ? void 0 : initializeSplitLines(preserveNewlines, state);
+var getSplitLinesGenerator = (binary, preserveNewlines, skipped, state) => binary || skipped ? void 0 : initializeSplitLines(preserveNewlines, state);
 var splitLinesSync = (chunk, preserveNewlines, objectMode) => objectMode ? chunk.flatMap((item) => splitLinesItemSync(item, preserveNewlines)) : splitLinesItemSync(chunk, preserveNewlines);
 var splitLinesItemSync = (chunk, preserveNewlines) => {
   const { transform: transform2, final } = initializeSplitLines(preserveNewlines, {});
@@ -29799,7 +29804,7 @@ var linesFinal = function* ({ previousChunks }) {
     yield previousChunks;
   }
 };
-var getAppendNewlineGenerator = ({ binary: binary2, preserveNewlines, readableObjectMode, state }) => binary2 || preserveNewlines || readableObjectMode ? void 0 : { transform: appendNewlineGenerator.bind(void 0, state) };
+var getAppendNewlineGenerator = ({ binary, preserveNewlines, readableObjectMode, state }) => binary || preserveNewlines || readableObjectMode ? void 0 : { transform: appendNewlineGenerator.bind(void 0, state) };
 var appendNewlineGenerator = function* ({ isWindowsNewline = false }, chunk) {
   const { unixNewline, windowsNewline, LF: LF2, concatBytes } = typeof chunk === "string" ? linesStringInfo : linesUint8ArrayInfo;
   if (chunk.at(-1) === LF2) {
@@ -29863,11 +29868,11 @@ Instead, \`yield\` should either be called with a value, or not be called at all
 init_esm_shims();
 import { Buffer as Buffer3 } from "node:buffer";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
-var getEncodingTransformGenerator = (binary2, encoding, skipped) => {
+var getEncodingTransformGenerator = (binary, encoding, skipped) => {
   if (skipped) {
     return;
   }
-  if (binary2) {
+  if (binary) {
     return { transform: encodingUint8ArrayGenerator.bind(void 0, new TextEncoder()) };
   }
   const stringDecoder = new StringDecoder2(encoding);
@@ -30024,16 +30029,16 @@ var runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
   }
   return chunks;
 };
-var addInternalGenerators = ({ transform: transform2, final, binary: binary2, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
+var addInternalGenerators = ({ transform: transform2, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
   const state = {};
   return [
     { transform: getValidateTransformInput(writableObjectMode, optionName) },
-    getEncodingTransformGenerator(binary2, encoding, writableObjectMode),
-    getSplitLinesGenerator(binary2, preserveNewlines, writableObjectMode, state),
+    getEncodingTransformGenerator(binary, encoding, writableObjectMode),
+    getSplitLinesGenerator(binary, preserveNewlines, writableObjectMode, state),
     { transform: transform2, final },
     { transform: getValidateTransformReturn(readableObjectMode, optionName) },
     getAppendNewlineGenerator({
-      binary: binary2,
+      binary,
       preserveNewlines,
       readableObjectMode,
       state
@@ -30198,13 +30203,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path14, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path14 === "string" ? path14 : path14.toString();
+  for (const { path: path17, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path17 === "string" ? path17 : path17.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync(path14, serializedResult);
+      appendFileSync(path17, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync(path14, serializedResult);
+      writeFileSync(path17, serializedResult);
     }
   }
 };
@@ -31053,7 +31058,7 @@ if (process.platform === "linux") {
 }
 
 // ../../.yarn/cache/signal-exit-npm-4.1.0-abb7bd2c45-41602dce54.zip/node_modules/signal-exit/dist/mjs/index.js
-var processOk = (process10) => !!process10 && typeof process10 === "object" && typeof process10.removeListener === "function" && typeof process10.emit === "function" && typeof process10.reallyExit === "function" && typeof process10.listeners === "function" && typeof process10.kill === "function" && typeof process10.pid === "number" && typeof process10.on === "function";
+var processOk = (process11) => !!process11 && typeof process11 === "object" && typeof process11.removeListener === "function" && typeof process11.emit === "function" && typeof process11.reallyExit === "function" && typeof process11.listeners === "function" && typeof process11.kill === "function" && typeof process11.pid === "number" && typeof process11.on === "function";
 var kExitEmitter = Symbol.for("signal-exit emitter");
 var global2 = globalThis;
 var ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -31146,15 +31151,15 @@ var SignalExit = class extends SignalExitBase {
   #originalProcessReallyExit;
   #sigListeners = {};
   #loaded = false;
-  constructor(process10) {
+  constructor(process11) {
     super();
-    this.#process = process10;
+    this.#process = process11;
     this.#sigListeners = {};
     for (const sig of signals) {
       this.#sigListeners[sig] = () => {
         const listeners = this.#process.listeners(sig);
         let { count: count2 } = this.#emitter;
-        const p = process10;
+        const p = process11;
         if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
           count2 += p.__signal_exit_emitter__.count;
         }
@@ -31163,12 +31168,12 @@ var SignalExit = class extends SignalExitBase {
           const ret = this.#emitter.emit("exit", null, sig);
           const s = sig === "SIGHUP" ? this.#hupSig : sig;
           if (!ret)
-            process10.kill(process10.pid, s);
+            process11.kill(process11.pid, s);
         }
       };
     }
-    this.#originalProcessReallyExit = process10.reallyExit;
-    this.#originalProcessEmit = process10.emit;
+    this.#originalProcessReallyExit = process11.reallyExit;
+    this.#originalProcessEmit = process11.emit;
   }
   onExit(cb, opts) {
     if (!processOk(this.#process)) {
@@ -31559,13 +31564,13 @@ import { setImmediate as setImmediate2 } from "node:timers/promises";
 init_esm_shims();
 import { on as on5 } from "node:events";
 import { getDefaultHighWaterMark as getDefaultHighWaterMark3 } from "node:stream";
-var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary: binary2, shouldEncode, encoding, preserveNewlines }) => {
+var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines }) => {
   const controller = new AbortController();
   stopReadingOnExit(subprocess, controller);
   return iterateOnStream({
     stream: subprocessStdout,
     controller,
-    binary: binary2,
+    binary,
     shouldEncode: !subprocessStdout.readableObjectMode && shouldEncode,
     encoding,
     shouldSplit: !subprocessStdout.readableObjectMode,
@@ -31603,7 +31608,7 @@ var stopReadingOnStreamEnd = async (onStreamEnd, controller, stream2) => {
     controller.abort();
   }
 };
-var iterateOnStream = ({ stream: stream2, controller, binary: binary2, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
+var iterateOnStream = ({ stream: stream2, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
   const onStdoutChunk = on5(stream2, "data", {
     signal: controller.signal,
     highWaterMark: HIGH_WATER_MARK,
@@ -31615,7 +31620,7 @@ var iterateOnStream = ({ stream: stream2, controller, binary: binary2, shouldEnc
   return iterateOnData({
     onStdoutChunk,
     controller,
-    binary: binary2,
+    binary,
     shouldEncode,
     encoding,
     shouldSplit,
@@ -31624,9 +31629,9 @@ var iterateOnStream = ({ stream: stream2, controller, binary: binary2, shouldEnc
 };
 var DEFAULT_OBJECT_HIGH_WATER_MARK = getDefaultHighWaterMark3(true);
 var HIGH_WATER_MARK = DEFAULT_OBJECT_HIGH_WATER_MARK;
-var iterateOnData = async function* ({ onStdoutChunk, controller, binary: binary2, shouldEncode, encoding, shouldSplit, preserveNewlines }) {
+var iterateOnData = async function* ({ onStdoutChunk, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) {
   const generators = getGenerators({
-    binary: binary2,
+    binary,
     shouldEncode,
     encoding,
     shouldSplit,
@@ -31644,9 +31649,9 @@ var iterateOnData = async function* ({ onStdoutChunk, controller, binary: binary
     yield* finalChunksSync(generators);
   }
 };
-var getGenerators = ({ binary: binary2, shouldEncode, encoding, shouldSplit, preserveNewlines }) => [
-  getEncodingTransformGenerator(binary2, encoding, !shouldEncode),
-  getSplitLinesGenerator(binary2, preserveNewlines, !shouldSplit, {})
+var getGenerators = ({ binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => [
+  getEncodingTransformGenerator(binary, encoding, !shouldEncode),
+  getSplitLinesGenerator(binary, preserveNewlines, !shouldSplit, {})
 ].filter(Boolean);
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/io/contents.js
@@ -32115,13 +32120,13 @@ var destroyOtherStream = (stream2, isOpen, error) => {
 
 // ../../.yarn/cache/execa-npm-9.5.2-ac35c57136-94782a6282.zip/node_modules/execa/lib/convert/readable.js
 var createReadable = ({ subprocess, concurrentStreams, encoding }, { from, binary: binaryOption = true, preserveNewlines = true } = {}) => {
-  const binary2 = binaryOption || BINARY_ENCODINGS.has(encoding);
+  const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
-  const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary2);
+  const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
   const { read, onStdoutDataDone } = getReadableMethods({
     subprocessStdout,
     subprocess,
-    binary: binary2,
+    binary,
     encoding,
     preserveNewlines
   });
@@ -32145,14 +32150,14 @@ var getSubprocessStdout = (subprocess, from, concurrentStreams) => {
   const waitReadableDestroy = addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy");
   return { subprocessStdout, waitReadableDestroy };
 };
-var getReadableOptions = ({ readableEncoding, readableObjectMode, readableHighWaterMark }, binary2) => binary2 ? { readableEncoding, readableObjectMode, readableHighWaterMark } : { readableEncoding, readableObjectMode: true, readableHighWaterMark: DEFAULT_OBJECT_HIGH_WATER_MARK };
-var getReadableMethods = ({ subprocessStdout, subprocess, binary: binary2, encoding, preserveNewlines }) => {
+var getReadableOptions = ({ readableEncoding, readableObjectMode, readableHighWaterMark }, binary) => binary ? { readableEncoding, readableObjectMode, readableHighWaterMark } : { readableEncoding, readableObjectMode: true, readableHighWaterMark: DEFAULT_OBJECT_HIGH_WATER_MARK };
+var getReadableMethods = ({ subprocessStdout, subprocess, binary, encoding, preserveNewlines }) => {
   const onStdoutDataDone = createDeferred();
   const onStdoutData = iterateOnSubprocessStream({
     subprocessStdout,
     subprocess,
-    binary: binary2,
-    shouldEncode: !binary2,
+    binary,
+    shouldEncode: !binary,
     encoding,
     preserveNewlines
   });
@@ -32270,14 +32275,14 @@ init_esm_shims();
 import { Duplex as Duplex3 } from "node:stream";
 import { callbackify as callbackify4 } from "node:util";
 var createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, binary: binaryOption = true, preserveNewlines = true } = {}) => {
-  const binary2 = binaryOption || BINARY_ENCODINGS.has(encoding);
+  const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
   const { subprocessStdin, waitWritableFinal, waitWritableDestroy } = getSubprocessStdin(subprocess, to, concurrentStreams);
-  const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary2);
+  const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
   const { read, onStdoutDataDone } = getReadableMethods({
     subprocessStdout,
     subprocess,
-    binary: binary2,
+    binary,
     encoding,
     preserveNewlines
   });
@@ -32327,12 +32332,12 @@ var createIterable = (subprocess, encoding, {
   binary: binaryOption = false,
   preserveNewlines = false
 } = {}) => {
-  const binary2 = binaryOption || BINARY_ENCODINGS.has(encoding);
+  const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const subprocessStdout = getFromStream(subprocess, from);
   const onStdoutData = iterateOnSubprocessStream({
     subprocessStdout,
     subprocess,
-    binary: binary2,
+    binary,
     shouldEncode: true,
     encoding,
     preserveNewlines
@@ -32653,133 +32658,372 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
+// ../../.yarn/cache/find-up-npm-7.0.0-a80086f7af-e6ee3e6154.zip/node_modules/find-up/index.js
+init_esm_shims();
+import path9 from "node:path";
+
+// ../../.yarn/cache/locate-path-npm-7.2.0-454f209f37-139e8a7fe1.zip/node_modules/locate-path/index.js
+init_esm_shims();
+import process10 from "node:process";
+import path8 from "node:path";
+import fs2, { promises as fsPromises } from "node:fs";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+
+// ../../.yarn/cache/p-locate-npm-6.0.0-d73b86f7fc-d72fa2f41a.zip/node_modules/p-locate/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/p-limit-npm-4.0.0-6161fa2142-a56af34a77.zip/node_modules/p-limit/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/yocto-queue-npm-1.1.1-3796fef980-cb287fe5e6.zip/node_modules/yocto-queue/index.js
+init_esm_shims();
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// ../../.yarn/cache/p-limit-npm-4.0.0-6161fa2142-a56af34a77.zip/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue2 = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue2.size > 0) {
+      queue2.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue2.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue2.size > 0) {
+        queue2.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue2.size
+    },
+    clearQueue: {
+      value: () => {
+        queue2.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// ../../.yarn/cache/p-locate-npm-6.0.0-d73b86f7fc-d72fa2f41a.zip/node_modules/p-locate/index.js
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+
+// ../../.yarn/cache/locate-path-npm-7.2.0-454f209f37-139e8a7fe1.zip/node_modules/locate-path/index.js
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath4(urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = process10.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath2(cwd);
+  const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path8.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+
+// ../../.yarn/cache/unicorn-magic-npm-0.1.0-352b6e3681-e4ed0de05b.zip/node_modules/unicorn-magic/node.js
+init_esm_shims();
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+function toPath3(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath5(urlOrPath) : urlOrPath;
+}
+
+// ../../.yarn/cache/path-exists-npm-5.0.0-126b43894b-b170f3060b.zip/node_modules/path-exists/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/find-up-npm-7.0.0-a80086f7af-e6ee3e6154.zip/node_modules/find-up/index.js
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options = {}) {
+  let directory = path9.resolve(toPath3(options.cwd) ?? "");
+  const { root } = path9.parse(directory);
+  const stopAt = path9.resolve(directory, toPath3(options.stopAt ?? root));
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path9.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path9.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+
+// src/plugins/utils/getPackageRoot.ts
+init_esm_shims();
+import fs3 from "fs";
+import path10 from "path";
+function getPackageRoot() {
+  let cwd = process.cwd();
+  const root = path10.parse(cwd).root;
+  while (cwd !== root) {
+    if (fs3.existsSync(path10.join(cwd, "package.json"))) {
+      return cwd;
+    }
+    cwd = path10.dirname(cwd);
+  }
+  return cwd;
+}
+
+// src/constants.ts
+init_esm_shims();
+var REACT_NATIVE_VERSION = "0_72_6";
+
 // src/plugins/utils/compileHbc.ts
-var binary = {
-  Darwin: "react-native/sdks/hermesc/osx-bin/hermesc",
-  Linux: "react-native/sdks/hermesc/linux64-bin/hermesc",
-  Windows_NT: void 0
-};
-async function compileHbc({ rootDir, reactNativeProjectDir, filePath }) {
-  const bindary = getHermesc(reactNativeProjectDir);
-  const outfile = path7.resolve(rootDir, filePath.replace(new RegExp(`${path7.extname(filePath)}$`), ".hbc"));
-  await execa(bindary, ["-w", "-emit-binary", "-out", outfile, filePath]);
+async function compileHbc({ outdir, filePath }) {
+  const packageRoot = getPackageRoot();
+  const bindary = await findHermesBinary();
+  const binaryPath = path11.join(packageRoot, ".bedrock", "hermesc");
+  await fs4.promises.copyFile(bindary, binaryPath);
+  const outfile = path11.resolve(outdir, filePath.replace(new RegExp(`${path11.extname(filePath)}$`), ".hbc"));
+  await execa(binaryPath, ["-w", "-emit-binary", "-out", outfile, filePath]);
   return { outfile };
 }
-function getHermesc(rootDir) {
-  const os3 = getOs();
-  const binarySource = binary[os3];
-  assert(binarySource, `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 OS \uC785\uB2C8\uB2E4: ${os3}`);
-  return resolveFromRoot(rootDir, binarySource);
+function getHermesOSBin() {
+  switch (process.platform) {
+    case "win32":
+      return "win64-bin";
+    case "darwin":
+      return "osx-bin";
+    default:
+      return "linux64-bin";
+  }
 }
-function getOs() {
-  return os.type();
+function getHermesOSExe() {
+  const hermesExecutableName = "hermesc";
+  return process.platform === "win32" ? `${hermesExecutableName}.exe` : hermesExecutableName;
 }
-function resolveFromRoot(rootDir, request) {
-  return __require.resolve(request, { paths: [rootDir] });
+async function findHermesBinary() {
+  const hermescPath = await findUp("hermesc", {
+    cwd: __dirname,
+    type: "directory"
+  });
+  if (!hermescPath) {
+    throw new Error("hermesc \uBC14\uC774\uB108\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  }
+  return path11.join(hermescPath, REACT_NATIVE_VERSION, getHermesOSBin(), getHermesOSExe());
 }
 
 // src/plugins/utils/compressToGzip.ts
 init_esm_shims();
-import fs2 from "fs";
-import path8 from "path";
+import fs5 from "fs";
 import stream from "stream";
 import util from "util";
 import zlib from "zlib";
 var pipelinePromisify = util.promisify(stream.pipeline);
 async function compressToGzip(options) {
-  const { rootDir, filePath } = options;
-  const inputPath = path8.resolve(rootDir, filePath);
-  const outfile = `${inputPath}.gz`;
-  await pipelinePromisify(fs2.createReadStream(inputPath), zlib.createGzip({ level: 9 }), fs2.createWriteStream(outfile));
+  const { inputPath, outfile } = options;
+  await pipelinePromisify(fs5.createReadStream(inputPath), zlib.createGzip({ level: 9 }), fs5.createWriteStream(outfile));
   return { outfile };
 }
 
 // src/plugins/utils/createCompressedBytecode.ts
-async function createCompressedBytecode(buildResult, { rootDir, reactNativeProjectDir }) {
+async function createCompressedBytecode(buildResult, { outdir }) {
   const { outfile: jsBundle } = buildResult;
   const { outfile: hbcFile } = await compileHbc({
-    reactNativeProjectDir,
-    rootDir,
+    outdir,
     filePath: jsBundle
   });
   const { outfile: gzipFile } = await compressToGzip({
-    rootDir,
-    filePath: hbcFile
+    inputPath: path12.resolve(outdir, hbcFile),
+    outfile: path12.resolve(outdir, `${hbcFile}.gz`)
   });
   return { origin: hbcFile, compressed: gzipFile };
 }
 
 // src/plugins/utils/createManifestWithBuildMeta.ts
 init_esm_shims();
-import * as fs3 from "fs/promises";
-import * as os2 from "os";
-import * as path9 from "path";
+import * as fs6 from "fs/promises";
+import * as os from "os";
+import * as path13 from "path";
 async function createManifestWithBuildMeta(manifest, metadata) {
   const newManifest = { ...manifest, _metadata: metadata };
   const data = JSON.stringify(newManifest, null, 2);
-  const outfile = path9.join(os2.tmpdir(), APP_MANIFEST_NAME);
-  await fs3.writeFile(outfile, data, "utf-8");
+  const outfile = path13.join(os.tmpdir(), APP_MANIFEST_NAME);
+  await fs6.writeFile(outfile, data, "utf-8");
   return outfile;
 }
 
-// src/plugins/utils/getBundleName.ts
-init_esm_shims();
-function normalizeRuntimeVersion(version) {
-  return version.replace(/[^0-9]/g, "_");
-}
-function getBundleName({ platform: platform2, runtime, tag }) {
-  const taggedSuffix = tag ? `-${tag}` : "";
-  return `bundle.${platform2}.${normalizeRuntimeVersion(runtime)}${taggedSuffix}`;
-}
-
-// src/plugins/utils/getRuntimeVersion.ts
-init_esm_shims();
-import assert2 from "assert";
-import * as fs4 from "fs/promises";
-async function getRuntimeVersion(rootDir) {
-  const reactNativePackageJson = __require.resolve("react-native/package.json", { paths: [rootDir] });
-  const rawPackageJson = await fs4.readFile(reactNativePackageJson, "utf-8");
-  const packageJson = JSON.parse(rawPackageJson);
-  assert2(packageJson.version, "invalid react-native version");
-  return packageJson.version;
-}
-
 // src/plugins/utils/loadAppManifest.ts
 init_esm_shims();
-import * as fs5 from "fs/promises";
-import * as path10 from "path";
+import * as fs7 from "fs/promises";
+import * as path14 from "path";
 async function resolveAppManifestPath(rootDir) {
-  const appManifestPath = path10.join(rootDir, ".bedrock", APP_MANIFEST_NAME);
-  await fs5.access(appManifestPath, fs5.constants.F_OK);
+  const appManifestPath = path14.join(rootDir, ".bedrock", APP_MANIFEST_NAME);
+  await fs7.access(appManifestPath, fs7.constants.F_OK);
   return appManifestPath;
 }
 async function loadAppManifest(rootDir) {
   const appJsonPath = await resolveAppManifestPath(rootDir);
-  const appJson = await fs5.readFile(appJsonPath, "utf8");
+  const appJson = await fs7.readFile(appJsonPath, "utf8");
   return JSON.parse(appJson);
 }
 
 // src/plugins/utils/createArtifact.ts
 async function createArtifact({
   buildResults,
-  rootDir,
+  outdir,
   deploymentId,
   webOutDir,
-  reactNativeProjectDir
+  cwd
 }) {
-  const manifest = await loadAppManifest(rootDir);
-  const runtimeVersion = await getRuntimeVersion(reactNativeProjectDir);
+  const manifest = await loadAppManifest(cwd);
   const bundleFiles = await Promise.all(
     buildResults.map(async (buildResult) => {
       const { compressed } = await createCompressedBytecode(buildResult, {
-        rootDir,
-        reactNativeProjectDir
-      });
-      const basename2 = getBundleName({
-        platform: buildResult.platform,
-        runtime: runtimeVersion
+        outdir
       });
-      return { path: compressed, name: `${basename2}.hbc.gz` };
+      return { path: compressed, name: `bundle.${buildResult.platform}.${REACT_NATIVE_VERSION}.hbc.gz` };
     })
   );
   const manifestPath = await createManifestWithBuildMeta(manifest, {
@@ -32787,20 +33031,20 @@ async function createArtifact({
     bundleFiles: bundleFiles.map(({ name }) => name)
   });
   const manifestFile = { path: manifestPath, name: APP_MANIFEST_NAME };
-  const outfile = path11.join(rootDir, `${manifest.appName}.ait`);
+  const outfile = path15.join(cwd, `${manifest.appName}.ait`);
   const webFilesWithPath = [];
   if (webOutDir) {
     try {
-      const allFiles = await fs6.readdir(webOutDir, { recursive: true });
+      const allFiles = await fs8.readdir(webOutDir, { recursive: true });
       const webFiles = await Promise.all(
         allFiles.map(async (file) => {
-          const filePath = path11.join(webOutDir, file);
-          const stat = await fs6.stat(filePath);
+          const filePath = path15.join(webOutDir, file);
+          const stat = await fs8.stat(filePath);
           return stat.isFile() ? file : null;
         })
       ).then((files) => files.filter((file) => file !== null));
       webFilesWithPath.push(
-        ...webFiles.map((file) => ({ path: path11.join(webOutDir, file), name: path11.join("web", file) }))
+        ...webFiles.map((file) => ({ path: path15.join(webOutDir, file), name: path15.join("web", file) }))
       );
     } catch {
     }
@@ -32966,42 +33210,25 @@ function generateDeploymentId() {
   return v7_default();
 }
 
-// src/plugins/utils/getPackageRoot.ts
-init_esm_shims();
-import fs7 from "fs";
-import path12 from "path";
-function getPackageRoot() {
-  let cwd = process.cwd();
-  const root = path12.parse(cwd).root;
-  while (cwd !== root) {
-    if (fs7.existsSync(path12.join(cwd, "package.json"))) {
-      return cwd;
-    }
-    cwd = path12.dirname(cwd);
-  }
-  return cwd;
-}
-
 // src/plugins/appsInToss.ts
 function appsInTossCreateArtifact(deploymentId) {
-  const packageRoot = getPackageRoot();
   return {
     name: "apps-in-toss:create-artifact",
     build: {
       order: "post",
       handler: async ({ buildResults, cwd, outdir }) => {
-        const webDistDir = path13.join(outdir, "web");
+        const webDistDir = path16.join(outdir, "web");
         const artifactOutfile = await createArtifact({
           buildResults,
           deploymentId,
-          rootDir: packageRoot,
-          reactNativeProjectDir: cwd,
-          webOutDir: webDistDir
+          outdir,
+          webOutDir: webDistDir,
+          cwd
         });
         if (!artifactOutfile) {
           throw new Error("\uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uC5D0 \uC2E4\uD328\uD588\uC5B4\uC694.");
         }
-        const filename = path13.basename(artifactOutfile);
+        const filename = path16.basename(artifactOutfile);
         console.log(`\u2705 ${import_picocolors.default.green(`${filename}`)} \uBE4C\uB4DC \uC644\uB8CC`);
       }
     }
@@ -33055,20 +33282,24 @@ function appsInTossDevServer(options) {
 async function appsInTossAppJson(options) {
   const packageRoot = getPackageRoot();
   const handleAppJson = async (appName) => {
-    const appJsonPath = path13.join(packageRoot, ".bedrock", APP_MANIFEST_NAME);
+    const appJsonPath = path16.join(packageRoot, ".bedrock", APP_MANIFEST_NAME);
     const appJsonObject = {
       appName,
       permissions: options.permissions,
       oauth: options.oauth
     };
-    await fs8.promises.mkdir(path13.dirname(appJsonPath), { recursive: true });
+    await fs9.promises.mkdir(path16.dirname(appJsonPath), { recursive: true });
     try {
-      const existingAppJson = await fs8.promises.readFile(appJsonPath, "utf8");
+      const existingAppJson = await fs9.promises.readFile(appJsonPath, "utf8");
       const existingAppJsonObject = JSON.parse(existingAppJson);
-      Object.assign(appJsonObject, existingAppJsonObject, { appName, permissions: appJsonObject.permissions });
+      Object.assign(appJsonObject, existingAppJsonObject, {
+        appName,
+        permissions: appJsonObject.permissions,
+        oauth: appJsonObject.oauth
+      });
     } catch (error) {
     }
-    await fs8.promises.writeFile(appJsonPath, JSON.stringify(appJsonObject, null, 2), "utf8");
+    await fs9.promises.writeFile(appJsonPath, JSON.stringify(appJsonObject, null, 2), "utf8");
   };
   return {
     name: "apps-in-toss:app-json",