@smicolon/fasla-ui 0.7.0 → 0.8.0

package/dist/cli/index.js

@@ -990,8 +990,8 @@ var require_command = __commonJS({
     init_esm_shims();
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path11 = __require("path");
-    var fs9 = __require("fs");
+    var path13 = __require("path");
+    var fs11 = __require("fs");
     var process10 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1923,11 +1923,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path11.resolve(baseDir, baseName);
-          if (fs9.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path11.extname(baseName))) return void 0;
+          const localBin = path13.resolve(baseDir, baseName);
+          if (fs11.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path13.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs9.existsSync(`${localBin}${ext}`)
+            (ext) => fs11.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1939,21 +1939,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs11.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path11.resolve(
-            path11.dirname(resolvedScriptPath),
+          executableDir = path13.resolve(
+            path13.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path11.basename(
+            const legacyName = path13.basename(
               this._scriptPath,
-              path11.extname(this._scriptPath)
+              path13.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1964,7 +1964,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path11.extname(executableFile));
+        launchWithNode = sourceExt.includes(path13.extname(executableFile));
         let proc;
         if (process10.platform !== "win32") {
           if (launchWithNode) {
@@ -2804,7 +2804,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path11.basename(filename, path11.extname(filename));
+        this._name = path13.basename(filename, path13.extname(filename));
         return this;
       }
       /**
@@ -2818,9 +2818,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path12) {
-        if (path12 === void 0) return this._executableDir;
-        this._executableDir = path12;
+      executableDir(path14) {
+        if (path14 === void 0) return this._executableDir;
+        this._executableDir = path14;
         return this;
       }
       /**
@@ -9677,54 +9677,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs9) {
+    function patch(fs11) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs9);
-      }
-      if (!fs9.lutimes) {
-        patchLutimes(fs9);
-      }
-      fs9.chown = chownFix(fs9.chown);
-      fs9.fchown = chownFix(fs9.fchown);
-      fs9.lchown = chownFix(fs9.lchown);
-      fs9.chmod = chmodFix(fs9.chmod);
-      fs9.fchmod = chmodFix(fs9.fchmod);
-      fs9.lchmod = chmodFix(fs9.lchmod);
-      fs9.chownSync = chownFixSync(fs9.chownSync);
-      fs9.fchownSync = chownFixSync(fs9.fchownSync);
-      fs9.lchownSync = chownFixSync(fs9.lchownSync);
-      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
-      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
-      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
-      fs9.stat = statFix(fs9.stat);
-      fs9.fstat = statFix(fs9.fstat);
-      fs9.lstat = statFix(fs9.lstat);
-      fs9.statSync = statFixSync(fs9.statSync);
-      fs9.fstatSync = statFixSync(fs9.fstatSync);
-      fs9.lstatSync = statFixSync(fs9.lstatSync);
-      if (fs9.chmod && !fs9.lchmod) {
-        fs9.lchmod = function(path11, mode, cb) {
+        patchLchmod(fs11);
+      }
+      if (!fs11.lutimes) {
+        patchLutimes(fs11);
+      }
+      fs11.chown = chownFix(fs11.chown);
+      fs11.fchown = chownFix(fs11.fchown);
+      fs11.lchown = chownFix(fs11.lchown);
+      fs11.chmod = chmodFix(fs11.chmod);
+      fs11.fchmod = chmodFix(fs11.fchmod);
+      fs11.lchmod = chmodFix(fs11.lchmod);
+      fs11.chownSync = chownFixSync(fs11.chownSync);
+      fs11.fchownSync = chownFixSync(fs11.fchownSync);
+      fs11.lchownSync = chownFixSync(fs11.lchownSync);
+      fs11.chmodSync = chmodFixSync(fs11.chmodSync);
+      fs11.fchmodSync = chmodFixSync(fs11.fchmodSync);
+      fs11.lchmodSync = chmodFixSync(fs11.lchmodSync);
+      fs11.stat = statFix(fs11.stat);
+      fs11.fstat = statFix(fs11.fstat);
+      fs11.lstat = statFix(fs11.lstat);
+      fs11.statSync = statFixSync(fs11.statSync);
+      fs11.fstatSync = statFixSync(fs11.fstatSync);
+      fs11.lstatSync = statFixSync(fs11.lstatSync);
+      if (fs11.chmod && !fs11.lchmod) {
+        fs11.lchmod = function(path13, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchmodSync = function() {
+        fs11.lchmodSync = function() {
         };
       }
-      if (fs9.chown && !fs9.lchown) {
-        fs9.lchown = function(path11, uid, gid, cb) {
+      if (fs11.chown && !fs11.lchown) {
+        fs11.lchown = function(path13, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs9.lchownSync = function() {
+        fs11.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs9.rename = typeof fs9.rename !== "function" ? fs9.rename : (function(fs$rename) {
+        fs11.rename = typeof fs11.rename !== "function" ? fs11.rename : (function(fs$rename) {
           function rename2(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs9.stat(to, function(stater, st) {
+                  fs11.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -9740,9 +9740,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
           return rename2;
-        })(fs9.rename);
+        })(fs11.rename);
       }
-      fs9.read = typeof fs9.read !== "function" ? fs9.read : (function(fs$read) {
+      fs11.read = typeof fs11.read !== "function" ? fs11.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -9750,22 +9750,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs9.read);
-      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs11.read);
+      fs11.readSync = typeof fs11.readSync !== "function" ? fs11.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs11, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -9775,11 +9775,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs9.readSync);
-      function patchLchmod(fs10) {
-        fs10.lchmod = function(path11, mode, callback) {
-          fs10.open(
-            path11,
+      })(fs11.readSync);
+      function patchLchmod(fs12) {
+        fs12.lchmod = function(path13, mode, callback) {
+          fs12.open(
+            path13,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -9787,80 +9787,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs10.fchmod(fd, mode, function(err2) {
-                fs10.close(fd, function(err22) {
+              fs12.fchmod(fd, mode, function(err2) {
+                fs12.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs10.lchmodSync = function(path11, mode) {
-          var fd = fs10.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs12.lchmodSync = function(path13, mode) {
+          var fd = fs12.openSync(path13, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs10.fchmodSync(fd, mode);
+            ret = fs12.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs10.closeSync(fd);
+                fs12.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs10.closeSync(fd);
+              fs12.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs10) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
-          fs10.lutimes = function(path11, at, mt, cb) {
-            fs10.open(path11, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs12) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs12.futimes) {
+          fs12.lutimes = function(path13, at, mt, cb) {
+            fs12.open(path13, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs10.futimes(fd, at, mt, function(er2) {
-                fs10.close(fd, function(er22) {
+              fs12.futimes(fd, at, mt, function(er2) {
+                fs12.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs10.lutimesSync = function(path11, at, mt) {
-            var fd = fs10.openSync(path11, constants.O_SYMLINK);
+          fs12.lutimesSync = function(path13, at, mt) {
+            var fd = fs12.openSync(path13, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs10.futimesSync(fd, at, mt);
+              ret = fs12.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs10.closeSync(fd);
+                  fs12.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs10.closeSync(fd);
+                fs12.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs10.futimes) {
-          fs10.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs12.futimes) {
+          fs12.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs10.lutimesSync = function() {
+          fs12.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs9, target, mode, function(er) {
+          return orig.call(fs11, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -9870,7 +9870,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs9, target, mode);
+            return orig.call(fs11, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -9879,7 +9879,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs9, target, uid, gid, function(er) {
+          return orig.call(fs11, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -9889,7 +9889,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs9, target, uid, gid);
+            return orig.call(fs11, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -9909,13 +9909,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback);
+          return options ? orig.call(fs11, target, options, callback) : orig.call(fs11, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target);
+          var stats = options ? orig.call(fs11, target, options) : orig.call(fs11, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -9946,16 +9946,16 @@ var require_legacy_streams = __commonJS({
     init_esm_shims();
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs9) {
+    function legacy(fs11) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path11, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path11, options);
+      function ReadStream(path13, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
         Stream.call(this);
         var self = this;
-        this.path = path11;
+        this.path = path13;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -9989,7 +9989,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs9.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs11.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -10000,10 +10000,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path11, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path11, options);
+      function WriteStream(path13, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path13, options);
         Stream.call(this);
-        this.path = path11;
+        this.path = path13;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -10028,7 +10028,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs9.open;
+          this._open = fs11.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -10066,7 +10066,7 @@ var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = __require("fs");
+    var fs11 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -10098,12 +10098,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs9[gracefulQueue]) {
+    if (!fs11[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs9, queue);
-      fs9.close = (function(fs$close) {
+      publishQueue(fs11, queue);
+      fs11.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs9, fd, function(err) {
+          return fs$close.call(fs11, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -10115,48 +10115,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs9.close);
-      fs9.closeSync = (function(fs$closeSync) {
+      })(fs11.close);
+      fs11.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs9, arguments);
+          fs$closeSync.apply(fs11, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs9.closeSync);
+      })(fs11.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs9[gracefulQueue]);
-          __require("assert").equal(fs9[gracefulQueue].length, 0);
+          debug(fs11[gracefulQueue]);
+          __require("assert").equal(fs11[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs9[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs9));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
-      module.exports = patch(fs9);
-      fs9.__patched = true;
-    }
-    function patch(fs10) {
-      polyfills(fs10);
-      fs10.gracefulify = patch;
-      fs10.createReadStream = createReadStream;
-      fs10.createWriteStream = createWriteStream;
-      var fs$readFile = fs10.readFile;
-      fs10.readFile = readFile;
-      function readFile(path11, options, cb) {
+      publishQueue(global, fs11[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs11));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs11.__patched) {
+      module.exports = patch(fs11);
+      fs11.__patched = true;
+    }
+    function patch(fs12) {
+      polyfills(fs12);
+      fs12.gracefulify = patch;
+      fs12.createReadStream = createReadStream;
+      fs12.createWriteStream = createWriteStream;
+      var fs$readFile = fs12.readFile;
+      fs12.readFile = readFile;
+      function readFile(path13, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path11, options, cb);
-        function go$readFile(path12, options2, cb2, startTime) {
-          return fs$readFile(path12, options2, function(err) {
+        return go$readFile(path13, options, cb);
+        function go$readFile(path14, options2, cb2, startTime) {
+          return fs$readFile(path14, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path12, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path14, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -10164,16 +10164,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs10.writeFile;
-      fs10.writeFile = writeFile;
-      function writeFile(path11, data, options, cb) {
+      var fs$writeFile = fs12.writeFile;
+      fs12.writeFile = writeFile;
+      function writeFile(path13, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path11, data, options, cb);
-        function go$writeFile(path12, data2, options2, cb2, startTime) {
-          return fs$writeFile(path12, data2, options2, function(err) {
+        return go$writeFile(path13, data, options, cb);
+        function go$writeFile(path14, data2, options2, cb2, startTime) {
+          return fs$writeFile(path14, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -10181,17 +10181,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs10.appendFile;
+      var fs$appendFile = fs12.appendFile;
       if (fs$appendFile)
-        fs10.appendFile = appendFile;
-      function appendFile(path11, data, options, cb) {
+        fs12.appendFile = appendFile;
+      function appendFile(path13, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path11, data, options, cb);
-        function go$appendFile(path12, data2, options2, cb2, startTime) {
-          return fs$appendFile(path12, data2, options2, function(err) {
+        return go$appendFile(path13, data, options, cb);
+        function go$appendFile(path14, data2, options2, cb2, startTime) {
+          return fs$appendFile(path14, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path12, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -10199,9 +10199,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs10.copyFile;
+      var fs$copyFile = fs12.copyFile;
       if (fs$copyFile)
-        fs10.copyFile = copyFile;
+        fs12.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -10219,34 +10219,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs10.readdir;
-      fs10.readdir = readdir;
+      var fs$readdir = fs12.readdir;
+      fs12.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path11, options, cb) {
+      function readdir(path13, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, fs$readdirCallback(
-            path12,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path14, options2, cb2, startTime) {
+          return fs$readdir(path14, fs$readdirCallback(
+            path14,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path12, options2, cb2, startTime) {
-          return fs$readdir(path12, options2, fs$readdirCallback(
-            path12,
+        } : function go$readdir2(path14, options2, cb2, startTime) {
+          return fs$readdir(path14, options2, fs$readdirCallback(
+            path14,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path11, options, cb);
-        function fs$readdirCallback(path12, options2, cb2, startTime) {
+        return go$readdir(path13, options, cb);
+        function fs$readdirCallback(path14, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path12, options2, cb2],
+                [path14, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -10261,21 +10261,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs10);
+        var legStreams = legacy(fs12);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs10.ReadStream;
+      var fs$ReadStream = fs12.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs10.WriteStream;
+      var fs$WriteStream = fs12.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs10, "ReadStream", {
+      Object.defineProperty(fs12, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -10285,7 +10285,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs10, "WriteStream", {
+      Object.defineProperty(fs12, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -10296,7 +10296,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs10, "FileReadStream", {
+      Object.defineProperty(fs12, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -10307,7 +10307,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs10, "FileWriteStream", {
+      Object.defineProperty(fs12, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -10317,7 +10317,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path11, options) {
+      function ReadStream(path13, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -10337,7 +10337,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path11, options) {
+      function WriteStream(path13, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -10355,22 +10355,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path11, options) {
-        return new fs10.ReadStream(path11, options);
+      function createReadStream(path13, options) {
+        return new fs12.ReadStream(path13, options);
       }
-      function createWriteStream(path11, options) {
-        return new fs10.WriteStream(path11, options);
+      function createWriteStream(path13, options) {
+        return new fs12.WriteStream(path13, options);
       }
-      var fs$open = fs10.open;
-      fs10.open = open2;
-      function open2(path11, flags, mode, cb) {
+      var fs$open = fs12.open;
+      fs12.open = open2;
+      function open2(path13, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path11, flags, mode, cb);
-        function go$open(path12, flags2, mode2, cb2, startTime) {
-          return fs$open(path12, flags2, mode2, function(err, fd) {
+        return go$open(path13, flags, mode, cb);
+        function go$open(path14, flags2, mode2, cb2, startTime) {
+          return fs$open(path14, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path12, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path14, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -10378,20 +10378,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs10;
+      return fs12;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs9[gracefulQueue].push(elem);
+      fs11[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs9[gracefulQueue].length; ++i) {
-        if (fs9[gracefulQueue][i].length > 2) {
-          fs9[gracefulQueue][i][3] = now;
-          fs9[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs11[gracefulQueue].length; ++i) {
+        if (fs11[gracefulQueue][i].length > 2) {
+          fs11[gracefulQueue][i][3] = now;
+          fs11[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -10399,9 +10399,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs9[gracefulQueue].length === 0)
+      if (fs11[gracefulQueue].length === 0)
         return;
-      var elem = fs9[gracefulQueue].shift();
+      var elem = fs11[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -10423,7 +10423,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs9[gracefulQueue].push(elem);
+          fs11[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -10439,7 +10439,7 @@ var require_fs = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var fs9 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -10480,26 +10480,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs9[key] === "function";
+      return typeof fs11[key] === "function";
     });
-    Object.assign(exports, fs9);
+    Object.assign(exports, fs11);
     api.forEach((method) => {
-      exports[method] = u(fs9[method]);
+      exports[method] = u(fs11[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs9.exists(filename, callback);
+        return fs11.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs9.exists(filename, resolve);
+        return fs11.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs9.read(fd, buffer, offset, length, position, callback);
+        return fs11.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs9.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs11.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -10507,10 +10507,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.write(fd, buffer, ...args);
+        return fs11.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs11.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -10518,10 +10518,10 @@ var require_fs = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.readv(fd, buffers, ...args);
+        return fs11.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs11.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -10529,17 +10529,17 @@ var require_fs = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs9.writev(fd, buffers, ...args);
+        return fs11.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs9.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs11.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs9.realpath.native === "function") {
-      exports.realpath.native = u(fs9.realpath.native);
+    if (typeof fs11.realpath.native === "function") {
+      exports.realpath.native = u(fs11.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -10555,10 +10555,10 @@ var require_utils = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path11 = __require("path");
+    var path13 = __require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path11.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path13.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -10574,7 +10574,7 @@ var require_make_dir = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
+    var fs11 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -10583,14 +10583,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs9.mkdir(dir, {
+      return fs11.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs9.mkdirSync(dir, {
+      return fs11.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -10624,13 +10624,13 @@ var require_path_exists = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    function pathExists(path11) {
-      return fs9.access(path11).then(() => true).catch(() => false);
+    var fs11 = require_fs();
+    function pathExists(path13) {
+      return fs11.access(path13).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs9.existsSync
+      pathExistsSync: fs11.existsSync
     };
   }
 });
@@ -10640,16 +10640,16 @@ var require_utimes = __commonJS({
   "../../node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
+    var fs11 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path11, atime, mtime) {
-      const fd = await fs9.open(path11, "r+");
+    async function utimesMillis(path13, atime, mtime) {
+      const fd = await fs11.open(path13, "r+");
       let closeErr = null;
       try {
-        await fs9.futimes(fd, atime, mtime);
+        await fs11.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs9.close(fd);
+          await fs11.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -10658,10 +10658,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path11, atime, mtime) {
-      const fd = fs9.openSync(path11, "r+");
-      fs9.futimesSync(fd, atime, mtime);
-      return fs9.closeSync(fd);
+    function utimesMillisSync(path13, atime, mtime) {
+      const fd = fs11.openSync(path13, "r+");
+      fs11.futimesSync(fd, atime, mtime);
+      return fs11.closeSync(fd);
     }
     module.exports = {
       utimesMillis: u(utimesMillis),
@@ -10675,11 +10675,11 @@ var require_stat = __commonJS({
   "../../node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
-    var path11 = __require("path");
+    var fs11 = require_fs();
+    var path13 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs9.stat(file, { bigint: true }) : (file) => fs9.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.stat(file, { bigint: true }) : (file) => fs11.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -10690,7 +10690,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs9.statSync(file, { bigint: true }) : (file) => fs9.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.statSync(file, { bigint: true }) : (file) => fs11.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -10704,8 +10704,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path11.basename(src);
-          const destBaseName = path11.basename(dest);
+          const srcBaseName = path13.basename(src);
+          const destBaseName = path13.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -10727,8 +10727,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path11.basename(src);
-          const destBaseName = path11.basename(dest);
+          const srcBaseName = path13.basename(src);
+          const destBaseName = path13.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -10747,12 +10747,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path11.resolve(path11.dirname(src));
-      const destParent = path11.resolve(path11.dirname(dest));
-      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
+      const srcParent = path13.resolve(path13.dirname(src));
+      const destParent = path13.resolve(path13.dirname(dest));
+      if (destParent === srcParent || destParent === path13.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs9.stat(destParent, { bigint: true });
+        destStat = await fs11.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -10763,12 +10763,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path11.resolve(path11.dirname(src));
-      const destParent = path11.resolve(path11.dirname(dest));
-      if (destParent === srcParent || destParent === path11.parse(destParent).root) return;
+      const srcParent = path13.resolve(path13.dirname(src));
+      const destParent = path13.resolve(path13.dirname(dest));
+      if (destParent === srcParent || destParent === path13.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs9.statSync(destParent, { bigint: true });
+        destStat = fs11.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -10782,8 +10782,8 @@ var require_stat = __commonJS({
       return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path11.resolve(src).split(path11.sep).filter((i) => i);
-      const destArr = path11.resolve(dest).split(path11.sep).filter((i) => i);
+      const srcArr = path13.resolve(src).split(path13.sep).filter((i) => i);
+      const destArr = path13.resolve(dest).split(path13.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -10837,8 +10837,8 @@ var require_copy = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
-    var path11 = __require("path");
+    var fs11 = require_fs();
+    var path13 = __require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -10861,7 +10861,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path11.dirname(dest);
+      const destParent = path13.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -10873,7 +10873,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs9.stat : fs9.lstat;
+      const statFn = opts.dereference ? fs11.stat : fs11.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);
@@ -10885,7 +10885,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs9.unlink(dest);
+        await fs11.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -10893,29 +10893,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs9.copyFile(src, dest);
+      await fs11.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs9.stat(src);
+        const updatedSrcStat = await fs11.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs9.chmod(dest, srcStat.mode);
+      return fs11.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs9.chmod(dest, srcMode | 128);
+      return fs11.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs9.mkdir(dest);
+        await fs11.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs9.opendir(src), async (item) => {
-        const srcItem = path11.join(src, item.name);
-        const destItem = path11.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs11.opendir(src), async (item) => {
+        const srcItem = path13.join(src, item.name);
+        const destItem = path13.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -10923,26 +10923,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs9.chmod(dest, srcStat.mode);
+        await fs11.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs9.readlink(src);
+      let resolvedSrc = await fs11.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path13.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlink(resolvedSrc, dest);
+        return fs11.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs9.readlink(dest);
+        resolvedDest = await fs11.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs9.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs11.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path11.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path13.resolve(process.cwd(), resolvedDest);
       }
       if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -10950,8 +10950,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs9.unlink(dest);
-      return fs9.symlink(resolvedSrc, dest);
+      await fs11.unlink(dest);
+      return fs11.symlink(resolvedSrc, dest);
     }
     module.exports = copy;
   }
@@ -10962,8 +10962,8 @@ var require_copy_sync = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs11 = require_graceful_fs();
+    var path13 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -10984,12 +10984,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path11.dirname(dest);
-      if (!fs9.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path13.dirname(dest);
+      if (!fs11.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs9.statSync : fs9.lstatSync;
+      const statSync = opts.dereference ? fs11.statSync : fs11.lstatSync;
       const srcStat = statSync(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);
@@ -11004,14 +11004,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs9.unlinkSync(dest);
+        fs11.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs9.copyFileSync(src, dest);
+      fs11.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -11026,10 +11026,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs9.chmodSync(dest, srcMode);
+      return fs11.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs9.statSync(src);
+      const updatedSrcStat = fs11.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -11037,12 +11037,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs9.mkdirSync(dest);
+      fs11.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs9.opendirSync(src);
+      const dir = fs11.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -11053,29 +11053,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path11.join(src, item);
-      const destItem = path11.join(dest, item);
+      const srcItem = path13.join(src, item);
+      const destItem = path13.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 = fs9.readlinkSync(src);
+      let resolvedSrc = fs11.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path11.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path13.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs9.symlinkSync(resolvedSrc, dest);
+        return fs11.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs9.readlinkSync(dest);
+          resolvedDest = fs11.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs9.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs11.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path11.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path13.resolve(process.cwd(), resolvedDest);
         }
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -11087,8 +11087,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs9.unlinkSync(dest);
-      return fs9.symlinkSync(resolvedSrc, dest);
+      fs11.unlinkSync(dest);
+      return fs11.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
@@ -11112,13 +11112,13 @@ var require_remove = __commonJS({
   "../../node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path11, callback) {
-      fs9.rm(path11, { recursive: true, force: true }, callback);
+    function remove(path13, callback) {
+      fs11.rm(path13, { recursive: true, force: true }, callback);
     }
-    function removeSync(path11) {
-      fs9.rmSync(path11, { recursive: true, force: true });
+    function removeSync(path13) {
+      fs11.rmSync(path13, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -11133,28 +11133,28 @@ var require_empty = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    var path11 = __require("path");
+    var fs11 = require_fs();
+    var path13 = __require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs9.readdir(dir);
+        items = await fs11.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path11.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path13.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs9.readdirSync(dir);
+        items = fs11.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path11.join(dir, item);
+        item = path13.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -11173,52 +11173,52 @@ var require_file = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs9 = require_fs();
+    var path13 = __require("path");
+    var fs11 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs9.stat(file);
+        stats = await fs11.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path11.dirname(file);
+      const dir = path13.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs9.stat(dir);
+        dirStats = await fs11.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs9.writeFile(file, "");
+          await fs11.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs9.writeFile(file, "");
+        await fs11.writeFile(file, "");
       } else {
-        await fs9.readdir(dir);
+        await fs11.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs9.statSync(file);
+        stats = fs11.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path11.dirname(file);
+      const dir = path13.dirname(file);
       try {
-        if (!fs9.statSync(dir).isDirectory()) {
-          fs9.readdirSync(dir);
+        if (!fs11.statSync(dir).isDirectory()) {
+          fs11.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs9.writeFileSync(file, "");
+      fs11.writeFileSync(file, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -11233,50 +11233,50 @@ var require_link = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs9 = require_fs();
+    var path13 = __require("path");
+    var fs11 = 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 fs9.lstat(dstpath);
+        dstStat = await fs11.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs9.lstat(srcpath);
+        srcStat = await fs11.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path11.dirname(dstpath);
+      const dir = path13.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs9.link(srcpath, dstpath);
+      await fs11.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs9.lstatSync(dstpath);
+        dstStat = fs11.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs9.lstatSync(srcpath);
+        const srcStat = fs11.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path11.dirname(dstpath);
-      const dirExists = fs9.existsSync(dir);
-      if (dirExists) return fs9.linkSync(srcpath, dstpath);
+      const dir = path13.dirname(dstpath);
+      const dirExists = fs11.existsSync(dir);
+      if (dirExists) return fs11.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs9.linkSync(srcpath, dstpath);
+      return fs11.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -11290,14 +11290,14 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path11 = __require("path");
-    var fs9 = require_fs();
+    var path13 = __require("path");
+    var fs11 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path11.isAbsolute(srcpath)) {
+      if (path13.isAbsolute(srcpath)) {
         try {
-          await fs9.lstat(srcpath);
+          await fs11.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -11307,8 +11307,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path11.dirname(dstpath);
-      const relativeToDst = path11.join(dstdir, srcpath);
+      const dstdir = path13.dirname(dstpath);
+      const relativeToDst = path13.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -11317,39 +11317,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs9.lstat(srcpath);
+        await fs11.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path11.relative(dstdir, srcpath)
+        toDst: path13.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path11.isAbsolute(srcpath)) {
-        const exists2 = fs9.existsSync(srcpath);
+      if (path13.isAbsolute(srcpath)) {
+        const exists2 = fs11.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path11.dirname(dstpath);
-      const relativeToDst = path11.join(dstdir, srcpath);
-      const exists = fs9.existsSync(relativeToDst);
+      const dstdir = path13.dirname(dstpath);
+      const relativeToDst = path13.join(dstdir, srcpath);
+      const exists = fs11.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs9.existsSync(srcpath);
+      const srcExists = fs11.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path11.relative(dstdir, srcpath)
+        toDst: path13.relative(dstdir, srcpath)
       };
     }
     module.exports = {
@@ -11364,13 +11364,13 @@ var require_symlink_type = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
+    var fs11 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs9.lstat(srcpath);
+        stats = await fs11.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -11380,7 +11380,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs9.lstatSync(srcpath);
+        stats = fs11.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -11399,8 +11399,8 @@ var require_symlink = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var path11 = __require("path");
-    var fs9 = require_fs();
+    var path13 = __require("path");
+    var fs11 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -11409,44 +11409,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs9.lstat(dstpath);
+        stats = await fs11.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs9.stat(srcpath),
-          fs9.stat(dstpath)
+          fs11.stat(srcpath),
+          fs11.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path11.dirname(dstpath);
+      const dir = path13.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs9.symlink(srcpath, dstpath, toType);
+      return fs11.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs9.lstatSync(dstpath);
+        stats = fs11.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs9.statSync(srcpath);
-        const dstStat = fs9.statSync(dstpath);
+        const srcStat = fs11.statSync(srcpath);
+        const dstStat = fs11.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path11.dirname(dstpath);
-      const exists = fs9.existsSync(dir);
-      if (exists) return fs9.symlinkSync(srcpath, dstpath, type);
+      const dir = path13.dirname(dstpath);
+      const exists = fs11.existsSync(dir);
+      if (exists) return fs11.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs9.symlinkSync(srcpath, dstpath, type);
+      return fs11.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -11518,9 +11518,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs9 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs9.readFile)(file, options);
+      let data = await universalify.fromCallback(fs11.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -11540,10 +11540,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs9 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs9.readFileSync(file, options);
+        let content = fs11.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -11556,15 +11556,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs9 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs9.writeFile)(file, str, options);
+      await universalify.fromCallback(fs11.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs9 = options.fs || _fs;
+      const fs11 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs9.writeFileSync(file, str, options);
+      return fs11.writeFileSync(file, str, options);
     }
     module.exports = {
       readFile,
@@ -11597,23 +11597,23 @@ var require_output_file = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var fs9 = require_fs();
-    var path11 = __require("path");
+    var fs11 = require_fs();
+    var path13 = __require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path11.dirname(file);
+      const dir = path13.dirname(file);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs9.writeFile(file, data, encoding);
+      return fs11.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path11.dirname(file);
-      if (!fs9.existsSync(dir)) {
+      const dir = path13.dirname(file);
+      if (!fs11.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs9.writeFileSync(file, ...args);
+      fs11.writeFileSync(file, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -11676,8 +11676,8 @@ var require_move = __commonJS({
   "../../node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_fs();
-    var path11 = __require("path");
+    var fs11 = require_fs();
+    var path13 = __require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -11687,8 +11687,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path11.dirname(dest);
-      const parsedParentPath = path11.parse(destParent);
+      const destParent = path13.dirname(dest);
+      const parsedParentPath = path13.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -11703,7 +11703,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs9.rename(src, dest);
+        await fs11.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -11729,8 +11729,8 @@ var require_move_sync = __commonJS({
   "../../node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs9 = require_graceful_fs();
-    var path11 = __require("path");
+    var fs11 = require_graceful_fs();
+    var path13 = __require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -11740,12 +11740,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path11.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path13.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path11.dirname(dest);
-      const parsedPath = path11.parse(parent);
+      const parent = path13.dirname(dest);
+      const parsedPath = path13.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -11754,12 +11754,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename2(src, dest, overwrite);
       }
-      if (fs9.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs11.existsSync(dest)) throw new Error("dest already exists.");
       return rename2(src, dest, overwrite);
     }
     function rename2(src, dest, overwrite) {
       try {
-        fs9.renameSync(src, dest);
+        fs11.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -15226,8 +15226,8 @@ function ora(options) {
 
 // src/cli/commands/add.ts
 var import_prompts3 = __toESM(require_prompts3(), 1);
-var import_fs_extra8 = __toESM(require_lib2(), 1);
-import path10 from "path";
+var import_fs_extra10 = __toESM(require_lib2(), 1);
+import path12 from "path";
 
 // src/cli/registry.ts
 init_esm_shims();
@@ -16358,6 +16358,17 @@ function pathToAlias(input, root) {
   if (rel.startsWith(`${root}/`)) return `@/${rel.slice(root.length + 1)}`;
   return void 0;
 }
+function componentsAliasFromPath(input, root) {
+  const alias = pathToAlias(input, root);
+  if (alias === void 0) return void 0;
+  const parent = alias.replace(/\/ui$/, "");
+  return parent !== alias && parent !== "@" ? parent : alias;
+}
+function effectiveComponentsAlias(aliases) {
+  const components = aliases?.components || "@/components";
+  const parent = components.replace(/\/ui$/, "");
+  return aliases?.ui === `${components}/ui` && parent !== components && parent !== "@" ? parent : components;
+}
 function outsideAliasMessage(input, root) {
   return `${normalise(input.trim()) || "."} is not inside ${root}/, the folder "@/" points to, so files there can't be imported through "@/". Enter a folder inside ${root}/, such as ${root}/components.`;
 }
@@ -16443,6 +16454,45 @@ function normalise(p) {
   return clean === "." ? "" : clean.replace(/^\.\//, "");
 }
 
+// src/cli/tty.ts
+init_esm_shims();
+function isInteractive2() {
+  return Boolean(process.stdin.isTTY);
+}
+
+// src/cli/init-options.ts
+init_esm_shims();
+var STYLE_CHOICES = ["default", "new-york"];
+function isStyleChoice(value) {
+  return STYLE_CHOICES.includes(value);
+}
+function missingInitFlags({ yes, interactive, path: path13, style, theme, needsOverwriteAnswer }) {
+  if (yes || interactive) return [];
+  const missing = [];
+  if (path13 === void 0) missing.push("--path <dir>");
+  if (style === void 0) missing.push("--style <default|new-york>");
+  if (theme === void 0) missing.push("--theme <fasla|brand>");
+  if (needsOverwriteAnswer) missing.push("--yes");
+  return missing;
+}
+function nonInteractiveInitMessage(missing) {
+  const flags = missing.includes("--yes") ? missing : [...missing, "or --yes to accept all defaults"];
+  return [
+    "Error: init asks questions, and stdin is not a terminal, so there is nobody to answer.",
+    `Pass ${flags.length === 1 ? "this flag" : "these flags"}: ${flags.join(", ")}.`,
+    "Example: npx @smicolon/fasla-ui@latest init --yes",
+    "Example: npx @smicolon/fasla-ui@latest init --path src/components --style default --theme fasla",
+    "Nothing was written."
+  ].join("\n");
+}
+function nonInteractiveAddMessage() {
+  return [
+    "Error: add asks for confirmation, and stdin is not a terminal, so there is nobody to answer.",
+    "Pass --yes to confirm: npx @smicolon/fasla-ui@latest add <component> --yes",
+    "Nothing was written."
+  ].join("\n");
+}
+
 // src/cli/pm.ts
 init_esm_shims();
 var import_fs_extra2 = __toESM(require_lib2(), 1);
@@ -16620,14 +16670,8 @@ function applyThemeItems(cwd, urls, run = spawnRunner) {
 // src/cli/commands/init.ts
 init_esm_shims();
 var import_prompts2 = __toESM(require_prompts3(), 1);
-var import_fs_extra7 = __toESM(require_lib2(), 1);
-import path9 from "path";
-
-// src/cli/commands/shared.ts
-init_esm_shims();
-var import_prompts = __toESM(require_prompts3(), 1);
-var import_fs_extra6 = __toESM(require_lib2(), 1);
-import path8 from "path";
+var import_fs_extra9 = __toESM(require_lib2(), 1);
+import path11 from "path";
 
 // src/cli/legacy.ts
 init_esm_shims();
@@ -17151,14 +17195,139 @@ async function sourceFiles(cwd, rel = "") {
   return out;
 }
 
-// src/cli/vite.ts
+// src/cli/fonts.ts
 init_esm_shims();
 var import_fs_extra5 = __toESM(require_lib2(), 1);
 import path7 from "path";
+var SYSTEM_FONT_STACKS = {
+  sans: "ui-sans-serif, system-ui, sans-serif",
+  mono: "ui-monospace, SFMono-Regular, Menlo, monospace",
+  arabic: "system-ui, sans-serif"
+};
+function layoutFontVariables(layout) {
+  return [...layout.matchAll(/\bvariable\s*:\s*["'`](--[\w-]+)["'`]/g)].map((m) => m[1]);
+}
+function kindOf(name) {
+  const kind = name.replace(/^--font-/, "");
+  return kind === "sans" || kind === "mono" || kind === "arabic" ? kind : void 0;
+}
+function projectFontVariable(kind, variables) {
+  const named = variables.filter((v) => v.includes(kind));
+  if (named.length > 0) return named[0];
+  if (kind === "sans") {
+    const rest = variables.filter((v) => !/mono|arabic|cairo|serif|display|heading/.test(v) && v !== "--font-sans");
+    return rest.length === 1 ? rest[0] : void 0;
+  }
+  return void 0;
+}
+function fixSelfReferencingFonts(css, layoutVariables) {
+  const fixed = [];
+  const out = css.replace(/(^[ \t]*)(--font-[\w-]+)(\s*:\s*)var\(\s*\2\s*\)(\s*;)/gm, (whole, indent, name, colon, end) => {
+    if (layoutVariables.includes(name)) return whole;
+    const declared = new RegExp(`(?<![\\w-])${name}\\s*:(?!\\s*var\\(\\s*${name}\\s*\\))`);
+    if (declared.test(css)) return whole;
+    const kind = kindOf(name);
+    const own = kind && projectFontVariable(kind, layoutVariables);
+    const to = own ? `var(${own})` : SYSTEM_FONT_STACKS[kind ?? "sans"];
+    fixed.push({ name, to });
+    return `${indent}${name}${colon}${to}${end}`;
+  });
+  return { css: out, fixed };
+}
+var LAYOUT_CANDIDATES = [
+  "src/app/layout.tsx",
+  "app/layout.tsx",
+  "src/app/layout.jsx",
+  "app/layout.jsx",
+  "src/app/layout.js",
+  "app/layout.js"
+];
+async function findLayout(cwd) {
+  for (const file of LAYOUT_CANDIDATES) {
+    if (await import_fs_extra5.default.pathExists(path7.join(cwd, file))) return file;
+  }
+  return void 0;
+}
+async function repairFontVariables(cwd, css) {
+  const cssPath = path7.join(cwd, css);
+  const text = await import_fs_extra5.default.readFile(cssPath, "utf8").catch(() => void 0);
+  if (text === void 0) return [];
+  const layoutFile = await findLayout(cwd);
+  const layout = layoutFile ? await import_fs_extra5.default.readFile(path7.join(cwd, layoutFile), "utf8").catch(() => "") : "";
+  const { css: next, fixed } = fixSelfReferencingFonts(text, layoutFontVariables(layout));
+  if (fixed.length > 0) await import_fs_extra5.default.writeFile(cssPath, next);
+  return fixed;
+}
+
+// src/cli/init-summary.ts
+init_esm_shims();
+var import_fs_extra6 = __toESM(require_lib2(), 1);
+import path8 from "path";
+async function snapshotFiles(cwd, files) {
+  const out = {};
+  for (const file of files) out[file] = await import_fs_extra6.default.readFile(path8.join(cwd, file), "utf8").catch(() => void 0);
+  return out;
+}
+function cssValue(css, name) {
+  return new RegExp(`${name}\\s*:\\s*([^;]+);`).exec(css)?.[1]?.trim();
+}
+function packageDelta(before, after) {
+  const names = (text) => {
+    try {
+      const pkg = JSON.parse(text ?? "{}");
+      return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+    } catch {
+      return [];
+    }
+  };
+  const had = new Set(names(before));
+  return names(after).filter((name) => !had.has(name));
+}
+function describeChanges({ before, after, components, utilsAlias, utils, css, layout, fontFixes, themeCommand: themeCommand2 }) {
+  const lines = [];
+  const status = (file) => before[file] === void 0 ? "created" : before[file] !== after[file] ? "changed" : "unchanged";
+  const row = (kind, file, note) => lines.push(`${kind.padEnd(9)} ${file}${note ? ` \u2014 ${note}` : ""}`);
+  row(status("components.json"), "components.json", `components alias ${components}, utils alias ${utilsAlias}`);
+  const utilsStatus = status(utils);
+  row(utilsStatus, utils, utilsStatus === "unchanged" ? "yours was already there, kept" : "the cn() helper every component imports");
+  const cssBefore = before[css] ?? "";
+  const cssAfter = after[css] ?? "";
+  if (cssBefore !== cssAfter) {
+    const notes = [];
+    const moved = ["--background", "--foreground"].filter((token) => cssValue(cssBefore, token) !== cssValue(cssAfter, token));
+    if (moved.length > 0) notes.push(`${moved.join(" and ")} changed to Fasla's ${moved.length > 1 ? "values" : "value"}`);
+    notes.push("adds Fasla's theme tokens and the Arabic font rule");
+    for (const fix of fontFixes) notes.push(`${fix.name} set to ${fix.to}`);
+    row("changed", css, notes.join("; "));
+  } else if (themeCommand2) {
+    row("unchanged", css, "the theme is not installed yet");
+  }
+  if (layout && (before[layout] ?? "") !== (after[layout] ?? "")) {
+    const text = after[layout] ?? "";
+    const notes = [];
+    if (/\bCairo\b/.test(text) && !/\bCairo\b/.test(before[layout] ?? "")) notes.push("adds the Cairo font");
+    if (/className=\{cn\(/.test(text) && !/className=\{cn\(/.test(before[layout] ?? "")) notes.push("the html className now goes through cn()");
+    row("changed", layout, notes.join("; ") || "font setup");
+  }
+  const added = packageDelta(before["package.json"], after["package.json"]);
+  if (added.length > 0) row("changed", "package.json", `adds ${added.join(", ")}`);
+  return lines;
+}
+
+// src/cli/commands/shared.ts
+init_esm_shims();
+var import_prompts = __toESM(require_prompts3(), 1);
+var import_fs_extra8 = __toESM(require_lib2(), 1);
+import path10 from "path";
+
+// src/cli/vite.ts
+init_esm_shims();
+var import_fs_extra7 = __toESM(require_lib2(), 1);
+import path9 from "path";
 var VITE_CONFIGS = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs", "vite.config.cts", "vite.config.cjs"];
 async function findViteConfig(cwd) {
   for (const name of VITE_CONFIGS) {
-    if (await import_fs_extra5.default.pathExists(path7.join(cwd, name))) return name;
+    if (await import_fs_extra7.default.pathExists(path9.join(cwd, name))) return name;
   }
   return void 0;
 }
@@ -17171,14 +17340,14 @@ function usesTsconfigPaths(source) {
 async function tsconfigFiles(cwd) {
   const files = [];
   for (const name of ["tsconfig.json", "tsconfig.app.json"]) {
-    if (await import_fs_extra5.default.pathExists(path7.join(cwd, name))) files.push(name);
+    if (await import_fs_extra7.default.pathExists(path9.join(cwd, name))) files.push(name);
   }
   if (files.length > 0) return files;
-  return await import_fs_extra5.default.pathExists(path7.join(cwd, "jsconfig.json")) ? ["jsconfig.json"] : ["tsconfig.json"];
+  return await import_fs_extra7.default.pathExists(path9.join(cwd, "jsconfig.json")) ? ["jsconfig.json"] : ["tsconfig.json"];
 }
 async function aliasAdvice(cwd, { root, mapped, pm }) {
   const viteConfig = await findViteConfig(cwd);
-  const source = viteConfig ? await import_fs_extra5.default.readFile(path7.join(cwd, viteConfig), "utf8").catch(() => "") : "";
+  const source = viteConfig ? await import_fs_extra7.default.readFile(path9.join(cwd, viteConfig), "utf8").catch(() => "") : "";
   const aliased = !viteConfig || viteConfigHasAlias(source);
   if (mapped && aliased) return void 0;
   const target = root ? `./${root}` : ".";
@@ -17271,11 +17440,11 @@ async function safeOrExit(check) {
   }
 }
 async function repairIfNeededOrExit(cwd, aliasRoot, yes) {
-  const configPath = path8.join(cwd, "components.json");
-  const readConfig = () => import_fs_extra6.default.readJson(configPath).catch(() => void 0);
+  const configPath = path10.join(cwd, "components.json");
+  const readConfig = () => import_fs_extra8.default.readJson(configPath).catch(() => void 0);
   const pending = async () => {
     const config = await readConfig();
-    return await import_fs_extra6.default.pathExists(path8.join(cwd, REPAIR_FILE)) || config !== void 0 && await isLegacyConfig(cwd, config);
+    return await import_fs_extra8.default.pathExists(path10.join(cwd, REPAIR_FILE)) || config !== void 0 && await isLegacyConfig(cwd, config);
   };
   if (!await pending()) return void 0;
   return repairOrExit(
@@ -17363,7 +17532,7 @@ ${printed}
   ${source_default.cyan(command)}`);
     return true;
   }
-  if (!await import_fs_extra6.default.pathExists(path8.join(cwd, "package.json"))) {
+  if (!await import_fs_extra8.default.pathExists(path10.join(cwd, "package.json"))) {
     console.log(source_default.yellow(`
 No package.json here, so nothing was installed. In your project, run:`));
     console.log(`  ${source_default.cyan(command)}`);
@@ -17412,7 +17581,7 @@ function rangeStaysBelow3(range) {
   return /^\s*(?:[\^~]|=|v)?\s*[0-2](?:\.(?:\d+|x|\*)){0,2}(?:-[0-9A-Za-z.-]+)?\s*$/.test(range);
 }
 async function tailwindMergeTooNew(cwd) {
-  const pkg = await import_fs_extra7.default.readJson(path9.join(cwd, "package.json")).catch(() => ({}));
+  const pkg = await import_fs_extra9.default.readJson(path11.join(cwd, "package.json")).catch(() => ({}));
   const listed = pkg.dependencies?.["tailwind-merge"] ?? pkg.devDependencies?.["tailwind-merge"];
   if (listed === void 0) return void 0;
   const installed = await installedVersion(cwd, "tailwind-merge");
@@ -17429,7 +17598,7 @@ async function cnPackagesToInstall(cwd, tailwindMajor = 4) {
 async function writeCnHelper(cwd, utilsAlias, aliasRoot) {
   const utilsRelative = aliasToPath(utilsAlias, aliasRoot);
   const utilsPath = await resolveInsideProject(cwd, `${utilsRelative}.ts`);
-  await import_fs_extra7.default.ensureDir(path9.dirname(utilsPath));
+  await import_fs_extra9.default.ensureDir(path11.dirname(utilsPath));
   return await writeFileIfAbsent(utilsPath, UTILS_SOURCE) ? `${utilsRelative}.ts` : void 0;
 }
 async function installCnPackages(cwd, pm, { enabled = true, run, tailwindMajor = 4 } = {}) {
@@ -17463,19 +17632,46 @@ ${tooNew}. tailwind-merge 3 supports only Tailwind 4; this project is on Tailwin
   );
 }
 function initCommand() {
-  return new Command().name("init").description("Initialize fasla-ui in your project").option("-y, --yes", "Skip confirmation prompts").option("--no-install", "Don't install clsx, tailwind-merge or the theme; print the commands instead").option("--theme <choice>", `The theme: "fasla" for Fasla's colours, "brand" to keep yours`).option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (options) => {
-    const cwd = path9.resolve(options.cwd);
+  return new Command().name("init").description("Initialize fasla-ui in your project").option("-y, --yes", "Accept every default and ask nothing").option("--path <dir>", "Where components go, e.g. src/components; the ui folder is added for you (src/components/ui works too)").option("--style <default|new-york>", "The shadcn style").option("--no-install", "Don't install clsx, tailwind-merge or the theme; print the commands instead").option("--theme <fasla|brand>", `The theme: "fasla" for Fasla's colours, "brand" to keep yours`).option("-c, --cwd <path>", "Working directory", process.cwd()).addHelpText(
+    "after",
+    `
+Without a terminal (an agent, a CI job) init asks nothing: pass --yes, or all
+of --path, --style and --theme. Missing ones are listed and nothing is written.
+
+Examples:
+  npx @smicolon/fasla-ui@latest init --yes
+  npx @smicolon/fasla-ui@latest init --path src/components --style default --theme fasla`
+  ).action(async (options) => {
+    const cwd = path11.resolve(options.cwd);
     const yes = Boolean(options.yes);
+    const interactive = isInteractive2();
+    const unattended = yes || !interactive;
+    if (options.style !== void 0 && !isStyleChoice(options.style)) {
+      console.log(source_default.red(`Error: --style is ${STYLE_CHOICES.map((c) => `"${c}"`).join(" or ")}, not "${options.style}". Nothing was written.`));
+      process.exit(1);
+    }
     if (options.theme !== void 0 && !THEME_CHOICES.some((c) => c.value === options.theme)) {
       console.log(source_default.red(`Error: --theme is "fasla" or "brand", not "${options.theme}". Nothing was written.`));
       process.exit(1);
     }
+    const configPath = path11.join(cwd, "components.json");
+    const missing = missingInitFlags({
+      yes,
+      interactive,
+      path: options.path,
+      style: options.style,
+      theme: options.theme,
+      needsOverwriteAnswer: await keepsAskingAboutOverwrite(cwd, configPath)
+    });
+    if (missing.length > 0) {
+      console.log(source_default.red(nonInteractiveInitMessage(missing)));
+      process.exit(1);
+    }
     console.log(source_default.bold("\nInitializing fasla-ui...\n"));
-    const configPath = path9.join(cwd, "components.json");
     const pm = await detectPackageManager(cwd);
-    const aliasRoot = await aliasRootOrExit(cwd, yes, pm);
-    let config = await repairIfNeededOrExit(cwd, aliasRoot.root, yes);
-    if (!config && await import_fs_extra7.default.pathExists(configPath)) {
+    const aliasRoot = await aliasRootOrExit(cwd, unattended, pm);
+    let config = await repairIfNeededOrExit(cwd, aliasRoot.root, unattended);
+    if (!config && await import_fs_extra9.default.pathExists(configPath)) {
       if (!yes) {
         const { overwrite } = await (0, import_prompts2.default)({
           type: "confirm",
@@ -17490,9 +17686,14 @@ function initCommand() {
       }
     }
     const style = await detectProjectStyle(cwd, aliasRoot.root);
-    if (!config) config = await askForConfig(cwd, aliasRoot.root, yes, style);
+    if (!config) config = await askForConfig(cwd, aliasRoot.root, unattended, style, { path: options.path, style: options.style });
     const aliases = config.aliases ?? {};
     const utilsAlias = aliases.utils ?? "@/lib/utils";
+    const css = typeof config.tailwind?.css === "string" ? config.tailwind.css : style.css;
+    const layout = style.rsc ? await findLayout(cwd) : void 0;
+    const utilsFile = `${aliasToPath(utilsAlias, aliasRoot.root)}.ts`;
+    const tracked = ["components.json", utilsFile, css, "package.json", ...layout ? [layout] : []];
+    const before = await snapshotFiles(cwd, tracked);
     await safeOrExit(async () => {
       await resolveWritableFile(cwd, "components.json");
       await resolveInsideProject(cwd, aliasToPath(aliases.components ?? "@/components", aliasRoot.root));
@@ -17512,17 +17713,33 @@ function initCommand() {
       process.exit(1);
     }
     if (!await installCnPackages(cwd, pm, { enabled: options.install !== false, tailwindMajor: style.tailwindMajor })) process.exit(1);
-    const css = typeof config.tailwind?.css === "string" ? config.tailwind.css : style.css;
     const theme = { flag: options.theme, yes, install: options.install !== false, nextMajor: style.nextMajor };
-    if (!await installTheme(cwd, css, theme)) process.exit(1);
+    const themeOk = await installTheme(cwd, css, theme);
+    const fontFixes = options.install !== false && themeOk ? await repairFontVariables(cwd, css) : [];
+    if (!themeOk) process.exit(1);
+    const after = await snapshotFiles(cwd, tracked);
+    const lines = describeChanges({
+      before,
+      after,
+      components: aliases.components ?? "@/components",
+      utilsAlias,
+      utils: utilsFile,
+      css,
+      layout,
+      fontFixes,
+      themeCommand: options.install === false ? "pending" : void 0
+    });
     console.log(source_default.green("\nSuccess! fasla-ui has been initialized."));
-    console.log("\nYou can now add components:");
-    console.log(source_default.cyan("  npx @smicolon/fasla-ui@latest add button"));
-    console.log(source_default.cyan("  npx @smicolon/fasla-ui@latest add shimmer-button"));
+    console.log("\nWhat init did:");
+    for (const line of lines) console.log(`  ${line}`);
+    console.log(`
+Components will be written to ${aliasToPath(aliases.ui ?? `${aliases.components}/ui`, aliasRoot.root)}, imported as ${aliases.ui}/<name>.`);
+    console.log("\nNext, add a component:");
+    console.log(source_default.cyan("  npx @smicolon/fasla-ui@latest add button --yes"));
   });
 }
 async function installTheme(cwd, css, { flag, yes, install: install2, nextMajor }) {
-  const hasColours = hasColourTokens(await import_fs_extra7.default.readFile(path9.join(cwd, css), "utf8").catch(() => ""));
+  const hasColours = hasColourTokens(await import_fs_extra9.default.readFile(path11.join(cwd, css), "utf8").catch(() => ""));
   let choice = themeWithoutAsking({ flag, yes, hasColours });
   if (!choice) {
     const { theme } = await (0, import_prompts2.default)({
@@ -17571,29 +17788,45 @@ Run this to finish:
   ${source_default.cyan(command)}`);
   return false;
 }
-async function askForConfig(cwd, aliasRoot, yes, project) {
+async function keepsAskingAboutOverwrite(cwd, configPath) {
+  const config = await import_fs_extra9.default.readJson(configPath).catch(() => void 0);
+  if (config === void 0) return false;
+  return !await isLegacyConfig(cwd, config);
+}
+async function askForConfig(cwd, aliasRoot, yes, project, flags = {}) {
   const under = (p) => aliasRoot ? `${aliasRoot}/${p}` : p;
   let componentsAlias = "@/components";
   let utilsAlias = "@/lib/utils";
-  let style = "default";
+  let style = flags.style ?? "default";
+  if (flags.path !== void 0) {
+    const alias = componentsAliasFromPath(flags.path, aliasRoot);
+    if (alias === void 0) {
+      console.log(source_default.red(`Error: --path ${outsideAliasMessage(flags.path, aliasRoot)} Nothing was written.`));
+      process.exit(1);
+    }
+    componentsAlias = alias;
+  }
   if (!yes) {
     const insideAlias = (answer) => pathToAlias(answer, aliasRoot) === void 0 ? outsideAliasMessage(answer, aliasRoot) : true;
-    const response = await (0, import_prompts2.default)([
-      {
+    const questions = [];
+    if (flags.path === void 0) {
+      questions.push({
         type: "text",
         name: "componentsDir",
         message: "Where should components be installed?",
         initial: under("components"),
         validate: insideAlias
-      },
-      {
-        type: "text",
-        name: "utilsPath",
-        message: "Where is your utils file (cn)?",
-        initial: under("lib/utils"),
-        validate: insideAlias
-      },
-      {
+      });
+    }
+    questions.push({
+      type: "text",
+      name: "utilsPath",
+      message: "Where is your utils file (cn)?",
+      initial: under("lib/utils"),
+      validate: insideAlias
+    });
+    if (flags.style === void 0) {
+      questions.push({
         type: "select",
         name: "style",
         message: "Which style would you like to use?",
@@ -17602,17 +17835,18 @@ async function askForConfig(cwd, aliasRoot, yes, project) {
           { title: "New York", value: "new-york" }
         ],
         initial: 0
-      }
-    ]);
-    const components = pathToAlias(response.componentsDir ?? "", aliasRoot);
+      });
+    }
+    const response = await (0, import_prompts2.default)(questions);
+    const components = flags.path === void 0 ? componentsAliasFromPath(response.componentsDir ?? "", aliasRoot) : componentsAlias;
     const utils = pathToAlias(response.utilsPath ?? "", aliasRoot);
-    if (components === void 0 || utils === void 0 || response.style === void 0) {
+    if (components === void 0 || utils === void 0 || flags.style === void 0 && response.style === void 0) {
       console.log(source_default.yellow("Cancelled."));
       process.exit(0);
     }
     componentsAlias = components;
     utilsAlias = utils;
-    style = response.style;
+    style = flags.style ?? response.style;
   }
   return {
     $schema: "https://ui.shadcn.com/schema.json",
@@ -17654,15 +17888,15 @@ function isFaslaFile(existing, incoming) {
 // src/cli/commands/add.ts
 function addCommand() {
   return new Command().name("add").description("Add components to your project").argument("[components...]", "Components to add").option("-y, --yes", "Skip confirmation").option("-o, --overwrite", "Overwrite existing files").option("-a, --all", "Add all available components").option("--no-install", "Don't install the packages the components import; print the command instead").option("-c, --cwd <path>", "Working directory", process.cwd()).action(async (components, options) => {
-    const cwd = path10.resolve(options.cwd);
-    const configPath = path10.join(cwd, "components.json");
-    const hasConfig = await import_fs_extra8.default.pathExists(configPath);
+    const cwd = path12.resolve(options.cwd);
+    const configPath = path12.join(cwd, "components.json");
+    const hasConfig = await import_fs_extra10.default.pathExists(configPath);
     if (!hasConfig) {
       console.log(source_default.red("Error: components.json not found."));
       console.log("Run", source_default.cyan("npx @smicolon/fasla-ui@latest init"), "first.");
       process.exit(1);
     }
-    let config = await import_fs_extra8.default.readJson(configPath);
+    let config = await import_fs_extra10.default.readJson(configPath);
     const yes = Boolean(options.yes);
     const pm = await detectPackageManager(cwd);
     const aliasRoot = await aliasRootOrExit(cwd, yes, pm);
@@ -17713,6 +17947,10 @@ function addCommand() {
       process.exit(1);
     }
     if (!options.yes) {
+      if (!isInteractive2()) {
+        console.log(source_default.red(nonInteractiveAddMessage()));
+        process.exit(1);
+      }
       const { confirm } = await (0, import_prompts3.default)({
         type: "confirm",
         name: "confirm",
@@ -17729,12 +17967,19 @@ function addCommand() {
       config = repaired;
       await safeOrExit(() => writeCnHelper(cwd, config.aliases?.utils ?? "@/lib/utils", aliasRoot.root));
     }
-    const componentsAlias = config.aliases?.components || "@/components";
+    const componentsAlias = effectiveComponentsAlias(config.aliases);
+    if (componentsAlias !== (config.aliases?.components || "@/components")) {
+      console.log(
+        source_default.yellow(
+          `components.json has components: "${config.aliases?.components}" and ui: "${config.aliases?.ui}", which puts files in a ui folder inside a ui folder. Writing to ${componentsAlias}/ui instead; set "components" to "${componentsAlias}" in components.json to match.`
+        )
+      );
+    }
     const componentsDir = aliasToPath(componentsAlias, aliasRoot.root);
     await safeOrExit(() => resolveInsideProject(cwd, componentsDir));
     const addSpinner = ora("Resolving dependencies...").start();
     const allDependencies = /* @__PURE__ */ new Set();
-    const baseDir = path10.join(cwd, componentsDir);
+    const baseDir = path12.join(cwd, componentsDir);
     const known = new Set(registry.items.map((item) => item.name));
     const bases = [REGISTRY_URL, DEFAULT_REGISTRY_URL, LEGACY_REGISTRY_URL];
     const nameOf = (dep) => registryItemName(dep, known, bases);
@@ -17762,7 +18007,7 @@ function addCommand() {
       const item = registry.items.find((i) => i.name === name);
       return item ? getTargetDirectory(item.type, baseDir) : void 0;
     };
-    const targetPathOf = (file, component) => path10.join(getTargetDirectory(file.type || component.type, baseDir), path10.basename(file.target || file.path));
+    const targetPathOf = (file, component) => path12.join(getTargetDirectory(file.type || component.type, baseDir), path12.basename(file.target || file.path));
     addSpinner.stop();
     const replace = /* @__PURE__ */ new Set();
     const kept = [];
@@ -17770,12 +18015,12 @@ function addCommand() {
       for (const component of resolved.items) {
         for (const file of component.files ?? []) {
           const target = targetPathOf(file, component);
-          await safeOrExit(() => resolveInsideProject(cwd, path10.dirname(target)));
-          const stat = await import_fs_extra8.default.lstat(target).catch(() => void 0);
+          await safeOrExit(() => resolveInsideProject(cwd, path12.dirname(target)));
+          const stat = await import_fs_extra10.default.lstat(target).catch(() => void 0);
           if (!stat?.isFile()) continue;
-          const existing = await import_fs_extra8.default.readFile(target, "utf8");
+          const existing = await import_fs_extra10.default.readFile(target, "utf8");
           if (isFaslaFile(existing, file.content ?? "")) continue;
-          const name = path10.relative(cwd, target);
+          const name = path12.relative(cwd, target);
           if (yes) {
             kept.push({ component: component.name, file: name });
             continue;
@@ -17783,7 +18028,7 @@ function addCommand() {
           const { replaceIt } = await (0, import_prompts3.default)({
             type: "confirm",
             name: "replaceIt",
-            message: `${path10.basename(target)} exists and isn't Fasla's. Replace it?`,
+            message: `${path12.basename(target)} exists and isn't Fasla's. Replace it?`,
             initial: true
           });
           if (replaceIt) replace.add(target);
@@ -17822,9 +18067,9 @@ function addCommand() {
             continue;
           }
           const targetPath = targetPathOf(file, component);
-          const targetDir = path10.dirname(targetPath);
-          const filename = path10.basename(targetPath);
-          await import_fs_extra8.default.ensureDir(targetDir);
+          const targetDir = path12.dirname(targetPath);
+          const filename = path12.basename(targetPath);
+          await import_fs_extra10.default.ensureDir(targetDir);
           let content = file.content;
           const utilsPath = config.aliases?.utils || "@/lib/utils";
           content = content.replace(