@seeka-labs/cli-apps 3.8.10 → 3.9.1

package/dist/index.cjs

@@ -177,16 +177,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize2(aPath) {
-      var path8 = aPath;
+      var path9 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path8 = url.path;
+        path9 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path8);
-      var parts = path8.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path9);
+      var parts = path9.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -203,18 +203,18 @@ var require_util = __commonJS({
           }
         }
       }
-      path8 = parts.join("/");
-      if (path8 === "") {
-        path8 = isAbsolute ? "/" : ".";
+      path9 = parts.join("/");
+      if (path9 === "") {
+        path9 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path8;
+        url.path = path9;
         return urlGenerate(url);
       }
-      return path8;
+      return path9;
     }
     exports2.normalize = normalize2;
-    function join4(aRoot, aPath) {
+    function join5(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -246,7 +246,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join4;
+    exports2.join = join5;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -419,7 +419,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index2 + 1);
           }
         }
-        sourceURL = join4(urlGenerate(parsed), sourceURL);
+        sourceURL = join5(urlGenerate(parsed), sourceURL);
       }
       return normalize2(sourceURL);
     }
@@ -1831,12 +1831,12 @@ var require_buffer_from = __commonJS({
 var require_source_map_support = __commonJS({
   "../../node_modules/source-map-support/source-map-support.js"(exports2, module2) {
     var SourceMapConsumer = require_source_map().SourceMapConsumer;
-    var path8 = require("path");
-    var fs7;
+    var path9 = require("path");
+    var fs8;
     try {
-      fs7 = require("fs");
-      if (!fs7.existsSync || !fs7.readFileSync) {
-        fs7 = null;
+      fs8 = require("fs");
+      if (!fs8.existsSync || !fs8.readFileSync) {
+        fs8 = null;
       }
     } catch (err) {
     }
@@ -1892,26 +1892,26 @@ var require_source_map_support = __commonJS({
       };
     }
     var retrieveFile = handlerExec(retrieveFileHandlers);
-    retrieveFileHandlers.push(function(path9) {
-      path9 = path9.trim();
-      if (/^file:/.test(path9)) {
-        path9 = path9.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    retrieveFileHandlers.push(function(path10) {
+      path10 = path10.trim();
+      if (/^file:/.test(path10)) {
+        path10 = path10.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : (
             // file:///C:/dir/file -> C:/dir/file
             "/"
           );
         });
       }
-      if (path9 in fileContentsCache) {
-        return fileContentsCache[path9];
+      if (path10 in fileContentsCache) {
+        return fileContentsCache[path10];
       }
       var contents = "";
       try {
-        if (!fs7) {
+        if (!fs8) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
-            path9,
+            path10,
             /** async */
             false
           );
@@ -1919,24 +1919,24 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs7.existsSync(path9)) {
-          contents = fs7.readFileSync(path9, "utf8");
+        } else if (fs8.existsSync(path10)) {
+          contents = fs8.readFileSync(path10, "utf8");
         }
       } catch (er) {
       }
-      return fileContentsCache[path9] = contents;
+      return fileContentsCache[path10] = contents;
     });
     function supportRelativeURL(file, url) {
       if (!file) return url;
-      var dir = path8.dirname(file);
+      var dir = path9.dirname(file);
       var match2 = /^\w+:\/\/[^\/]*/.exec(dir);
       var protocol = match2 ? match2[0] : "";
       var startPath = dir.slice(protocol.length);
       if (protocol && /^\/\w\:/.test(startPath)) {
         protocol += "/";
-        return protocol + path8.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+        return protocol + path9.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
       }
-      return protocol + path8.resolve(dir.slice(protocol.length), url);
+      return protocol + path9.resolve(dir.slice(protocol.length), url);
     }
     function retrieveSourceMapURL(source) {
       var fileData;
@@ -2184,9 +2184,9 @@ var require_source_map_support = __commonJS({
         var line = +match2[2];
         var column = +match2[3];
         var contents = fileContentsCache[source];
-        if (!contents && fs7 && fs7.existsSync(source)) {
+        if (!contents && fs8 && fs8.existsSync(source)) {
           try {
-            contents = fs7.readFileSync(source, "utf8");
+            contents = fs8.readFileSync(source, "utf8");
           } catch (er) {
             contents = "";
           }
@@ -3460,8 +3460,8 @@ var require_command = __commonJS({
   "../../node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter2 = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path8 = require("node:path");
-    var fs7 = require("node:fs");
+    var path9 = require("node:path");
+    var fs8 = require("node:fs");
     var process4 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -4455,7 +4455,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs7.existsSync(executableFile)) return;
+        if (fs8.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -4473,11 +4473,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path8.resolve(baseDir, baseName);
-          if (fs7.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path8.extname(baseName))) return void 0;
+          const localBin = path9.resolve(baseDir, baseName);
+          if (fs8.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path9.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs7.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs8.existsSync(`${localBin}${ext2}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -4489,21 +4489,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs7.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs8.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path8.resolve(
-            path8.dirname(resolvedScriptPath),
+          executableDir = path9.resolve(
+            path9.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path8.basename(
+            const legacyName = path9.basename(
               this._scriptPath,
-              path8.extname(this._scriptPath)
+              path9.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -4514,7 +4514,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path8.extname(executableFile));
+        launchWithNode = sourceExt.includes(path9.extname(executableFile));
         let proc2;
         if (process4.platform !== "win32") {
           if (launchWithNode) {
@@ -5429,7 +5429,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path8.basename(filename, path8.extname(filename));
+        this._name = path9.basename(filename, path9.extname(filename));
         return this;
       }
       /**
@@ -5443,9 +5443,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path9) {
-        if (path9 === void 0) return this._executableDir;
-        this._executableDir = path9;
+      executableDir(path10) {
+        if (path10 === void 0) return this._executableDir;
+        this._executableDir = path10;
         return this;
       }
       /**
@@ -5728,8 +5728,8 @@ var require_windows = __commonJS({
   "../../node_modules/cross-spawn/node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync3;
-    var fs7 = require("fs");
-    function checkPathExt(path8, options) {
+    var fs8 = require("fs");
+    function checkPathExt(path9, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -5740,25 +5740,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path8.substr(-p.length).toLowerCase() === p) {
+        if (p && path9.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path8, options) {
+    function checkStat(stat, path9, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path8, options);
+      return checkPathExt(path9, options);
     }
-    function isexe(path8, options, cb) {
-      fs7.stat(path8, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path8, options));
+    function isexe(path9, options, cb) {
+      fs8.stat(path9, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path9, options));
       });
     }
-    function sync3(path8, options) {
-      return checkStat(fs7.statSync(path8), path8, options);
+    function sync3(path9, options) {
+      return checkStat(fs8.statSync(path9), path9, options);
     }
   }
 });
@@ -5768,14 +5768,14 @@ var require_mode = __commonJS({
   "../../node_modules/cross-spawn/node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync3;
-    var fs7 = require("fs");
-    function isexe(path8, options, cb) {
-      fs7.stat(path8, function(er, stat) {
+    var fs8 = require("fs");
+    function isexe(path9, options, cb) {
+      fs8.stat(path9, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync3(path8, options) {
-      return checkStat(fs7.statSync(path8), options);
+    function sync3(path9, options) {
+      return checkStat(fs8.statSync(path9), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -5799,7 +5799,7 @@ var require_mode = __commonJS({
 // ../../node_modules/cross-spawn/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/cross-spawn/node_modules/isexe/index.js"(exports2, module2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -5808,7 +5808,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync3;
-    function isexe(path8, options, cb) {
+    function isexe(path9, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -5818,7 +5818,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve4, reject) {
-          isexe(path8, options || {}, function(er, is) {
+          isexe(path9, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -5827,7 +5827,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path8, options || {}, function(er, is) {
+      core(path9, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -5837,9 +5837,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync3(path8, options) {
+    function sync3(path9, options) {
       try {
-        return core.sync(path8, options || {});
+        return core.sync(path9, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -5855,7 +5855,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "../../node_modules/cross-spawn/node_modules/which/which.js"(exports2, module2) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path8 = require("path");
+    var path9 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -5893,7 +5893,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path8.join(pathPart, cmd);
+        const pCmd = path9.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve4(subStep(p, i, 0));
       });
@@ -5920,7 +5920,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path8.join(pathPart, cmd);
+        const pCmd = path9.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -5968,7 +5968,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "../../node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path8 = require("path");
+    var path9 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -5986,7 +5986,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path8.delimiter : void 0
+          pathExt: withoutPathExt ? path9.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -5995,7 +5995,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path8.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path9.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -6049,8 +6049,8 @@ var require_shebang_command = __commonJS({
       if (!match2) {
         return null;
       }
-      const [path8, argument] = match2[0].replace(/#! ?/, "").split(" ");
-      const binary = path8.split("/").pop();
+      const [path9, argument] = match2[0].replace(/#! ?/, "").split(" ");
+      const binary = path9.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -6063,16 +6063,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs7.openSync(command, "r");
-        fs7.readSync(fd, buffer, 0, size, 0);
-        fs7.closeSync(fd);
+        fd = fs8.openSync(command, "r");
+        fs8.readSync(fd, buffer, 0, size, 0);
+        fs8.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -6085,7 +6085,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "../../node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path8 = require("path");
+    var path9 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape2 = require_escape();
     var readShebang = require_readShebang();
@@ -6110,7 +6110,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path8.normalize(parsed.command);
+        parsed.command = path9.normalize(parsed.command);
         parsed.command = escape2.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -7145,9 +7145,9 @@ var require_pump = __commonJS({
   "../../node_modules/pump/index.js"(exports2, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs7;
+    var fs8;
     try {
-      fs7 = require("fs");
+      fs8 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -7158,8 +7158,8 @@ var require_pump = __commonJS({
     };
     var isFS = function(stream2) {
       if (!ancient) return false;
-      if (!fs7) return false;
-      return (stream2 instanceof (fs7.ReadStream || noop) || stream2 instanceof (fs7.WriteStream || noop)) && isFn(stream2.close);
+      if (!fs8) return false;
+      return (stream2 instanceof (fs8.ReadStream || noop) || stream2 instanceof (fs8.WriteStream || noop)) && isFn(stream2.close);
     };
     var isRequest = function(stream2) {
       return stream2.setHeader && isFn(stream2.abort);
@@ -7371,7 +7371,7 @@ var require_pend = __commonJS({
 // ../../node_modules/fd-slicer/index.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/fd-slicer/index.js"(exports2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var util = require("util");
     var stream2 = require("stream");
     var Readable = stream2.Readable;
@@ -7396,7 +7396,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs7.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs8.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -7405,7 +7405,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs7.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs8.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -7426,7 +7426,7 @@ var require_fd_slicer = __commonJS({
       if (self2.refCount > 0) return;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.autoClose) {
-        fs7.close(self2.fd, onCloseDone);
+        fs8.close(self2.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -7463,7 +7463,7 @@ var require_fd_slicer = __commonJS({
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
         var buffer = new Buffer(toRead);
-        fs7.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        fs8.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
           if (err) {
             self2.destroy(err);
           } else if (bytesRead === 0) {
@@ -7510,7 +7510,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
-        fs7.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        fs8.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
           if (err2) {
             self2.destroy();
             cb();
@@ -7937,7 +7937,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/yauzl/index.js"(exports2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var zlib = require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -7955,7 +7955,7 @@ var require_yauzl = __commonJS({
     exports2.ZipFile = ZipFile;
     exports2.Entry = Entry;
     exports2.RandomAccessReader = RandomAccessReader;
-    function open(path8, options, callback) {
+    function open(path9, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = null;
@@ -7967,10 +7967,10 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs7.open(path8, "r", function(err, fd) {
+      fs8.open(path9, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
-          if (err2) fs7.close(fd, defaultCallback);
+          if (err2) fs8.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -7987,7 +7987,7 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs7.fstat(fd, function(err, stats) {
+      fs8.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options, callback);
@@ -8567,9 +8567,9 @@ var require_yauzl = __commonJS({
 var require_extract_zip = __commonJS({
   "../../node_modules/extract-zip/index.js"(exports2, module2) {
     var debug = require_src()("extract-zip");
-    var { createWriteStream, promises: fs7 } = require("fs");
+    var { createWriteStream, promises: fs8 } = require("fs");
     var getStream = require_get_stream();
-    var path8 = require("path");
+    var path9 = require("path");
     var { promisify } = require("util");
     var stream2 = require("stream");
     var yauzl = require_yauzl();
@@ -8606,12 +8606,12 @@ var require_extract_zip = __commonJS({
               this.zipfile.readEntry();
               return;
             }
-            const destDir = path8.dirname(path8.join(this.opts.dir, entry.fileName));
+            const destDir = path9.dirname(path9.join(this.opts.dir, entry.fileName));
             try {
-              await fs7.mkdir(destDir, { recursive: true });
-              const canonicalDestDir = await fs7.realpath(destDir);
-              const relativeDestDir = path8.relative(this.opts.dir, canonicalDestDir);
-              if (relativeDestDir.split(path8.sep).includes("..")) {
+              await fs8.mkdir(destDir, { recursive: true });
+              const canonicalDestDir = await fs8.realpath(destDir);
+              const relativeDestDir = path9.relative(this.opts.dir, canonicalDestDir);
+              if (relativeDestDir.split(path9.sep).includes("..")) {
                 throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
               }
               await this.extractEntry(entry);
@@ -8633,7 +8633,7 @@ var require_extract_zip = __commonJS({
         if (this.opts.onEntry) {
           this.opts.onEntry(entry, this.zipfile);
         }
-        const dest = path8.join(this.opts.dir, entry.fileName);
+        const dest = path9.join(this.opts.dir, entry.fileName);
         const mode = entry.externalFileAttributes >> 16 & 65535;
         const IFMT2 = 61440;
         const IFDIR2 = 16384;
@@ -8647,20 +8647,20 @@ var require_extract_zip = __commonJS({
         if (!isDir) isDir = madeBy === 0 && entry.externalFileAttributes === 16;
         debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
         const procMode = this.getExtractedMode(mode, isDir) & 511;
-        const destDir = isDir ? dest : path8.dirname(dest);
+        const destDir = isDir ? dest : path9.dirname(dest);
         const mkdirOptions = { recursive: true };
         if (isDir) {
           mkdirOptions.mode = procMode;
         }
         debug("mkdir", { dir: destDir, ...mkdirOptions });
-        await fs7.mkdir(destDir, mkdirOptions);
+        await fs8.mkdir(destDir, mkdirOptions);
         if (isDir) return;
         debug("opening read stream", dest);
         const readStream = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
-          await fs7.symlink(link, dest);
+          await fs8.symlink(link, dest);
         } else {
           await pipeline(readStream, createWriteStream(dest, { mode: procMode }));
         }
@@ -8689,11 +8689,11 @@ var require_extract_zip = __commonJS({
     };
     module2.exports = async function(zipPath, opts) {
       debug("creating target directory", opts.dir);
-      if (!path8.isAbsolute(opts.dir)) {
+      if (!path9.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
-      await fs7.mkdir(opts.dir, { recursive: true });
-      opts.dir = await fs7.realpath(opts.dir);
+      await fs8.mkdir(opts.dir, { recursive: true });
+      opts.dir = await fs8.realpath(opts.dir);
       return new Extractor(zipPath, opts).extract();
     };
   }
@@ -8980,7 +8980,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;
@@ -11567,8 +11567,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path8) {
-      var parts = path8.split("/");
+    exports2.resolve = function(path9) {
+      var parts = path9.split("/");
       var result = [];
       for (var index2 = 0; index2 < parts.length; index2++) {
         var part = parts[index2];
@@ -17421,18 +17421,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path8) {
-      if (path8.slice(-1) === "/") {
-        path8 = path8.substring(0, path8.length - 1);
+    var parentFolder = function(path9) {
+      if (path9.slice(-1) === "/") {
+        path9 = path9.substring(0, path9.length - 1);
       }
-      var lastSlash = path8.lastIndexOf("/");
-      return lastSlash > 0 ? path8.substring(0, lastSlash) : "";
+      var lastSlash = path9.lastIndexOf("/");
+      return lastSlash > 0 ? path9.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path8) {
-      if (path8.slice(-1) !== "/") {
-        path8 += "/";
+    var forceTrailingSlash = function(path9) {
+      if (path9.slice(-1) !== "/") {
+        path9 += "/";
       }
-      return path8;
+      return path9;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults2.createFolders;
@@ -18485,54 +18485,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs7) {
+    function patch(fs8) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs7);
-      }
-      if (!fs7.lutimes) {
-        patchLutimes(fs7);
-      }
-      fs7.chown = chownFix(fs7.chown);
-      fs7.fchown = chownFix(fs7.fchown);
-      fs7.lchown = chownFix(fs7.lchown);
-      fs7.chmod = chmodFix(fs7.chmod);
-      fs7.fchmod = chmodFix(fs7.fchmod);
-      fs7.lchmod = chmodFix(fs7.lchmod);
-      fs7.chownSync = chownFixSync(fs7.chownSync);
-      fs7.fchownSync = chownFixSync(fs7.fchownSync);
-      fs7.lchownSync = chownFixSync(fs7.lchownSync);
-      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
-      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
-      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
-      fs7.stat = statFix(fs7.stat);
-      fs7.fstat = statFix(fs7.fstat);
-      fs7.lstat = statFix(fs7.lstat);
-      fs7.statSync = statFixSync(fs7.statSync);
-      fs7.fstatSync = statFixSync(fs7.fstatSync);
-      fs7.lstatSync = statFixSync(fs7.lstatSync);
-      if (fs7.chmod && !fs7.lchmod) {
-        fs7.lchmod = function(path8, mode, cb) {
+        patchLchmod(fs8);
+      }
+      if (!fs8.lutimes) {
+        patchLutimes(fs8);
+      }
+      fs8.chown = chownFix(fs8.chown);
+      fs8.fchown = chownFix(fs8.fchown);
+      fs8.lchown = chownFix(fs8.lchown);
+      fs8.chmod = chmodFix(fs8.chmod);
+      fs8.fchmod = chmodFix(fs8.fchmod);
+      fs8.lchmod = chmodFix(fs8.lchmod);
+      fs8.chownSync = chownFixSync(fs8.chownSync);
+      fs8.fchownSync = chownFixSync(fs8.fchownSync);
+      fs8.lchownSync = chownFixSync(fs8.lchownSync);
+      fs8.chmodSync = chmodFixSync(fs8.chmodSync);
+      fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
+      fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
+      fs8.stat = statFix(fs8.stat);
+      fs8.fstat = statFix(fs8.fstat);
+      fs8.lstat = statFix(fs8.lstat);
+      fs8.statSync = statFixSync(fs8.statSync);
+      fs8.fstatSync = statFixSync(fs8.fstatSync);
+      fs8.lstatSync = statFixSync(fs8.lstatSync);
+      if (fs8.chmod && !fs8.lchmod) {
+        fs8.lchmod = function(path9, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs7.lchmodSync = function() {
+        fs8.lchmodSync = function() {
         };
       }
-      if (fs7.chown && !fs7.lchown) {
-        fs7.lchown = function(path8, uid, gid, cb) {
+      if (fs8.chown && !fs8.lchown) {
+        fs8.lchown = function(path9, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs7.lchownSync = function() {
+        fs8.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : (function(fs$rename) {
+        fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : (function(fs$rename) {
           function rename(from2, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from2, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs7.stat(to, function(stater, st) {
+                  fs8.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from2, to, CB);
                     else
@@ -18548,9 +18548,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs7.rename);
+        })(fs8.rename);
       }
-      fs7.read = typeof fs7.read !== "function" ? fs7.read : (function(fs$read) {
+      fs8.read = typeof fs8.read !== "function" ? fs8.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -18558,22 +18558,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs7.read);
-      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs8.read);
+      fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs8, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -18583,11 +18583,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs7.readSync);
-      function patchLchmod(fs8) {
-        fs8.lchmod = function(path8, mode, callback) {
-          fs8.open(
-            path8,
+      })(fs8.readSync);
+      function patchLchmod(fs9) {
+        fs9.lchmod = function(path9, mode, callback) {
+          fs9.open(
+            path9,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -18595,80 +18595,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs8.fchmod(fd, mode, function(err2) {
-                fs8.close(fd, function(err22) {
+              fs9.fchmod(fd, mode, function(err2) {
+                fs9.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs8.lchmodSync = function(path8, mode) {
-          var fd = fs8.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs9.lchmodSync = function(path9, mode) {
+          var fd = fs9.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs8.fchmodSync(fd, mode);
+            ret = fs9.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs8.closeSync(fd);
+                fs9.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs8.closeSync(fd);
+              fs9.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs8) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
-          fs8.lutimes = function(path8, at, mt, cb) {
-            fs8.open(path8, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs9) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
+          fs9.lutimes = function(path9, at, mt, cb) {
+            fs9.open(path9, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs8.futimes(fd, at, mt, function(er2) {
-                fs8.close(fd, function(er22) {
+              fs9.futimes(fd, at, mt, function(er2) {
+                fs9.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs8.lutimesSync = function(path8, at, mt) {
-            var fd = fs8.openSync(path8, constants.O_SYMLINK);
+          fs9.lutimesSync = function(path9, at, mt) {
+            var fd = fs9.openSync(path9, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs8.futimesSync(fd, at, mt);
+              ret = fs9.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs8.closeSync(fd);
+                  fs9.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs8.closeSync(fd);
+                fs9.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs8.futimes) {
-          fs8.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs9.futimes) {
+          fs9.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs8.lutimesSync = function() {
+          fs9.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs7, target, mode, function(er) {
+          return orig.call(fs8, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -18678,7 +18678,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs7, target, mode);
+            return orig.call(fs8, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -18687,7 +18687,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs7, target, uid, gid, function(er) {
+          return orig.call(fs8, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -18697,7 +18697,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs7, target, uid, gid);
+            return orig.call(fs8, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -18717,13 +18717,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
+          return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
+          var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -18752,16 +18752,16 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs7) {
+    function legacy(fs8) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path8, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path8, options);
+      function ReadStream(path9, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
         Stream2.call(this);
         var self2 = this;
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -18795,7 +18795,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs8.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -18806,10 +18806,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path8, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path8, options);
+      function WriteStream(path9, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
         Stream2.call(this);
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -18834,7 +18834,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs7.open;
+          this._open = fs8.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -18869,7 +18869,7 @@ var require_clone = __commonJS({
 // ../../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -18901,12 +18901,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs7[gracefulQueue]) {
+    if (!fs8[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs7, queue);
-      fs7.close = (function(fs$close) {
+      publishQueue(fs8, queue);
+      fs8.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs7, fd, function(err) {
+          return fs$close.call(fs8, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -18918,48 +18918,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs7.close);
-      fs7.closeSync = (function(fs$closeSync) {
+      })(fs8.close);
+      fs8.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs7, arguments);
+          fs$closeSync.apply(fs8, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs7.closeSync);
+      })(fs8.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs7[gracefulQueue]);
-          require("assert").equal(fs7[gracefulQueue].length, 0);
+          debug(fs8[gracefulQueue]);
+          require("assert").equal(fs8[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs7[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs7));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
-      module2.exports = patch(fs7);
-      fs7.__patched = true;
-    }
-    function patch(fs8) {
-      polyfills(fs8);
-      fs8.gracefulify = patch;
-      fs8.createReadStream = createReadStream;
-      fs8.createWriteStream = createWriteStream;
-      var fs$readFile = fs8.readFile;
-      fs8.readFile = readFile;
-      function readFile(path8, options, cb) {
+      publishQueue(global, fs8[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs8));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
+      module2.exports = patch(fs8);
+      fs8.__patched = true;
+    }
+    function patch(fs9) {
+      polyfills(fs9);
+      fs9.gracefulify = patch;
+      fs9.createReadStream = createReadStream;
+      fs9.createWriteStream = createWriteStream;
+      var fs$readFile = fs9.readFile;
+      fs9.readFile = readFile;
+      function readFile(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path8, options, cb);
-        function go$readFile(path9, options2, cb2, startTime) {
-          return fs$readFile(path9, options2, function(err) {
+        return go$readFile(path9, options, cb);
+        function go$readFile(path10, options2, cb2, startTime) {
+          return fs$readFile(path10, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -18967,16 +18967,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs8.writeFile;
-      fs8.writeFile = writeFile;
-      function writeFile(path8, data, options, cb) {
+      var fs$writeFile = fs9.writeFile;
+      fs9.writeFile = writeFile;
+      function writeFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path8, data, options, cb);
-        function go$writeFile(path9, data2, options2, cb2, startTime) {
-          return fs$writeFile(path9, data2, options2, function(err) {
+        return go$writeFile(path9, data, options, cb);
+        function go$writeFile(path10, data2, options2, cb2, startTime) {
+          return fs$writeFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -18984,17 +18984,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs8.appendFile;
+      var fs$appendFile = fs9.appendFile;
       if (fs$appendFile)
-        fs8.appendFile = appendFile;
-      function appendFile(path8, data, options, cb) {
+        fs9.appendFile = appendFile;
+      function appendFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path8, data, options, cb);
-        function go$appendFile(path9, data2, options2, cb2, startTime) {
-          return fs$appendFile(path9, data2, options2, function(err) {
+        return go$appendFile(path9, data, options, cb);
+        function go$appendFile(path10, data2, options2, cb2, startTime) {
+          return fs$appendFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -19002,9 +19002,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs8.copyFile;
+      var fs$copyFile = fs9.copyFile;
       if (fs$copyFile)
-        fs8.copyFile = copyFile;
+        fs9.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -19022,34 +19022,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs8.readdir;
-      fs8.readdir = readdir2;
+      var fs$readdir = fs9.readdir;
+      fs9.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path8, options, cb) {
+      function readdir2(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options2, cb2, startTime) {
-          return fs$readdir(path9, fs$readdirCallback(
-            path9,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path9, options2, cb2, startTime) {
-          return fs$readdir(path9, options2, fs$readdirCallback(
-            path9,
+        } : function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, options2, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path8, options, cb);
-        function fs$readdirCallback(path9, options2, cb2, startTime) {
+        return go$readdir(path9, options, cb);
+        function fs$readdirCallback(path10, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path9, options2, cb2],
+                [path10, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -19064,21 +19064,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs8);
+        var legStreams = legacy(fs9);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs8.ReadStream;
+      var fs$ReadStream = fs9.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs8.WriteStream;
+      var fs$WriteStream = fs9.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs8, "ReadStream", {
+      Object.defineProperty(fs9, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -19088,7 +19088,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs8, "WriteStream", {
+      Object.defineProperty(fs9, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -19099,7 +19099,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs8, "FileReadStream", {
+      Object.defineProperty(fs9, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -19110,7 +19110,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs8, "FileWriteStream", {
+      Object.defineProperty(fs9, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -19120,7 +19120,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path8, options) {
+      function ReadStream(path9, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -19140,7 +19140,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path8, options) {
+      function WriteStream(path9, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -19158,22 +19158,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path8, options) {
-        return new fs8.ReadStream(path8, options);
+      function createReadStream(path9, options) {
+        return new fs9.ReadStream(path9, options);
       }
-      function createWriteStream(path8, options) {
-        return new fs8.WriteStream(path8, options);
+      function createWriteStream(path9, options) {
+        return new fs9.WriteStream(path9, options);
       }
-      var fs$open = fs8.open;
-      fs8.open = open;
-      function open(path8, flags, mode, cb) {
+      var fs$open = fs9.open;
+      fs9.open = open;
+      function open(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path8, flags, mode, cb);
-        function go$open(path9, flags2, mode2, cb2, startTime) {
-          return fs$open(path9, flags2, mode2, function(err, fd) {
+        return go$open(path9, flags, mode, cb);
+        function go$open(path10, flags2, mode2, cb2, startTime) {
+          return fs$open(path10, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -19181,20 +19181,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs8;
+      return fs9;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs7[gracefulQueue].push(elem);
+      fs8[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs7[gracefulQueue].length; ++i) {
-        if (fs7[gracefulQueue][i].length > 2) {
-          fs7[gracefulQueue][i][3] = now;
-          fs7[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs8[gracefulQueue].length; ++i) {
+        if (fs8[gracefulQueue][i].length > 2) {
+          fs8[gracefulQueue][i][3] = now;
+          fs8[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -19202,9 +19202,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs7[gracefulQueue].length === 0)
+      if (fs8[gracefulQueue].length === 0)
         return;
-      var elem = fs7[gracefulQueue].shift();
+      var elem = fs8[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -19226,7 +19226,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs7[gracefulQueue].push(elem);
+          fs8[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -19241,7 +19241,7 @@ var require_fs = __commonJS({
   "../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -19282,26 +19282,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs7[key] === "function";
+      return typeof fs8[key] === "function";
     });
-    Object.assign(exports2, fs7);
+    Object.assign(exports2, fs8);
     api.forEach((method) => {
-      exports2[method] = u(fs7[method]);
+      exports2[method] = u(fs8[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs7.exists(filename, callback);
+        return fs8.exists(filename, callback);
       }
       return new Promise((resolve4) => {
-        return fs7.exists(filename, resolve4);
+        return fs8.exists(filename, resolve4);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs7.read(fd, buffer, offset, length, position, callback);
+        return fs8.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve4, reject) => {
-        fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs8.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve4({ bytesRead, buffer: buffer2 });
         });
@@ -19309,10 +19309,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.write(fd, buffer, ...args);
+        return fs8.write(fd, buffer, ...args);
       }
       return new Promise((resolve4, reject) => {
-        fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs8.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve4({ bytesWritten, buffer: buffer2 });
         });
@@ -19320,10 +19320,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.readv(fd, buffers, ...args);
+        return fs8.readv(fd, buffers, ...args);
       }
       return new Promise((resolve4, reject) => {
-        fs7.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs8.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve4({ bytesRead, buffers: buffers2 });
         });
@@ -19331,17 +19331,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs7.writev(fd, buffers, ...args);
+        return fs8.writev(fd, buffers, ...args);
       }
       return new Promise((resolve4, reject) => {
-        fs7.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs8.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve4({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs7.realpath.native === "function") {
-      exports2.realpath.native = u(fs7.realpath.native);
+    if (typeof fs8.realpath.native === "function") {
+      exports2.realpath.native = u(fs8.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -19356,10 +19356,10 @@ var require_fs = __commonJS({
 var require_utils2 = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path8 = require("path");
+    var path9 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path8.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path9.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -19374,7 +19374,7 @@ var require_utils2 = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var { checkPath } = require_utils2();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -19383,14 +19383,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs7.mkdir(dir, {
+      return fs8.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs7.mkdirSync(dir, {
+      return fs8.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -19422,13 +19422,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    function pathExists(path8) {
-      return fs7.access(path8).then(() => true).catch(() => false);
+    var fs8 = require_fs();
+    function pathExists(path9) {
+      return fs8.access(path9).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs7.existsSync
+      pathExistsSync: fs8.existsSync
     };
   }
 });
@@ -19437,16 +19437,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path8, atime, mtime) {
-      const fd = await fs7.open(path8, "r+");
+    async function utimesMillis(path9, atime, mtime) {
+      const fd = await fs8.open(path9, "r+");
       let closeErr = null;
       try {
-        await fs7.futimes(fd, atime, mtime);
+        await fs8.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs7.close(fd);
+          await fs8.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -19455,10 +19455,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path8, atime, mtime) {
-      const fd = fs7.openSync(path8, "r+");
-      fs7.futimesSync(fd, atime, mtime);
-      return fs7.closeSync(fd);
+    function utimesMillisSync(path9, atime, mtime) {
+      const fd = fs8.openSync(path9, "r+");
+      fs8.futimesSync(fd, atime, mtime);
+      return fs8.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -19471,11 +19471,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
-    var path8 = require("path");
+    var fs8 = require_fs();
+    var path9 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs7.stat(file, { bigint: true }) : (file) => fs7.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs8.stat(file, { bigint: true }) : (file) => fs8.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -19486,7 +19486,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs7.statSync(file, { bigint: true }) : (file) => fs7.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs8.statSync(file, { bigint: true }) : (file) => fs8.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -19500,8 +19500,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path8.basename(src);
-          const destBaseName = path8.basename(dest);
+          const srcBaseName = path9.basename(src);
+          const destBaseName = path9.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -19523,8 +19523,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path8.basename(src);
-          const destBaseName = path8.basename(dest);
+          const srcBaseName = path9.basename(src);
+          const destBaseName = path9.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -19543,12 +19543,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path8.resolve(path8.dirname(src));
-      const destParent = path8.resolve(path8.dirname(dest));
-      if (destParent === srcParent || destParent === path8.parse(destParent).root) return;
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs7.stat(destParent, { bigint: true });
+        destStat = await fs8.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -19559,12 +19559,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path8.resolve(path8.dirname(src));
-      const destParent = path8.resolve(path8.dirname(dest));
-      if (destParent === srcParent || destParent === path8.parse(destParent).root) return;
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs7.statSync(destParent, { bigint: true });
+        destStat = fs8.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -19578,8 +19578,8 @@ var require_stat = __commonJS({
       return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path8.resolve(src).split(path8.sep).filter((i) => i);
-      const destArr = path8.resolve(dest).split(path8.sep).filter((i) => i);
+      const srcArr = path9.resolve(src).split(path9.sep).filter((i) => i);
+      const destArr = path9.resolve(dest).split(path9.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -19631,8 +19631,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
-    var path8 = require("path");
+    var fs8 = require_fs();
+    var path9 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -19655,7 +19655,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path8.dirname(dest);
+      const destParent = path9.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -19667,7 +19667,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs7.stat : fs7.lstat;
+      const statFn = opts.dereference ? fs8.stat : fs8.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -19679,7 +19679,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs7.unlink(dest);
+        await fs8.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -19687,29 +19687,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs7.copyFile(src, dest);
+      await fs8.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs7.stat(src);
+        const updatedSrcStat = await fs8.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs7.chmod(dest, srcStat.mode);
+      return fs8.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs7.chmod(dest, srcMode | 128);
+      return fs8.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs7.mkdir(dest);
+        await fs8.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs7.opendir(src), async (item) => {
-        const srcItem = path8.join(src, item.name);
-        const destItem = path8.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs8.opendir(src), async (item) => {
+        const srcItem = path9.join(src, item.name);
+        const destItem = path9.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -19717,26 +19717,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs7.chmod(dest, srcStat.mode);
+        await fs8.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs7.readlink(src);
+      let resolvedSrc = await fs8.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs7.symlink(resolvedSrc, dest);
+        return fs8.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs7.readlink(dest);
+        resolvedDest = await fs8.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs7.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs8.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path9.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -19746,8 +19746,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs7.unlink(dest);
-      return fs7.symlink(resolvedSrc, dest);
+      await fs8.unlink(dest);
+      return fs8.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -19757,8 +19757,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
-    var path8 = require("path");
+    var fs8 = require_graceful_fs();
+    var path9 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -19779,12 +19779,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path8.dirname(dest);
-      if (!fs7.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path9.dirname(dest);
+      if (!fs8.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync2 = opts.dereference ? fs7.statSync : fs7.lstatSync;
+      const statSync2 = opts.dereference ? fs8.statSync : fs8.lstatSync;
       const srcStat = statSync2(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -19799,14 +19799,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs7.unlinkSync(dest);
+        fs8.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs7.copyFileSync(src, dest);
+      fs8.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -19821,10 +19821,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs7.chmodSync(dest, srcMode);
+      return fs8.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs7.statSync(src);
+      const updatedSrcStat = fs8.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -19832,12 +19832,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs7.mkdirSync(dest);
+      fs8.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs7.opendirSync(src);
+      const dir = fs8.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -19848,29 +19848,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path8.join(src, item);
-      const destItem = path8.join(dest, item);
+      const srcItem = path9.join(src, item);
+      const destItem = path9.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs7.readlinkSync(src);
+      let resolvedSrc = fs8.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs7.symlinkSync(resolvedSrc, dest);
+        return fs8.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs7.readlinkSync(dest);
+          resolvedDest = fs8.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs7.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs8.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path9.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -19884,8 +19884,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs7.unlinkSync(dest);
-      return fs7.symlinkSync(resolvedSrc, dest);
+      fs8.unlinkSync(dest);
+      return fs8.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -19907,13 +19907,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
+    var fs8 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path8, callback) {
-      fs7.rm(path8, { recursive: true, force: true }, callback);
+    function remove(path9, callback) {
+      fs8.rm(path9, { recursive: true, force: true }, callback);
     }
-    function removeSync(path8) {
-      fs7.rmSync(path8, { recursive: true, force: true });
+    function removeSync(path9) {
+      fs8.rmSync(path9, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -19927,28 +19927,28 @@ var require_empty = __commonJS({
   "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    var path8 = require("path");
+    var fs8 = require_fs();
+    var path9 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs7.readdir(dir);
+        items = await fs8.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path8.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path9.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs7.readdirSync(dir);
+        items = fs8.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path8.join(dir, item);
+        item = path9.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -19966,52 +19966,52 @@ var require_file = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path8 = require("path");
-    var fs7 = require_fs();
+    var path9 = require("path");
+    var fs8 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs7.stat(file);
+        stats = await fs8.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path8.dirname(file);
+      const dir = path9.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs7.stat(dir);
+        dirStats = await fs8.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs7.writeFile(file, "");
+          await fs8.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs7.writeFile(file, "");
+        await fs8.writeFile(file, "");
       } else {
-        await fs7.readdir(dir);
+        await fs8.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs7.statSync(file);
+        stats = fs8.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path8.dirname(file);
+      const dir = path9.dirname(file);
       try {
-        if (!fs7.statSync(dir).isDirectory()) {
-          fs7.readdirSync(dir);
+        if (!fs8.statSync(dir).isDirectory()) {
+          fs8.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs7.writeFileSync(file, "");
+      fs8.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -20025,50 +20025,50 @@ var require_link = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path8 = require("path");
-    var fs7 = require_fs();
+    var path9 = require("path");
+    var fs8 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs7.lstat(dstpath);
+        dstStat = await fs8.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs7.lstat(srcpath);
+        srcStat = await fs8.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path8.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs7.link(srcpath, dstpath);
+      await fs8.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs7.lstatSync(dstpath);
+        dstStat = fs8.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs7.lstatSync(srcpath);
+        const srcStat = fs8.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path8.dirname(dstpath);
-      const dirExists = fs7.existsSync(dir);
-      if (dirExists) return fs7.linkSync(srcpath, dstpath);
+      const dir = path9.dirname(dstpath);
+      const dirExists = fs8.existsSync(dir);
+      if (dirExists) return fs8.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs7.linkSync(srcpath, dstpath);
+      return fs8.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -20081,14 +20081,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path8 = require("path");
-    var fs7 = require_fs();
+    var path9 = require("path");
+    var fs8 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path8.isAbsolute(srcpath)) {
+      if (path9.isAbsolute(srcpath)) {
         try {
-          await fs7.lstat(srcpath);
+          await fs8.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -20098,8 +20098,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path8.dirname(dstpath);
-      const relativeToDst = path8.join(dstdir, srcpath);
+      const dstdir = path9.dirname(dstpath);
+      const relativeToDst = path9.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -20108,39 +20108,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs7.lstat(srcpath);
+        await fs8.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path8.relative(dstdir, srcpath)
+        toDst: path9.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path8.isAbsolute(srcpath)) {
-        const exists2 = fs7.existsSync(srcpath);
+      if (path9.isAbsolute(srcpath)) {
+        const exists2 = fs8.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path8.dirname(dstpath);
-      const relativeToDst = path8.join(dstdir, srcpath);
-      const exists = fs7.existsSync(relativeToDst);
+      const dstdir = path9.dirname(dstpath);
+      const relativeToDst = path9.join(dstdir, srcpath);
+      const exists = fs8.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs7.existsSync(srcpath);
+      const srcExists = fs8.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path8.relative(dstdir, srcpath)
+        toDst: path9.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -20154,13 +20154,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
+    var fs8 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs7.lstat(srcpath);
+        stats = await fs8.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -20170,7 +20170,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs7.lstatSync(srcpath);
+        stats = fs8.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -20188,8 +20188,8 @@ var require_symlink = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path8 = require("path");
-    var fs7 = require_fs();
+    var path9 = require("path");
+    var fs8 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -20198,44 +20198,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs7.lstat(dstpath);
+        stats = await fs8.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs7.stat(srcpath),
-          fs7.stat(dstpath)
+          fs8.stat(srcpath),
+          fs8.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = await symlinkPaths(srcpath, dstpath);
       srcpath = relative2.toDst;
       const toType = await symlinkType(relative2.toCwd, type);
-      const dir = path8.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs7.symlink(srcpath, dstpath, toType);
+      return fs8.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs7.lstatSync(dstpath);
+        stats = fs8.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs7.statSync(srcpath);
-        const dstStat = fs7.statSync(dstpath);
+        const srcStat = fs8.statSync(srcpath);
+        const dstStat = fs8.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
-      const dir = path8.dirname(dstpath);
-      const exists = fs7.existsSync(dir);
-      if (exists) return fs7.symlinkSync(srcpath, dstpath, type);
+      const dir = path9.dirname(dstpath);
+      const exists = fs8.existsSync(dir);
+      if (exists) return fs8.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs7.symlinkSync(srcpath, dstpath, type);
+      return fs8.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -20302,9 +20302,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs7.readFile)(file, options);
+      let data = await universalify.fromCallback(fs8.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -20320,14 +20320,14 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     var readFile = universalify.fromPromise(_readFile);
-    function readFileSync5(file, options = {}) {
+    function readFileSync6(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs7.readFileSync(file, options);
+        let content = fs8.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -20340,21 +20340,21 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+      const fs8 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs7.writeFile)(file, str, options);
+      await universalify.fromCallback(fs8.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
-    function writeFileSync6(file, obj, options = {}) {
-      const fs7 = options.fs || _fs;
+    function writeFileSync7(file, obj, options = {}) {
+      const fs8 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs7.writeFileSync(file, str, options);
+      return fs8.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile,
-      readFileSync: readFileSync5,
+      readFileSync: readFileSync6,
       writeFile,
-      writeFileSync: writeFileSync6
+      writeFileSync: writeFileSync7
     };
   }
 });
@@ -20379,23 +20379,23 @@ var require_output_file = __commonJS({
   "../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs7 = require_fs();
-    var path8 = require("path");
+    var fs8 = require_fs();
+    var path9 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path8.dirname(file);
+      const dir = path9.dirname(file);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs7.writeFile(file, data, encoding);
+      return fs8.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path8.dirname(file);
-      if (!fs7.existsSync(dir)) {
+      const dir = path9.dirname(file);
+      if (!fs8.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs7.writeFileSync(file, ...args);
+      fs8.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -20454,8 +20454,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_fs();
-    var path8 = require("path");
+    var fs8 = require_fs();
+    var path9 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -20465,8 +20465,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path8.dirname(dest);
-      const parsedParentPath = path8.parse(destParent);
+      const destParent = path9.dirname(dest);
+      const parsedParentPath = path9.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -20481,7 +20481,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs7.rename(src, dest);
+        await fs8.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -20506,8 +20506,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs7 = require_graceful_fs();
-    var path8 = require("path");
+    var fs8 = require_graceful_fs();
+    var path9 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -20517,12 +20517,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path8.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path9.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path8.dirname(dest);
-      const parsedPath = path8.parse(parent);
+      const parent = path9.dirname(dest);
+      const parsedPath = path9.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -20531,12 +20531,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs7.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs8.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs7.renameSync(src, dest);
+        fs8.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -26340,10 +26340,10 @@ var require_lib6 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve4, reject) => {
       let fd;
-      const fs7 = (0, node_1.default)();
+      const fs8 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs7.closeSync(fd);
+          fs8.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -26355,9 +26355,9 @@ var require_lib6 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs7.openSync(filepath, "r");
+        fd = fs8.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs7.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs8.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -26369,22 +26369,22 @@ var require_lib6 = __commonJS({
         });
         return;
       }
-      fs7.readFile(filepath, handler);
+      fs8.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs7 = (0, node_1.default)();
+      const fs8 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs7.openSync(filepath, "r");
+        const fd = fs8.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs7.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs8.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs7.closeSync(fd);
+        fs8.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs7.readFileSync(filepath));
+      return (0, exports2.detect)(fs8.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -39927,21 +39927,21 @@ function camelCase(input, options) {
 
 // src/commands/init/v2/index.ts
 var spawn = __toESM(require_cross_spawn(), 1);
-var fs6 = __toESM(require("fs"), 1);
+var fs7 = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
-var path6 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 
 // package.json
-var version = "3.8.10";
+var version = "3.9.1";
 
 // src/helpers/index.ts
 var fs2 = __toESM(require("fs"), 1);
 var isAlphaNumericAndHyphens = (str) => {
   return /^[a-zA-Z0-9-]+$/.test(str);
 };
-function isEmptyDir(path8) {
+function isEmptyDir(path9) {
   try {
-    const directory = fs2.opendirSync(path8);
+    const directory = fs2.opendirSync(path9);
     const entry = directory.readSync();
     directory.closeSync();
     return entry === null;
@@ -44143,12 +44143,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path8) {
-    if (!path8) {
+  resolve(path9) {
+    if (!path9) {
       return this;
     }
-    const rootPath = this.getRootString(path8);
-    const dir = path8.substring(rootPath.length);
+    const rootPath = this.getRootString(path9);
+    const dir = path9.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -44900,8 +44900,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path8) {
-    return import_node_path.win32.parse(path8).root;
+  getRootString(path9) {
+    return import_node_path.win32.parse(path9).root;
   }
   /**
    * @internal
@@ -44947,8 +44947,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path8) {
-    return path8.startsWith("/") ? "/" : "";
+  getRootString(path9) {
+    return path9.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -44997,8 +44997,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs7);
+  constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs8 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs8);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -45037,11 +45037,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path8 = this.cwd) {
-    if (typeof path8 === "string") {
-      path8 = this.cwd.resolve(path8);
+  depth(path9 = this.cwd) {
+    if (typeof path9 === "string") {
+      path9 = this.cwd.resolve(path9);
     }
-    return path8.depth();
+    return path9.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -45528,9 +45528,9 @@ var PathScurryBase = class {
     process4();
     return results;
   }
-  chdir(path8 = this.cwd) {
+  chdir(path9 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
+    this.cwd = typeof path9 === "string" ? this.cwd.resolve(path9) : path9;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -45556,8 +45556,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs7) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+  newRoot(fs8) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -45585,8 +45585,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs7) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+  newRoot(fs8) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -45886,8 +45886,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path8, n]) => [
-      path8,
+    return [...this.store.entries()].map(([path9, n]) => [
+      path9,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -46092,9 +46092,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path8, opts) {
+  constructor(patterns, path9, opts) {
     this.patterns = patterns;
-    this.path = path8;
+    this.path = path9;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -46113,11 +46113,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path8) {
-    return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
+  #ignored(path9) {
+    return this.seen.has(path9) || !!this.#ignore?.ignored?.(path9);
   }
-  #childrenIgnored(path8) {
-    return !!this.#ignore?.childrenIgnored?.(path8);
+  #childrenIgnored(path9) {
+    return !!this.#ignore?.childrenIgnored?.(path9);
   }
   // backpressure mechanism
   pause() {
@@ -46332,8 +46332,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path8, opts) {
-    super(patterns, path8, opts);
+  constructor(patterns, path9, opts) {
+    super(patterns, path9, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -46370,8 +46370,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path8, opts) {
-    super(patterns, path8, opts);
+  constructor(patterns, path9, opts) {
+    super(patterns, path9, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -48035,8 +48035,8 @@ JSONPath.prototype._getPreferredOutput = function(ea) {
   const resultType = this.currResultType;
   switch (resultType) {
     case "all": {
-      const path8 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
-      ea.pointer = JSONPath.toPointer(path8);
+      const path9 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
+      ea.pointer = JSONPath.toPointer(path9);
       ea.path = typeof ea.path === "string" ? ea.path : JSONPath.toPathString(ea.path);
       return ea;
     }
@@ -48059,11 +48059,11 @@ JSONPath.prototype._handleCallback = function(fullRetObj, callback, type) {
     callback(preferredOutput, type, fullRetObj);
   }
 };
-JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, callback, hasArrExpr, literalPriority) {
+JSONPath.prototype._trace = function(expr, val, path9, parent, parentPropName, callback, hasArrExpr, literalPriority) {
   let retObj;
   if (!expr.length) {
     retObj = {
-      path: path8,
+      path: path9,
       value: val,
       parent,
       parentProperty: parentPropName,
@@ -48084,28 +48084,28 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
     }
   }
   if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path8, loc), val, loc, callback, hasArrExpr));
+    addRet(this._trace(x, val[loc], push(path9, loc), val, loc, callback, hasArrExpr));
   } else if (loc === "*") {
     this._walk(val, (m) => {
-      addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true, true));
+      addRet(this._trace(x, val[m], push(path9, m), val, m, callback, true, true));
     });
   } else if (loc === "..") {
-    addRet(this._trace(x, val, path8, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(x, val, path9, parent, parentPropName, callback, hasArrExpr));
     this._walk(val, (m) => {
       if (typeof val[m] === "object") {
-        addRet(this._trace(expr.slice(), val[m], push(path8, m), val, m, callback, true));
+        addRet(this._trace(expr.slice(), val[m], push(path9, m), val, m, callback, true));
       }
     });
   } else if (loc === "^") {
     this._hasParentSelector = true;
     return {
-      path: path8.slice(0, -1),
+      path: path9.slice(0, -1),
       expr: x,
       isParentSelector: true
     };
   } else if (loc === "~") {
     retObj = {
-      path: push(path8, loc),
+      path: push(path9, loc),
       value: parentPropName,
       parent,
       parentProperty: null
@@ -48113,9 +48113,9 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
     this._handleCallback(retObj, callback, "property");
     return retObj;
   } else if (loc === "$") {
-    addRet(this._trace(x, val, path8, null, null, callback, hasArrExpr));
+    addRet(this._trace(x, val, path9, null, null, callback, hasArrExpr));
   } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
-    addRet(this._slice(loc, x, val, path8, parent, parentPropName, callback));
+    addRet(this._slice(loc, x, val, path9, parent, parentPropName, callback));
   } else if (loc.indexOf("?(") === 0) {
     if (this.currEval === false) {
       throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
@@ -48126,15 +48126,15 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
       this._walk(val, (m) => {
         const npath = [nested[2]];
         const nvalue = nested[1] ? val[m][nested[1]] : val[m];
-        const filterResults = this._trace(npath, nvalue, path8, parent, parentPropName, callback, true);
+        const filterResults = this._trace(npath, nvalue, path9, parent, parentPropName, callback, true);
         if (filterResults.length > 0) {
-          addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true));
+          addRet(this._trace(x, val[m], push(path9, m), val, m, callback, true));
         }
       });
     } else {
       this._walk(val, (m) => {
-        if (this._eval(safeLoc, val[m], m, path8, parent, parentPropName)) {
-          addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true));
+        if (this._eval(safeLoc, val[m], m, path9, parent, parentPropName)) {
+          addRet(this._trace(x, val[m], push(path9, m), val, m, callback, true));
         }
       });
     }
@@ -48142,7 +48142,7 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
     if (this.currEval === false) {
       throw new Error("Eval [(expr)] prevented in JSONPath expression.");
     }
-    addRet(this._trace(unshift(this._eval(loc, val, path8.at(-1), path8.slice(0, -1), parent, parentPropName), x), val, path8, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(unshift(this._eval(loc, val, path9.at(-1), path9.slice(0, -1), parent, parentPropName), x), val, path9, parent, parentPropName, callback, hasArrExpr));
   } else if (loc[0] === "@") {
     let addType = false;
     const valueType = loc.slice(1, -2);
@@ -48186,7 +48186,7 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
         }
         break;
       case "other":
-        addType = this.currOtherTypeCallback(val, path8, parent, parentPropName);
+        addType = this.currOtherTypeCallback(val, path9, parent, parentPropName);
         break;
       case "null":
         if (val === null) {
@@ -48199,7 +48199,7 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
     }
     if (addType) {
       retObj = {
-        path: path8,
+        path: path9,
         value: val,
         parent,
         parentProperty: parentPropName
@@ -48209,14 +48209,14 @@ JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, c
     }
   } else if (loc[0] === "`" && val && Object.hasOwn(val, loc.slice(1))) {
     const locProp = loc.slice(1);
-    addRet(this._trace(x, val[locProp], push(path8, locProp), val, locProp, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[locProp], push(path9, locProp), val, locProp, callback, hasArrExpr, true));
   } else if (loc.includes(",")) {
     const parts = loc.split(",");
     for (const part of parts) {
-      addRet(this._trace(unshift(part, x), val, path8, parent, parentPropName, callback, true));
+      addRet(this._trace(unshift(part, x), val, path9, parent, parentPropName, callback, true));
     }
   } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path8, loc), val, loc, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[loc], push(path9, loc), val, loc, callback, hasArrExpr, true));
   }
   if (this._hasParentSelector) {
     for (let t = 0; t < ret.length; t++) {
@@ -48250,7 +48250,7 @@ JSONPath.prototype._walk = function(val, f) {
     });
   }
 };
-JSONPath.prototype._slice = function(loc, expr, val, path8, parent, parentPropName, callback) {
+JSONPath.prototype._slice = function(loc, expr, val, path9, parent, parentPropName, callback) {
   if (!Array.isArray(val)) {
     return void 0;
   }
@@ -48260,14 +48260,14 @@ JSONPath.prototype._slice = function(loc, expr, val, path8, parent, parentPropNa
   end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);
   const ret = [];
   for (let i = start; i < end; i += step) {
-    const tmp = this._trace(unshift(i, expr), val, path8, parent, parentPropName, callback, true);
+    const tmp = this._trace(unshift(i, expr), val, path9, parent, parentPropName, callback, true);
     tmp.forEach((t) => {
       ret.push(t);
     });
   }
   return ret;
 };
-JSONPath.prototype._eval = function(code, _v, _vname, path8, parent, parentPropName) {
+JSONPath.prototype._eval = function(code, _v, _vname, path9, parent, parentPropName) {
   this.currSandbox._$_parentProperty = parentPropName;
   this.currSandbox._$_parent = parent;
   this.currSandbox._$_property = _vname;
@@ -48275,7 +48275,7 @@ JSONPath.prototype._eval = function(code, _v, _vname, path8, parent, parentPropN
   this.currSandbox._$_v = _v;
   const containsPath = code.includes("@path");
   if (containsPath) {
-    this.currSandbox._$_path = JSONPath.toPathString(path8.concat([_vname]));
+    this.currSandbox._$_path = JSONPath.toPathString(path9.concat([_vname]));
   }
   const scriptCacheKey = this.currEval + "Script:" + code;
   if (!JSONPath.cache[scriptCacheKey]) {
@@ -48718,10 +48718,32 @@ var SeekaAppScaffolder = class {
   }
 };
 
-// src/commands/ai/context/index.ts
-var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+// src/helpers/zip.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
 var import_jszip = __toESM(require_lib3(), 1);
+async function extractZipToDirectory(zipBuffer, destDir) {
+  const zip = await import_jszip.default.loadAsync(zipBuffer);
+  const entries = Object.entries(zip.files);
+  for (const [relativePath, zipEntry] of entries) {
+    const destPath = path4.join(destDir, relativePath);
+    if (zipEntry.dir) {
+      fs4.mkdirSync(destPath, { recursive: true });
+    } else {
+      fs4.mkdirSync(path4.dirname(destPath), { recursive: true });
+      const content = await zipEntry.async("nodebuffer");
+      fs4.writeFileSync(destPath, content);
+    }
+  }
+}
+async function extractZipFileToDirectory(zipPath, destDir) {
+  const zipBuffer = fs4.readFileSync(zipPath);
+  await extractZipToDirectory(zipBuffer, destDir);
+}
+
+// src/commands/ai/context/index.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/helpers/config/index.ts
 var import_path = __toESM(require("path"), 1);
@@ -48758,34 +48780,20 @@ async function downloadFile(url) {
   const arrayBuffer = await response.arrayBuffer();
   return Buffer.from(arrayBuffer);
 }
-async function extractZipToDirectory(zipBuffer, destDir) {
-  const zip = await import_jszip.default.loadAsync(zipBuffer);
-  const entries = Object.entries(zip.files);
-  for (const [relativePath, zipEntry] of entries) {
-    const destPath = path5.join(destDir, relativePath);
-    if (zipEntry.dir) {
-      fs5.mkdirSync(destPath, { recursive: true });
-    } else {
-      fs5.mkdirSync(path5.dirname(destPath), { recursive: true });
-      const content = await zipEntry.async("nodebuffer");
-      fs5.writeFileSync(destPath, content);
-    }
-  }
-}
 var aiContextCommand = async (options = {}) => {
   const targetDir = options.targetDir || process.cwd();
-  const contextDestDir = path5.join(targetDir, ".seeka", "ai", "context");
+  const contextDestDir = path6.join(targetDir, ".seeka", "ai", "context");
   const contextUrl = getContextPackageUrl(targetDir, options.contextPackageUrl);
   console.log("Seeka AI Context");
   console.log("================");
   console.log("");
   console.log(`Target: ${contextDestDir}`);
   console.log("");
-  if (fs5.existsSync(contextDestDir)) {
+  if (fs6.existsSync(contextDestDir)) {
     console.log("Removing existing AI context...");
-    fs5.rmSync(contextDestDir, { recursive: true, force: true });
+    fs6.rmSync(contextDestDir, { recursive: true, force: true });
   }
-  fs5.mkdirSync(contextDestDir, { recursive: true });
+  fs6.mkdirSync(contextDestDir, { recursive: true });
   console.log("Downloading AI context package...");
   let zipBuffer;
   try {
@@ -48823,8 +48831,8 @@ var aiContextCommand = async (options = {}) => {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     source: options.contextPackageUrl ? "custom" : "public"
   };
-  const metaPath = path5.join(contextDestDir, "meta.json");
-  fs5.writeFileSync(metaPath, JSON.stringify(metaJson, null, 2), "utf-8");
+  const metaPath = path6.join(contextDestDir, "meta.json");
+  fs6.writeFileSync(metaPath, JSON.stringify(metaJson, null, 2), "utf-8");
   console.log("");
   console.log("\u2713 AI context installed successfully!");
   console.log("");
@@ -48859,35 +48867,38 @@ var initCommandV2 = async (options) => {
   }
   const orgName = options.orgName.toLowerCase();
   const projectPascalCase = camelCase(projectName, { pascalCase: true });
-  const projectDir = path6.resolve(options.outputDirectory, !options.skipSubDir ? options.directoryName || projectName : "");
+  const projectDir = path7.resolve(options.outputDirectory, !options.skipSubDir ? options.directoryName || projectName : "");
   console.log(`Creating new ${options.template.replace(/-/gi, " ")} Seeka app in ${projectDir}`);
   console.log("");
-  if (!options.skipSubDir && fs6.existsSync(projectDir) && isEmptyDir(projectDir) === false) {
+  if (!options.skipSubDir && fs7.existsSync(projectDir) && isEmptyDir(projectDir) === false) {
     if (options.force) {
       console.log("--force was used and destination directory is not empty. Clearing out the directory");
-      const gitDirPath = path6.resolve(projectDir, ".git");
-      const gitDirExists = fs6.existsSync(gitDirPath);
+      const gitDirPath = path7.resolve(projectDir, ".git");
+      const gitDirExists = fs7.existsSync(gitDirPath);
       if (gitDirExists) {
         console.info(".git directory found in directory, I will preserve it and remove all other files and directories to prepare for the app creation");
       }
-      const items = fs6.readdirSync(projectDir);
+      const items = fs7.readdirSync(projectDir);
       for (const item of items) {
         if (item === ".git") {
           continue;
         }
-        const itemPath = path6.resolve(projectDir, item);
-        fs6.rmSync(itemPath, { recursive: true, force: true });
+        const itemPath = path7.resolve(projectDir, item);
+        fs7.rmSync(itemPath, { recursive: true, force: true });
       }
     } else {
       console.error("Directory is not empty. Use --force to create app in non-empty directory");
       return;
     }
   }
-  if (!fs6.existsSync(projectDir)) {
-    fs6.mkdirSync(projectDir, { recursive: true });
+  if (!fs7.existsSync(projectDir)) {
+    fs7.mkdirSync(projectDir, { recursive: true });
   }
-  const templateDir = path6.resolve(__dirname, "init-template");
-  const scaffoldOutputDir = options.skipSubDir ? fs6.mkdtempSync(path6.join(os2.tmpdir(), "seeka-app-init-v2-")) : projectDir;
+  const templateZipPath = path7.resolve(__dirname, "init-template.zip");
+  const templateDir = fs7.mkdtempSync(path7.join(os2.tmpdir(), "seeka-init-template-"));
+  console.log("Extracting template...");
+  await extractZipFileToDirectory(templateZipPath, templateDir);
+  const scaffoldOutputDir = options.skipSubDir ? fs7.mkdtempSync(path7.join(os2.tmpdir(), "seeka-app-init-v2-")) : projectDir;
   const scaffolder = new SeekaAppScaffolder();
   await scaffolder.scaffoldSeekaApp({
     templateDir,
@@ -48895,6 +48906,12 @@ var initCommandV2 = async (options) => {
     environmentVariables: options.environmentVariables,
     destinationDir: scaffoldOutputDir,
     force: options.force,
+    fileRenames: [
+      options.template === "azure-function" ? {
+        sourcePath: "./README.azurefunc.md",
+        newPath: "README.md"
+      } : null
+    ].filter(Boolean),
     textReplacements: [
       {
         sourcePath: "**/*",
@@ -48926,6 +48943,16 @@ var initCommandV2 = async (options) => {
         findText: "server-azurefunc",
         replaceText: "server"
       },
+      {
+        sourcePath: "README.md",
+        findText: "server-azurefunc",
+        replaceText: "server"
+      },
+      {
+        sourcePath: "app/ui/vite.config.mts",
+        findText: "server-azurefunc",
+        replaceText: "server"
+      },
       {
         sourcePath: "app/browser/scripts/esbuild/build-browser-plugin.mjs",
         findText: "server-azurefunc",
@@ -48989,8 +49016,8 @@ var initCommandV2 = async (options) => {
     ]
   });
   if (options.skipSubDir) {
-    fs6.cpSync(scaffoldOutputDir, projectDir, { recursive: true });
-    fs6.rmSync(scaffoldOutputDir, { recursive: true, force: true });
+    fs7.cpSync(scaffoldOutputDir, projectDir, { recursive: true });
+    fs7.rmSync(scaffoldOutputDir, { recursive: true, force: true });
   }
   if (options.installDependencies) {
     console.info("Installing package dependencies");
@@ -49000,7 +49027,7 @@ var initCommandV2 = async (options) => {
       console.error("Error installing package dependencies", err);
     }
   }
-  const yarnRcFilePath = path6.resolve(projectDir, ".yarnrc.yml");
+  const yarnRcFilePath = path7.resolve(projectDir, ".yarnrc.yml");
   let npmAuthToken = "<< GET TOKEN FROM https://seeka.app/settings/integrations/api >>";
   if (!options.npmUsername || !options.npmPassword) {
     console.warn('npmUsername and npmPassword was not provided. Either delete the "browser" directory from the app template before installing dependencies or get your NPM login from https://seeka.app/settings/integrations/api');
@@ -49008,7 +49035,7 @@ var initCommandV2 = async (options) => {
     console.log("Using NPM registry username " + options.npmUsername);
     npmAuthToken = `${options.npmUsername}:${options.npmPassword}`;
   }
-  fs6.writeFileSync(
+  fs7.writeFileSync(
     yarnRcFilePath,
     `nodeLinker: node-modules
 
@@ -49019,14 +49046,14 @@ npmScopes:
     npmRegistryServer: "https://npm.packages.seeka.services"`,
     { encoding: "utf8" }
   );
-  const yarnLockFilePath = path6.resolve(projectDir, "yarn.lock");
-  fs6.writeFileSync(yarnLockFilePath, "", { encoding: "utf8" });
-  const seekaDir = path6.join(projectDir, ".seeka");
-  if (!fs6.existsSync(seekaDir)) {
-    fs6.mkdirSync(seekaDir, { recursive: true });
+  const yarnLockFilePath = path7.resolve(projectDir, "yarn.lock");
+  fs7.writeFileSync(yarnLockFilePath, "", { encoding: "utf8" });
+  const seekaDir = path7.join(projectDir, ".seeka");
+  if (!fs7.existsSync(seekaDir)) {
+    fs7.mkdirSync(seekaDir, { recursive: true });
   }
   const { environmentVariables, ...otherOptions } = options;
-  const configPath = path6.join(seekaDir, "init.app.seeka.cli.config.json");
+  const configPath = path7.join(seekaDir, "init.app.seeka.cli.config.json");
   const configOutput = {
     ...otherOptions,
     sdk: {
@@ -49035,12 +49062,12 @@ npmScopes:
   };
   delete configOutput.textReplacements;
   delete configOutput.jsonActions;
-  fs6.writeFileSync(configPath, JSON.stringify(configOutput, null, 2), { encoding: "utf8" });
-  const secretsConfigPath = path6.join(seekaDir, "init.app.secrets.seeka.cli.config.json");
+  fs7.writeFileSync(configPath, JSON.stringify(configOutput, null, 2), { encoding: "utf8" });
+  const secretsConfigPath = path7.join(seekaDir, "init.app.secrets.seeka.cli.config.json");
   const secretsConfigOutput = {
     environmentVariables: environmentVariables || {}
   };
-  fs6.writeFileSync(secretsConfigPath, JSON.stringify(secretsConfigOutput, null, 2), { encoding: "utf8" });
+  fs7.writeFileSync(secretsConfigPath, JSON.stringify(secretsConfigOutput, null, 2), { encoding: "utf8" });
   console.log("");
   console.log("Installing AI context...");
   try {
@@ -49056,7 +49083,7 @@ npmScopes:
   console.log(`Created ${projectName} in ${projectDir}`);
   console.log("Boom! Your new Seeka app is ready!");
   writeSeparator();
-  const relativePath = options.skipSubDir ? projectDir : path6.relative(process.cwd(), projectDir);
+  const relativePath = options.skipSubDir ? projectDir : path7.relative(process.cwd(), projectDir);
   console.log(`Run "cd ${relativePath}" to change to your apps directory and start creating some magic!`);
   console.log("");
   console.log("");
@@ -51895,9 +51922,9 @@ var import_rxjs = __toESM(require_cjs(), 1);
 var import_run_async = __toESM(require_run_async(), 1);
 var import_mute_stream2 = __toESM(require_lib5(), 1);
 var _ = {
-  set: (obj, path8 = "", value) => {
+  set: (obj, path9 = "", value) => {
     let pointer = obj;
-    path8.split(".").forEach((key, index2, arr) => {
+    path9.split(".").forEach((key, index2, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index2 === arr.length - 1) {
@@ -51908,8 +51935,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path8 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path8, regexp).filter(Boolean).reduce(
+  get: (obj, path9 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path9, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res == null ? res : res[key],
       obj
@@ -52299,6 +52326,188 @@ var interactiveMenu = {
     aiContext: "Install AI context files"
   }
 };
+var sharedEnvConfigPrompts = {
+  seekaAppId: {
+    message: "Enter SEEKA_APP_ID:",
+    validation: {
+      required: "SEEKA_APP_ID is required"
+    }
+  },
+  seekaAppSecret: {
+    message: "Enter SEEKA_APP_SECRET:",
+    validation: {
+      required: "SEEKA_APP_SECRET is required"
+    }
+  },
+  dataEncryptionKey: {
+    message: "Enter DATA_ENCRYPTION_KEY (leave empty to auto-generate):"
+  },
+  redisConnectionHost: {
+    message: "Enter REDIS_CONNECTION_HOST:",
+    validation: {
+      required: "REDIS_CONNECTION_HOST is required"
+    }
+  },
+  redisConnectionPort: {
+    message: "Enter REDIS_CONNECTION_PORT:"
+  },
+  redisConnectionUser: {
+    message: "Enter REDIS_CONNECTION_USER:"
+  },
+  redisConnectionPassword: {
+    message: "Enter REDIS_CONNECTION_PASSWORD:",
+    validation: {
+      required: "REDIS_CONNECTION_PASSWORD is required"
+    }
+  },
+  redisConnectionTls: {
+    message: "Enter REDIS_CONNECTION_TLS:"
+  },
+  otelExporterOtlpLogsEndpoint: {
+    message: "Enter OTEL_EXPORTER_OTLP_LOGS_ENDPOINT (optional):"
+  },
+  otelExporterOtlpLogsHeaders: {
+    message: "Enter OTEL_EXPORTER_OTLP_LOGS_HEADERS (optional):"
+  },
+  selfHostBaseUrl: {
+    message: "Enter SELF_HOST_BASEURL:"
+  }
+};
+var initAppCommand = {
+  description: "Initialize a new Seeka app with GitHub repository and Azure deployment configuration",
+  interactive: {
+    localAppPath: {
+      message: "Enter local directory path where the app will be stored:",
+      validation: {
+        required: "Local app path is required"
+      }
+    },
+    azureFunctionResourceGroupName: {
+      message: "Enter Azure Function Resource Group Name:",
+      validation: {
+        required: "Azure Function Resource Group Name is required"
+      }
+    },
+    viteBaseUrl: {
+      message: "Enter VITE_BASE_URL:",
+      validation: {
+        required: "VITE_BASE_URL is required"
+      }
+    },
+    selectedOwner: {
+      message: "Where do you want to create the repository?"
+    },
+    developerName: {
+      message: "Enter developer name:",
+      validation: {
+        required: "Developer name is required"
+      }
+    },
+    developerEmail: {
+      message: "Enter developer email:",
+      validation: {
+        required: "Developer email is required"
+      }
+    },
+    npmUsername: {
+      message: "Enter NPM username (optional):"
+    },
+    npmPassword: {
+      message: "Enter NPM password (optional):"
+    },
+    ...sharedEnvConfigPrompts
+  }
+};
+var addEnvCommand = {
+  description: "Add a new environment to an existing GitHub repository",
+  interactive: {
+    owner: {
+      message: "Enter GitHub repository owner (username or organization):",
+      validation: {
+        required: "Repository owner is required"
+      }
+    },
+    repo: {
+      message: "Enter GitHub repository name:",
+      validation: {
+        required: "Repository name is required"
+      }
+    },
+    environmentName: {
+      message: "Enter environment name:",
+      validation: {
+        required: "Environment name is required"
+      }
+    },
+    azureFunctionResourceGroupName: {
+      message: "Enter Azure Function Resource Group Name:",
+      validation: {
+        required: "Azure Function Resource Group Name is required"
+      }
+    },
+    azureFuncSlotName: {
+      message: "Enter AZURE_FUNC_SLOT_NAME (empty for production):"
+    },
+    viteBaseUrl: {
+      message: "Enter VITE_BASE_URL:",
+      validation: {
+        required: "VITE_BASE_URL is required"
+      }
+    },
+    viteUrlsSeekaApiCore: {
+      message: "Enter VITE_URLS_SEEKA_API_CORE (optional):"
+    },
+    viteUrlsSeekaAppCoreOrigin: {
+      message: "Enter VITE_URLS_SEEKA_APP_CORE_ORIGIN (optional):"
+    },
+    hostingEnvName: {
+      message: "Enter HOSTING_ENV_NAME:",
+      validation: {
+        required: "HOSTING_ENV_NAME is required"
+      }
+    },
+    ...sharedEnvConfigPrompts
+  }
+};
+var updateEnvCommand = {
+  description: "Update all environment variables and secrets, overwriting existing values",
+  interactive: {
+    owner: {
+      message: "Enter GitHub repository owner (username or organization):",
+      validation: {
+        required: "Repository owner is required"
+      }
+    },
+    repo: {
+      message: "Enter GitHub repository name:",
+      validation: {
+        required: "Repository name is required"
+      }
+    },
+    environmentName: {
+      message: "Enter environment name:",
+      validation: {
+        required: "Environment name is required"
+      }
+    },
+    azureFunctionResourceGroupName: {
+      message: "Enter Azure Function Resource Group Name:",
+      validation: {
+        required: "Azure Function Resource Group Name is required"
+      }
+    },
+    azureFuncSlotName: {
+      message: "Enter AZURE_FUNC_SLOT_NAME (empty for production):"
+    },
+    ...sharedEnvConfigPrompts
+  },
+  confirmOverwrite: {
+    variable: (name, oldValue, newValue) => `Overwrite variable "${name}"?
+  Old: ${oldValue}
+  New: ${newValue}`,
+    secret: (name) => `Overwrite secret "${name}"? (value hidden for security)`
+  }
+};
 function formatPromptMessage(message, hint) {
   return hint ? `${message} ${hint}` : message;
 }