@seeka-labs/cli-apps 3.8.2 → 3.8.6

package/dist/index.cjs

@@ -177,16 +177,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize2(aPath) {
-      var path7 = aPath;
+      var path8 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path7 = url.path;
+        path8 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path7);
-      var parts = path7.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path8);
+      var parts = path8.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -203,15 +203,15 @@ var require_util = __commonJS({
           }
         }
       }
-      path7 = parts.join("/");
-      if (path7 === "") {
-        path7 = isAbsolute ? "/" : ".";
+      path8 = parts.join("/");
+      if (path8 === "") {
+        path8 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path7;
+        url.path = path8;
         return urlGenerate(url);
       }
-      return path7;
+      return path8;
     }
     exports2.normalize = normalize2;
     function join4(aRoot, aPath) {
@@ -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 path7 = require("path");
-    var fs6;
+    var path8 = require("path");
+    var fs7;
     try {
-      fs6 = require("fs");
-      if (!fs6.existsSync || !fs6.readFileSync) {
-        fs6 = null;
+      fs7 = require("fs");
+      if (!fs7.existsSync || !fs7.readFileSync) {
+        fs7 = null;
       }
     } catch (err) {
     }
@@ -1892,26 +1892,26 @@ var require_source_map_support = __commonJS({
       };
     }
     var retrieveFile = handlerExec(retrieveFileHandlers);
-    retrieveFileHandlers.push(function(path8) {
-      path8 = path8.trim();
-      if (/^file:/.test(path8)) {
-        path8 = path8.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    retrieveFileHandlers.push(function(path9) {
+      path9 = path9.trim();
+      if (/^file:/.test(path9)) {
+        path9 = path9.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : (
             // file:///C:/dir/file -> C:/dir/file
             "/"
           );
         });
       }
-      if (path8 in fileContentsCache) {
-        return fileContentsCache[path8];
+      if (path9 in fileContentsCache) {
+        return fileContentsCache[path9];
       }
       var contents = "";
       try {
-        if (!fs6) {
+        if (!fs7) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
-            path8,
+            path9,
             /** async */
             false
           );
@@ -1919,24 +1919,24 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs6.existsSync(path8)) {
-          contents = fs6.readFileSync(path8, "utf8");
+        } else if (fs7.existsSync(path9)) {
+          contents = fs7.readFileSync(path9, "utf8");
         }
       } catch (er) {
       }
-      return fileContentsCache[path8] = contents;
+      return fileContentsCache[path9] = contents;
     });
     function supportRelativeURL(file, url) {
       if (!file) return url;
-      var dir = path7.dirname(file);
+      var dir = path8.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 + path7.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+        return protocol + path8.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
       }
-      return protocol + path7.resolve(dir.slice(protocol.length), url);
+      return protocol + path8.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 && fs6 && fs6.existsSync(source)) {
+        if (!contents && fs7 && fs7.existsSync(source)) {
           try {
-            contents = fs6.readFileSync(source, "utf8");
+            contents = fs7.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 path7 = require("node:path");
-    var fs6 = require("node:fs");
+    var path8 = require("node:path");
+    var fs7 = 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 (fs6.existsSync(executableFile)) return;
+        if (fs7.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 = path7.resolve(baseDir, baseName);
-          if (fs6.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path7.extname(baseName))) return void 0;
+          const localBin = path8.resolve(baseDir, baseName);
+          if (fs7.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path8.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext2) => fs6.existsSync(`${localBin}${ext2}`)
+            (ext2) => fs7.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 = fs6.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs7.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path7.resolve(
-            path7.dirname(resolvedScriptPath),
+          executableDir = path8.resolve(
+            path8.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path7.basename(
+            const legacyName = path8.basename(
               this._scriptPath,
-              path7.extname(this._scriptPath)
+              path8.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -4514,7 +4514,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path7.extname(executableFile));
+        launchWithNode = sourceExt.includes(path8.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 = path7.basename(filename, path7.extname(filename));
+        this._name = path8.basename(filename, path8.extname(filename));
         return this;
       }
       /**
@@ -5443,9 +5443,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path8) {
-        if (path8 === void 0) return this._executableDir;
-        this._executableDir = path8;
+      executableDir(path9) {
+        if (path9 === void 0) return this._executableDir;
+        this._executableDir = path9;
         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 fs6 = require("fs");
-    function checkPathExt(path7, options) {
+    var fs7 = require("fs");
+    function checkPathExt(path8, 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 && path7.substr(-p.length).toLowerCase() === p) {
+        if (p && path8.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path7, options) {
+    function checkStat(stat, path8, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path7, options);
+      return checkPathExt(path8, options);
     }
-    function isexe(path7, options, cb) {
-      fs6.stat(path7, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path7, options));
+    function isexe(path8, options, cb) {
+      fs7.stat(path8, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path8, options));
       });
     }
-    function sync3(path7, options) {
-      return checkStat(fs6.statSync(path7), path7, options);
+    function sync3(path8, options) {
+      return checkStat(fs7.statSync(path8), path8, 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 fs6 = require("fs");
-    function isexe(path7, options, cb) {
-      fs6.stat(path7, function(er, stat) {
+    var fs7 = require("fs");
+    function isexe(path8, options, cb) {
+      fs7.stat(path8, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync3(path7, options) {
-      return checkStat(fs6.statSync(path7), options);
+    function sync3(path8, options) {
+      return checkStat(fs7.statSync(path8), 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 fs6 = require("fs");
+    var fs7 = 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(path7, options, cb) {
+    function isexe(path8, 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(path7, options || {}, function(er, is) {
+          isexe(path8, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -5827,7 +5827,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path7, options || {}, function(er, is) {
+      core(path8, 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(path7, options) {
+    function sync3(path8, options) {
       try {
-        return core.sync(path7, options || {});
+        return core.sync(path8, 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 path7 = require("path");
+    var path8 = 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 = path7.join(pathPart, cmd);
+        const pCmd = path8.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 = path7.join(pathPart, cmd);
+        const pCmd = path8.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 path7 = require("path");
+    var path8 = 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 ? path7.delimiter : void 0
+          pathExt: withoutPathExt ? path8.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -5995,7 +5995,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path8.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -6049,8 +6049,8 @@ var require_shebang_command = __commonJS({
       if (!match2) {
         return null;
       }
-      const [path7, argument] = match2[0].replace(/#! ?/, "").split(" ");
-      const binary = path7.split("/").pop();
+      const [path8, argument] = match2[0].replace(/#! ?/, "").split(" ");
+      const binary = path8.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 fs6 = require("fs");
+    var fs7 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs6.openSync(command, "r");
-        fs6.readSync(fd, buffer, 0, size, 0);
-        fs6.closeSync(fd);
+        fd = fs7.openSync(command, "r");
+        fs7.readSync(fd, buffer, 0, size, 0);
+        fs7.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 path7 = require("path");
+    var path8 = 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 = path7.normalize(parsed.command);
+        parsed.command = path8.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 fs6;
+    var fs7;
     try {
-      fs6 = require("fs");
+      fs7 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -7158,8 +7158,8 @@ var require_pump = __commonJS({
     };
     var isFS = function(stream2) {
       if (!ancient) return false;
-      if (!fs6) return false;
-      return (stream2 instanceof (fs6.ReadStream || noop) || stream2 instanceof (fs6.WriteStream || noop)) && isFn(stream2.close);
+      if (!fs7) return false;
+      return (stream2 instanceof (fs7.ReadStream || noop) || stream2 instanceof (fs7.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 fs6 = require("fs");
+    var fs7 = 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) {
-        fs6.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs7.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -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) {
-        fs6.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs7.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -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) {
-        fs6.close(self2.fd, onCloseDone);
+        fs7.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);
-        fs6.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        fs7.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
           if (err) {
             self2.destroy(err);
           } else if (bytesRead === 0) {
@@ -7510,7 +7510,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         if (self2.destroyed) return cb();
-        fs6.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        fs7.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
           if (err2) {
             self2.destroy();
             cb();
@@ -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 fs6 = require("fs");
+    var fs7 = 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(path7, options, callback) {
+    function open(path8, 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;
-      fs6.open(path7, "r", function(err, fd) {
+      fs7.open(path8, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
-          if (err2) fs6.close(fd, defaultCallback);
+          if (err2) fs7.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;
-      fs6.fstat(fd, function(err, stats) {
+      fs7.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, 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: fs6 } = require("fs");
+    var { createWriteStream, promises: fs7 } = require("fs");
     var getStream = require_get_stream();
-    var path7 = require("path");
+    var path8 = 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 = path7.dirname(path7.join(this.opts.dir, entry.fileName));
+            const destDir = path8.dirname(path8.join(this.opts.dir, entry.fileName));
             try {
-              await fs6.mkdir(destDir, { recursive: true });
-              const canonicalDestDir = await fs6.realpath(destDir);
-              const relativeDestDir = path7.relative(this.opts.dir, canonicalDestDir);
-              if (relativeDestDir.split(path7.sep).includes("..")) {
+              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("..")) {
                 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 = path7.join(this.opts.dir, entry.fileName);
+        const dest = path8.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 : path7.dirname(dest);
+        const destDir = isDir ? dest : path8.dirname(dest);
         const mkdirOptions = { recursive: true };
         if (isDir) {
           mkdirOptions.mode = procMode;
         }
         debug("mkdir", { dir: destDir, ...mkdirOptions });
-        await fs6.mkdir(destDir, mkdirOptions);
+        await fs7.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 fs6.symlink(link, dest);
+          await fs7.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 (!path7.isAbsolute(opts.dir)) {
+      if (!path8.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
-      await fs6.mkdir(opts.dir, { recursive: true });
-      opts.dir = await fs6.realpath(opts.dir);
+      await fs7.mkdir(opts.dir, { recursive: true });
+      opts.dir = await fs7.realpath(opts.dir);
       return new Extractor(zipPath, opts).extract();
     };
   }
@@ -11567,8 +11567,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path7) {
-      var parts = path7.split("/");
+    exports2.resolve = function(path8) {
+      var parts = path8.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(path7) {
-      if (path7.slice(-1) === "/") {
-        path7 = path7.substring(0, path7.length - 1);
+    var parentFolder = function(path8) {
+      if (path8.slice(-1) === "/") {
+        path8 = path8.substring(0, path8.length - 1);
       }
-      var lastSlash = path7.lastIndexOf("/");
-      return lastSlash > 0 ? path7.substring(0, lastSlash) : "";
+      var lastSlash = path8.lastIndexOf("/");
+      return lastSlash > 0 ? path8.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path7) {
-      if (path7.slice(-1) !== "/") {
-        path7 += "/";
+    var forceTrailingSlash = function(path8) {
+      if (path8.slice(-1) !== "/") {
+        path8 += "/";
       }
-      return path7;
+      return path8;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults2.createFolders;
@@ -18431,6 +18431,2163 @@ var require_lib3 = __commonJS({
   }
 });
 
+// ../../node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../../node_modules/universalify/index.js"(exports2) {
+    "use strict";
+    exports2.fromCallback = function(fn) {
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+        else {
+          return new Promise((resolve4, reject) => {
+            args.push((err, res) => err != null ? reject(err) : resolve4(res));
+            fn.apply(this, args);
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports2.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function") return fn.apply(this, args);
+        else {
+          args.pop();
+          fn.apply(this, args).then((r) => cb(null, r), cb);
+        }
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    var constants = require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs7) {
+      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) {
+          if (cb) process.nextTick(cb);
+        };
+        fs7.lchmodSync = function() {
+        };
+      }
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path8, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs7.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.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) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from2, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            });
+          }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        })(fs7.rename);
+      }
+      fs7.read = typeof fs7.read !== "function" ? fs7.read : (function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _2, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs7, 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) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path8, mode, callback) {
+          fs8.open(
+            path8,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs8.fchmod(fd, mode, function(err2) {
+                fs8.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);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs8.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs8.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs8.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) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs8.lutimesSync = function(path8, at, mt) {
+            var fd = fs8.openSync(path8, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs8.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs8.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs8.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs8.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs7, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs7, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs7, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs7, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, 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);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/legacy-streams.js
+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) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path8, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path8, options);
+        Stream2.call(this);
+        var self2 = this;
+        this.path = path8;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index2 = 0, length = keys.length; index2 < length; index2++) {
+          var key = keys[index2];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self2._read();
+          });
+          return;
+        }
+        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self2.emit("error", err);
+            self2.readable = false;
+            return;
+          }
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2._read();
+        });
+      }
+      function WriteStream(path8, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path8, options);
+        Stream2.call(this);
+        this.path = path8;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index2 = 0, length = keys.length; index2 < length; index2++) {
+          var key = keys[index2];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs7.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../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 polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
+      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs7[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs7, queue);
+      fs7.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs7, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs7.close);
+      fs7.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs7, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs7.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs7[gracefulQueue]);
+          require("assert").equal(fs7[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) {
+        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) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile;
+      function writeFile(path8, 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) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs8.appendFile;
+      if (fs$appendFile)
+        fs8.appendFile = appendFile;
+      function appendFile(path8, 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) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path9, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs8.copyFile;
+      if (fs$copyFile)
+        fs8.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir2;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir2(path8, 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,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path9, options2, cb2, startTime) {
+          return fs$readdir(path9, options2, fs$readdirCallback(
+            path9,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path8, options, cb);
+        function fs$readdirCallback(path9, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path9, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs8);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs8.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs8.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs8, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs8, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs8, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs8, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path8, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path8, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path8, options) {
+        return new fs8.ReadStream(path8, options);
+      }
+      function createWriteStream(path8, options) {
+        return new fs8.WriteStream(path8, options);
+      }
+      var fs$open = fs8.open;
+      fs8.open = open;
+      function open(path8, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path8, flags, mode, cb);
+        function go$open(path9, flags2, mode2, cb2, startTime) {
+          return fs$open(path9, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs8;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs7[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;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs7[gracefulQueue].length === 0)
+        return;
+      var elem = fs7[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs7[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/fs-extra/lib/fs/index.js
+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 api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "cp",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "glob",
+      "lchmod",
+      "lchown",
+      "lutimes",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "statfs",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs7[key] === "function";
+    });
+    Object.assign(exports2, fs7);
+    api.forEach((method) => {
+      exports2[method] = u(fs7[method]);
+    });
+    exports2.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs7.exists(filename, callback);
+      }
+      return new Promise((resolve4) => {
+        return fs7.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 new Promise((resolve4, reject) => {
+        fs7.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve4({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs7.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve4, reject) => {
+        fs7.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve4({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs7.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve4, reject) => {
+        fs7.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err) return reject(err);
+          resolve4({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports2.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs7.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve4, reject) => {
+        fs7.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);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
+    "use strict";
+    var path8 = require("path");
+    module2.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path8.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+    "use strict";
+    var fs7 = require_fs();
+    var { checkPath } = require_utils2();
+    var getMode = (options) => {
+      const defaults2 = { mode: 511 };
+      if (typeof options === "number") return options;
+      return { ...defaults2, ...options }.mode;
+    };
+    module2.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs7.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module2.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs7.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module2.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/path-exists/index.js
+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);
+    }
+    module2.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs7.existsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+    "use strict";
+    var fs7 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path8, atime, mtime) {
+      const fd = await fs7.open(path8, "r+");
+      let closeErr = null;
+      try {
+        await fs7.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs7.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
+    }
+    function utimesMillisSync(path8, atime, mtime) {
+      const fd = fs7.openSync(path8, "r+");
+      fs7.futimesSync(fd, atime, mtime);
+      return fs7.closeSync(fd);
+    }
+    module2.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/stat.js
+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 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 });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT") return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs7.statSync(file, { bigint: true }) : (file) => fs7.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT") return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path8.basename(src);
+          const destBaseName = path8.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path8.basename(src);
+          const destBaseName = path8.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      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;
+      let destStat;
+      try {
+        destStat = await fs7.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      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;
+      let destStat;
+      try {
+        destStat = fs7.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      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);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module2.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/async.js
+var require_async = __commonJS({
+  "../../node_modules/fs-extra/lib/util/async.js"(exports2, module2) {
+    "use strict";
+    async function asyncIteratorConcurrentProcess(iterator, fn) {
+      const promises = [];
+      for await (const item of iterator) {
+        promises.push(
+          fn(item).then(
+            () => null,
+            (err) => err ?? new Error("unknown error")
+          )
+        );
+      }
+      await Promise.all(
+        promises.map(
+          (promise) => promise.then((possibleErr) => {
+            if (possibleErr !== null) throw possibleErr;
+          })
+        )
+      );
+    }
+    module2.exports = {
+      asyncIteratorConcurrentProcess
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy.js
+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 { mkdirs } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat = require_stat();
+    var { asyncIteratorConcurrentProcess } = require_async();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include) return;
+      const destParent = path8.dirname(dest);
+      const dirExists = await pathExists(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter) return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs7.stat : fs7.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);
+      if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs7.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs7.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs7.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs7.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs7.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs7.mkdir(dest);
+      }
+      await asyncIteratorConcurrentProcess(await fs7.opendir(src), async (item) => {
+        const srcItem = path8.join(src, item.name);
+        const destItem = path8.join(dest, item.name);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (include) {
+          const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+          await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+        }
+      });
+      if (!destStat) {
+        await fs7.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs7.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs7.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs7.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs7.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+      }
+      if (resolvedSrc !== resolvedDest) {
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+      }
+      await fs7.unlink(dest);
+      return fs7.symlink(resolvedSrc, dest);
+    }
+    module2.exports = copy;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy-sync.js
+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 mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
+      }
+      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);
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync2 = opts.dereference ? fs7.statSync : fs7.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);
+      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs7.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);
+      if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs7.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs7.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs7.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      const dir = fs7.opendirSync(src);
+      try {
+        let dirent;
+        while ((dirent = dir.readSync()) !== null) {
+          copyDirItem(dirent.name, src, dest, opts);
+        }
+      } finally {
+        dir.closeSync();
+      }
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path8.join(src, item);
+      const destItem = path8.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);
+      if (opts.dereference) {
+        resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs7.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs7.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs7.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+        }
+        if (resolvedSrc !== resolvedDest) {
+          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+            throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+          }
+          if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+            throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+          }
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs7.unlinkSync(dest);
+      return fs7.symlinkSync(resolvedSrc, dest);
+    }
+    module2.exports = copySync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module2.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+    "use strict";
+    var fs7 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove(path8, callback) {
+      fs7.rm(path8, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path8) {
+      fs7.rmSync(path8, { recursive: true, force: true });
+    }
+    module2.exports = {
+      remove: u(remove),
+      removeSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/empty/index.js
+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 mkdir = require_mkdirs();
+    var remove = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs7.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path8.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs7.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path8.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module2.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/file.js
+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 mkdir = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs7.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path8.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs7.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs7.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs7.writeFile(file, "");
+      } else {
+        await fs7.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs7.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path8.dirname(file);
+      try {
+        if (!fs7.statSync(dir).isDirectory()) {
+          fs7.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+        else throw err;
+      }
+      fs7.writeFileSync(file, "");
+    }
+    module2.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/link.js
+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 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);
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs7.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 dirExists = await pathExists(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs7.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs7.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs7.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);
+      mkdir.mkdirsSync(dir);
+      return fs7.linkSync(srcpath, dstpath);
+    }
+    module2.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js
+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 { pathExists } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path8.isAbsolute(srcpath)) {
+        try {
+          await fs7.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path8.dirname(dstpath);
+      const relativeToDst = path8.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs7.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path8.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path8.isAbsolute(srcpath)) {
+        const exists2 = fs7.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);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs7.existsSync(srcpath);
+      if (!srcExists) throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path8.relative(dstdir, srcpath)
+      };
+    }
+    module2.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+    "use strict";
+    var fs7 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = await fs7.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = fs7.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module2.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink.js
+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 { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs7.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs7.stat(srcpath),
+          fs7.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);
+      if (!await pathExists(dir)) {
+        await mkdirs(dir);
+      }
+      return fs7.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs7.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs7.statSync(srcpath);
+        const dstStat = fs7.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);
+      mkdirsSync(dir);
+      return fs7.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+    "use strict";
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module2.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/jsonfile/utils.js
+var require_utils3 = __commonJS({
+  "../../node_modules/jsonfile/utils.js"(exports2, module2) {
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF2 = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF2;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content)) content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module2.exports = { stringify, stripBom };
+  }
+});
+
+// ../../node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../../node_modules/jsonfile/index.js"(exports2, module2) {
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_2) {
+      _fs = require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils3();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs7 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs7.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile = universalify.fromPromise(_readFile);
+    function readFileSync5(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs7 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs7.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs7 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs7.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync6(file, obj, options = {}) {
+      const fs7 = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs7.writeFileSync(file, str, options);
+    }
+    module2.exports = {
+      readFile,
+      readFileSync: readFileSync5,
+      writeFile,
+      writeFileSync: writeFileSync6
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module2.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/output-file/index.js
+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 mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path8.dirname(file);
+      if (!await pathExists(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs7.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path8.dirname(file);
+      if (!fs7.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs7.writeFileSync(file, ...args);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils3();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module2.exports = outputJson;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+    "use strict";
+    var { stringify } = require_utils3();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module2.exports = outputJsonSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module2.exports = jsonFile;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/move.js
+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 { copy } = require_copy2();
+    var { remove } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var stat = require_stat();
+    async function move(src, dest, opts = {}) {
+      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);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove(dest);
+        } else if (await pathExists(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs7.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove(src);
+    }
+    module2.exports = move;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/move-sync.js
+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 copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      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));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path8.dirname(dest);
+      const parsedPath = path8.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase) return rename(src, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs7.existsSync(dest)) throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs7.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module2.exports = moveSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module2.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/index.js
+var require_lib4 = __commonJS({
+  "../../node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
 // ../../node_modules/cli-width/index.js
 var require_cli_width = __commonJS({
   "../../node_modules/cli-width/index.js"(exports2, module2) {
@@ -18484,7 +20641,7 @@ var require_emoji_regex = __commonJS({
 });
 
 // ../../node_modules/inquirer/node_modules/mute-stream/lib/index.js
-var require_lib4 = __commonJS({
+var require_lib5 = __commonJS({
   "../../node_modules/inquirer/node_modules/mute-stream/lib/index.js"(exports2, module2) {
     var Stream2 = require("stream");
     var MuteStream3 = class extends Stream2 {
@@ -24048,7 +26205,7 @@ var require_iso2022 = __commonJS({
 });
 
 // ../../node_modules/chardet/lib/utils.js
-var require_utils2 = __commonJS({
+var require_utils4 = __commonJS({
   "../../node_modules/chardet/lib/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -24063,7 +26220,7 @@ var require_utils2 = __commonJS({
 });
 
 // ../../node_modules/chardet/lib/index.js
-var require_lib5 = __commonJS({
+var require_lib6 = __commonJS({
   "../../node_modules/chardet/lib/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -24115,7 +26272,7 @@ var require_lib5 = __commonJS({
     var mbcs = __importStar(require_mbcs());
     var sbcs = __importStar(require_sbcs());
     var iso2022 = __importStar(require_iso2022());
-    var utils_1 = require_utils2();
+    var utils_1 = require_utils4();
     var recognisers = [
       new utf8_1.default(),
       new unicode.UTF_16BE(),
@@ -24183,10 +26340,10 @@ var require_lib5 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve4, reject) => {
       let fd;
-      const fs6 = (0, node_1.default)();
+      const fs7 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs6.closeSync(fd);
+          fs7.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -24198,9 +26355,9 @@ var require_lib5 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs6.openSync(filepath, "r");
+        fd = fs7.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs6.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs7.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -24212,22 +26369,22 @@ var require_lib5 = __commonJS({
         });
         return;
       }
-      fs6.readFile(filepath, handler);
+      fs7.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs6 = (0, node_1.default)();
+      const fs7 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs6.openSync(filepath, "r");
+        const fd = fs7.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs6.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs7.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs6.closeSync(fd);
+        fs7.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs6.readFileSync(filepath));
+      return (0, exports2.detect)(fs7.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -27890,7 +30047,7 @@ var require_streams = __commonJS({
 });
 
 // ../../node_modules/iconv-lite/lib/index.js
-var require_lib6 = __commonJS({
+var require_lib7 = __commonJS({
   "../../node_modules/iconv-lite/lib/index.js"(exports2, module2) {
     "use strict";
     var Buffer2 = require_safer().Buffer;
@@ -30133,7 +32290,7 @@ var require_asap = __commonJS({
 });
 
 // ../../node_modules/rxjs/dist/cjs/internal/scheduler/async.js
-var require_async = __commonJS({
+var require_async2 = __commonJS({
   "../../node_modules/rxjs/dist/cjs/internal/scheduler/async.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -30543,7 +32700,7 @@ var require_VirtualTimeScheduler = __commonJS({
 });
 
 // ../../node_modules/rxjs/dist/cjs/internal/observable/empty.js
-var require_empty = __commonJS({
+var require_empty2 = __commonJS({
   "../../node_modules/rxjs/dist/cjs/internal/observable/empty.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -31494,7 +33651,7 @@ var require_Notification = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.observeNotification = exports2.Notification = exports2.NotificationKind = void 0;
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var of_1 = require_of();
     var throwError_1 = require_throwError();
     var isFunction_1 = require_isFunction();
@@ -31725,7 +33882,7 @@ var require_timeout = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.timeout = exports2.TimeoutError = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var isDate_1 = require_isDate();
     var lift_1 = require_lift();
     var innerFrom_1 = require_innerFrom();
@@ -32651,7 +34808,7 @@ var require_timer = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.timer = void 0;
     var Observable_1 = require_Observable();
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var isScheduler_1 = require_isScheduler();
     var isDate_1 = require_isDate();
     function timer(dueTime, intervalOrScheduler, scheduler) {
@@ -32697,7 +34854,7 @@ var require_interval = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.interval = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var timer_1 = require_timer();
     function interval(period, scheduler) {
       if (period === void 0) {
@@ -32723,7 +34880,7 @@ var require_merge = __commonJS({
     exports2.merge = void 0;
     var mergeAll_1 = require_mergeAll();
     var innerFrom_1 = require_innerFrom();
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var args_1 = require_args();
     var from_1 = require_from();
     function merge() {
@@ -32926,7 +35083,7 @@ var require_range = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.range = void 0;
     var Observable_1 = require_Observable();
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     function range2(start, count, scheduler) {
       if (count == null) {
         count = start;
@@ -32966,7 +35123,7 @@ var require_using = __commonJS({
     exports2.using = void 0;
     var Observable_1 = require_Observable();
     var innerFrom_1 = require_innerFrom();
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     function using(resourceFactory, observableFactory) {
       return new Observable_1.Observable(function(subscriber) {
         var resource = resourceFactory();
@@ -33015,7 +35172,7 @@ var require_zip = __commonJS({
     var Observable_1 = require_Observable();
     var innerFrom_1 = require_innerFrom();
     var argsOrArgArray_1 = require_argsOrArgArray();
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     var args_1 = require_args();
     function zip() {
@@ -33128,7 +35285,7 @@ var require_auditTime = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.auditTime = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var audit_1 = require_audit();
     var timer_1 = require_timer();
     function auditTime(duration, scheduler) {
@@ -33292,7 +35449,7 @@ var require_bufferTime = __commonJS({
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     var arrRemove_1 = require_arrRemove();
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var args_1 = require_args();
     var executeSchedule_1 = require_executeSchedule();
     function bufferTime(bufferTimeSpan) {
@@ -33933,7 +36090,7 @@ var require_debounceTime = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.debounceTime = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     function debounceTime(dueTime, scheduler) {
@@ -34014,7 +36171,7 @@ var require_take = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.take = void 0;
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     function take(count) {
@@ -34102,7 +36259,7 @@ var require_delay = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.delay = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var delayWhen_1 = require_delayWhen();
     var timer_1 = require_timer();
     function delay(due, scheduler) {
@@ -34648,7 +36805,7 @@ var require_takeLast = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.takeLast = void 0;
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     function takeLast(count) {
@@ -35188,7 +37345,7 @@ var require_repeat = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.repeat = void 0;
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     var innerFrom_1 = require_innerFrom();
@@ -35456,7 +37613,7 @@ var require_sampleTime = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.sampleTime = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var sample_1 = require_sample();
     var interval_1 = require_interval();
     function sampleTime(period, scheduler) {
@@ -36090,7 +38247,7 @@ var require_throttleTime = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.throttleTime = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var throttle_1 = require_throttle();
     var timer_1 = require_timer();
     function throttleTime(duration, scheduler, config) {
@@ -36112,7 +38269,7 @@ var require_timeInterval = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.TimeInterval = exports2.timeInterval = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
     function timeInterval(scheduler) {
@@ -36147,7 +38304,7 @@ var require_timeoutWith = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.timeoutWith = void 0;
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var isDate_1 = require_isDate();
     var timeout_1 = require_timeout();
     function timeoutWith(due, withObservable, scheduler) {
@@ -36322,7 +38479,7 @@ var require_windowTime = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.windowTime = void 0;
     var Subject_1 = require_Subject();
-    var async_1 = require_async();
+    var async_1 = require_async2();
     var Subscription_1 = require_Subscription();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
@@ -36767,7 +38924,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "asapScheduler", { enumerable: true, get: function() {
       return asap_1.asapScheduler;
     } });
-    var async_1 = require_async();
+    var async_1 = require_async2();
     Object.defineProperty(exports2, "async", { enumerable: true, get: function() {
       return async_1.async;
     } });
@@ -36890,7 +39047,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "defer", { enumerable: true, get: function() {
       return defer_1.defer;
     } });
-    var empty_1 = require_empty();
+    var empty_1 = require_empty2();
     Object.defineProperty(exports2, "empty", { enumerable: true, get: function() {
       return empty_1.empty;
     } });
@@ -36974,7 +39131,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "scheduled", { enumerable: true, get: function() {
       return scheduled_1.scheduled;
     } });
-    var empty_2 = require_empty();
+    var empty_2 = require_empty2();
     Object.defineProperty(exports2, "EMPTY", { enumerable: true, get: function() {
       return empty_2.EMPTY;
     } });
@@ -37770,21 +39927,21 @@ function camelCase(input, options) {
 
 // src/commands/init/v2/index.ts
 var spawn = __toESM(require_cross_spawn(), 1);
-var fs5 = __toESM(require("fs"), 1);
+var fs6 = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // package.json
-var version = "3.8.1";
+var version = "3.8.6";
 
 // src/helpers/index.ts
 var fs2 = __toESM(require("fs"), 1);
 var isAlphaNumericAndHyphens = (str) => {
   return /^[a-zA-Z0-9-]+$/.test(str);
 };
-function isEmptyDir(path7) {
+function isEmptyDir(path8) {
   try {
-    const directory = fs2.opendirSync(path7);
+    const directory = fs2.opendirSync(path8);
     const entry = directory.readSync();
     directory.closeSync();
     return entry === null;
@@ -41986,12 +44143,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path7) {
-    if (!path7) {
+  resolve(path8) {
+    if (!path8) {
       return this;
     }
-    const rootPath = this.getRootString(path7);
-    const dir = path7.substring(rootPath.length);
+    const rootPath = this.getRootString(path8);
+    const dir = path8.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -42743,8 +44900,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path7) {
-    return import_node_path.win32.parse(path7).root;
+  getRootString(path8) {
+    return import_node_path.win32.parse(path8).root;
   }
   /**
    * @internal
@@ -42790,8 +44947,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path7) {
-    return path7.startsWith("/") ? "/" : "";
+  getRootString(path8) {
+    return path8.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -42840,8 +44997,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs6);
+  constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs7);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -42880,11 +45037,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path7 = this.cwd) {
-    if (typeof path7 === "string") {
-      path7 = this.cwd.resolve(path7);
+  depth(path8 = this.cwd) {
+    if (typeof path8 === "string") {
+      path8 = this.cwd.resolve(path8);
     }
-    return path7.depth();
+    return path8.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -43371,9 +45528,9 @@ var PathScurryBase = class {
     process4();
     return results;
   }
-  chdir(path7 = this.cwd) {
+  chdir(path8 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path7 === "string" ? this.cwd.resolve(path7) : path7;
+    this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -43399,8 +45556,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs6) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -43428,8 +45585,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs6) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -43729,8 +45886,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path7, n]) => [
-      path7,
+    return [...this.store.entries()].map(([path8, n]) => [
+      path8,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -43935,9 +46092,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path7, opts) {
+  constructor(patterns, path8, opts) {
     this.patterns = patterns;
-    this.path = path7;
+    this.path = path8;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -43956,11 +46113,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path7) {
-    return this.seen.has(path7) || !!this.#ignore?.ignored?.(path7);
+  #ignored(path8) {
+    return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
   }
-  #childrenIgnored(path7) {
-    return !!this.#ignore?.childrenIgnored?.(path7);
+  #childrenIgnored(path8) {
+    return !!this.#ignore?.childrenIgnored?.(path8);
   }
   // backpressure mechanism
   pause() {
@@ -44175,8 +46332,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path7, opts) {
-    super(patterns, path7, opts);
+  constructor(patterns, path8, opts) {
+    super(patterns, path8, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -44213,8 +46370,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path7, opts) {
-    super(patterns, path7, opts);
+  constructor(patterns, path8, opts) {
+    super(patterns, path8, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -45878,8 +48035,8 @@ JSONPath.prototype._getPreferredOutput = function(ea) {
   const resultType = this.currResultType;
   switch (resultType) {
     case "all": {
-      const path7 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
-      ea.pointer = JSONPath.toPointer(path7);
+      const path8 = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
+      ea.pointer = JSONPath.toPointer(path8);
       ea.path = typeof ea.path === "string" ? ea.path : JSONPath.toPathString(ea.path);
       return ea;
     }
@@ -45902,11 +48059,11 @@ JSONPath.prototype._handleCallback = function(fullRetObj, callback, type) {
     callback(preferredOutput, type, fullRetObj);
   }
 };
-JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, callback, hasArrExpr, literalPriority) {
+JSONPath.prototype._trace = function(expr, val, path8, parent, parentPropName, callback, hasArrExpr, literalPriority) {
   let retObj;
   if (!expr.length) {
     retObj = {
-      path: path7,
+      path: path8,
       value: val,
       parent,
       parentProperty: parentPropName,
@@ -45927,28 +48084,28 @@ JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, c
     }
   }
   if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path7, loc), val, loc, callback, hasArrExpr));
+    addRet(this._trace(x, val[loc], push(path8, loc), val, loc, callback, hasArrExpr));
   } else if (loc === "*") {
     this._walk(val, (m) => {
-      addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true, true));
+      addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true, true));
     });
   } else if (loc === "..") {
-    addRet(this._trace(x, val, path7, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(x, val, path8, parent, parentPropName, callback, hasArrExpr));
     this._walk(val, (m) => {
       if (typeof val[m] === "object") {
-        addRet(this._trace(expr.slice(), val[m], push(path7, m), val, m, callback, true));
+        addRet(this._trace(expr.slice(), val[m], push(path8, m), val, m, callback, true));
       }
     });
   } else if (loc === "^") {
     this._hasParentSelector = true;
     return {
-      path: path7.slice(0, -1),
+      path: path8.slice(0, -1),
       expr: x,
       isParentSelector: true
     };
   } else if (loc === "~") {
     retObj = {
-      path: push(path7, loc),
+      path: push(path8, loc),
       value: parentPropName,
       parent,
       parentProperty: null
@@ -45956,9 +48113,9 @@ JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, c
     this._handleCallback(retObj, callback, "property");
     return retObj;
   } else if (loc === "$") {
-    addRet(this._trace(x, val, path7, null, null, callback, hasArrExpr));
+    addRet(this._trace(x, val, path8, null, null, callback, hasArrExpr));
   } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
-    addRet(this._slice(loc, x, val, path7, parent, parentPropName, callback));
+    addRet(this._slice(loc, x, val, path8, parent, parentPropName, callback));
   } else if (loc.indexOf("?(") === 0) {
     if (this.currEval === false) {
       throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
@@ -45969,15 +48126,15 @@ JSONPath.prototype._trace = function(expr, val, path7, 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, path7, parent, parentPropName, callback, true);
+        const filterResults = this._trace(npath, nvalue, path8, parent, parentPropName, callback, true);
         if (filterResults.length > 0) {
-          addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true));
+          addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true));
         }
       });
     } else {
       this._walk(val, (m) => {
-        if (this._eval(safeLoc, val[m], m, path7, parent, parentPropName)) {
-          addRet(this._trace(x, val[m], push(path7, m), val, m, callback, true));
+        if (this._eval(safeLoc, val[m], m, path8, parent, parentPropName)) {
+          addRet(this._trace(x, val[m], push(path8, m), val, m, callback, true));
         }
       });
     }
@@ -45985,7 +48142,7 @@ JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, c
     if (this.currEval === false) {
       throw new Error("Eval [(expr)] prevented in JSONPath expression.");
     }
-    addRet(this._trace(unshift(this._eval(loc, val, path7.at(-1), path7.slice(0, -1), parent, parentPropName), x), val, path7, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(unshift(this._eval(loc, val, path8.at(-1), path8.slice(0, -1), parent, parentPropName), x), val, path8, parent, parentPropName, callback, hasArrExpr));
   } else if (loc[0] === "@") {
     let addType = false;
     const valueType = loc.slice(1, -2);
@@ -46029,7 +48186,7 @@ JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, c
         }
         break;
       case "other":
-        addType = this.currOtherTypeCallback(val, path7, parent, parentPropName);
+        addType = this.currOtherTypeCallback(val, path8, parent, parentPropName);
         break;
       case "null":
         if (val === null) {
@@ -46042,7 +48199,7 @@ JSONPath.prototype._trace = function(expr, val, path7, parent, parentPropName, c
     }
     if (addType) {
       retObj = {
-        path: path7,
+        path: path8,
         value: val,
         parent,
         parentProperty: parentPropName
@@ -46052,14 +48209,14 @@ JSONPath.prototype._trace = function(expr, val, path7, 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(path7, locProp), val, locProp, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[locProp], push(path8, 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, path7, parent, parentPropName, callback, true));
+      addRet(this._trace(unshift(part, x), val, path8, parent, parentPropName, callback, true));
     }
   } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
-    addRet(this._trace(x, val[loc], push(path7, loc), val, loc, callback, hasArrExpr, true));
+    addRet(this._trace(x, val[loc], push(path8, loc), val, loc, callback, hasArrExpr, true));
   }
   if (this._hasParentSelector) {
     for (let t = 0; t < ret.length; t++) {
@@ -46093,7 +48250,7 @@ JSONPath.prototype._walk = function(val, f) {
     });
   }
 };
-JSONPath.prototype._slice = function(loc, expr, val, path7, parent, parentPropName, callback) {
+JSONPath.prototype._slice = function(loc, expr, val, path8, parent, parentPropName, callback) {
   if (!Array.isArray(val)) {
     return void 0;
   }
@@ -46103,14 +48260,14 @@ JSONPath.prototype._slice = function(loc, expr, val, path7, 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, path7, parent, parentPropName, callback, true);
+    const tmp = this._trace(unshift(i, expr), val, path8, parent, parentPropName, callback, true);
     tmp.forEach((t) => {
       ret.push(t);
     });
   }
   return ret;
 };
-JSONPath.prototype._eval = function(code, _v, _vname, path7, parent, parentPropName) {
+JSONPath.prototype._eval = function(code, _v, _vname, path8, parent, parentPropName) {
   this.currSandbox._$_parentProperty = parentPropName;
   this.currSandbox._$_parent = parent;
   this.currSandbox._$_property = _vname;
@@ -46118,7 +48275,7 @@ JSONPath.prototype._eval = function(code, _v, _vname, path7, parent, parentPropN
   this.currSandbox._$_v = _v;
   const containsPath = code.includes("@path");
   if (containsPath) {
-    this.currSandbox._$_path = JSONPath.toPathString(path7.concat([_vname]));
+    this.currSandbox._$_path = JSONPath.toPathString(path8.concat([_vname]));
   }
   const scriptCacheKey = this.currEval + "Script:" + code;
   if (!JSONPath.cache[scriptCacheKey]) {
@@ -46562,10 +48719,36 @@ var SeekaAppScaffolder = class {
 };
 
 // src/commands/ai/context/index.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 var import_jszip = __toESM(require_lib3(), 1);
+
+// src/helpers/config/index.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs_extra = __toESM(require_lib4(), 1);
+var getAppInitConfig = (baseDir) => {
+  const initConfigPath = import_path.default.resolve(baseDir || process.cwd(), ".seeka", "init.app.seeka.cli.config.json");
+  if (import_fs_extra.default.existsSync(initConfigPath)) {
+    console.log("Reading init config from", initConfigPath);
+    const initConfig = JSON.parse(import_fs_extra.default.readFileSync(initConfigPath, "utf-8"));
+    if (initConfig) {
+      return initConfig;
+    }
+  }
+  return void 0;
+};
 var DEFAULT_PUBLIC_CONTEXT_URL = "https://saseekaaueaprodpub.blob.core.windows.net/sdk-apps/ai-context/public/ai-context-latest.zip";
+var getContextPackageUrl = (baseDir, initialPackageUrl) => {
+  if (!initialPackageUrl) {
+    const initConfig = getAppInitConfig(baseDir);
+    if (initConfig?.contextPackageUrl) {
+      return initConfig.contextPackageUrl;
+    }
+  }
+  return initialPackageUrl || DEFAULT_PUBLIC_CONTEXT_URL;
+};
+
+// src/commands/ai/context/index.ts
 async function downloadFile(url) {
   const response = await fetch(url);
   if (!response.ok) {
@@ -46578,30 +48761,30 @@ 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);
+    const destPath = path5.join(destDir, relativePath);
     if (zipEntry.dir) {
-      fs4.mkdirSync(destPath, { recursive: true });
+      fs5.mkdirSync(destPath, { recursive: true });
     } else {
-      fs4.mkdirSync(path4.dirname(destPath), { recursive: true });
+      fs5.mkdirSync(path5.dirname(destPath), { recursive: true });
       const content = await zipEntry.async("nodebuffer");
-      fs4.writeFileSync(destPath, content);
+      fs5.writeFileSync(destPath, content);
     }
   }
 }
 var aiContextCommand = async (options = {}) => {
   const targetDir = options.targetDir || process.cwd();
-  const contextDestDir = path4.join(targetDir, ".seeka", "ai", "context");
-  const contextUrl = options.contextPackageUrl || DEFAULT_PUBLIC_CONTEXT_URL;
+  const contextDestDir = path5.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 (fs4.existsSync(contextDestDir)) {
+  if (fs5.existsSync(contextDestDir)) {
     console.log("Removing existing AI context...");
-    fs4.rmSync(contextDestDir, { recursive: true, force: true });
+    fs5.rmSync(contextDestDir, { recursive: true, force: true });
   }
-  fs4.mkdirSync(contextDestDir, { recursive: true });
+  fs5.mkdirSync(contextDestDir, { recursive: true });
   console.log("Downloading AI context package...");
   let zipBuffer;
   try {
@@ -46639,8 +48822,8 @@ var aiContextCommand = async (options = {}) => {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     source: options.contextPackageUrl ? "custom" : "public"
   };
-  const metaPath = path4.join(contextDestDir, "meta.json");
-  fs4.writeFileSync(metaPath, JSON.stringify(metaJson, null, 2), "utf-8");
+  const metaPath = path5.join(contextDestDir, "meta.json");
+  fs5.writeFileSync(metaPath, JSON.stringify(metaJson, null, 2), "utf-8");
   console.log("");
   console.log("\u2713 AI context installed successfully!");
   console.log("");
@@ -46651,9 +48834,6 @@ var aiContextCommand = async (options = {}) => {
   console.log("  - Architecture documentation");
   console.log("  - Implementation guides");
   console.log("  - SDK API reference");
-  if (options.contextPackageUrl) {
-    console.log("  - Example apps (custom package)");
-  }
   console.log("");
   console.log("AI assistants can now reference .seeka/ai/context/ for app development guidance.");
 };
@@ -46678,35 +48858,35 @@ var initCommandV2 = async (options) => {
   }
   const orgName = options.orgName.toLowerCase();
   const projectPascalCase = camelCase(projectName, { pascalCase: true });
-  const projectDir = path5.resolve(options.outputDirectory, !options.skipSubDir ? options.directoryName || projectName : "");
+  const projectDir = path6.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 && fs5.existsSync(projectDir) && isEmptyDir(projectDir) === false) {
+  if (!options.skipSubDir && fs6.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 = path5.resolve(projectDir, ".git");
-      const gitDirExists = fs5.existsSync(gitDirPath);
+      const gitDirPath = path6.resolve(projectDir, ".git");
+      const gitDirExists = fs6.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 = fs5.readdirSync(projectDir);
+      const items = fs6.readdirSync(projectDir);
       for (const item of items) {
         if (item === ".git") {
           continue;
         }
-        const itemPath = path5.resolve(projectDir, item);
-        fs5.rmSync(itemPath, { recursive: true, force: true });
+        const itemPath = path6.resolve(projectDir, item);
+        fs6.rmSync(itemPath, { recursive: true, force: true });
       }
     } else {
       console.error("Directory is not empty. Use --force to create app in non-empty directory");
       return;
     }
   }
-  if (!fs5.existsSync(projectDir)) {
-    fs5.mkdirSync(projectDir, { recursive: true });
+  if (!fs6.existsSync(projectDir)) {
+    fs6.mkdirSync(projectDir, { recursive: true });
   }
-  const templateDir = path5.resolve(__dirname, "init-template");
-  const scaffoldOutputDir = options.skipSubDir ? fs5.mkdtempSync(path5.join(os2.tmpdir(), "seeka-app-init-v2-")) : projectDir;
+  const templateDir = path6.resolve(__dirname, "init-template");
+  const scaffoldOutputDir = options.skipSubDir ? fs6.mkdtempSync(path6.join(os2.tmpdir(), "seeka-app-init-v2-")) : projectDir;
   const scaffolder = new SeekaAppScaffolder();
   await scaffolder.scaffoldSeekaApp({
     templateDir,
@@ -46808,8 +48988,8 @@ var initCommandV2 = async (options) => {
     ]
   });
   if (options.skipSubDir) {
-    fs5.cpSync(scaffoldOutputDir, projectDir, { recursive: true });
-    fs5.rmSync(scaffoldOutputDir, { recursive: true, force: true });
+    fs6.cpSync(scaffoldOutputDir, projectDir, { recursive: true });
+    fs6.rmSync(scaffoldOutputDir, { recursive: true, force: true });
   }
   if (options.installDependencies) {
     console.info("Installing package dependencies");
@@ -46819,7 +48999,7 @@ var initCommandV2 = async (options) => {
       console.error("Error installing package dependencies", err);
     }
   }
-  const yarnRcFilePath = path5.resolve(projectDir, ".yarnrc.yml");
+  const yarnRcFilePath = path6.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');
@@ -46827,7 +49007,7 @@ var initCommandV2 = async (options) => {
     console.log("Using NPM registry username " + options.npmUsername);
     npmAuthToken = `${options.npmUsername}:${options.npmPassword}`;
   }
-  fs5.writeFileSync(
+  fs6.writeFileSync(
     yarnRcFilePath,
     `nodeLinker: node-modules
 
@@ -46838,14 +49018,14 @@ npmScopes:
     npmRegistryServer: "https://npm.packages.seeka.services"`,
     { encoding: "utf8" }
   );
-  const yarnLockFilePath = path5.resolve(projectDir, "yarn.lock");
-  fs5.writeFileSync(yarnLockFilePath, "", { encoding: "utf8" });
-  const seekaDir = path5.join(projectDir, ".seeka");
-  if (!fs5.existsSync(seekaDir)) {
-    fs5.mkdirSync(seekaDir, { recursive: true });
+  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 { environmentVariables, ...otherOptions } = options;
-  const configPath = path5.join(seekaDir, "init.app.seeka.cli.config.json");
+  const configPath = path6.join(seekaDir, "init.app.seeka.cli.config.json");
   const configOutput = {
     ...otherOptions,
     sdk: {
@@ -46854,18 +49034,19 @@ npmScopes:
   };
   delete configOutput.textReplacements;
   delete configOutput.jsonActions;
-  fs5.writeFileSync(configPath, JSON.stringify(configOutput, null, 2), { encoding: "utf8" });
-  const secretsConfigPath = path5.join(seekaDir, "init.app.secrets.seeka.cli.config.json");
+  fs6.writeFileSync(configPath, JSON.stringify(configOutput, null, 2), { encoding: "utf8" });
+  const secretsConfigPath = path6.join(seekaDir, "init.app.secrets.seeka.cli.config.json");
   const secretsConfigOutput = {
     environmentVariables: environmentVariables || {}
   };
-  fs5.writeFileSync(secretsConfigPath, JSON.stringify(secretsConfigOutput, null, 2), { encoding: "utf8" });
+  fs6.writeFileSync(secretsConfigPath, JSON.stringify(secretsConfigOutput, null, 2), { encoding: "utf8" });
   console.log("");
   console.log("Installing AI context...");
   try {
+    let packageUrl = getContextPackageUrl(projectDir, options.contextPackageUrl);
     await aiContextCommand({
       targetDir: projectDir,
-      contextPackageUrl: options.contextPackageUrl
+      contextPackageUrl: packageUrl
     });
   } catch (err) {
     console.warn("Warning: Failed to install AI context", err);
@@ -46874,7 +49055,7 @@ npmScopes:
   console.log(`Created ${projectName} in ${projectDir}`);
   console.log("Boom! Your new Seeka app is ready!");
   writeSeparator();
-  const relativePath = options.skipSubDir ? projectDir : path5.relative(process.cwd(), projectDir);
+  const relativePath = options.skipSubDir ? projectDir : path6.relative(process.cwd(), projectDir);
   console.log(`Run "cd ${relativePath}" to change to your apps directory and start creating some magic!`);
   console.log("");
   console.log("");
@@ -48009,7 +50190,7 @@ function usePagination({ items, active, renderItem, pageSize, loop = true }) {
 // ../../node_modules/inquirer/node_modules/@inquirer/core/dist/lib/create-prompt.js
 var readline2 = __toESM(require("node:readline"), 1);
 var import_node_async_hooks3 = require("node:async_hooks");
-var import_mute_stream = __toESM(require_lib4(), 1);
+var import_mute_stream = __toESM(require_lib5(), 1);
 
 // ../../node_modules/inquirer/node_modules/signal-exit/dist/mjs/signals.js
 var signals = [];
@@ -48632,13 +50813,13 @@ var dist_default2 = createPrompt((config, done) => {
 });
 
 // ../../node_modules/inquirer/node_modules/@inquirer/external-editor/dist/index.js
-var import_chardet = __toESM(require_lib5(), 1);
+var import_chardet = __toESM(require_lib6(), 1);
 var import_child_process = require("child_process");
 var import_fs2 = require("fs");
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_crypto = require("node:crypto");
-var import_iconv_lite = __toESM(require_lib6(), 1);
+var import_iconv_lite = __toESM(require_lib7(), 1);
 
 // ../../node_modules/inquirer/node_modules/@inquirer/external-editor/dist/errors/CreateFileError.js
 var CreateFileError = class extends Error {
@@ -49711,11 +51892,11 @@ var dist_default11 = createPrompt((config, done) => {
 var import_node_readline = __toESM(require("node:readline"), 1);
 var import_rxjs = __toESM(require_cjs(), 1);
 var import_run_async = __toESM(require_run_async(), 1);
-var import_mute_stream2 = __toESM(require_lib4(), 1);
+var import_mute_stream2 = __toESM(require_lib5(), 1);
 var _ = {
-  set: (obj, path7 = "", value) => {
+  set: (obj, path8 = "", value) => {
     let pointer = obj;
-    path7.split(".").forEach((key, index2, arr) => {
+    path8.split(".").forEach((key, index2, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index2 === arr.length - 1) {
@@ -49726,8 +51907,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path7 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path7, regexp).filter(Boolean).reduce(
+  get: (obj, path8 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path8, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res == null ? res : res[key],
       obj
@@ -50168,11 +52349,13 @@ async function runAiContextInteractive() {
       type: "input",
       name: "targetDir",
       message: aiCommand.context.interactive.targetDir.message,
-      default: ""
+      default: process.cwd()
     }
   ]);
+  let packageUrl = getContextPackageUrl(answers.targetDir, void 0);
   await aiContextCommand({
-    targetDir: answers.targetDir || void 0
+    targetDir: answers.targetDir || void 0,
+    contextPackageUrl: packageUrl
   });
 }
 async function runInitInteractive() {
@@ -50256,7 +52439,7 @@ async function runInitInteractive() {
       type: "input",
       name: "outDir",
       message: initCommand.interactive.outDir.message,
-      default: ""
+      default: process.cwd()
     },
     // {
     //     type: 'select',
@@ -50366,15 +52549,16 @@ var buildProgram = () => {
       // appSettings: options.appSettings ? map(stringArrayToMap(options.appSettings), (k, v) => { return { name: k } }) : [],
       npmUsername: options.npmUsername,
       npmPassword: options.npmPassword,
-      contextPackageUrl: options.contextPackageUrl
+      contextPackageUrl: getContextPackageUrl(void 0, options.contextPackageUrl)
     };
     await initCommandV2(initOptions);
   }).showHelpAfterError(true);
   const aiCmd = program2.command("ai").description(aiCommand.description);
   aiCmd.command("context").description(aiCommand.context.description).option("--target <directory>", aiCommand.context.options.target.description).addOption(new Option("--contextPackageUrl <url>", aiCommand.context.options.contextPackageUrl.description).hideHelp()).action(async (options) => {
+    let packageUrl = getContextPackageUrl(options.target, options.contextPackageUrl);
     await aiContextCommand({
       targetDir: options.target,
-      contextPackageUrl: options.contextPackageUrl
+      contextPackageUrl: packageUrl
     });
   }).showHelpAfterError(true);
   program2.showHelpAfterError(true);
@@ -50384,7 +52568,7 @@ var main = async (argv = process.argv) => {
   showSeekaLogo();
   const program2 = buildProgram();
   if (argv.length <= 2) {
-    runInteractive();
+    await runInteractive();
   } else {
     await program2.parseAsync(argv);
   }