npm - microfox - Versions diffs - 1.2.0 → 1.2.1 - Mend

microfox 1.2.0 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/cli.mjs CHANGED Viewed

@@ -8885,11 +8885,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path11) {
-      if (!path11 || typeof path11 !== "string") {
+    function lookup(path12) {
+      if (!path12 || typeof path12 !== "string") {
         return false;
       }
-      var extension2 = extname("x." + path11).toLowerCase().substr(1);
+      var extension2 = extname("x." + path12).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -10004,11 +10004,11 @@ var require_form_data = __commonJS({
     "use strict";
     var CombinedStream = require_combined_stream();
     var util3 = __require("util");
-    var path11 = __require("path");
+    var path12 = __require("path");
     var http2 = __require("http");
     var https2 = __require("https");
     var parseUrl = __require("url").parse;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var Stream = __require("stream").Stream;
     var crypto2 = __require("crypto");
     var mime = require_mime_types();
@@ -10075,7 +10075,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs9.stat(value.path, function(err, stat) {
+          fs10.stat(value.path, function(err, stat) {
             if (err) {
               callback(err);
               return;
@@ -10132,11 +10132,11 @@ var require_form_data = __commonJS({
     FormData4.prototype._getContentDisposition = function(value, options) {
       var filename;
       if (typeof options.filepath === "string") {
-        filename = path11.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path12.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value && (value.name || value.path)) {
-        filename = path11.basename(options.filename || value && (value.name || value.path));
+        filename = path12.basename(options.filename || value && (value.name || value.path));
       } else if (value && value.readable && hasOwn(value, "httpVersion")) {
-        filename = path11.basename(value.client._httpMessage.path || "");
+        filename = path12.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
         return 'filename="' + filename + '"';
@@ -12644,7 +12644,7 @@ var require_braces = __commonJS({
 var require_constants2 = __commonJS({
   "../../node_modules/picomatch/lib/constants.js"(exports, module) {
     "use strict";
-    var path11 = __require("path");
+    var path12 = __require("path");
     var WIN_SLASH = "\\\\/";
     var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
     var DOT_LITERAL = "\\.";
@@ -12814,7 +12814,7 @@ var require_constants2 = __commonJS({
       /* | */
       CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
       /* \uFEFF */
-      SEP: path11.sep,
+      SEP: path12.sep,
       /**
        * Create EXTGLOB_CHARS
        */
@@ -12841,7 +12841,7 @@ var require_constants2 = __commonJS({
 var require_utils2 = __commonJS({
   "../../node_modules/picomatch/lib/utils.js"(exports) {
     "use strict";
-    var path11 = __require("path");
+    var path12 = __require("path");
     var win32 = process.platform === "win32";
     var {
       REGEX_BACKSLASH,
@@ -12870,7 +12870,7 @@ var require_utils2 = __commonJS({
       if (options && typeof options.windows === "boolean") {
         return options.windows;
       }
-      return win32 === true || path11.sep === "\\";
+      return win32 === true || path12.sep === "\\";
     };
     exports.escapeLast = (input, char, lastIdx) => {
       const idx = input.lastIndexOf(char, lastIdx);
@@ -14005,7 +14005,7 @@ var require_parse2 = __commonJS({
 var require_picomatch = __commonJS({
   "../../node_modules/picomatch/lib/picomatch.js"(exports, module) {
     "use strict";
-    var path11 = __require("path");
+    var path12 = __require("path");
     var scan = require_scan();
     var parse = require_parse2();
     var utils = require_utils2();
@@ -14090,7 +14090,7 @@ var require_picomatch = __commonJS({
     };
     picomatch.matchBase = (input, glob2, options, posix = utils.isWindows(options)) => {
       const regex = glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options);
-      return regex.test(path11.basename(input));
+      return regex.test(path12.basename(input));
     };
     picomatch.isMatch = (str2, patterns, options) => picomatch(patterns, options)(str2);
     picomatch.parse = (pattern, options) => {
@@ -14483,8 +14483,8 @@ var require_minimatch = __commonJS({
       return new Minimatch(pattern, options).match(p);
     };
     module.exports = minimatch;
-    var path11 = require_path();
-    minimatch.sep = path11.sep;
+    var path12 = require_path();
+    minimatch.sep = path12.sep;
     var GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     var expand = require_brace_expansion2();
@@ -14993,8 +14993,8 @@ var require_minimatch = __commonJS({
         if (this.empty) return f === "";
         if (f === "/" && partial) return true;
         const options = this.options;
-        if (path11.sep !== "/") {
-          f = f.split(path11.sep).join("/");
+        if (path12.sep !== "/") {
+          f = f.split(path12.sep).join("/");
         }
         f = f.split(slashSplit);
         this.debug(this.pattern, "split", f);
@@ -15033,13 +15033,13 @@ var require_readdir_glob = __commonJS({
   "../../node_modules/readdir-glob/index.js"(exports, module) {
     "use strict";
     module.exports = readdirGlob;
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var { EventEmitter: EventEmitter2 } = __require("events");
     var { Minimatch } = require_minimatch();
     var { resolve: resolve3 } = __require("path");
     function readdir(dir2, strict) {
       return new Promise((resolve4, reject2) => {
-        fs9.readdir(dir2, { withFileTypes: true }, (err, files) => {
+        fs10.readdir(dir2, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -15072,7 +15072,7 @@ var require_readdir_glob = __commonJS({
     }
     function stat(file, followSymlinks) {
       return new Promise((resolve4, reject2) => {
-        const statFunc = followSymlinks ? fs9.stat : fs9.lstat;
+        const statFunc = followSymlinks ? fs10.stat : fs10.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -15093,8 +15093,8 @@ var require_readdir_glob = __commonJS({
         });
       });
     }
-    async function* exploreWalkAsync(dir2, path11, followSymlinks, useStat, shouldSkip, strict) {
-      let files = await readdir(path11 + dir2, strict);
+    async function* exploreWalkAsync(dir2, path12, followSymlinks, useStat, shouldSkip, strict) {
+      let files = await readdir(path12 + dir2, strict);
       for (const file of files) {
         let name = file.name;
         if (name === void 0) {
@@ -15103,7 +15103,7 @@ var require_readdir_glob = __commonJS({
         }
         const filename = dir2 + "/" + name;
         const relative = filename.slice(1);
-        const absolute = path11 + "/" + relative;
+        const absolute = path12 + "/" + relative;
         let stats = null;
         if (useStat || followSymlinks) {
           stats = await stat(absolute, followSymlinks);
@@ -15117,15 +15117,15 @@ var require_readdir_glob = __commonJS({
         if (stats.isDirectory()) {
           if (!shouldSkip(relative)) {
             yield { relative, absolute, stats };
-            yield* exploreWalkAsync(filename, path11, followSymlinks, useStat, shouldSkip, false);
+            yield* exploreWalkAsync(filename, path12, followSymlinks, useStat, shouldSkip, false);
           }
         } else {
           yield { relative, absolute, stats };
         }
       }
     }
-    async function* explore(path11, followSymlinks, useStat, shouldSkip) {
-      yield* exploreWalkAsync("", path11, followSymlinks, useStat, shouldSkip, true);
+    async function* explore(path12, followSymlinks, useStat, shouldSkip) {
+      yield* exploreWalkAsync("", path12, followSymlinks, useStat, shouldSkip, true);
     }
     function readOptions(options) {
       return {
@@ -17135,54 +17135,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs9) {
+    function patch(fs10) {
       if (constants.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(path11, 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(path12, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs10.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path11, uid, gid, cb) {
+      if (fs10.chown && !fs10.lchown) {
+        fs10.lchown = function(path12, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs10.lchownSync = function() {
         };
       }
       if (platform === "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
@@ -17198,9 +17198,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") {
@@ -17208,22 +17208,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++;
@@ -17233,11 +17233,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path11, mode, callback) {
-          fs10.open(
-            path11,
+      }(fs10.readSync);
+      function patchLchmod(fs11) {
+        fs11.lchmod = function(path12, mode, callback) {
+          fs11.open(
+            path12,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -17245,80 +17245,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(path11, mode) {
-          var fd = fs10.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs11.lchmodSync = function(path12, mode) {
+          var fd = fs11.openSync(path12, constants.O_WRONLY | constants.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 (constants.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path11, at, mt, cb) {
-            fs10.open(path11, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs11) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
+          fs11.lutimes = function(path12, at, mt, cb) {
+            fs11.open(path12, constants.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(path11, at, mt) {
-            var fd = fs10.openSync(path11, constants.O_SYMLINK);
+          fs11.lutimesSync = function(path12, at, mt) {
+            var fd = fs11.openSync(path12, constants.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);
           });
@@ -17328,7 +17328,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;
           }
@@ -17337,7 +17337,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);
           });
@@ -17347,7 +17347,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;
           }
@@ -17367,13 +17367,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;
@@ -17403,16 +17403,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs10) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path11, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path11, options);
+      function ReadStream(path12, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path12, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path11;
+        this.path = path12;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -17446,7 +17446,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;
@@ -17457,10 +17457,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path11, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path11, options);
+      function WriteStream(path12, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path12, options);
         Stream.call(this);
-        this.path = path11;
+        this.path = path12;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -17485,7 +17485,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();
         }
@@ -17521,7 +17521,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -17553,12 +17553,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();
             }
@@ -17570,48 +17570,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 = createReadStream2;
-      fs10.createWriteStream = createWriteStream2;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile;
-      function readFile(path11, 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 = createReadStream2;
+      fs11.createWriteStream = createWriteStream2;
+      var fs$readFile = fs11.readFile;
+      fs11.readFile = readFile;
+      function readFile(path12, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path11, options, cb);
-        function go$readFile(path12, options2, cb2, startTime) {
-          return fs$readFile(path12, options2, function(err) {
+        return go$readFile(path12, options, cb);
+        function go$readFile(path13, options2, cb2, startTime) {
+          return fs$readFile(path13, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path12, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path13, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -17619,16 +17619,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile;
-      function writeFile(path11, data, options, cb) {
+      var fs$writeFile = fs11.writeFile;
+      fs11.writeFile = writeFile;
+      function writeFile(path12, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path11, data, options, cb);
-        function go$writeFile(path12, data2, options2, cb2, startTime) {
-          return fs$writeFile(path12, data2, options2, function(err) {
+        return go$writeFile(path12, data, options, cb);
+        function go$writeFile(path13, data2, options2, cb2, startTime) {
+          return fs$writeFile(path13, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path13, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -17636,17 +17636,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs11.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
-      function appendFile(path11, data, options, cb) {
+        fs11.appendFile = appendFile;
+      function appendFile(path12, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path11, data, options, cb);
-        function go$appendFile(path12, data2, options2, cb2, startTime) {
-          return fs$appendFile(path12, data2, options2, function(err) {
+        return go$appendFile(path12, data, options, cb);
+        function go$appendFile(path13, data2, options2, cb2, startTime) {
+          return fs$appendFile(path13, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path13, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -17654,9 +17654,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;
@@ -17674,34 +17674,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(path11, options, cb) {
+      function readdir(path12, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, fs$readdirCallback(
-            path12,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path13, options2, cb2, startTime) {
+          return fs$readdir(path13, fs$readdirCallback(
+            path13,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, options2, fs$readdirCallback(
-            path12,
+        } : function go$readdir2(path13, options2, cb2, startTime) {
+          return fs$readdir(path13, options2, fs$readdirCallback(
+            path13,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path11, options, cb);
-        function fs$readdirCallback(path12, options2, cb2, startTime) {
+        return go$readdir(path12, options, cb);
+        function fs$readdirCallback(path13, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path12, options2, cb2],
+                [path13, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -17716,21 +17716,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;
         },
@@ -17740,7 +17740,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs11, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -17751,7 +17751,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs11, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -17762,7 +17762,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs11, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -17772,7 +17772,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path11, options) {
+      function ReadStream(path12, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -17792,7 +17792,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path11, options) {
+      function WriteStream(path12, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -17810,22 +17810,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream2(path11, options) {
-        return new fs10.ReadStream(path11, options);
+      function createReadStream2(path12, options) {
+        return new fs11.ReadStream(path12, options);
       }
-      function createWriteStream2(path11, options) {
-        return new fs10.WriteStream(path11, options);
+      function createWriteStream2(path12, options) {
+        return new fs11.WriteStream(path12, options);
       }
-      var fs$open = fs10.open;
-      fs10.open = open;
-      function open(path11, flags, mode, cb) {
+      var fs$open = fs11.open;
+      fs11.open = open;
+      function open(path12, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path11, flags, mode, cb);
-        function go$open(path12, flags2, mode2, cb2, startTime) {
-          return fs$open(path12, flags2, mode2, function(err, fd) {
+        return go$open(path12, flags, mode, cb);
+        function go$open(path13, flags2, mode2, cb2, startTime) {
+          return fs$open(path13, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path12, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path13, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -17833,20 +17833,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 i = 0; i < fs9[gracefulQueue].length; ++i) {
-        if (fs9[gracefulQueue][i].length > 2) {
-          fs9[gracefulQueue][i][3] = now;
-          fs9[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs10[gracefulQueue].length; ++i) {
+        if (fs10[gracefulQueue][i].length > 2) {
+          fs10[gracefulQueue][i][3] = now;
+          fs10[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -17854,9 +17854,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];
@@ -17878,7 +17878,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) {
@@ -18140,7 +18140,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join4(s) {
+      BufferList.prototype.join = function join5(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -19885,22 +19885,22 @@ var require_lazystream = __commonJS({
 var require_normalize_path = __commonJS({
   "../../node_modules/normalize-path/index.js"(exports, module) {
     "use strict";
-    module.exports = function(path11, stripTrailing) {
-      if (typeof path11 !== "string") {
+    module.exports = function(path12, stripTrailing) {
+      if (typeof path12 !== "string") {
         throw new TypeError("expected path to be a string");
       }
-      if (path11 === "\\" || path11 === "/") return "/";
-      var len = path11.length;
-      if (len <= 1) return path11;
+      if (path12 === "\\" || path12 === "/") return "/";
+      var len = path12.length;
+      if (len <= 1) return path12;
       var prefix = "";
-      if (len > 4 && path11[3] === "\\") {
-        var ch = path11[2];
-        if ((ch === "?" || ch === ".") && path11.slice(0, 2) === "\\\\") {
-          path11 = path11.slice(2);
+      if (len > 4 && path12[3] === "\\") {
+        var ch = path12[2];
+        if ((ch === "?" || ch === ".") && path12.slice(0, 2) === "\\\\") {
+          path12 = path12.slice(2);
           prefix = "//";
         }
       }
-      var segs = path11.split(/[/\\]+/);
+      var segs = path12.split(/[/\\]+/);
       if (stripTrailing !== false && segs[segs.length - 1] === "") {
         segs.pop();
       }
@@ -28427,11 +28427,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 path11 = {
+    var path12 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    exports.sep = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
+    exports.sep = defaultPlatform === "win32" ? path12.win32.sep : path12.posix.sep;
     exports.minimatch.sep = exports.sep;
     exports.GLOBSTAR = Symbol("globstar **");
     exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
@@ -31752,13 +31752,13 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path11) {
+      resolve(path12) {
         var _a;
-        if (!path11) {
+        if (!path12) {
           return this;
         }
-        const rootPath = this.getRootString(path11);
-        const dir2 = path11.substring(rootPath.length);
+        const rootPath = this.getRootString(path12);
+        const dir2 = path12.substring(rootPath.length);
         const dirParts = dir2.split(this.splitSep);
         const result = rootPath ? __privateMethod(_a = this.getRoot(rootPath), _PathBase_instances, resolveParts_fn).call(_a, dirParts) : __privateMethod(this, _PathBase_instances, resolveParts_fn).call(this, dirParts);
         return result;
@@ -32547,8 +32547,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path11) {
-        return node_path_1.win32.parse(path11).root;
+      getRootString(path12) {
+        return node_path_1.win32.parse(path12).root;
       }
       /**
        * @internal
@@ -32595,8 +32595,8 @@ var require_commonjs4 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path11) {
-        return path11.startsWith("/") ? "/" : "";
+      getRootString(path12) {
+        return path12.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -32621,7 +32621,7 @@ var require_commonjs4 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs9 = defaultFS } = {}) {
+      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs10 = defaultFS } = {}) {
         /**
          * The root Path entry for the current working directory of this Scurry
          */
@@ -32648,7 +32648,7 @@ var require_commonjs4 = __commonJS({
          */
         __publicField(this, "nocase");
         __privateAdd(this, _fs2);
-        __privateSet(this, _fs2, fsFromOption(fs9));
+        __privateSet(this, _fs2, fsFromOption(fs10));
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -32687,11 +32687,11 @@ var require_commonjs4 = __commonJS({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path11 = this.cwd) {
-        if (typeof path11 === "string") {
-          path11 = this.cwd.resolve(path11);
+      depth(path12 = this.cwd) {
+        if (typeof path12 === "string") {
+          path12 = this.cwd.resolve(path12);
         }
-        return path11.depth();
+        return path12.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -33178,9 +33178,9 @@ var require_commonjs4 = __commonJS({
         process3();
         return results;
       }
-      chdir(path11 = this.cwd) {
+      chdir(path12 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path11 === "string" ? this.cwd.resolve(path11) : path11;
+        this.cwd = typeof path12 === "string" ? this.cwd.resolve(path12) : path12;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -33211,8 +33211,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
@@ -33241,8 +33241,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
@@ -33587,8 +33587,8 @@ var require_processor = __commonJS({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path11, n]) => [
-          path11,
+        return [...this.store.entries()].map(([path12, n]) => [
+          path12,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -33797,7 +33797,7 @@ var require_walker = __commonJS({
     var makeIgnore = (ignore, opts) => typeof ignore === "string" ? new ignore_js_1.Ignore([ignore], opts) : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts) : ignore;
     var _onResume, _ignore, _sep, _GlobUtil_instances, ignored_fn, childrenIgnored_fn;
     var GlobUtil = class {
-      constructor(patterns, path11, opts) {
+      constructor(patterns, path12, opts) {
         __privateAdd(this, _GlobUtil_instances);
         __publicField(this, "path");
         __publicField(this, "patterns");
@@ -33813,7 +33813,7 @@ var require_walker = __commonJS({
         __publicField(this, "includeChildMatches");
         var _a;
         this.patterns = patterns;
-        this.path = path11;
+        this.path = path12;
         this.opts = opts;
         __privateSet(this, _sep, !opts.posix && opts.platform === "win32" ? "\\" : "/");
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -34055,18 +34055,18 @@ var require_walker = __commonJS({
     _ignore = new WeakMap();
     _sep = new WeakMap();
     _GlobUtil_instances = new WeakSet();
-    ignored_fn = function(path11) {
+    ignored_fn = function(path12) {
       var _a, _b;
-      return this.seen.has(path11) || !!((_b = (_a = __privateGet(this, _ignore)) == null ? void 0 : _a.ignored) == null ? void 0 : _b.call(_a, path11));
+      return this.seen.has(path12) || !!((_b = (_a = __privateGet(this, _ignore)) == null ? void 0 : _a.ignored) == null ? void 0 : _b.call(_a, path12));
     };
-    childrenIgnored_fn = function(path11) {
+    childrenIgnored_fn = function(path12) {
       var _a, _b;
-      return !!((_b = (_a = __privateGet(this, _ignore)) == null ? void 0 : _a.childrenIgnored) == null ? void 0 : _b.call(_a, path11));
+      return !!((_b = (_a = __privateGet(this, _ignore)) == null ? void 0 : _a.childrenIgnored) == null ? void 0 : _b.call(_a, path12));
     };
     exports.GlobUtil = GlobUtil;
     var GlobWalker = class extends GlobUtil {
-      constructor(patterns, path11, opts) {
-        super(patterns, path11, opts);
+      constructor(patterns, path12, opts) {
+        super(patterns, path12, opts);
         __publicField(this, "matches", /* @__PURE__ */ new Set());
       }
       matchEmit(e) {
@@ -34108,8 +34108,8 @@ var require_walker = __commonJS({
     };
     exports.GlobWalker = GlobWalker;
     var GlobStream = class extends GlobUtil {
-      constructor(patterns, path11, opts) {
-        super(patterns, path11, opts);
+      constructor(patterns, path12, opts) {
+        super(patterns, path12, opts);
         __publicField(this, "results");
         this.results = new minipass_1.Minipass({
           signal: this.signal,
@@ -34466,8 +34466,8 @@ var require_commonjs5 = __commonJS({
 var require_file = __commonJS({
   "node_modules/archiver-utils/file.js"(exports, module) {
     "use strict";
-    var fs9 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs10 = require_graceful_fs();
+    var path12 = __require("path");
     var flatten = require_flatten();
     var difference = require_difference();
     var union = require_union();
@@ -34492,8 +34492,8 @@ var require_file = __commonJS({
       return result;
     };
     file.exists = function() {
-      var filepath = path11.join.apply(path11, arguments);
-      return fs9.existsSync(filepath);
+      var filepath = path12.join.apply(path12, arguments);
+      return fs10.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options = isPlainObject2(args[0]) ? args.shift() : {};
@@ -34506,12 +34506,12 @@ var require_file = __commonJS({
       });
       if (options.filter) {
         matches = matches.filter(function(filepath) {
-          filepath = path11.join(options.cwd || "", filepath);
+          filepath = path12.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;
@@ -34523,7 +34523,7 @@ var require_file = __commonJS({
     file.expandMapping = function(patterns, destBase, options) {
       options = Object.assign({
         rename: function(destBase2, destPath) {
-          return path11.join(destBase2 || "", destPath);
+          return path12.join(destBase2 || "", destPath);
         }
       }, options);
       var files = [];
@@ -34531,14 +34531,14 @@ var require_file = __commonJS({
       file.expand(options, patterns).forEach(function(src) {
         var destPath = src;
         if (options.flatten) {
-          destPath = path11.basename(destPath);
+          destPath = path12.basename(destPath);
         }
         if (options.ext) {
           destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
         }
         var dest = options.rename(destBase, destPath, options);
         if (options.cwd) {
-          src = path11.join(options.cwd, src);
+          src = path12.join(options.cwd, src);
         }
         dest = dest.replace(pathSeparatorRe, "/");
         src = src.replace(pathSeparatorRe, "/");
@@ -34620,8 +34620,8 @@ var require_file = __commonJS({
 var require_archiver_utils = __commonJS({
   "node_modules/archiver-utils/index.js"(exports, module) {
     "use strict";
-    var fs9 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs10 = require_graceful_fs();
+    var path12 = __require("path");
     var isStream2 = require_is_stream();
     var lazystream = require_lazystream();
     var normalizePath = require_normalize_path();
@@ -34669,7 +34669,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) {
@@ -34697,7 +34697,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs9.readdir(dirpath, function(err, list) {
+      fs10.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -34709,11 +34709,11 @@ var require_archiver_utils = __commonJS({
           if (!file) {
             return callback(null, results);
           }
-          filepath = path11.join(dirpath, file);
-          fs9.stat(filepath, function(err2, stats) {
+          filepath = path12.join(dirpath, file);
+          fs10.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
-              relative: path11.relative(base, filepath).replace(/\\/g, "/"),
+              relative: path12.relative(base, filepath).replace(/\\/g, "/"),
               stats
             });
             if (stats && stats.isDirectory()) {
@@ -34774,10 +34774,10 @@ var require_error = __commonJS({
 var require_core = __commonJS({
   "node_modules/archiver/lib/core.js"(exports, module) {
     "use strict";
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var glob2 = require_readdir_glob();
     var async = (init_async(), __toCommonJS(async_exports));
-    var path11 = __require("path");
+    var path12 = __require("path");
     var util3 = require_archiver_utils();
     var inherits2 = __require("util").inherits;
     var ArchiverError = require_error();
@@ -34838,7 +34838,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) {
@@ -35009,7 +35009,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;
@@ -35052,10 +35052,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 = path11.dirname(task.filepath);
+        var linkPath = fs10.readlinkSync(task.filepath);
+        var dirName = path12.dirname(task.filepath);
         task.data.type = "symlink";
-        task.data.linkname = path11.relative(dirName, path11.resolve(dirName, linkPath));
+        task.data.linkname = path12.relative(dirName, path12.resolve(dirName, linkPath));
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else {
@@ -39935,14 +39935,14 @@ var require_util5 = __commonJS({
         }
         const port = url2.port != null ? url2.port : url2.protocol === "https:" ? 443 : 80;
         let origin2 = url2.origin != null ? url2.origin : `${url2.protocol}//${url2.hostname}:${port}`;
-        let path11 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
+        let path12 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
         if (origin2.endsWith("/")) {
           origin2 = origin2.substring(0, origin2.length - 1);
         }
-        if (path11 && !path11.startsWith("/")) {
-          path11 = `/${path11}`;
+        if (path12 && !path12.startsWith("/")) {
+          path12 = `/${path12}`;
         }
-        url2 = new URL(origin2 + path11);
+        url2 = new URL(origin2 + path12);
       }
       return url2;
     }
@@ -41556,20 +41556,20 @@ var require_parseParams = __commonJS({
 var require_basename = __commonJS({
   "../../node_modules/@fastify/busboy/lib/utils/basename.js"(exports, module) {
     "use strict";
-    module.exports = function basename2(path11) {
-      if (typeof path11 !== "string") {
+    module.exports = function basename2(path12) {
+      if (typeof path12 !== "string") {
         return "";
       }
-      for (var i = path11.length - 1; i >= 0; --i) {
-        switch (path11.charCodeAt(i)) {
+      for (var i = path12.length - 1; i >= 0; --i) {
+        switch (path12.charCodeAt(i)) {
           case 47:
           // '/'
           case 92:
-            path11 = path11.slice(i + 1);
-            return path11 === ".." || path11 === "." ? "" : path11;
+            path12 = path12.slice(i + 1);
+            return path12 === ".." || path12 === "." ? "" : path12;
         }
       }
-      return path11 === ".." || path11 === "." ? "" : path11;
+      return path12 === ".." || path12 === "." ? "" : path12;
     };
   }
 });
@@ -44611,7 +44611,7 @@ var require_request = __commonJS({
     }
     var Request2 = class _Request {
       constructor(origin2, {
-        path: path11,
+        path: path12,
         method,
         body,
         headers,
@@ -44625,11 +44625,11 @@ var require_request = __commonJS({
         throwOnError,
         expectContinue
       }, handler) {
-        if (typeof path11 !== "string") {
+        if (typeof path12 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path11[0] !== "/" && !(path11.startsWith("http://") || path11.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path12[0] !== "/" && !(path12.startsWith("http://") || path12.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.exec(path11) !== null) {
+        } else if (invalidPathRegex.exec(path12) !== null) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -44692,7 +44692,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? util3.buildURL(path11, query) : path11;
+        this.path = query ? util3.buildURL(path12, query) : path12;
         this.origin = origin2;
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
         this.blocking = blocking == null ? false : blocking;
@@ -45700,9 +45700,9 @@ var require_RedirectHandler = __commonJS({
           return this.handler.onHeaders(statusCode, headers, resume, statusText);
         }
         const { origin: origin2, pathname, search } = util3.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path11 = search ? `${pathname}${search}` : pathname;
+        const path12 = search ? `${pathname}${search}` : pathname;
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin2);
-        this.opts.path = path11;
+        this.opts.path = path12;
         this.opts.origin = origin2;
         this.opts.maxRedirections = 0;
         this.opts.query = null;
@@ -46944,7 +46944,7 @@ var require_client = __commonJS({
         writeH2(client, client[kHTTP2Session], request);
         return;
       }
-      const { body, method, path: path11, host, upgrade, headers, blocking, reset } = request;
+      const { body, method, path: path12, host, upgrade, headers, blocking, reset } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
         body.read(0);
@@ -46994,7 +46994,7 @@ var require_client = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
-      let header = `${method} ${path11} HTTP/1.1\r
+      let header = `${method} ${path12} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -47057,7 +47057,7 @@ upgrade: ${upgrade}\r
       return true;
     }
     function writeH2(client, session, request) {
-      const { body, method, path: path11, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
+      const { body, method, path: path12, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
       let headers;
       if (typeof reqHeaders === "string") headers = Request2[kHTTP2CopyHeaders](reqHeaders.trim());
       else headers = reqHeaders;
@@ -47100,7 +47100,7 @@ upgrade: ${upgrade}\r
         });
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path11;
+      headers[HTTP2_HEADER_PATH] = path12;
       headers[HTTP2_HEADER_SCHEME] = "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -49343,20 +49343,20 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
-    function safeUrl(path11) {
-      if (typeof path11 !== "string") {
-        return path11;
+    function safeUrl(path12) {
+      if (typeof path12 !== "string") {
+        return path12;
       }
-      const pathSegments = path11.split("?");
+      const pathSegments = path12.split("?");
       if (pathSegments.length !== 2) {
-        return path11;
+        return path12;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path11, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path11);
+    function matchKey(mockDispatch2, { path: path12, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path12);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -49374,7 +49374,7 @@ var require_mock_utils = __commonJS({
     function getMockDispatch(mockDispatches, key) {
       const basePath = key.query ? buildURL2(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path11 }) => matchValue(safeUrl(path11), resolvedPath));
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path12 }) => matchValue(safeUrl(path12), resolvedPath));
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
       }
@@ -49411,9 +49411,9 @@ var require_mock_utils = __commonJS({
       }
     }
     function buildKey(opts) {
-      const { path: path11, method, body, headers, query } = opts;
+      const { path: path12, method, body, headers, query } = opts;
       return {
-        path: path11,
+        path: path12,
         method,
         body,
         headers,
@@ -49862,10 +49862,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path11, data: { statusCode }, persist, times: times2, timesInvoked, origin: origin2 }) => ({
+          ({ method, path: path12, data: { statusCode }, persist, times: times2, timesInvoked, origin: origin2 }) => ({
             Method: method,
             Origin: origin2,
-            Path: path11,
+            Path: path12,
             "Status code": statusCode,
             Persistent: persist ? "\u2705" : "\u274C",
             Invocations: timesInvoked,
@@ -54512,8 +54512,8 @@ var require_util10 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path11) {
-      for (const char of path11) {
+    function validateCookiePath(path12) {
+      for (const char of path12) {
         const code = char.charCodeAt(0);
         if (code < 33 || char === ";") {
           throw new Error("Invalid cookie path");
@@ -56222,11 +56222,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path11 = opts.path;
+          let path12 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path11 = `/${path11}`;
+            path12 = `/${path12}`;
           }
-          url2 = new URL(util3.parseOrigin(url2).origin + path11);
+          url2 = new URL(util3.parseOrigin(url2).origin + path12);
         } else {
           if (!opts) {
             opts = typeof url2 === "object" ? url2 : {};
@@ -56764,9 +56764,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path11, key, dots) {
-  if (!path11) return key;
-  return path11.concat(key).map(function each2(token, i) {
+function renderKey(path12, key, dots) {
+  if (!path12) return key;
+  return path12.concat(key).map(function each2(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -56814,9 +56814,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path11) {
+  function defaultVisitor(value, key, path12) {
     let arr = value;
-    if (value && !path11 && typeof value === "object") {
+    if (value && !path12 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -56835,7 +56835,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path11, key, dots), convertValue(value));
+    formData.append(renderKey(path12, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -56844,10 +56844,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path11) {
+  function build(value, path12) {
     if (utils_default.isUndefined(value)) return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path11.join("."));
+      throw Error("Circular reference detected in " + path12.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each2(el, key) {
@@ -56855,11 +56855,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path11,
+        path12,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path11 ? path11.concat(key) : [key]);
+        build(el, path12 ? path12.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -57071,7 +57071,7 @@ var platform_default = {
 // ../../node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams(), Object.assign({
-    visitor: function(value, key, path11, helpers) {
+    visitor: function(value, key, path12, helpers) {
       if (platform_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -57100,11 +57100,11 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path11, value, target, index2) {
-    let name = path11[index2++];
+  function buildPath(path12, value, target, index2) {
+    let name = path12[index2++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index2 >= path11.length;
+    const isLast = index2 >= path12.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -57117,7 +57117,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path11, value, target[name], index2);
+    const result = buildPath(path12, value, target[name], index2);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -58252,9 +58252,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path11;
+    let path12;
     try {
-      path11 = buildURL(
+      path12 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -58272,7 +58272,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path: path11,
+      path: path12,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -58502,10 +58502,10 @@ var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PUR
 var cookies_default = platform_default.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
-    write(name, value, expires, path11, domain, secure) {
+    write(name, value, expires, path12, domain, secure) {
       const cookie = [name + "=" + encodeURIComponent(value)];
       utils_default.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
-      utils_default.isString(path11) && cookie.push("path=" + path11);
+      utils_default.isString(path12) && cookie.push("path=" + path12);
       utils_default.isString(domain) && cookie.push("domain=" + domain);
       secure === true && cookie.push("secure");
       document.cookie = cookie.join("; ");
@@ -61206,7 +61206,7 @@ var kickstartCommand = new Command("kickstart").description("Kickstart a new Mic
 });
 // package.json
-var version = "1.2.0";
+var version = "1.2.1";
 // src/commands/track.ts
 var track = new Command("track").description("Run tracker scripts locally.").option("--file <path>", "Run a single tracker file instead of all.").action(async (options) => {
@@ -63995,17 +63995,17 @@ var ESC_1_RE = /~1/g;
 var TS_UNION_INTERSECTION_RE = /[&|]/;
 var TS_READONLY_RE = /^readonly\s+/;
 var JS_OBJ_KEY = /^(\d+|[A-Za-z_$][A-Za-z0-9_$]*)$/;
-function walk(obj, cb, path11 = []) {
+function walk(obj, cb, path12 = []) {
   if (!obj || typeof obj !== "object")
     return;
   if (Array.isArray(obj)) {
     for (let i = 0; i < obj.length; i++)
-      walk(obj[i], cb, path11.concat(i));
+      walk(obj[i], cb, path12.concat(i));
     return;
   }
-  cb(obj, path11);
+  cb(obj, path12);
   for (const k of Object.keys(obj))
-    walk(obj[k], cb, path11.concat(k));
+    walk(obj[k], cb, path12.concat(k));
 }
 function getSchemaObjectComment(v, indentLv) {
   if (!v || typeof v !== "object")
@@ -64060,23 +64060,23 @@ function parseRef(ref) {
   if (ref.includes("#/")) {
     const [filename, pathStr] = ref.split("#");
     const parts = pathStr.split("/");
-    const path11 = [];
+    const path12 = [];
     for (const part of parts) {
       if (!part || part === "properties")
         continue;
-      path11.push(decodeRef(part));
+      path12.push(decodeRef(part));
     }
-    return { filename: filename || ".", path: path11 };
+    return { filename: filename || ".", path: path12 };
   } else if (ref.includes('["')) {
     const parts = ref.split('["');
-    const path11 = [];
+    const path12 = [];
     for (const part of parts) {
       const sanitized = part.replace('"]', "").trim();
       if (!sanitized || sanitized === "properties")
         continue;
-      path11.push(sanitized);
+      path12.push(sanitized);
     }
-    return { filename: ".", path: path11 };
+    return { filename: ".", path: path12 };
   }
   return { filename: ref, path: [] };
 }
@@ -64393,124 +64393,124 @@ function relativePath(src, dest) {
   }
   return dest.href;
 }
-function getHint({ path: path11, external, startFrom }) {
+function getHint({ path: path12, external, startFrom }) {
   if (startFrom && startFrom !== "OpenAPI3") {
     switch (startFrom) {
       case "OperationObject":
-        return getHintFromOperationObject(path11, external);
+        return getHintFromOperationObject(path12, external);
       case "RequestBodyObject":
-        return getHintFromRequestBodyObject(path11, external);
+        return getHintFromRequestBodyObject(path12, external);
       case "ResponseObject":
-        return getHintFromResponseObject(path11, external);
+        return getHintFromResponseObject(path12, external);
       case "SchemaMap":
         return "SchemaObject";
       default:
         return startFrom;
     }
   }
-  switch (path11[0]) {
+  switch (path12[0]) {
     case "paths": {
-      if (EXT_RE.test(path11[2])) {
+      if (EXT_RE.test(path12[2])) {
         return "SchemaMap";
       }
-      return getHintFromPathItemObject(path11.slice(2), external);
+      return getHintFromPathItemObject(path12.slice(2), external);
     }
     case "components":
-      return getHintFromComponentsObject(path11.slice(1), external);
+      return getHintFromComponentsObject(path12.slice(1), external);
   }
   return void 0;
 }
-function getHintFromComponentsObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromComponentsObject(path12, external) {
+  switch (path12[0]) {
     case "schemas":
     case "headers":
-      return getHintFromSchemaObject(path11.slice(2), external);
+      return getHintFromSchemaObject(path12.slice(2), external);
     case "parameters":
-      return getHintFromParameterObject(path11.slice(2), external);
+      return getHintFromParameterObject(path12.slice(2), external);
     case "responses":
-      return getHintFromResponseObject(path11.slice(2), external);
+      return getHintFromResponseObject(path12.slice(2), external);
     case "requestBodies":
-      return getHintFromRequestBodyObject(path11.slice(2), external);
+      return getHintFromRequestBodyObject(path12.slice(2), external);
     case "pathItems":
-      return getHintFromPathItemObject(path11.slice(2), external);
+      return getHintFromPathItemObject(path12.slice(2), external);
   }
   return "SchemaObject";
 }
-function getHintFromMediaTypeObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromMediaTypeObject(path12, external) {
+  switch (path12[0]) {
     case "schema":
-      return getHintFromSchemaObject(path11.slice(1), external);
+      return getHintFromSchemaObject(path12.slice(1), external);
   }
   return "MediaTypeObject";
 }
-function getHintFromOperationObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromOperationObject(path12, external) {
+  switch (path12[0]) {
     case "parameters":
       return "ParameterObject[]";
     case "requestBody":
-      return getHintFromRequestBodyObject(path11.slice(1), external);
+      return getHintFromRequestBodyObject(path12.slice(1), external);
     case "responses":
-      return getHintFromResponseObject(path11.slice(2), external);
+      return getHintFromResponseObject(path12.slice(2), external);
   }
   return "OperationObject";
 }
-function getHintFromParameterObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromParameterObject(path12, external) {
+  switch (path12[0]) {
     case "content":
-      return getHintFromMediaTypeObject(path11.slice(2), external);
+      return getHintFromMediaTypeObject(path12.slice(2), external);
     case "schema":
-      return getHintFromSchemaObject(path11.slice(1), external);
+      return getHintFromSchemaObject(path12.slice(1), external);
   }
   return "ParameterObject";
 }
-function getHintFromPathItemObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromPathItemObject(path12, external) {
+  switch (path12[0]) {
     case "parameters": {
-      if (typeof path11[1] === "number") {
+      if (typeof path12[1] === "number") {
         return "ParameterObject[]";
       }
-      return getHintFromParameterObject(path11.slice(1), external);
+      return getHintFromParameterObject(path12.slice(1), external);
     }
     default:
-      return getHintFromOperationObject(path11.slice(1), external);
+      return getHintFromOperationObject(path12.slice(1), external);
   }
 }
-function getHintFromRequestBodyObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromRequestBodyObject(path12, external) {
+  switch (path12[0]) {
     case "content":
-      return getHintFromMediaTypeObject(path11.slice(2), external);
+      return getHintFromMediaTypeObject(path12.slice(2), external);
   }
   return "RequestBodyObject";
 }
-function getHintFromResponseObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromResponseObject(path12, external) {
+  switch (path12[0]) {
     case "headers":
-      return getHintFromSchemaObject(path11.slice(2), external);
+      return getHintFromSchemaObject(path12.slice(2), external);
     case "content":
-      return getHintFromMediaTypeObject(path11.slice(2), external);
+      return getHintFromMediaTypeObject(path12.slice(2), external);
   }
   return "ResponseObject";
 }
-function getHintFromSchemaObject(path11, external) {
-  switch (path11[0]) {
+function getHintFromSchemaObject(path12, external) {
+  switch (path12[0]) {
     case "allOf":
     case "anyOf":
     case "oneOf":
       return "SchemaMap";
   }
-  if (path11.length >= 2 && external) {
+  if (path12.length >= 2 && external) {
     return "SchemaMap";
   }
   return "SchemaObject";
 }
 // node_modules/openapi-typescript/dist/transform/parameter-object.js
-function transformParameterObject(parameterObject, { path: path11, ctx }) {
-  return parameterObject.schema ? transformSchemaObject(parameterObject.schema, { path: path11, ctx }) : "string";
+function transformParameterObject(parameterObject, { path: path12, ctx }) {
+  return parameterObject.schema ? transformSchemaObject(parameterObject.schema, { path: path12, ctx }) : "string";
 }
 // node_modules/openapi-typescript/dist/transform/request-body-object.js
-function transformRequestBodyObject(requestBodyObject, { path: path11, ctx }) {
+function transformRequestBodyObject(requestBodyObject, { path: path12, ctx }) {
   let { indentLv } = ctx;
   const output = ["{"];
   indentLv++;
@@ -64528,12 +64528,12 @@ function transformRequestBodyObject(requestBodyObject, { path: path11, ctx }) {
       key = tsReadonly(key);
     if ("$ref" in mediaTypeObject) {
       output.push(indent(`${key}: ${transformSchemaObject(mediaTypeObject, {
-        path: `${path11}/${contentType}`,
+        path: `${path12}/${contentType}`,
         ctx: { ...ctx, indentLv }
       })};`, indentLv));
     } else {
       const mediaType = transformMediaTypeObject(mediaTypeObject, {
-        path: `${path11}/${contentType}`,
+        path: `${path12}/${contentType}`,
         ctx: { ...ctx, indentLv }
       });
       output.push(indent(`${key}: ${mediaType};`, indentLv));
@@ -64547,7 +64547,7 @@ function transformRequestBodyObject(requestBodyObject, { path: path11, ctx }) {
 }
 // node_modules/openapi-typescript/dist/transform/response-object.js
-function transformResponseObject(responseObject, { path: path11, ctx }) {
+function transformResponseObject(responseObject, { path: path12, ctx }) {
   const output = ["{"];
   let { indentLv } = ctx;
   if (responseObject.headers) {
@@ -64567,7 +64567,7 @@ function transformResponseObject(responseObject, { path: path11, ctx }) {
         if (!headerObject.required)
           key = tsOptionalProperty(key);
         output.push(indent(`${key}: ${transformHeaderObject(headerObject, {
-          path: `${path11}/headers/${name}`,
+          path: `${path12}/headers/${name}`,
           ctx: { ...ctx, indentLv }
         })};`, indentLv));
       }
@@ -64585,7 +64585,7 @@ function transformResponseObject(responseObject, { path: path11, ctx }) {
       if (ctx.immutableTypes)
         key = tsReadonly(key);
       output.push(indent(`${key}: ${transformMediaTypeObject(mediaTypeObject, {
-        path: `${path11}/content/${contentType}`,
+        path: `${path12}/content/${contentType}`,
         ctx: { ...ctx, indentLv }
       })};`, indentLv));
     }
@@ -64602,7 +64602,7 @@ function transformResponseObject(responseObject, { path: path11, ctx }) {
 }
 // node_modules/openapi-typescript/dist/transform/operation-object.js
-function transformOperationObject(operationObject, { path: path11, ctx, wrapObject = true }) {
+function transformOperationObject(operationObject, { path: path12, ctx, wrapObject = true }) {
   let { indentLv } = ctx;
   const output = wrapObject ? ["{"] : [];
   indentLv++;
@@ -64630,7 +64630,7 @@ function transformOperationObject(operationObject, { path: path11, ctx, wrapObje
           if (c2)
             paramInternalOutput.push(indent(c2, indentLv));
           const parameterType = "$ref" in param ? param.$ref : transformParameterObject(param, {
-            path: `${path11}/parameters/${param.name}`,
+            path: `${path12}/parameters/${param.name}`,
             ctx: { ...ctx, indentLv }
           });
           paramInternalOutput.push(indent(`${key}: ${parameterType};`, indentLv));
@@ -64660,12 +64660,12 @@ function transformOperationObject(operationObject, { path: path11, ctx, wrapObje
       if (ctx.immutableTypes)
         key = tsReadonly(key);
       if ("$ref" in operationObject.requestBody) {
-        output.push(indent(`${key}: ${transformSchemaObject(operationObject.requestBody, { path: path11, ctx })};`, indentLv));
+        output.push(indent(`${key}: ${transformSchemaObject(operationObject.requestBody, { path: path12, ctx })};`, indentLv));
       } else {
         if (!operationObject.requestBody.required)
           key = tsOptionalProperty(key);
         const requestBody = transformRequestBodyObject(operationObject.requestBody, {
-          path: `${path11}/requestBody`,
+          path: `${path12}/requestBody`,
           ctx: { ...ctx, indentLv }
         });
         output.push(indent(`${key}: ${requestBody};`, indentLv));
@@ -64683,12 +64683,12 @@ function transformOperationObject(operationObject, { path: path11, ctx, wrapObje
           output.push(indent(c2, indentLv));
         if ("$ref" in responseObject) {
           output.push(indent(`${key}: ${transformSchemaObject(responseObject, {
-            path: `${path11}/responses/${responseCode}`,
+            path: `${path12}/responses/${responseCode}`,
             ctx
           })};`, indentLv));
         } else {
           const responseType = transformResponseObject(responseObject, {
-            path: `${path11}/responses/${responseCode}`,
+            path: `${path12}/responses/${responseCode}`,
             ctx: { ...ctx, indentLv }
           });
           output.push(indent(`${key}: ${responseType};`, indentLv));
@@ -64706,7 +64706,7 @@ function transformOperationObject(operationObject, { path: path11, ctx, wrapObje
 }
 // node_modules/openapi-typescript/dist/transform/path-item-object.js
-function transformPathItemObject(pathItem, { path: path11, ctx }) {
+function transformPathItemObject(pathItem, { path: path12, ctx }) {
   var _a, _b;
   let { indentLv } = ctx;
   const output = [];
@@ -64728,19 +64728,19 @@ function transformPathItemObject(pathItem, { path: path11, ctx }) {
     if ("$ref" in operationObject) {
       output.push(indent(`${method}: ${operationObject.$ref}`, indentLv));
     } else if (operationObject.operationId) {
-      const operationType = transformOperationObject({ ...operationObject, parameters: Object.values(keyedParameters) }, { path: path11, ctx: { ...ctx, indentLv: 1 } });
+      const operationType = transformOperationObject({ ...operationObject, parameters: Object.values(keyedParameters) }, { path: path12, ctx: { ...ctx, indentLv: 1 } });
       ctx.operations[operationObject.operationId] = {
         operationType,
         comment: getSchemaObjectComment(operationObject, 1)
       };
       output.push(indent(`${method}: operations[${escStr(operationObject.operationId)}];`, indentLv));
     } else {
-      const operationType = transformOperationObject({ ...operationObject, parameters: Object.values(keyedParameters) }, { path: path11, ctx: { ...ctx, indentLv } });
+      const operationType = transformOperationObject({ ...operationObject, parameters: Object.values(keyedParameters) }, { path: path12, ctx: { ...ctx, indentLv } });
       output.push(indent(`${method}: ${operationType};`, indentLv));
     }
   }
   if ((_b = pathItem.parameters) == null ? void 0 : _b.length) {
-    output.push(indent(transformOperationObject({ parameters: pathItem.parameters }, { path: path11, ctx, wrapObject: false }).trim(), indentLv));
+    output.push(indent(transformOperationObject({ parameters: pathItem.parameters }, { path: path12, ctx, wrapObject: false }).trim(), indentLv));
   }
   indentLv--;
   output.push(indent("}", indentLv));
@@ -64748,9 +64748,9 @@ function transformPathItemObject(pathItem, { path: path11, ctx }) {
 }
 // node_modules/openapi-typescript/dist/transform/schema-object-map.js
-function transformSchemaObjectMap(schemaObjMap, { path: path11, ctx }) {
+function transformSchemaObjectMap(schemaObjMap, { path: path12, ctx }) {
   if ("type" in schemaObjMap && typeof schemaObjMap.type === "string" || "allOf" in schemaObjMap && Array.isArray(schemaObjMap.allOf) || "oneOf" in schemaObjMap && Array.isArray(schemaObjMap.oneOf) || "anyOf" in schemaObjMap && Array.isArray(schemaObjMap.anyOf)) {
-    return transformSchemaObject(schemaObjMap, { path: path11, ctx });
+    return transformSchemaObject(schemaObjMap, { path: path12, ctx });
   }
   let { indentLv } = ctx;
   const output = ["{"];
@@ -64767,16 +64767,16 @@ function transformSchemaObjectMap(schemaObjMap, { path: path11, ctx }) {
     if (!("type" in schemaObject) && !("$ref" in schemaObject)) {
       for (const method of ["get", "put", "post", "delete", "options", "head", "patch", "trace"]) {
         if (method in schemaObject) {
-          output.push(indent(`${key}: ${transformPathItemObject(schemaObject, { path: `${path11}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
+          output.push(indent(`${key}: ${transformPathItemObject(schemaObject, { path: `${path12}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
           continue outer;
         }
       }
     }
     if ("in" in schemaObject) {
-      output.push(indent(`${key}: ${transformParameterObject(schemaObject, { path: `${path11}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
+      output.push(indent(`${key}: ${transformParameterObject(schemaObject, { path: `${path12}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
       continue;
     }
-    output.push(indent(`${key}: ${transformSchemaObject(schemaObject, { path: `${path11}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
+    output.push(indent(`${key}: ${transformSchemaObject(schemaObject, { path: `${path12}${name}`, ctx: { ...ctx, indentLv } })};`, indentLv));
   }
   indentLv--;
   output.push(indent("}", indentLv));
@@ -64793,7 +64793,7 @@ function transformSchemaObject(schemaObject, options) {
   }
   return result;
 }
-function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
+function defaultSchemaObjectTransform(schemaObject, { path: path12, ctx }) {
   var _a, _b, _c;
   let { indentLv } = ctx;
   if (typeof schemaObject === "boolean") {
@@ -64809,13 +64809,13 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
     return schemaObject.$ref;
   }
   if (typeof ctx.transform === "function") {
-    const result = ctx.transform(schemaObject, { path: path11, ctx });
+    const result = ctx.transform(schemaObject, { path: path12, ctx });
     if (result)
       return result;
   }
   if (schemaObject.const !== null && schemaObject.const !== void 0) {
     return transformSchemaObject(escStr(schemaObject.const), {
-      path: path11,
+      path: path12,
       ctx: { ...ctx, immutableTypes: false, indentLv: indentLv + 1 }
     });
   }
@@ -64832,16 +64832,16 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
   }
   const oneOf = typeof schemaObject === "object" && !schemaObject.discriminator && schemaObject.oneOf || schemaObject.enum || void 0;
   if (oneOf && !oneOf.some((t) => "$ref" in t && ctx.discriminators[t.$ref])) {
-    const oneOfNormalized = oneOf.map((item) => transformSchemaObject(item, { path: path11, ctx }));
+    const oneOfNormalized = oneOf.map((item) => transformSchemaObject(item, { path: path12, ctx }));
     if (schemaObject.nullable)
       oneOfNormalized.push("null");
     if ("type" in schemaObject && Array.isArray(schemaObject.type)) {
-      const coreTypes = schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, oneOf: void 0, type: t }, { path: path11, ctx }));
+      const coreTypes = schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, oneOf: void 0, type: t }, { path: path12, ctx }));
       return tsUnionOf(...oneOfNormalized, ...coreTypes);
     }
     const oneOfTypes = oneOfNormalized.some((t) => typeof t === "string" && t.includes("{")) ? tsOneOf(...oneOfNormalized) : tsUnionOf(...oneOfNormalized);
     if ("type" in schemaObject && schemaObject.type === "object" && (schemaObject.properties || schemaObject.additionalProperties)) {
-      return tsIntersectionOf(transformSchemaObject({ ...schemaObject, oneOf: void 0, enum: void 0 }, { path: path11, ctx }), oneOfTypes);
+      return tsIntersectionOf(transformSchemaObject({ ...schemaObject, oneOf: void 0, enum: void 0 }, { path: path12, ctx }), oneOfTypes);
     }
     return oneOfTypes;
   }
@@ -64862,11 +64862,11 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
         isTupleType = true;
         const result = [];
         for (const item of (_a = schemaObject.prefixItems) != null ? _a : schemaObject.items) {
-          result.push(transformSchemaObject(item, { path: path11, ctx: { ...ctx, indentLv } }));
+          result.push(transformSchemaObject(item, { path: path12, ctx: { ...ctx, indentLv } }));
         }
         itemType = `[${result.join(", ")}]`;
       } else if (schemaObject.items) {
-        itemType = transformSchemaObject(schemaObject.items, { path: path11, ctx: { ...ctx, indentLv } });
+        itemType = transformSchemaObject(schemaObject.items, { path: path12, ctx: { ...ctx, indentLv } });
       }
       const min = typeof schemaObject.minItems === "number" && schemaObject.minItems >= 0 ? schemaObject.minItems : 0;
       const max = typeof schemaObject.maxItems === "number" && schemaObject.maxItems >= 0 && min <= schemaObject.maxItems ? schemaObject.maxItems : void 0;
@@ -64889,7 +64889,7 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
       return schemaObject.nullable ? tsUnionOf(itemType, "null") : itemType;
     }
     if (Array.isArray(schemaObject.type)) {
-      return tsUnionOf(...schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, type: t }, { path: path11, ctx })));
+      return tsUnionOf(...schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, type: t }, { path: path12, ctx })));
     }
   }
   const coreType = [];
@@ -64898,16 +64898,16 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
       continue;
     const discriminatorRef = schemaObject[k].find((t) => "$ref" in t && (ctx.discriminators[t.$ref] || Object.values(ctx.discriminators).find((d) => {
       var _a2;
-      return (_a2 = d.oneOf) == null ? void 0 : _a2.includes(path11);
+      return (_a2 = d.oneOf) == null ? void 0 : _a2.includes(path12);
     })));
     if (discriminatorRef && ctx.discriminators[discriminatorRef.$ref]) {
-      coreType.unshift(indent(getDiscriminatorPropertyName(path11, ctx.discriminators[discriminatorRef.$ref]), indentLv + 1));
+      coreType.unshift(indent(getDiscriminatorPropertyName(path12, ctx.discriminators[discriminatorRef.$ref]), indentLv + 1));
       break;
     }
   }
   for (const d of Object.values(ctx.discriminators)) {
-    if ((_b = d.oneOf) == null ? void 0 : _b.includes(path11)) {
-      coreType.unshift(indent(getDiscriminatorPropertyName(path11, d), indentLv + 1));
+    if ((_b = d.oneOf) == null ? void 0 : _b.includes(path12)) {
+      coreType.unshift(indent(getDiscriminatorPropertyName(path12, d), indentLv + 1));
       break;
     }
   }
@@ -64925,7 +64925,7 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
         key = tsOptionalProperty(key);
       if (ctx.immutableTypes || schemaObject.readOnly)
         key = tsReadonly(key);
-      coreType.push(indent(`${key}: ${transformSchemaObject(v, { path: path11, ctx: { ...ctx, indentLv } })};`, indentLv));
+      coreType.push(indent(`${key}: ${transformSchemaObject(v, { path: path12, ctx: { ...ctx, indentLv } })};`, indentLv));
     }
     if (schemaObject.additionalProperties || ctx.additionalProperties) {
       let addlType = "unknown";
@@ -64934,7 +64934,7 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
           addlType = "unknown";
         } else {
           addlType = transformSchemaObject(schemaObject.additionalProperties, {
-            path: path11,
+            path: path12,
             ctx: { ...ctx, indentLv }
           });
         }
@@ -64947,7 +64947,7 @@ function defaultSchemaObjectTransform(schemaObject, { path: path11, ctx }) {
       }
     }
     if (schemaObject.$defs && typeof schemaObject.$defs === "object" && Object.keys(schemaObject.$defs).length) {
-      coreType.push(indent(`$defs: ${transformSchemaObjectMap(schemaObject.$defs, { path: `${path11}$defs/`, ctx: { ...ctx, indentLv } })};`, indentLv));
+      coreType.push(indent(`$defs: ${transformSchemaObjectMap(schemaObject.$defs, { path: `${path12}$defs/`, ctx: { ...ctx, indentLv } })};`, indentLv));
     }
     indentLv--;
   }
@@ -64957,7 +64957,7 @@ ${indent("}", indentLv)}` : "";
   function collectCompositions(items) {
     const output = [];
     for (const item of items) {
-      const itemType = transformSchemaObject(item, { path: path11, ctx: { ...ctx, indentLv } });
+      const itemType = transformSchemaObject(item, { path: path12, ctx: { ...ctx, indentLv } });
       if ("$ref" in item && ctx.discriminators[item.$ref]) {
         output.push(tsOmit(itemType, [ctx.discriminators[item.$ref].propertyName]));
         continue;
@@ -64994,8 +64994,8 @@ ${indent("}", indentLv)}` : "";
     return "unknown";
   return ctx.emptyObjectsUnknown ? "Record<string, unknown>" : "Record<string, never>";
 }
-function getDiscriminatorPropertyName(path11, discriminator) {
-  let value = parseRef(path11).path.pop();
+function getDiscriminatorPropertyName(path12, discriminator) {
+  let value = parseRef(path12).path.pop();
   if (discriminator.mapping) {
     const matchedValue = Object.entries(discriminator.mapping).find(([, v]) => !v.startsWith("#") && v === value || v.startsWith("#") && parseRef(v).path.pop() === value);
     if (matchedValue)
@@ -65005,16 +65005,16 @@ function getDiscriminatorPropertyName(path11, discriminator) {
 }
 // node_modules/openapi-typescript/dist/transform/media-type-object.js
-function transformMediaTypeObject(mediaTypeObject, { path: path11, ctx }) {
+function transformMediaTypeObject(mediaTypeObject, { path: path12, ctx }) {
   if (!mediaTypeObject.schema)
     return "unknown";
-  return transformSchemaObject(mediaTypeObject.schema, { path: path11, ctx });
+  return transformSchemaObject(mediaTypeObject.schema, { path: path12, ctx });
 }
 // node_modules/openapi-typescript/dist/transform/header-object.js
-function transformHeaderObject(headerObject, { path: path11, ctx }) {
+function transformHeaderObject(headerObject, { path: path12, ctx }) {
   if (headerObject.schema)
-    return transformSchemaObject(headerObject.schema, { path: path11, ctx });
+    return transformSchemaObject(headerObject.schema, { path: path12, ctx });
   if (headerObject.content) {
     let { indentLv } = ctx;
     const output = ["{"];
@@ -65027,9 +65027,9 @@ function transformHeaderObject(headerObject, { path: path11, ctx }) {
       if (ctx.immutableTypes)
         key = tsReadonly(key);
       if ("$ref" in mediaTypeObject) {
-        output.push(indent(`${key}: ${transformSchemaObject(mediaTypeObject, { path: `${path11}/${contentType}`, ctx })};`, indentLv));
+        output.push(indent(`${key}: ${transformSchemaObject(mediaTypeObject, { path: `${path12}/${contentType}`, ctx })};`, indentLv));
       } else {
-        const mediaType = transformMediaTypeObject(mediaTypeObject, { path: `${path11}/${contentType}`, ctx });
+        const mediaType = transformMediaTypeObject(mediaTypeObject, { path: `${path12}/${contentType}`, ctx });
         output.push(indent(`${key}: ${mediaType};`, indentLv));
       }
     }
@@ -65209,25 +65209,25 @@ function transformPathsObject(pathsObject, ctx) {
   for (const [url2, pathItemObject] of getEntries(pathsObject, ctx.alphabetize, ctx.excludeDeprecated)) {
     if (!pathItemObject || typeof pathItemObject !== "object")
       continue;
-    let path11 = url2;
+    let path12 = url2;
     if ("$ref" in pathItemObject) {
       const c2 = getSchemaObjectComment(pathItemObject, indentLv);
       if (c2)
         output.push(indent(c2, indentLv));
-      output.push(indent(`${escStr(path11)}: ${pathItemObject.$ref};`, indentLv));
+      output.push(indent(`${escStr(path12)}: ${pathItemObject.$ref};`, indentLv));
       continue;
     }
     const pathParams = new Map([...extractPathParams(pathItemObject), ...OPERATIONS.flatMap((op) => Array.from(extractPathParams(pathItemObject[op])))]);
     if (ctx.pathParamsAsTypes && pathParams.size) {
       for (const p of pathParams.values()) {
         const paramType = transformParameterObject(p, { path: `#/paths/${url2}/parameters/${p.name}`, ctx });
-        path11 = path11.replace(`{${p.name}}`, `\${${paramType}}`);
+        path12 = path12.replace(`{${p.name}}`, `\${${paramType}}`);
       }
-      path11 = `[path: \`${path11}\`]`;
+      path12 = `[path: \`${path12}\`]`;
     } else {
-      path11 = escStr(path11);
+      path12 = escStr(path12);
     }
-    output.push(indent(`${path11}: ${transformPathItemObject(pathItemObject, {
+    output.push(indent(`${path12}: ${transformPathItemObject(pathItemObject, {
       path: `#/paths/${url2}`,
       ctx: { ...ctx, indentLv }
     })};`, indentLv));
@@ -65278,7 +65278,7 @@ function transformSchema(schema2, ctx) {
 }
 // node_modules/openapi-typescript/dist/transform/parameter-object-array.js
-function transformParameterObjectArray(parameterObjectArray, { path: path11, ctx }) {
+function transformParameterObjectArray(parameterObjectArray, { path: path12, ctx }) {
   const output = [];
   const parameters = Array.isArray(parameterObjectArray) ? parameterObjectArray.map((p) => [p.name, p]) : Object.entries(parameterObjectArray);
   for (const [id, param] of parameters) {
@@ -65291,7 +65291,7 @@ function transformParameterObjectArray(parameterObjectArray, { path: path11, ctx
     if (node.in !== "path" && !node.required)
       key = tsOptionalProperty(key);
     output.push(indent(`${key}: ${transformParameterObject(node, {
-      path: `${path11}/${node.in}/${node.name}`,
+      path: `${path12}/${node.in}/${node.name}`,
       ctx: { ...ctx, indentLv: ctx.indentLv + 1 }
     })};`, ctx.indentLv));
   }
@@ -65393,7 +65393,7 @@ async function openapiTS(schema2, options = {}) {
     for (const subschemaID of externalKeys) {
       const subschema = allSchemas[subschemaID];
       const key = escObjKey(subschemaID);
-      const path11 = `${subschemaID}#`;
+      const path12 = `${subschemaID}#`;
       let subschemaOutput = "";
       let comment2;
       switch (subschema.hint) {
@@ -65414,25 +65414,25 @@ async function openapiTS(schema2, options = {}) {
           break;
         }
         case "MediaTypeObject": {
-          subschemaOutput = transformMediaTypeObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } });
+          subschemaOutput = transformMediaTypeObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } });
           break;
         }
         case "OperationObject": {
           comment2 = getSchemaObjectComment(subschema.schema, indentLv);
-          subschemaOutput = transformOperationObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } });
+          subschemaOutput = transformOperationObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } });
           break;
         }
         case "ParameterObject": {
-          subschemaOutput = transformParameterObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } });
+          subschemaOutput = transformParameterObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } });
           break;
         }
         case "ParameterObject[]": {
           if (typeof subschema.schema === "object" && ("schema" in subschema.schema || "type" in subschema.schema)) {
-            subschemaOutput = transformSchemaObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } });
+            subschemaOutput = transformSchemaObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } });
           } else {
             subschemaOutput += "{\n";
             indentLv++;
-            subschemaOutput += transformParameterObjectArray(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } });
+            subschemaOutput += transformParameterObjectArray(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } });
             subschemaOutput += "\n";
             indentLv--;
             subschemaOutput += indent("};", indentLv);
@@ -65440,19 +65440,19 @@ async function openapiTS(schema2, options = {}) {
           break;
         }
         case "RequestBodyObject": {
-          subschemaOutput = `${transformRequestBodyObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } })};`;
+          subschemaOutput = `${transformRequestBodyObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } })};`;
           break;
         }
         case "ResponseObject": {
-          subschemaOutput = `${transformResponseObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } })};`;
+          subschemaOutput = `${transformResponseObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } })};`;
           break;
         }
         case "SchemaMap": {
-          subschemaOutput = `${transformSchemaObjectMap(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } })};`;
+          subschemaOutput = `${transformSchemaObjectMap(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } })};`;
           break;
         }
         case "SchemaObject": {
-          subschemaOutput = `${transformSchemaObject(subschema.schema, { path: path11, ctx: { ...ctx, indentLv } })};`;
+          subschemaOutput = `${transformSchemaObject(subschema.schema, { path: path12, ctx: { ...ctx, indentLv } })};`;
           break;
         }
         default: {
@@ -65508,6 +65508,109 @@ var openapi = new Command("openapi:gen").description("Generate TypeScript types
   }
 });
+// src/commands/delete-group.ts
+import * as fs9 from "fs";
+import * as path11 from "path";
+var ENDPOINT_BASE2 = ({ mode, version: version2, port }) => {
+  const normalizedMode = (mode == null ? void 0 : mode.toLowerCase()) === "prod" || (mode == null ? void 0 : mode.toLowerCase()) === "production" ? "prod" : "staging";
+  const normalizedVersion = (version2 == null ? void 0 : version2.toLowerCase()) === "v2" ? "v2" : "v1";
+  if (port) return `http://localhost:${port}`;
+  if (normalizedVersion === "v2") return `https://${normalizedMode}-v2-cicd.microfox.app`;
+  return `https://${normalizedMode}-v1-cicd.microfox.app`;
+};
+function resolveMicrofoxConfig(startCwd) {
+  const cwd = startCwd;
+  const configPath = path11.join(cwd, "microfox.json");
+  if (fs9.existsSync(configPath)) {
+    return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+  }
+  const parentConfigPath = path11.join(path11.dirname(cwd), "microfox.json");
+  if (fs9.existsSync(parentConfigPath)) {
+    return JSON.parse(fs9.readFileSync(parentConfigPath, "utf-8"));
+  }
+  const serverlessDir = findServerlessWorkersDir(cwd);
+  if (serverlessDir) {
+    const inServerlessPath = path11.join(serverlessDir, "microfox.json");
+    const inServerlessParentPath = path11.join(path11.dirname(serverlessDir), "microfox.json");
+    if (!fs9.existsSync(inServerlessPath) && fs9.existsSync(inServerlessParentPath)) {
+      try {
+        fs9.copyFileSync(inServerlessParentPath, inServerlessPath);
+      } catch (e) {
+      }
+    }
+    const finalConfigPath = fs9.existsSync(inServerlessPath) ? inServerlessPath : inServerlessParentPath;
+    if (fs9.existsSync(finalConfigPath)) {
+      return JSON.parse(fs9.readFileSync(finalConfigPath, "utf-8"));
+    }
+  }
+  console.error(source_default.red("\u274C Error: `microfox.json` not found. Run from project root or `.serverless-workers`."));
+  process.exit(1);
+}
+async function deleteGroupAction(group) {
+  var _a, _b, _c, _d;
+  const normalizedGroup = group == null ? void 0 : group.trim();
+  if (!normalizedGroup) {
+    console.error(source_default.red("\u274C Error: group name is required."));
+    process.exit(1);
+  }
+  const cfg = resolveMicrofoxConfig(process.cwd());
+  const deploymentConfig = cfg.deployment || {};
+  const apiVersion = (deploymentConfig.apiVersion || cfg.apiVersion || cfg.API_VERSION || "").toString().toLowerCase();
+  if (apiVersion !== "v2") {
+    console.error(source_default.red("\u274C Error: `delete-group` is supported only for v2 deployments."));
+    process.exit(1);
+  }
+  const mode = deploymentConfig.apiMode || cfg.apiMode || cfg.API_MODE;
+  const port = deploymentConfig.port || cfg.port || cfg.PORT;
+  const base = ENDPOINT_BASE2({ mode, version: "v2", port });
+  const projectId = cfg.projectId || process.env.PROJECT_ID;
+  if (!projectId) {
+    console.error(source_default.red("\u274C Error: `projectId` is required. Add `projectId` to your microfox.json."));
+    process.exit(1);
+  }
+  const url2 = `${base}/api/projects/${encodeURIComponent(projectId)}/groups/${encodeURIComponent(normalizedGroup)}`;
+  console.log(source_default.cyan(`\u{1F9F9} Requesting deletion for group "${normalizedGroup}"...`));
+  try {
+    const response = await axios_default.delete(url2, {
+      headers: {
+        "x-project-id": projectId
+      },
+      data: {
+        group: normalizedGroup
+      }
+    });
+    if (response.status >= 200 && response.status < 300) {
+      console.log(source_default.green("\u2705 Group resource deletion initiated."));
+      if ((_a = response.data) == null ? void 0 : _a.message) {
+        console.log(source_default.green(`   Message: ${response.data.message}`));
+      }
+      if ((_b = response.data) == null ? void 0 : _b.workerName) {
+        console.log(source_default.green(`   Worker: ${response.data.workerName}`));
+      }
+      return;
+    }
+    console.error(source_default.red(`\u274C Failed with status ${response.status}`));
+    process.exit(1);
+  } catch (error2) {
+    if (axios_default.isAxiosError(error2) && error2.response) {
+      console.error(source_default.red(`\u274C Error: ${error2.response.status}`));
+      const message = ((_c = error2.response.data) == null ? void 0 : _c.error) || ((_d = error2.response.data) == null ? void 0 : _d.message);
+      if (message) {
+        console.error(source_default.red(`   ${message}`));
+      } else {
+        console.error(source_default.red(`   ${JSON.stringify(error2.response.data)}`));
+      }
+    } else {
+      console.error(source_default.red("\u274C Failed to delete group resources."));
+      console.error(error2);
+    }
+    process.exit(1);
+  }
+}
+var deleteGroupCommand = new Command("delete-group").description("Delete resources for a specific project group (v2)").argument("<group>", "Group name to delete (e.g. default, core, workflows)").action(async (group) => {
+  await deleteGroupAction(group);
+});
 // src/cli.ts
 var program = new Command();
 program.name("microfox").description("Universal CLI tool for creating and managing Microfox projects").version(version);
@@ -65525,6 +65628,7 @@ program.addCommand(kickstartCommand);
 program.addCommand(track);
 program.addCommand(trackCi);
 program.addCommand(openapi);
+program.addCommand(deleteGroupCommand);
 program.addCommand(addCommand);
 program.action(() => {
   if (process.argv.length <= 2) {