npm - @sinoia/hubdoc-tools - Versions diffs - 1.7.0 → 1.8.0 - Mend

@sinoia/hubdoc-tools 1.7.0 → 1.8.0

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

Files changed (2) hide show

package/cli.js +1394 -819
package/package.json +3 -2

package/cli.js CHANGED Viewed

@@ -925,8 +925,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter3 = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path24 = require("path");
-    var fs20 = require("fs");
+    var path25 = require("path");
+    var fs21 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1749,10 +1749,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path24.resolve(baseDir, baseName);
-          if (fs20.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path24.extname(baseName))) return void 0;
-          const foundExt = sourceExt.find((ext2) => fs20.existsSync(`${localBin}${ext2}`));
+          const localBin = path25.resolve(baseDir, baseName);
+          if (fs21.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path25.extname(baseName))) return void 0;
+          const foundExt = sourceExt.find((ext2) => fs21.existsSync(`${localBin}${ext2}`));
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
         }
@@ -1763,23 +1763,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs20.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs21.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path24.resolve(path24.dirname(resolvedScriptPath), executableDir);
+          executableDir = path25.resolve(path25.dirname(resolvedScriptPath), executableDir);
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path24.basename(this._scriptPath, path24.extname(this._scriptPath));
+            const legacyName = path25.basename(this._scriptPath, path25.extname(this._scriptPath));
             if (legacyName !== this._name) {
               localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
             }
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path24.extname(executableFile));
+        launchWithNode = sourceExt.includes(path25.extname(executableFile));
         let proc2;
         if (process3.platform !== "win32") {
           if (launchWithNode) {
@@ -2562,7 +2562,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path24.basename(filename, path24.extname(filename));
+        this._name = path25.basename(filename, path25.extname(filename));
         return this;
       }
       /**
@@ -2576,9 +2576,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {string|null|Command}
        */
-      executableDir(path25) {
-        if (path25 === void 0) return this._executableDir;
-        this._executableDir = path25;
+      executableDir(path26) {
+        if (path26 === void 0) return this._executableDir;
+        this._executableDir = path26;
         return this;
       }
       /**
@@ -3638,15 +3638,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path24 = [graph[toModel].parent, toModel];
+      const path25 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path24.unshift(graph[cur].parent);
+        path25.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path24;
+      fn.conversion = path25;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -3886,7 +3886,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os7 = require("os");
+    var os9 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -3934,7 +3934,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os7.release().split(".");
+        const osRelease = os9.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -4085,14 +4085,14 @@ var require_templates = __commonJS({
       }
       return results;
     }
-    function buildStyle(chalk27, styles) {
+    function buildStyle(chalk28, styles) {
       const enabled = {};
       for (const layer of styles) {
         for (const style of layer.styles) {
           enabled[style[0]] = layer.inverse ? null : style.slice(1);
         }
       }
-      let current = chalk27;
+      let current = chalk28;
       for (const [styleName, styles2] of Object.entries(enabled)) {
         if (!Array.isArray(styles2)) {
           continue;
@@ -4104,7 +4104,7 @@ var require_templates = __commonJS({
       }
       return current;
     }
-    module2.exports = (chalk27, temporary) => {
+    module2.exports = (chalk28, temporary) => {
       const styles = [];
       const chunks = [];
       let chunk = [];
@@ -4114,13 +4114,13 @@ var require_templates = __commonJS({
         } else if (style) {
           const string = chunk.join("");
           chunk = [];
-          chunks.push(styles.length === 0 ? string : buildStyle(chalk27, styles)(string));
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk28, styles)(string));
           styles.push({ inverse, styles: parseStyle(style) });
         } else if (close3) {
           if (styles.length === 0) {
             throw new Error("Found extraneous } in Chalk template literal");
           }
-          chunks.push(buildStyle(chalk27, styles)(chunk.join("")));
+          chunks.push(buildStyle(chalk28, styles)(chunk.join("")));
           chunk = [];
           styles.pop();
         } else {
@@ -4168,16 +4168,16 @@ var require_source = __commonJS({
       }
     };
     var chalkFactory = (options) => {
-      const chalk28 = {};
-      applyOptions(chalk28, options);
-      chalk28.template = (...arguments_) => chalkTag(chalk28.template, ...arguments_);
-      Object.setPrototypeOf(chalk28, Chalk.prototype);
-      Object.setPrototypeOf(chalk28.template, chalk28);
-      chalk28.template.constructor = () => {
+      const chalk29 = {};
+      applyOptions(chalk29, options);
+      chalk29.template = (...arguments_) => chalkTag(chalk29.template, ...arguments_);
+      Object.setPrototypeOf(chalk29, Chalk.prototype);
+      Object.setPrototypeOf(chalk29.template, chalk29);
+      chalk29.template.constructor = () => {
         throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
       };
-      chalk28.template.Instance = ChalkClass;
-      return chalk28.template;
+      chalk29.template.Instance = ChalkClass;
+      return chalk29.template;
     };
     function Chalk(options) {
       return chalkFactory(options);
@@ -4288,7 +4288,7 @@ var require_source = __commonJS({
       return openAll + string + closeAll;
     };
     var template;
-    var chalkTag = (chalk28, ...strings) => {
+    var chalkTag = (chalk29, ...strings) => {
       const [firstString] = strings;
       if (!isArray2(firstString) || !isArray2(firstString.raw)) {
         return strings.join(" ");
@@ -4304,14 +4304,14 @@ var require_source = __commonJS({
       if (template === void 0) {
         template = require_templates();
       }
-      return template(chalk28, parts2.join(""));
+      return template(chalk29, parts2.join(""));
     };
     Object.defineProperties(Chalk.prototype, styles);
-    var chalk27 = Chalk();
-    chalk27.supportsColor = stdoutColor;
-    chalk27.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
-    chalk27.stderr.supportsColor = stderrColor;
-    module2.exports = chalk27;
+    var chalk28 = Chalk();
+    chalk28.supportsColor = stdoutColor;
+    chalk28.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk28.stderr.supportsColor = stderrColor;
+    module2.exports = chalk28;
   }
 });
@@ -4369,54 +4369,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs20) {
+    function patch(fs21) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs20);
-      }
-      if (!fs20.lutimes) {
-        patchLutimes(fs20);
-      }
-      fs20.chown = chownFix(fs20.chown);
-      fs20.fchown = chownFix(fs20.fchown);
-      fs20.lchown = chownFix(fs20.lchown);
-      fs20.chmod = chmodFix(fs20.chmod);
-      fs20.fchmod = chmodFix(fs20.fchmod);
-      fs20.lchmod = chmodFix(fs20.lchmod);
-      fs20.chownSync = chownFixSync(fs20.chownSync);
-      fs20.fchownSync = chownFixSync(fs20.fchownSync);
-      fs20.lchownSync = chownFixSync(fs20.lchownSync);
-      fs20.chmodSync = chmodFixSync(fs20.chmodSync);
-      fs20.fchmodSync = chmodFixSync(fs20.fchmodSync);
-      fs20.lchmodSync = chmodFixSync(fs20.lchmodSync);
-      fs20.stat = statFix(fs20.stat);
-      fs20.fstat = statFix(fs20.fstat);
-      fs20.lstat = statFix(fs20.lstat);
-      fs20.statSync = statFixSync(fs20.statSync);
-      fs20.fstatSync = statFixSync(fs20.fstatSync);
-      fs20.lstatSync = statFixSync(fs20.lstatSync);
-      if (fs20.chmod && !fs20.lchmod) {
-        fs20.lchmod = function(path24, mode, cb) {
+        patchLchmod(fs21);
+      }
+      if (!fs21.lutimes) {
+        patchLutimes(fs21);
+      }
+      fs21.chown = chownFix(fs21.chown);
+      fs21.fchown = chownFix(fs21.fchown);
+      fs21.lchown = chownFix(fs21.lchown);
+      fs21.chmod = chmodFix(fs21.chmod);
+      fs21.fchmod = chmodFix(fs21.fchmod);
+      fs21.lchmod = chmodFix(fs21.lchmod);
+      fs21.chownSync = chownFixSync(fs21.chownSync);
+      fs21.fchownSync = chownFixSync(fs21.fchownSync);
+      fs21.lchownSync = chownFixSync(fs21.lchownSync);
+      fs21.chmodSync = chmodFixSync(fs21.chmodSync);
+      fs21.fchmodSync = chmodFixSync(fs21.fchmodSync);
+      fs21.lchmodSync = chmodFixSync(fs21.lchmodSync);
+      fs21.stat = statFix(fs21.stat);
+      fs21.fstat = statFix(fs21.fstat);
+      fs21.lstat = statFix(fs21.lstat);
+      fs21.statSync = statFixSync(fs21.statSync);
+      fs21.fstatSync = statFixSync(fs21.fstatSync);
+      fs21.lstatSync = statFixSync(fs21.lstatSync);
+      if (fs21.chmod && !fs21.lchmod) {
+        fs21.lchmod = function(path25, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs20.lchmodSync = function() {
+        fs21.lchmodSync = function() {
         };
       }
-      if (fs20.chown && !fs20.lchown) {
-        fs20.lchown = function(path24, uid, gid, cb) {
+      if (fs21.chown && !fs21.lchown) {
+        fs21.lchown = function(path25, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs20.lchownSync = function() {
+        fs21.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs20.rename = typeof fs20.rename !== "function" ? fs20.rename : (function(fs$rename) {
+        fs21.rename = typeof fs21.rename !== "function" ? fs21.rename : (function(fs$rename) {
           function rename(from3, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from3, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs20.stat(to, function(stater, st) {
+                  fs21.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -4432,9 +4432,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs20.rename);
+        })(fs21.rename);
       }
-      fs20.read = typeof fs20.read !== "function" ? fs20.read : (function(fs$read) {
+      fs21.read = typeof fs21.read !== "function" ? fs21.read : (function(fs$read) {
         function read3(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4442,22 +4442,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs21, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read3, fs$read);
         return read3;
-      })(fs20.read);
-      fs20.readSync = typeof fs20.readSync !== "function" ? fs20.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs21.read);
+      fs21.readSync = typeof fs21.readSync !== "function" ? fs21.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs20, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs21, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4467,11 +4467,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs20.readSync);
-      function patchLchmod(fs21) {
-        fs21.lchmod = function(path24, mode, callback) {
-          fs21.open(
-            path24,
+      })(fs21.readSync);
+      function patchLchmod(fs22) {
+        fs22.lchmod = function(path25, mode, callback) {
+          fs22.open(
+            path25,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -4479,80 +4479,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs21.fchmod(fd, mode, function(err2) {
-                fs21.close(fd, function(err22) {
+              fs22.fchmod(fd, mode, function(err2) {
+                fs22.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs21.lchmodSync = function(path24, mode) {
-          var fd = fs21.openSync(path24, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs22.lchmodSync = function(path25, mode) {
+          var fd = fs22.openSync(path25, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs21.fchmodSync(fd, mode);
+            ret = fs22.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs21.closeSync(fd);
+                fs22.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs21.closeSync(fd);
+              fs22.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs21) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs21.futimes) {
-          fs21.lutimes = function(path24, at, mt, cb) {
-            fs21.open(path24, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs22) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs22.futimes) {
+          fs22.lutimes = function(path25, at, mt, cb) {
+            fs22.open(path25, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs21.futimes(fd, at, mt, function(er2) {
-                fs21.close(fd, function(er22) {
+              fs22.futimes(fd, at, mt, function(er2) {
+                fs22.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs21.lutimesSync = function(path24, at, mt) {
-            var fd = fs21.openSync(path24, constants.O_SYMLINK);
+          fs22.lutimesSync = function(path25, at, mt) {
+            var fd = fs22.openSync(path25, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs21.futimesSync(fd, at, mt);
+              ret = fs22.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs21.closeSync(fd);
+                  fs22.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs21.closeSync(fd);
+                fs22.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs21.futimes) {
-          fs21.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs22.futimes) {
+          fs22.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs21.lutimesSync = function() {
+          fs22.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs20, target, mode, function(er) {
+          return orig.call(fs21, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4562,7 +4562,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs20, target, mode);
+            return orig.call(fs21, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4571,7 +4571,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs20, target, uid, gid, function(er) {
+          return orig.call(fs21, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4581,7 +4581,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs20, target, uid, gid);
+            return orig.call(fs21, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4601,13 +4601,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs20, target, options, callback) : orig.call(fs20, target, callback);
+          return options ? orig.call(fs21, target, options, callback) : orig.call(fs21, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs20, target, options) : orig.call(fs20, target);
+          var stats = options ? orig.call(fs21, target, options) : orig.call(fs21, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -4636,16 +4636,16 @@ var require_legacy_streams = __commonJS({
   "node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs20) {
+    function legacy(fs21) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path24, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path24, options);
+      function ReadStream(path25, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path25, options);
         Stream2.call(this);
         var self2 = this;
-        this.path = path24;
+        this.path = path25;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -4679,7 +4679,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs20.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs21.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -4690,10 +4690,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path24, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path24, options);
+      function WriteStream(path25, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path25, options);
         Stream2.call(this);
-        this.path = path24;
+        this.path = path25;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -4718,7 +4718,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs20.open;
+          this._open = fs21.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -4753,7 +4753,7 @@ var require_clone = __commonJS({
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs20 = require("fs");
+    var fs21 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -4785,12 +4785,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs20[gracefulQueue]) {
+    if (!fs21[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs20, queue);
-      fs20.close = (function(fs$close) {
+      publishQueue(fs21, queue);
+      fs21.close = (function(fs$close) {
         function close3(fd, cb) {
-          return fs$close.call(fs20, fd, function(err) {
+          return fs$close.call(fs21, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -4802,48 +4802,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close3;
-      })(fs20.close);
-      fs20.closeSync = (function(fs$closeSync) {
+      })(fs21.close);
+      fs21.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs20, arguments);
+          fs$closeSync.apply(fs21, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs20.closeSync);
+      })(fs21.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs20[gracefulQueue]);
-          require("assert").equal(fs20[gracefulQueue].length, 0);
+          debug(fs21[gracefulQueue]);
+          require("assert").equal(fs21[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs20[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs20));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs20.__patched) {
-      module2.exports = patch(fs20);
-      fs20.__patched = true;
-    }
-    function patch(fs21) {
-      polyfills(fs21);
-      fs21.gracefulify = patch;
-      fs21.createReadStream = createReadStream3;
-      fs21.createWriteStream = createWriteStream;
-      var fs$readFile = fs21.readFile;
-      fs21.readFile = readFile;
-      function readFile(path24, options, cb) {
+      publishQueue(global, fs21[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs21));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs21.__patched) {
+      module2.exports = patch(fs21);
+      fs21.__patched = true;
+    }
+    function patch(fs22) {
+      polyfills(fs22);
+      fs22.gracefulify = patch;
+      fs22.createReadStream = createReadStream3;
+      fs22.createWriteStream = createWriteStream;
+      var fs$readFile = fs22.readFile;
+      fs22.readFile = readFile;
+      function readFile(path25, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path24, options, cb);
-        function go$readFile(path25, options2, cb2, startTime) {
-          return fs$readFile(path25, options2, function(err) {
+        return go$readFile(path25, options, cb);
+        function go$readFile(path26, options2, cb2, startTime) {
+          return fs$readFile(path26, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path25, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path26, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4851,16 +4851,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs21.writeFile;
-      fs21.writeFile = writeFile;
-      function writeFile(path24, data, options, cb) {
+      var fs$writeFile = fs22.writeFile;
+      fs22.writeFile = writeFile;
+      function writeFile(path25, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path24, data, options, cb);
-        function go$writeFile(path25, data2, options2, cb2, startTime) {
-          return fs$writeFile(path25, data2, options2, function(err) {
+        return go$writeFile(path25, data, options, cb);
+        function go$writeFile(path26, data2, options2, cb2, startTime) {
+          return fs$writeFile(path26, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path25, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path26, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4868,17 +4868,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs21.appendFile;
+      var fs$appendFile = fs22.appendFile;
       if (fs$appendFile)
-        fs21.appendFile = appendFile;
-      function appendFile(path24, data, options, cb) {
+        fs22.appendFile = appendFile;
+      function appendFile(path25, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path24, data, options, cb);
-        function go$appendFile(path25, data2, options2, cb2, startTime) {
-          return fs$appendFile(path25, data2, options2, function(err) {
+        return go$appendFile(path25, data, options, cb);
+        function go$appendFile(path26, data2, options2, cb2, startTime) {
+          return fs$appendFile(path26, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path25, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path26, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -4886,9 +4886,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs21.copyFile;
+      var fs$copyFile = fs22.copyFile;
       if (fs$copyFile)
-        fs21.copyFile = copyFile;
+        fs22.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -4906,34 +4906,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs21.readdir;
-      fs21.readdir = readdir2;
+      var fs$readdir = fs22.readdir;
+      fs22.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path24, options, cb) {
+      function readdir2(path25, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path25, options2, cb2, startTime) {
-          return fs$readdir(path25, fs$readdirCallback(
-            path25,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path26, options2, cb2, startTime) {
+          return fs$readdir(path26, fs$readdirCallback(
+            path26,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path25, options2, cb2, startTime) {
-          return fs$readdir(path25, options2, fs$readdirCallback(
-            path25,
+        } : function go$readdir2(path26, options2, cb2, startTime) {
+          return fs$readdir(path26, options2, fs$readdirCallback(
+            path26,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path24, options, cb);
-        function fs$readdirCallback(path25, options2, cb2, startTime) {
+        return go$readdir(path25, options, cb);
+        function fs$readdirCallback(path26, options2, cb2, startTime) {
           return function(err, files2) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path25, options2, cb2],
+                [path26, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -4948,21 +4948,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs21);
+        var legStreams = legacy(fs22);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs21.ReadStream;
+      var fs$ReadStream = fs22.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs21.WriteStream;
+      var fs$WriteStream = fs22.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs21, "ReadStream", {
+      Object.defineProperty(fs22, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -4972,7 +4972,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs21, "WriteStream", {
+      Object.defineProperty(fs22, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -4983,7 +4983,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs21, "FileReadStream", {
+      Object.defineProperty(fs22, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -4994,7 +4994,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs21, "FileWriteStream", {
+      Object.defineProperty(fs22, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5004,7 +5004,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path24, options) {
+      function ReadStream(path25, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -5024,7 +5024,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path24, options) {
+      function WriteStream(path25, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -5042,22 +5042,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream3(path24, options) {
-        return new fs21.ReadStream(path24, options);
+      function createReadStream3(path25, options) {
+        return new fs22.ReadStream(path25, options);
       }
-      function createWriteStream(path24, options) {
-        return new fs21.WriteStream(path24, options);
+      function createWriteStream(path25, options) {
+        return new fs22.WriteStream(path25, options);
       }
-      var fs$open = fs21.open;
-      fs21.open = open3;
-      function open3(path24, flags, mode, cb) {
+      var fs$open = fs22.open;
+      fs22.open = open3;
+      function open3(path25, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path24, flags, mode, cb);
-        function go$open(path25, flags2, mode2, cb2, startTime) {
-          return fs$open(path25, flags2, mode2, function(err, fd) {
+        return go$open(path25, flags, mode, cb);
+        function go$open(path26, flags2, mode2, cb2, startTime) {
+          return fs$open(path26, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path25, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path26, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -5065,20 +5065,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs21;
+      return fs22;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs20[gracefulQueue].push(elem);
+      fs21[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs20[gracefulQueue].length; ++i) {
-        if (fs20[gracefulQueue][i].length > 2) {
-          fs20[gracefulQueue][i][3] = now;
-          fs20[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs21[gracefulQueue].length; ++i) {
+        if (fs21[gracefulQueue][i].length > 2) {
+          fs21[gracefulQueue][i][3] = now;
+          fs21[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -5086,9 +5086,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs20[gracefulQueue].length === 0)
+      if (fs21[gracefulQueue].length === 0)
         return;
-      var elem = fs20[gracefulQueue].shift();
+      var elem = fs21[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -5110,7 +5110,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs20[gracefulQueue].push(elem);
+          fs21[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5125,7 +5125,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -5166,26 +5166,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs20[key] === "function";
+      return typeof fs21[key] === "function";
     });
-    Object.assign(exports2, fs20);
+    Object.assign(exports2, fs21);
     api.forEach((method) => {
-      exports2[method] = u(fs20[method]);
+      exports2[method] = u(fs21[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs20.exists(filename, callback);
+        return fs21.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs20.exists(filename, resolve);
+        return fs21.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs20.read(fd, buffer, offset, length, position, callback);
+        return fs21.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs20.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs21.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -5193,10 +5193,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.write(fd, buffer, ...args);
+        return fs21.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs20.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs21.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -5204,10 +5204,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.readv(fd, buffers, ...args);
+        return fs21.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs20.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs21.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -5215,17 +5215,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs20.writev(fd, buffers, ...args);
+        return fs21.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs20.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs21.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs20.realpath.native === "function") {
-      exports2.realpath.native = u(fs20.realpath.native);
+    if (typeof fs21.realpath.native === "function") {
+      exports2.realpath.native = u(fs21.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -5240,10 +5240,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path24 = require("path");
+    var path25 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path24.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path25.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -5258,7 +5258,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults3 = { mode: 511 };
@@ -5267,14 +5267,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs20.mkdir(dir, {
+      return fs21.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs20.mkdirSync(dir, {
+      return fs21.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5306,13 +5306,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs20 = require_fs();
-    function pathExists3(path24) {
-      return fs20.access(path24).then(() => true).catch(() => false);
+    var fs21 = require_fs();
+    function pathExists3(path25) {
+      return fs21.access(path25).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists3),
-      pathExistsSync: fs20.existsSync
+      pathExistsSync: fs21.existsSync
     };
   }
 });
@@ -5321,16 +5321,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path24, atime, mtime) {
-      const fd = await fs20.open(path24, "r+");
+    async function utimesMillis(path25, atime, mtime) {
+      const fd = await fs21.open(path25, "r+");
       let closeErr = null;
       try {
-        await fs20.futimes(fd, atime, mtime);
+        await fs21.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs20.close(fd);
+          await fs21.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -5339,10 +5339,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path24, atime, mtime) {
-      const fd = fs20.openSync(path24, "r+");
-      fs20.futimesSync(fd, atime, mtime);
-      return fs20.closeSync(fd);
+    function utimesMillisSync(path25, atime, mtime) {
+      const fd = fs21.openSync(path25, "r+");
+      fs21.futimesSync(fd, atime, mtime);
+      return fs21.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -5355,11 +5355,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
-    var path24 = require("path");
+    var fs21 = require_fs();
+    var path25 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs20.stat(file, { bigint: true }) : (file) => fs20.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs21.stat(file, { bigint: true }) : (file) => fs21.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5370,7 +5370,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs20.statSync(file, { bigint: true }) : (file) => fs20.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs21.statSync(file, { bigint: true }) : (file) => fs21.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5384,8 +5384,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path24.basename(src);
-          const destBaseName = path24.basename(dest);
+          const srcBaseName = path25.basename(src);
+          const destBaseName = path25.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5407,8 +5407,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path24.basename(src);
-          const destBaseName = path24.basename(dest);
+          const srcBaseName = path25.basename(src);
+          const destBaseName = path25.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -5427,12 +5427,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path24.resolve(path24.dirname(src));
-      const destParent = path24.resolve(path24.dirname(dest));
-      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
+      const srcParent = path25.resolve(path25.dirname(src));
+      const destParent = path25.resolve(path25.dirname(dest));
+      if (destParent === srcParent || destParent === path25.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs20.stat(destParent, { bigint: true });
+        destStat = await fs21.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5443,12 +5443,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path24.resolve(path24.dirname(src));
-      const destParent = path24.resolve(path24.dirname(dest));
-      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
+      const srcParent = path25.resolve(path25.dirname(src));
+      const destParent = path25.resolve(path25.dirname(dest));
+      if (destParent === srcParent || destParent === path25.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs20.statSync(destParent, { bigint: true });
+        destStat = fs21.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5462,8 +5462,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 = path24.resolve(src).split(path24.sep).filter((i) => i);
-      const destArr = path24.resolve(dest).split(path24.sep).filter((i) => i);
+      const srcArr = path25.resolve(src).split(path25.sep).filter((i) => i);
+      const destArr = path25.resolve(dest).split(path25.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -5515,8 +5515,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
-    var path24 = require("path");
+    var fs21 = require_fs();
+    var path25 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists: pathExists3 } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -5539,7 +5539,7 @@ var require_copy = __commonJS({
       await stat3.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path24.dirname(dest);
+      const destParent = path25.dirname(dest);
       const dirExists = await pathExists3(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -5551,7 +5551,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs20.stat : fs20.lstat;
+      const statFn = opts.dereference ? fs21.stat : fs21.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);
@@ -5563,7 +5563,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 fs20.unlink(dest);
+        await fs21.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5571,29 +5571,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs20.copyFile(src, dest);
+      await fs21.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs20.stat(src);
+        const updatedSrcStat = await fs21.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs20.chmod(dest, srcStat.mode);
+      return fs21.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs20.chmod(dest, srcMode | 128);
+      return fs21.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs20.mkdir(dest);
+        await fs21.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs20.opendir(src), async (item) => {
-        const srcItem = path24.join(src, item.name);
-        const destItem = path24.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs21.opendir(src), async (item) => {
+        const srcItem = path25.join(src, item.name);
+        const destItem = path25.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat3.checkPaths(srcItem, destItem, "copy", opts);
@@ -5601,26 +5601,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs20.chmod(dest, srcStat.mode);
+        await fs21.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs20.readlink(src);
+      let resolvedSrc = await fs21.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path25.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs20.symlink(resolvedSrc, dest);
+        return fs21.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs20.readlink(dest);
+        resolvedDest = await fs21.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs20.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs21.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path24.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path25.resolve(process.cwd(), resolvedDest);
       }
       if (stat3.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -5628,8 +5628,8 @@ var require_copy = __commonJS({
       if (stat3.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs20.unlink(dest);
-      return fs20.symlink(resolvedSrc, dest);
+      await fs21.unlink(dest);
+      return fs21.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -5639,8 +5639,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
-    var path24 = require("path");
+    var fs21 = require_graceful_fs();
+    var path25 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat3 = require_stat();
@@ -5661,12 +5661,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat3.checkPathsSync(src, dest, "copy", opts);
       stat3.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path24.dirname(dest);
-      if (!fs20.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path25.dirname(dest);
+      if (!fs21.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs20.statSync : fs20.lstatSync;
+      const statSync = opts.dereference ? fs21.statSync : fs21.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);
@@ -5681,14 +5681,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs20.unlinkSync(dest);
+        fs21.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs20.copyFileSync(src, dest);
+      fs21.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -5703,10 +5703,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs20.chmodSync(dest, srcMode);
+      return fs21.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs20.statSync(src);
+      const updatedSrcStat = fs21.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -5714,12 +5714,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs20.mkdirSync(dest);
+      fs21.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs20.opendirSync(src);
+      const dir = fs21.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -5730,29 +5730,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path24.join(src, item);
-      const destItem = path24.join(dest, item);
+      const srcItem = path25.join(src, item);
+      const destItem = path25.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat3.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs20.readlinkSync(src);
+      let resolvedSrc = fs21.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path25.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs20.symlinkSync(resolvedSrc, dest);
+        return fs21.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs20.readlinkSync(dest);
+          resolvedDest = fs21.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs20.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs21.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path24.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path25.resolve(process.cwd(), resolvedDest);
         }
         if (stat3.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -5764,8 +5764,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs20.unlinkSync(dest);
-      return fs20.symlinkSync(resolvedSrc, dest);
+      fs21.unlinkSync(dest);
+      return fs21.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -5787,13 +5787,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
+    var fs21 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path24, callback) {
-      fs20.rm(path24, { recursive: true, force: true }, callback);
+    function remove(path25, callback) {
+      fs21.rm(path25, { recursive: true, force: true }, callback);
     }
-    function removeSync(path24) {
-      fs20.rmSync(path24, { recursive: true, force: true });
+    function removeSync(path25) {
+      fs21.rmSync(path25, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -5807,28 +5807,28 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs20 = require_fs();
-    var path24 = require("path");
+    var fs21 = require_fs();
+    var path25 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs20.readdir(dir);
+        items = await fs21.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path24.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path25.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs20.readdirSync(dir);
+        items = fs21.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path24.join(dir, item);
+        item = path25.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -5846,52 +5846,52 @@ var require_file = __commonJS({
   "node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path24 = require("path");
-    var fs20 = require_fs();
+    var path25 = require("path");
+    var fs21 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs20.stat(file);
+        stats = await fs21.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path24.dirname(file);
+      const dir = path25.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs20.stat(dir);
+        dirStats = await fs21.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs20.writeFile(file, "");
+          await fs21.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs20.writeFile(file, "");
+        await fs21.writeFile(file, "");
       } else {
-        await fs20.readdir(dir);
+        await fs21.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs20.statSync(file);
+        stats = fs21.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path24.dirname(file);
+      const dir = path25.dirname(file);
       try {
-        if (!fs20.statSync(dir).isDirectory()) {
-          fs20.readdirSync(dir);
+        if (!fs21.statSync(dir).isDirectory()) {
+          fs21.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs20.writeFileSync(file, "");
+      fs21.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -5905,50 +5905,50 @@ var require_link = __commonJS({
   "node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path24 = require("path");
-    var fs20 = require_fs();
+    var path25 = require("path");
+    var fs21 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists: pathExists3 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs20.lstat(dstpath);
+        dstStat = await fs21.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs20.lstat(srcpath);
+        srcStat = await fs21.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path24.dirname(dstpath);
+      const dir = path25.dirname(dstpath);
       const dirExists = await pathExists3(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs20.link(srcpath, dstpath);
+      await fs21.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs20.lstatSync(dstpath);
+        dstStat = fs21.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs20.lstatSync(srcpath);
+        const srcStat = fs21.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path24.dirname(dstpath);
-      const dirExists = fs20.existsSync(dir);
-      if (dirExists) return fs20.linkSync(srcpath, dstpath);
+      const dir = path25.dirname(dstpath);
+      const dirExists = fs21.existsSync(dir);
+      if (dirExists) return fs21.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs20.linkSync(srcpath, dstpath);
+      return fs21.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -5961,14 +5961,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path24 = require("path");
-    var fs20 = require_fs();
+    var path25 = require("path");
+    var fs21 = require_fs();
     var { pathExists: pathExists3 } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path24.isAbsolute(srcpath)) {
+      if (path25.isAbsolute(srcpath)) {
         try {
-          await fs20.lstat(srcpath);
+          await fs21.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -5978,8 +5978,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path24.dirname(dstpath);
-      const relativeToDst = path24.join(dstdir, srcpath);
+      const dstdir = path25.dirname(dstpath);
+      const relativeToDst = path25.join(dstdir, srcpath);
       const exists = await pathExists3(relativeToDst);
       if (exists) {
         return {
@@ -5988,39 +5988,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs20.lstat(srcpath);
+        await fs21.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path24.relative(dstdir, srcpath)
+        toDst: path25.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path24.isAbsolute(srcpath)) {
-        const exists2 = fs20.existsSync(srcpath);
+      if (path25.isAbsolute(srcpath)) {
+        const exists2 = fs21.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path24.dirname(dstpath);
-      const relativeToDst = path24.join(dstdir, srcpath);
-      const exists = fs20.existsSync(relativeToDst);
+      const dstdir = path25.dirname(dstpath);
+      const relativeToDst = path25.join(dstdir, srcpath);
+      const exists = fs21.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs20.existsSync(srcpath);
+      const srcExists = fs21.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path24.relative(dstdir, srcpath)
+        toDst: path25.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -6034,13 +6034,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
+    var fs21 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs20.lstat(srcpath);
+        stats = await fs21.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -6050,7 +6050,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs20.lstatSync(srcpath);
+        stats = fs21.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -6068,8 +6068,8 @@ var require_symlink = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path24 = require("path");
-    var fs20 = require_fs();
+    var path25 = require("path");
+    var fs21 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -6078,44 +6078,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs20.lstat(dstpath);
+        stats = await fs21.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs20.stat(srcpath),
-          fs20.stat(dstpath)
+          fs21.stat(srcpath),
+          fs21.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 = path24.dirname(dstpath);
+      const dir = path25.dirname(dstpath);
       if (!await pathExists3(dir)) {
         await mkdirs(dir);
       }
-      return fs20.symlink(srcpath, dstpath, toType);
+      return fs21.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs20.lstatSync(dstpath);
+        stats = fs21.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs20.statSync(srcpath);
-        const dstStat = fs20.statSync(dstpath);
+        const srcStat = fs21.statSync(srcpath);
+        const dstStat = fs21.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path24.dirname(dstpath);
-      const exists = fs20.existsSync(dir);
-      if (exists) return fs20.symlinkSync(srcpath, dstpath, type);
+      const dir = path25.dirname(dstpath);
+      const exists = fs21.existsSync(dir);
+      if (exists) return fs21.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs20.symlinkSync(srcpath, dstpath, type);
+      return fs21.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -6182,9 +6182,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs20.readFile)(file, options);
+      let data = await universalify.fromCallback(fs21.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -6204,10 +6204,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs20.readFileSync(file, options);
+        let content = fs21.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -6220,15 +6220,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs20.writeFile)(file, str, options);
+      await universalify.fromCallback(fs21.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file, obj, options = {}) {
-      const fs20 = options.fs || _fs;
+      const fs21 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs20.writeFileSync(file, str, options);
+      return fs21.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile,
@@ -6259,23 +6259,23 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs20 = require_fs();
-    var path24 = require("path");
+    var fs21 = require_fs();
+    var path25 = require("path");
     var mkdir = require_mkdirs();
     var pathExists3 = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path24.dirname(file);
+      const dir = path25.dirname(file);
       if (!await pathExists3(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs20.writeFile(file, data, encoding);
+      return fs21.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path24.dirname(file);
-      if (!fs20.existsSync(dir)) {
+      const dir = path25.dirname(file);
+      if (!fs21.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs20.writeFileSync(file, ...args);
+      fs21.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -6334,8 +6334,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_fs();
-    var path24 = require("path");
+    var fs21 = require_fs();
+    var path25 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -6345,8 +6345,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat3.checkPaths(src, dest, "move", opts);
       await stat3.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path24.dirname(dest);
-      const parsedParentPath = path24.parse(destParent);
+      const destParent = path25.dirname(dest);
+      const parsedParentPath = path25.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -6361,7 +6361,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs20.rename(src, dest);
+        await fs21.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6386,8 +6386,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs20 = require_graceful_fs();
-    var path24 = require("path");
+    var fs21 = require_graceful_fs();
+    var path25 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -6397,12 +6397,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat3.checkPathsSync(src, dest, "move", opts);
       stat3.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path24.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path25.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path24.dirname(dest);
-      const parsedPath = path24.parse(parent);
+      const parent = path25.dirname(dest);
+      const parsedPath = path25.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -6411,12 +6411,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs20.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs21.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs20.renameSync(src, dest);
+        fs21.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -18202,19 +18202,19 @@ var require_is_unicode_supported = __commonJS({
 var require_log_symbols = __commonJS({
   "node_modules/log-symbols/index.js"(exports2, module2) {
     "use strict";
-    var chalk27 = require_source();
+    var chalk28 = require_source();
     var isUnicodeSupported2 = require_is_unicode_supported();
     var main = {
-      info: chalk27.blue("\u2139"),
-      success: chalk27.green("\u2714"),
-      warning: chalk27.yellow("\u26A0"),
-      error: chalk27.red("\u2716")
+      info: chalk28.blue("\u2139"),
+      success: chalk28.green("\u2714"),
+      warning: chalk28.yellow("\u26A0"),
+      error: chalk28.red("\u2716")
     };
     var fallback = {
-      info: chalk27.blue("i"),
-      success: chalk27.green("\u221A"),
-      warning: chalk27.yellow("\u203C"),
-      error: chalk27.red("\xD7")
+      info: chalk28.blue("i"),
+      success: chalk28.green("\u221A"),
+      warning: chalk28.yellow("\u203C"),
+      error: chalk28.red("\xD7")
     };
     module2.exports = isUnicodeSupported2() ? main : fallback;
   }
@@ -21682,7 +21682,7 @@ var require_ora = __commonJS({
   "node_modules/ora/index.js"(exports2, module2) {
     "use strict";
     var readline2 = require("readline");
-    var chalk27 = require_source();
+    var chalk28 = require_source();
     var cliCursor = require_cli_cursor();
     var cliSpinners = require_cli_spinners();
     var logSymbols = require_log_symbols();
@@ -21879,7 +21879,7 @@ var require_ora = __commonJS({
         const { frames } = this.spinner;
         let frame = frames[this.frameIndex];
         if (this.color) {
-          frame = chalk27[this.color](frame);
+          frame = chalk28[this.color](frame);
         }
         this.frameIndex = ++this.frameIndex % frames.length;
         const fullPrefixText = typeof this.prefixText === "string" && this.prefixText !== "" ? this.prefixText + " " : "";
@@ -27580,10 +27580,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs20 = (0, node_1.default)();
+      const fs21 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs20.closeSync(fd);
+          fs21.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -27595,9 +27595,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs20.openSync(filepath, "r");
+        fd = fs21.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs20.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs21.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -27609,22 +27609,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs20.readFile(filepath, handler);
+      fs21.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs20 = (0, node_1.default)();
+      const fs21 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs20.openSync(filepath, "r");
+        const fd = fs21.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs20.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs21.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs20.closeSync(fd);
+        fs21.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs20.readFileSync(filepath));
+      return (0, exports2.detect)(fs21.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -40388,11 +40388,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path24) {
-      if (!path24 || typeof path24 !== "string") {
+    function lookup(path25) {
+      if (!path25 || typeof path25 !== "string") {
         return false;
       }
-      var extension2 = extname3("x." + path24).toLowerCase().substr(1);
+      var extension2 = extname3("x." + path25).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -41497,21 +41497,21 @@ var require_form_data = __commonJS({
     "use strict";
     var CombinedStream = require_combined_stream();
     var util3 = require("util");
-    var path24 = require("path");
+    var path25 = require("path");
     var http4 = require("http");
     var https2 = require("https");
     var parseUrl = require("url").parse;
-    var fs20 = require("fs");
+    var fs21 = require("fs");
     var Stream2 = require("stream").Stream;
-    var crypto4 = require("crypto");
+    var crypto5 = require("crypto");
     var mime = require_mime_types();
     var asynckit = require_asynckit();
     var setToStringTag = require_es_set_tostringtag();
     var hasOwn = require_hasown();
     var populate = require_populate();
-    function FormData5(options) {
-      if (!(this instanceof FormData5)) {
-        return new FormData5(options);
+    function FormData6(options) {
+      if (!(this instanceof FormData6)) {
+        return new FormData6(options);
       }
       this._overheadLength = 0;
       this._valueLength = 0;
@@ -41522,10 +41522,10 @@ var require_form_data = __commonJS({
         this[option] = options[option];
       }
     }
-    util3.inherits(FormData5, CombinedStream);
-    FormData5.LINE_BREAK = "\r\n";
-    FormData5.DEFAULT_CONTENT_TYPE = "application/octet-stream";
-    FormData5.prototype.append = function(field, value2, options) {
+    util3.inherits(FormData6, CombinedStream);
+    FormData6.LINE_BREAK = "\r\n";
+    FormData6.DEFAULT_CONTENT_TYPE = "application/octet-stream";
+    FormData6.prototype.append = function(field, value2, options) {
       options = options || {};
       if (typeof options === "string") {
         options = { filename: options };
@@ -41545,7 +41545,7 @@ var require_form_data = __commonJS({
       append2(footer);
       this._trackLength(header, value2, options);
     };
-    FormData5.prototype._trackLength = function(header, value2, options) {
+    FormData6.prototype._trackLength = function(header, value2, options) {
       var valueLength = 0;
       if (options.knownLength != null) {
         valueLength += Number(options.knownLength);
@@ -41555,7 +41555,7 @@ var require_form_data = __commonJS({
         valueLength = Buffer.byteLength(value2);
       }
       this._valueLength += valueLength;
-      this._overheadLength += Buffer.byteLength(header) + FormData5.LINE_BREAK.length;
+      this._overheadLength += Buffer.byteLength(header) + FormData6.LINE_BREAK.length;
       if (!value2 || !value2.path && !(value2.readable && hasOwn(value2, "httpVersion")) && !(value2 instanceof Stream2)) {
         return;
       }
@@ -41563,12 +41563,12 @@ var require_form_data = __commonJS({
         this._valuesToMeasure.push(value2);
       }
     };
-    FormData5.prototype._lengthRetriever = function(value2, callback) {
+    FormData6.prototype._lengthRetriever = function(value2, callback) {
       if (hasOwn(value2, "fd")) {
         if (value2.end != void 0 && value2.end != Infinity && value2.start != void 0) {
           callback(null, value2.end + 1 - (value2.start ? value2.start : 0));
         } else {
-          fs20.stat(value2.path, function(err, stat3) {
+          fs21.stat(value2.path, function(err, stat3) {
             if (err) {
               callback(err);
               return;
@@ -41589,7 +41589,7 @@ var require_form_data = __commonJS({
         callback("Unknown stream");
       }
     };
-    FormData5.prototype._multiPartHeader = function(field, value2, options) {
+    FormData6.prototype._multiPartHeader = function(field, value2, options) {
       if (typeof options.header === "string") {
         return options.header;
       }
@@ -41616,26 +41616,26 @@ var require_form_data = __commonJS({
             header = [header];
           }
           if (header.length) {
-            contents += prop + ": " + header.join("; ") + FormData5.LINE_BREAK;
+            contents += prop + ": " + header.join("; ") + FormData6.LINE_BREAK;
           }
         }
       }
-      return "--" + this.getBoundary() + FormData5.LINE_BREAK + contents + FormData5.LINE_BREAK;
+      return "--" + this.getBoundary() + FormData6.LINE_BREAK + contents + FormData6.LINE_BREAK;
     };
-    FormData5.prototype._getContentDisposition = function(value2, options) {
+    FormData6.prototype._getContentDisposition = function(value2, options) {
       var filename;
       if (typeof options.filepath === "string") {
-        filename = path24.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path25.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value2 && (value2.name || value2.path)) {
-        filename = path24.basename(options.filename || value2 && (value2.name || value2.path));
+        filename = path25.basename(options.filename || value2 && (value2.name || value2.path));
       } else if (value2 && value2.readable && hasOwn(value2, "httpVersion")) {
-        filename = path24.basename(value2.client._httpMessage.path || "");
+        filename = path25.basename(value2.client._httpMessage.path || "");
       }
       if (filename) {
         return 'filename="' + filename + '"';
       }
     };
-    FormData5.prototype._getContentType = function(value2, options) {
+    FormData6.prototype._getContentType = function(value2, options) {
       var contentType = options.contentType;
       if (!contentType && value2 && value2.name) {
         contentType = mime.lookup(value2.name);
@@ -41650,13 +41650,13 @@ var require_form_data = __commonJS({
         contentType = mime.lookup(options.filepath || options.filename);
       }
       if (!contentType && value2 && typeof value2 === "object") {
-        contentType = FormData5.DEFAULT_CONTENT_TYPE;
+        contentType = FormData6.DEFAULT_CONTENT_TYPE;
       }
       return contentType;
     };
-    FormData5.prototype._multiPartFooter = function() {
+    FormData6.prototype._multiPartFooter = function() {
       return function(next) {
-        var footer = FormData5.LINE_BREAK;
+        var footer = FormData6.LINE_BREAK;
         var lastPart = this._streams.length === 0;
         if (lastPart) {
           footer += this._lastBoundary();
@@ -41664,10 +41664,10 @@ var require_form_data = __commonJS({
         next(footer);
       }.bind(this);
     };
-    FormData5.prototype._lastBoundary = function() {
-      return "--" + this.getBoundary() + "--" + FormData5.LINE_BREAK;
+    FormData6.prototype._lastBoundary = function() {
+      return "--" + this.getBoundary() + "--" + FormData6.LINE_BREAK;
     };
-    FormData5.prototype.getHeaders = function(userHeaders) {
+    FormData6.prototype.getHeaders = function(userHeaders) {
       var header;
       var formHeaders = {
         "content-type": "multipart/form-data; boundary=" + this.getBoundary()
@@ -41679,19 +41679,19 @@ var require_form_data = __commonJS({
       }
       return formHeaders;
     };
-    FormData5.prototype.setBoundary = function(boundary) {
+    FormData6.prototype.setBoundary = function(boundary) {
       if (typeof boundary !== "string") {
         throw new TypeError("FormData boundary must be a string");
       }
       this._boundary = boundary;
     };
-    FormData5.prototype.getBoundary = function() {
+    FormData6.prototype.getBoundary = function() {
       if (!this._boundary) {
         this._generateBoundary();
       }
       return this._boundary;
     };
-    FormData5.prototype.getBuffer = function() {
+    FormData6.prototype.getBuffer = function() {
       var dataBuffer = new Buffer.alloc(0);
       var boundary = this.getBoundary();
       for (var i = 0, len = this._streams.length; i < len; i++) {
@@ -41702,16 +41702,16 @@ var require_form_data = __commonJS({
             dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
           }
           if (typeof this._streams[i] !== "string" || this._streams[i].substring(2, boundary.length + 2) !== boundary) {
-            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData5.LINE_BREAK)]);
+            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData6.LINE_BREAK)]);
           }
         }
       }
       return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
     };
-    FormData5.prototype._generateBoundary = function() {
-      this._boundary = "--------------------------" + crypto4.randomBytes(12).toString("hex");
+    FormData6.prototype._generateBoundary = function() {
+      this._boundary = "--------------------------" + crypto5.randomBytes(12).toString("hex");
     };
-    FormData5.prototype.getLengthSync = function() {
+    FormData6.prototype.getLengthSync = function() {
       var knownLength = this._overheadLength + this._valueLength;
       if (this._streams.length) {
         knownLength += this._lastBoundary().length;
@@ -41721,14 +41721,14 @@ var require_form_data = __commonJS({
       }
       return knownLength;
     };
-    FormData5.prototype.hasKnownLength = function() {
+    FormData6.prototype.hasKnownLength = function() {
       var hasKnownLength = true;
       if (this._valuesToMeasure.length) {
         hasKnownLength = false;
       }
       return hasKnownLength;
     };
-    FormData5.prototype.getLength = function(cb) {
+    FormData6.prototype.getLength = function(cb) {
       var knownLength = this._overheadLength + this._valueLength;
       if (this._streams.length) {
         knownLength += this._lastBoundary().length;
@@ -41748,7 +41748,7 @@ var require_form_data = __commonJS({
         cb(null, knownLength);
       });
     };
-    FormData5.prototype.submit = function(params, cb) {
+    FormData6.prototype.submit = function(params, cb) {
       var request;
       var options;
       var defaults3 = { method: "post" };
@@ -41795,18 +41795,18 @@ var require_form_data = __commonJS({
       }.bind(this));
       return request;
     };
-    FormData5.prototype._error = function(err) {
+    FormData6.prototype._error = function(err) {
       if (!this.error) {
         this.error = err;
         this.pause();
         this.emit("error", err);
       }
     };
-    FormData5.prototype.toString = function() {
+    FormData6.prototype.toString = function() {
       return "[object FormData]";
     };
-    setToStringTag(FormData5, "FormData");
-    module2.exports = FormData5;
+    setToStringTag(FormData6, "FormData");
+    module2.exports = FormData6;
   }
 });
@@ -43115,10 +43115,10 @@ var require_package = __commonJS({
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs20 = require("fs");
-    var path24 = require("path");
-    var os7 = require("os");
-    var crypto4 = require("crypto");
+    var fs21 = require("fs");
+    var path25 = require("path");
+    var os9 = require("os");
+    var crypto5 = require("crypto");
     var packageJson = require_package();
     var version = packageJson.version;
     var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
@@ -43224,7 +43224,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs20.existsSync(filepath)) {
+            if (fs21.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -43232,15 +43232,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path25.resolve(process.cwd(), ".env.vault");
       }
-      if (fs20.existsSync(possibleVaultPath)) {
+      if (fs21.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path24.join(os7.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path25.join(os9.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -43257,7 +43257,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path24.resolve(process.cwd(), ".env");
+      const dotenvPath = path25.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -43281,13 +43281,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path25 of optionPaths) {
+      for (const path26 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs20.readFileSync(path25, { encoding }));
+          const parsed = DotenvModule.parse(fs21.readFileSync(path26, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path25} ${e.message}`);
+            _debug(`Failed to load ${path26} ${e.message}`);
           }
           lastError = e;
         }
@@ -43302,7 +43302,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path24.relative(process.cwd(), filePath);
+            const relative = path25.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -43337,7 +43337,7 @@ var require_main = __commonJS({
       const authTag = ciphertext.subarray(-16);
       ciphertext = ciphertext.subarray(12, -16);
       try {
-        const aesgcm = crypto4.createDecipheriv("aes-256-gcm", key, nonce);
+        const aesgcm = crypto5.createDecipheriv("aes-256-gcm", key, nonce);
         aesgcm.setAuthTag(authTag);
         return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
       } catch (error) {
@@ -44287,11 +44287,11 @@ var require_file_writer = __commonJS({
     var FileWriter = (
       /** @class */
       (function() {
-        function FileWriter2(path24, append2, encoding) {
+        function FileWriter2(path25, append2, encoding) {
           if (encoding === void 0) {
             encoding = DEFAULT_ENCODING;
           }
-          this.path = path24;
+          this.path = path25;
           this.append = append2;
           this.encoding = encoding;
         }
@@ -44431,13 +44431,13 @@ var require_csv_writer = __commonJS({
     var CsvWriter = (
       /** @class */
       (function() {
-        function CsvWriter2(csvStringifier, path24, encoding, append2) {
+        function CsvWriter2(csvStringifier, path25, encoding, append2) {
           if (append2 === void 0) {
             append2 = DEFAULT_INITIAL_APPEND_FLAG;
           }
           this.csvStringifier = csvStringifier;
           this.append = append2;
-          this.fileWriter = new file_writer_1.FileWriter(path24, this.append, encoding);
+          this.fileWriter = new file_writer_1.FileWriter(path25, this.append, encoding);
         }
         CsvWriter2.prototype.writeRecords = function(records) {
           return __awaiter(this, void 0, void 0, function() {
@@ -50708,14 +50708,14 @@ var require_yn = __commonJS({
 var require_create_require = __commonJS({
   "node_modules/create-require/create-require.js"(exports2, module2) {
     var nativeModule = require("module");
-    var path24 = require("path");
-    var fs20 = require("fs");
+    var path25 = require("path");
+    var fs21 = require("fs");
     function createRequire(filename) {
       if (!filename) {
         filename = process.cwd();
       }
       if (isDir(filename)) {
-        filename = path24.join(filename, "index.js");
+        filename = path25.join(filename, "index.js");
       }
       if (nativeModule.createRequire) {
         return nativeModule.createRequire(filename);
@@ -50728,13 +50728,13 @@ var require_create_require = __commonJS({
     function _createRequire(filename) {
       const mod = new nativeModule.Module(filename, null);
       mod.filename = filename;
-      mod.paths = nativeModule.Module._nodeModulePaths(path24.dirname(filename));
+      mod.paths = nativeModule.Module._nodeModulePaths(path25.dirname(filename));
       mod._compile("module.exports = require;", filename);
       return mod.exports;
     }
-    function isDir(path25) {
+    function isDir(path26) {
       try {
-        const stat3 = fs20.lstatSync(path25);
+        const stat3 = fs21.lstatSync(path26);
         return stat3.isDirectory();
       } catch (e) {
         return false;
@@ -50749,18 +50749,18 @@ var require_v8_compile_cache = __commonJS({
   "node_modules/v8-compile-cache-lib/v8-compile-cache.js"(exports2, module2) {
     "use strict";
     var Module = require("module");
-    var crypto4 = require("crypto");
-    var fs20 = require("fs");
-    var path24 = require("path");
+    var crypto5 = require("crypto");
+    var fs21 = require("fs");
+    var path25 = require("path");
     var vm = require("vm");
-    var os7 = require("os");
+    var os9 = require("os");
     var hasOwnProperty2 = Object.prototype.hasOwnProperty;
     var FileSystemBlobStore = class {
       constructor(directory, prefix) {
         const name = prefix ? slashEscape(prefix + ".") : "";
-        this._blobFilename = path24.join(directory, name + "BLOB");
-        this._mapFilename = path24.join(directory, name + "MAP");
-        this._lockFilename = path24.join(directory, name + "LOCK");
+        this._blobFilename = path25.join(directory, name + "BLOB");
+        this._mapFilename = path25.join(directory, name + "MAP");
+        this._lockFilename = path25.join(directory, name + "LOCK");
         this._directory = directory;
         this._load();
       }
@@ -50812,22 +50812,22 @@ var require_v8_compile_cache = __commonJS({
         const mapToStore = JSON.stringify(dump[1]);
         try {
           mkdirpSync(this._directory);
-          fs20.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
+          fs21.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
         } catch (error) {
           return false;
         }
         try {
-          fs20.writeFileSync(this._blobFilename, blobToStore);
-          fs20.writeFileSync(this._mapFilename, mapToStore);
+          fs21.writeFileSync(this._blobFilename, blobToStore);
+          fs21.writeFileSync(this._mapFilename, mapToStore);
         } finally {
-          fs20.unlinkSync(this._lockFilename);
+          fs21.unlinkSync(this._lockFilename);
         }
         return true;
       }
       _load() {
         try {
-          this._storedBlob = fs20.readFileSync(this._blobFilename);
-          this._storedMap = JSON.parse(fs20.readFileSync(this._mapFilename));
+          this._storedBlob = fs21.readFileSync(this._blobFilename);
+          this._storedMap = JSON.parse(fs21.readFileSync(this._mapFilename));
         } catch (e) {
           this._storedBlob = Buffer.alloc(0);
           this._storedMap = {};
@@ -50891,7 +50891,7 @@ var require_v8_compile_cache = __commonJS({
           require2.main = process.mainModule;
           require2.extensions = Module._extensions;
           require2.cache = Module._cache;
-          const dirname = path24.dirname(filename);
+          const dirname = path25.dirname(filename);
           const compiledWrapper = self2._moduleCompile(filename, content);
           const args = [mod.exports, require2, mod, filename, dirname, process, global, Buffer];
           return compiledWrapper.apply(mod.exports, args);
@@ -50924,7 +50924,7 @@ var require_v8_compile_cache = __commonJS({
           }
         }
         var wrapper = Module.wrap(content);
-        var invalidationKey = crypto4.createHash("sha1").update(content, "utf8").digest("hex");
+        var invalidationKey = crypto5.createHash("sha1").update(content, "utf8").digest("hex");
         var buffer = this._cacheStore.get(filename, invalidationKey);
         var script = new vm.Script(wrapper, {
           filename,
@@ -50948,18 +50948,18 @@ var require_v8_compile_cache = __commonJS({
       }
     };
     function mkdirpSync(p_) {
-      _mkdirpSync(path24.resolve(p_), 511);
+      _mkdirpSync(path25.resolve(p_), 511);
     }
     function _mkdirpSync(p, mode) {
       try {
-        fs20.mkdirSync(p, mode);
+        fs21.mkdirSync(p, mode);
       } catch (err0) {
         if (err0.code === "ENOENT") {
-          _mkdirpSync(path24.dirname(p));
+          _mkdirpSync(path25.dirname(p));
           _mkdirpSync(p);
         } else {
           try {
-            const stat3 = fs20.statSync(p);
+            const stat3 = fs21.statSync(p);
             if (!stat3.isDirectory()) {
               throw err0;
             }
@@ -50991,7 +50991,7 @@ var require_v8_compile_cache = __commonJS({
       }
       const dirname = typeof process.getuid === "function" ? "v8-compile-cache-" + process.getuid() : "v8-compile-cache";
       const version = typeof process.versions.v8 === "string" ? process.versions.v8 : typeof process.versions.chakracore === "string" ? "chakracore-" + process.versions.chakracore : "node-" + process.version;
-      const cacheDir = path24.join(os7.tmpdir(), dirname, version);
+      const cacheDir = path25.join(os9.tmpdir(), dirname, version);
       return cacheDir;
     }
     function getMainName() {
@@ -51199,11 +51199,11 @@ var require_ts_internals = __commonJS({
       }
       return { getExtendsConfigPath };
     }
-    function isRootedDiskPath(path24) {
-      return (0, path_1.isAbsolute)(path24);
+    function isRootedDiskPath(path25) {
+      return (0, path_1.isAbsolute)(path25);
     }
-    function combinePaths(path24, ...paths) {
-      return (0, util_1.normalizeSlashes)((0, path_1.resolve)(path24, ...paths.filter((path25) => path25)));
+    function combinePaths(path25, ...paths) {
+      return (0, util_1.normalizeSlashes)((0, path_1.resolve)(path25, ...paths.filter((path26) => path26)));
     }
     function getNormalizedAbsolutePath(fileName, currentDirectory) {
       return (0, util_1.normalizeSlashes)(currentDirectory != null ? (0, path_1.resolve)(currentDirectory, fileName) : (0, path_1.resolve)(fileName));
@@ -51253,12 +51253,12 @@ var require_ts_internals = __commonJS({
       doubleAsteriskRegexFragment: "(/.+?)?",
       replaceWildcardCharacter: (match2) => replaceWildcardCharacter(match2, excludeMatcher.singleAsteriskRegexFragment)
     };
-    function getNormalizedPathComponents(path24, currentDirectory) {
-      return reducePathComponents(getPathComponents(path24, currentDirectory));
+    function getNormalizedPathComponents(path25, currentDirectory) {
+      return reducePathComponents(getPathComponents(path25, currentDirectory));
     }
-    function getPathComponents(path24, currentDirectory = "") {
-      path24 = combinePaths(currentDirectory, path24);
-      return pathComponents(path24, getRootLength(path24));
+    function getPathComponents(path25, currentDirectory = "") {
+      path25 = combinePaths(currentDirectory, path25);
+      return pathComponents(path25, getRootLength(path25));
     }
     function reducePathComponents(components) {
       if (!some(components))
@@ -51283,64 +51283,64 @@ var require_ts_internals = __commonJS({
       }
       return reduced;
     }
-    function getRootLength(path24) {
-      const rootLength = getEncodedRootLength(path24);
+    function getRootLength(path25) {
+      const rootLength = getEncodedRootLength(path25);
       return rootLength < 0 ? ~rootLength : rootLength;
     }
-    function getEncodedRootLength(path24) {
-      if (!path24)
+    function getEncodedRootLength(path25) {
+      if (!path25)
         return 0;
-      const ch0 = path24.charCodeAt(0);
+      const ch0 = path25.charCodeAt(0);
       if (ch0 === 47 || ch0 === 92) {
-        if (path24.charCodeAt(1) !== ch0)
+        if (path25.charCodeAt(1) !== ch0)
           return 1;
-        const p1 = path24.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+        const p1 = path25.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
         if (p1 < 0)
-          return path24.length;
+          return path25.length;
         return p1 + 1;
       }
-      if (isVolumeCharacter(ch0) && path24.charCodeAt(1) === 58) {
-        const ch2 = path24.charCodeAt(2);
+      if (isVolumeCharacter(ch0) && path25.charCodeAt(1) === 58) {
+        const ch2 = path25.charCodeAt(2);
         if (ch2 === 47 || ch2 === 92)
           return 3;
-        if (path24.length === 2)
+        if (path25.length === 2)
           return 2;
       }
-      const schemeEnd = path24.indexOf(urlSchemeSeparator);
+      const schemeEnd = path25.indexOf(urlSchemeSeparator);
       if (schemeEnd !== -1) {
         const authorityStart = schemeEnd + urlSchemeSeparator.length;
-        const authorityEnd = path24.indexOf(directorySeparator, authorityStart);
+        const authorityEnd = path25.indexOf(directorySeparator, authorityStart);
         if (authorityEnd !== -1) {
-          const scheme = path24.slice(0, schemeEnd);
-          const authority = path24.slice(authorityStart, authorityEnd);
-          if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path24.charCodeAt(authorityEnd + 1))) {
-            const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path24, authorityEnd + 2);
+          const scheme = path25.slice(0, schemeEnd);
+          const authority = path25.slice(authorityStart, authorityEnd);
+          if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path25.charCodeAt(authorityEnd + 1))) {
+            const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path25, authorityEnd + 2);
             if (volumeSeparatorEnd !== -1) {
-              if (path24.charCodeAt(volumeSeparatorEnd) === 47) {
+              if (path25.charCodeAt(volumeSeparatorEnd) === 47) {
                 return ~(volumeSeparatorEnd + 1);
               }
-              if (volumeSeparatorEnd === path24.length) {
+              if (volumeSeparatorEnd === path25.length) {
                 return ~volumeSeparatorEnd;
               }
             }
           }
           return ~(authorityEnd + 1);
         }
-        return ~path24.length;
+        return ~path25.length;
       }
       return 0;
     }
-    function hasTrailingDirectorySeparator(path24) {
-      return path24.length > 0 && isAnyDirectorySeparator(path24.charCodeAt(path24.length - 1));
+    function hasTrailingDirectorySeparator(path25) {
+      return path25.length > 0 && isAnyDirectorySeparator(path25.charCodeAt(path25.length - 1));
     }
     function isAnyDirectorySeparator(charCode) {
       return charCode === 47 || charCode === 92;
     }
-    function removeTrailingDirectorySeparator(path24) {
-      if (hasTrailingDirectorySeparator(path24)) {
-        return path24.substr(0, path24.length - 1);
+    function removeTrailingDirectorySeparator(path25) {
+      if (hasTrailingDirectorySeparator(path25)) {
+        return path25.substr(0, path25.length - 1);
       }
-      return path24;
+      return path25;
     }
     var directorySeparator = "/";
     var altDirectorySeparator = "\\";
@@ -51373,9 +51373,9 @@ var require_ts_internals = __commonJS({
       }
       return false;
     }
-    function pathComponents(path24, rootLength) {
-      const root = path24.substring(0, rootLength);
-      const rest = path24.substring(rootLength).split(directorySeparator);
+    function pathComponents(path25, rootLength) {
+      const root = path25.substring(0, rootLength);
+      const rest = path25.substring(rootLength).split(directorySeparator);
       if (rest.length && !lastOrUndefined(rest))
         rest.pop();
       return [root, ...rest];
@@ -51649,7 +51649,7 @@ var require_configuration = __commonJS({
         const options = filterRecognizedTsConfigTsNodeOptions(config2["ts-node"]).recognized;
         if (options.require) {
           const tsconfigRelativeResolver = (0, util_1.createProjectLocalResolveHelper)((0, path_1.dirname)(configPath));
-          options.require = options.require.map((path24) => tsconfigRelativeResolver(path24, false));
+          options.require = options.require.map((path25) => tsconfigRelativeResolver(path25, false));
         }
         if (options.scopeDir) {
           options.scopeDir = (0, path_1.resolve)(basePath2, options.scopeDir);
@@ -51801,14 +51801,14 @@ var require_module_type_classifier = __commonJS({
         }
       };
       const auto = classifications.package;
-      function classifyModuleNonCached(path24) {
-        const matched = matchPatterns(patternTypePairs, (_2) => _2.pattern, path24);
+      function classifyModuleNonCached(path25) {
+        const matched = matchPatterns(patternTypePairs, (_2) => _2.pattern, path25);
         if (matched)
           return classifications[matched.type];
         return auto;
       }
       const classifyModule = (0, util_1.cachedLookup)(classifyModuleNonCached);
-      function classifyModuleAuto(path24) {
+      function classifyModuleAuto(path25) {
         return auto;
       }
       return {
@@ -52028,12 +52028,12 @@ var require_node_nativemodule = __commonJS({
 // node_modules/ts-node/dist-raw/node-internalBinding-fs.js
 var require_node_internalBinding_fs = __commonJS({
   "node_modules/ts-node/dist-raw/node-internalBinding-fs.js"(exports2, module2) {
-    var fs20 = require("fs");
+    var fs21 = require("fs");
     var { versionGteLt } = require_util2();
-    function internalModuleReadJSON(path24) {
+    function internalModuleReadJSON(path25) {
       let string;
       try {
-        string = fs20.readFileSync(path24, "utf8");
+        string = fs21.readFileSync(path25, "utf8");
       } catch (e) {
         if (e.code === "ENOENT") return [];
         throw e;
@@ -52041,15 +52041,15 @@ var require_node_internalBinding_fs = __commonJS({
       const containsKeys = true;
       return [string, containsKeys];
     }
-    function internalModuleStat(path24) {
-      const stat3 = fs20.statSync(path24, { throwIfNoEntry: false });
+    function internalModuleStat(path25) {
+      const stat3 = fs21.statSync(path25, { throwIfNoEntry: false });
       if (!stat3) return -1;
       if (stat3.isFile()) return 0;
       if (stat3.isDirectory()) return 1;
     }
-    function internalModuleStatInefficient(path24) {
+    function internalModuleStatInefficient(path25) {
       try {
-        const stat3 = fs20.statSync(path24);
+        const stat3 = fs21.statSync(path25);
         if (stat3.isFile()) return 0;
         if (stat3.isDirectory()) return 1;
       } catch (e) {
@@ -52357,7 +52357,7 @@ var require_node_internal_modules_cjs_helpers = __commonJS({
 var require_node_internal_errors = __commonJS({
   "node_modules/ts-node/dist-raw/node-internal-errors.js"(exports2) {
     "use strict";
-    var path24 = require("path");
+    var path25 = require("path");
     exports2.codes = {
       ERR_INPUT_TYPE_NOT_ALLOWED: createErrorCtor(joinArgs("ERR_INPUT_TYPE_NOT_ALLOWED")),
       ERR_INVALID_ARG_VALUE: createErrorCtor(joinArgs("ERR_INVALID_ARG_VALUE")),
@@ -52365,8 +52365,8 @@ var require_node_internal_errors = __commonJS({
       ERR_INVALID_PACKAGE_CONFIG: createErrorCtor(joinArgs("ERR_INVALID_PACKAGE_CONFIG")),
       ERR_INVALID_PACKAGE_TARGET: createErrorCtor(joinArgs("ERR_INVALID_PACKAGE_TARGET")),
       ERR_MANIFEST_DEPENDENCY_MISSING: createErrorCtor(joinArgs("ERR_MANIFEST_DEPENDENCY_MISSING")),
-      ERR_MODULE_NOT_FOUND: createErrorCtor((path25, base, type = "package") => {
-        return `Cannot find ${type} '${path25}' imported from ${base}`;
+      ERR_MODULE_NOT_FOUND: createErrorCtor((path26, base, type = "package") => {
+        return `Cannot find ${type} '${path26}' imported from ${base}`;
       }),
       ERR_PACKAGE_IMPORT_NOT_DEFINED: createErrorCtor(joinArgs("ERR_PACKAGE_IMPORT_NOT_DEFINED")),
       ERR_PACKAGE_PATH_NOT_EXPORTED: createErrorCtor(joinArgs("ERR_PACKAGE_PATH_NOT_EXPORTED")),
@@ -52387,9 +52387,9 @@ var require_node_internal_errors = __commonJS({
       };
     }
     exports2.createErrRequireEsm = createErrRequireEsm;
-    function createErrRequireEsm(filename, parentPath, packageJsonPath) {
+    function createErrRequireEsm(filename, parentPath2, packageJsonPath) {
       const code = "ERR_REQUIRE_ESM";
-      const err = new Error(getErrRequireEsmMessage(filename, parentPath, packageJsonPath));
+      const err = new Error(getErrRequireEsmMessage(filename, parentPath2, packageJsonPath));
       err.name = `Error [${code}]`;
       err.stack;
       Object.defineProperty(err, "name", {
@@ -52401,15 +52401,15 @@ var require_node_internal_errors = __commonJS({
       err.code = code;
       return err;
     }
-    function getErrRequireEsmMessage(filename, parentPath = null, packageJsonPath = null) {
-      const ext2 = path24.extname(filename);
+    function getErrRequireEsmMessage(filename, parentPath2 = null, packageJsonPath = null) {
+      const ext2 = path25.extname(filename);
       let msg = `Must use import to load ES Module: ${filename}`;
-      if (parentPath && packageJsonPath) {
-        const path25 = require("path");
-        const basename3 = path25.basename(filename) === path25.basename(parentPath) ? filename : path25.basename(filename);
+      if (parentPath2 && packageJsonPath) {
+        const path26 = require("path");
+        const basename3 = path26.basename(filename) === path26.basename(parentPath2) ? filename : path26.basename(filename);
         msg += `
 require() of ES modules is not supported.
-require() of ${filename} ${parentPath ? `from ${parentPath} ` : ""}is an ES module file as it is a ${ext2} file whose nearest parent package.json contains "type": "module" which defines all ${ext2} files in that package scope as ES modules.
+require() of ${filename} ${parentPath2 ? `from ${parentPath2} ` : ""}is an ES module file as it is a ${ext2} file whose nearest parent package.json contains "type": "module" which defines all ${ext2} files in that package scope as ES modules.
 Instead change the requiring code to use import(), or remove "type": "module" from ${packageJsonPath}.
 `;
         return msg;
@@ -52453,9 +52453,9 @@ var require_node_internal_modules_cjs_loader = __commonJS({
     } = require_node_primordials();
     var { NativeModule } = require_node_nativemodule();
     var { pathToFileURL, fileURLToPath: fileURLToPath3 } = require("url");
-    var fs20 = require("fs");
-    var path24 = require("path");
-    var { sep: sep2 } = path24;
+    var fs21 = require("fs");
+    var path25 = require("path");
+    var { sep: sep2 } = path25;
     var { internalModuleStat } = require_node_internalBinding_fs();
     var packageJsonReader = require_node_internal_modules_package_json_reader();
     var {
@@ -52478,7 +52478,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
     var isWindows = process.platform === "win32";
     var statCache = null;
     function stat3(filename) {
-      filename = path24.toNamespacedPath(filename);
+      filename = path25.toNamespacedPath(filename);
       if (statCache !== null) {
         const result2 = statCache.get(filename);
         if (result2 !== void 0) return result2;
@@ -52492,7 +52492,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
     var moduleParentCache = new SafeWeakMap();
     var packageJsonCache = new SafeMap();
     function readPackage(requestPath) {
-      const jsonPath = path24.resolve(requestPath, "package.json");
+      const jsonPath = path25.resolve(requestPath, "package.json");
       const existing = packageJsonCache.get(jsonPath);
       if (existing !== void 0) return existing;
       const result = packageJsonReader.read(jsonPath);
@@ -52546,22 +52546,22 @@ var require_node_internal_modules_cjs_loader = __commonJS({
         const tmp = readPackage(requestPath);
         const pkg = tmp != null ? tmp.main : void 0;
         if (!pkg) {
-          return tryExtensions(path24.resolve(requestPath, "index"), exts, isMain);
+          return tryExtensions(path25.resolve(requestPath, "index"), exts, isMain);
         }
-        const filename = path24.resolve(requestPath, pkg);
-        let actual = tryReplacementExtensions(filename, isMain) || tryFile(filename, isMain) || tryExtensions(filename, exts, isMain) || tryExtensions(path24.resolve(filename, "index"), exts, isMain);
+        const filename = path25.resolve(requestPath, pkg);
+        let actual = tryReplacementExtensions(filename, isMain) || tryFile(filename, isMain) || tryExtensions(filename, exts, isMain) || tryExtensions(path25.resolve(filename, "index"), exts, isMain);
         if (actual === false) {
-          actual = tryExtensions(path24.resolve(requestPath, "index"), exts, isMain);
+          actual = tryExtensions(path25.resolve(requestPath, "index"), exts, isMain);
           if (!actual) {
             const err = new Error(
               `Cannot find module '${filename}'. Please verify that the package.json has a valid "main" entry`
             );
             err.code = "MODULE_NOT_FOUND";
-            err.path = path24.resolve(requestPath, "package.json");
+            err.path = path25.resolve(requestPath, "package.json");
             err.requestPath = originalPath;
             throw err;
           } else {
-            const jsonPath = path24.resolve(requestPath, "package.json");
+            const jsonPath = path25.resolve(requestPath, "package.json");
             process.emitWarning(
               `Invalid 'main' field in '${jsonPath}' of '${pkg}'. Please either fix that or report it to the module author`,
               "DeprecationWarning",
@@ -52576,12 +52576,12 @@ var require_node_internal_modules_cjs_loader = __commonJS({
         const rc = stat3(requestPath);
         if (rc !== 0) return;
         if (preserveSymlinks && !isMain) {
-          return path24.resolve(requestPath);
+          return path25.resolve(requestPath);
         }
         return toRealPath(requestPath);
       }
       function toRealPath(requestPath) {
-        return fs20.realpathSync(requestPath, {
+        return fs21.realpathSync(requestPath, {
           // [internalFS.realpathCacheKey]: realpathCache
         });
       }
@@ -52635,15 +52635,15 @@ var require_node_internal_modules_cjs_loader = __commonJS({
           return parent.filename;
         } else if (parent.id === "<repl>" || parent.id === "internal/preload") {
           try {
-            return process.cwd() + path24.sep;
+            return process.cwd() + path25.sep;
           } catch {
             return false;
           }
         }
       }
-      function trySelf(parentPath, request) {
-        if (!parentPath) return false;
-        const { data: pkg, path: pkgPath } = readPackageScope(parentPath) || {};
+      function trySelf(parentPath2, request) {
+        if (!parentPath2) return false;
+        const { data: pkg, path: pkgPath } = readPackageScope(parentPath2) || {};
         if (!pkg || pkg.exports === void 0) return false;
         if (typeof pkg.name !== "string") return false;
         let expansion;
@@ -52659,9 +52659,9 @@ var require_node_internal_modules_cjs_loader = __commonJS({
             pathToFileURL(pkgPath + "/package.json"),
             expansion,
             pkg,
-            pathToFileURL(parentPath),
+            pathToFileURL(parentPath2),
             cjsConditions
-          ).resolved, parentPath, pkgPath);
+          ).resolved, parentPath2, pkgPath);
         } catch (e) {
           if (e.code === "ERR_MODULE_NOT_FOUND")
             throw createEsmNotFoundErr(request, pkgPath + "/package.json");
@@ -52673,7 +52673,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
         const { 1: name, 2: expansion = "" } = StringPrototypeMatch(request, EXPORTS_PATTERN) || [];
         if (!name)
           return;
-        const pkgPath = path24.resolve(nmPath, name);
+        const pkgPath = path25.resolve(nmPath, name);
         const pkg = readPackage(pkgPath);
         if (pkg != null && pkg.exports != null) {
           try {
@@ -52697,7 +52697,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
       const Module_pathCache_set = hasModulePathCache ? (cacheKey, value2) => Module._pathCache[cacheKey] = value2 : (cacheKey) => Module_pathCache[cacheKey] = value;
       const trailingSlashRegex = /(?:^|\/)\.?\.$/;
       const Module_findPath = function _findPath(request, paths, isMain) {
-        const absoluteRequest = path24.isAbsolute(request);
+        const absoluteRequest = path25.isAbsolute(request);
         if (absoluteRequest) {
           paths = [""];
         } else if (!paths || paths.length === 0) {
@@ -52720,19 +52720,19 @@ var require_node_internal_modules_cjs_loader = __commonJS({
             if (exportsResolved)
               return exportsResolved;
           }
-          const _basePath = path24.resolve(curPath, request);
+          const _basePath = path25.resolve(curPath, request);
           let filename;
           const [rc, basePath] = statReplacementExtensions(_basePath);
           if (!trailingSlash) {
             if (rc === 0) {
               if (!isMain) {
                 if (preserveSymlinks) {
-                  filename = path24.resolve(basePath);
+                  filename = path25.resolve(basePath);
                 } else {
                   filename = toRealPath(basePath);
                 }
               } else if (preserveSymlinksMain) {
-                filename = path24.resolve(basePath);
+                filename = path25.resolve(basePath);
               } else {
                 filename = toRealPath(basePath);
               }
@@ -52769,8 +52769,8 @@ var require_node_internal_modules_cjs_loader = __commonJS({
               const fakeParent = new Module("", null);
               paths = [];
               for (let i = 0; i < options.paths.length; i++) {
-                const path25 = options.paths[i];
-                fakeParent.paths = Module._nodeModulePaths(path25);
+                const path26 = options.paths[i];
+                fakeParent.paths = Module._nodeModulePaths(path26);
                 const lookupPaths = Module._resolveLookupPaths(request, fakeParent);
                 for (let j = 0; j < lookupPaths.length; j++) {
                   if (!ArrayPrototypeIncludes(paths, lookupPaths[j]))
@@ -52808,8 +52808,8 @@ var require_node_internal_modules_cjs_loader = __commonJS({
             }
           }
         }
-        const parentPath = trySelfParentPath(parent);
-        const selfResolved = trySelf(parentPath, request);
+        const parentPath2 = trySelfParentPath(parent);
+        const selfResolved = trySelf(parentPath2, request);
         if (selfResolved) {
           const cacheKey = request + "\0" + (paths.length === 1 ? paths[0] : ArrayPrototypeJoin(paths, "\0"));
           Module._pathCache[cacheKey] = selfResolved;
@@ -52830,12 +52830,12 @@ var require_node_internal_modules_cjs_loader = __commonJS({
         err.requireStack = requireStack;
         throw err;
       };
-      function finalizeEsmResolution(resolved, parentPath, pkgPath) {
+      function finalizeEsmResolution(resolved, parentPath2, pkgPath) {
         if (RegExpPrototypeTest(encodedSepRegEx, resolved))
           throw new ERR_INVALID_MODULE_SPECIFIER(
             resolved,
             'must not include encoded "/" or "\\" characters',
-            parentPath
+            parentPath2
           );
         const filename = fileURLToPath3(resolved);
         const actual = tryReplacementExtensions(filename) || tryFile(filename);
@@ -52843,15 +52843,15 @@ var require_node_internal_modules_cjs_loader = __commonJS({
           return actual;
         const err = createEsmNotFoundErr(
           filename,
-          path24.resolve(pkgPath, "package.json")
+          path25.resolve(pkgPath, "package.json")
         );
         throw err;
       }
-      function createEsmNotFoundErr(request, path25) {
+      function createEsmNotFoundErr(request, path26) {
         const err = new Error(`Cannot find module '${request}'`);
         err.code = "MODULE_NOT_FOUND";
-        if (path25)
-          err.path = path25;
+        if (path26)
+          err.path = path26;
         return err;
       }
       return {
@@ -52867,9 +52867,9 @@ var require_node_internal_modules_cjs_loader = __commonJS({
       const ext2 = lastDotIndex >= 0 ? filename.slice(lastDotIndex) : "";
       if ((ext2 === ".cts" || ext2 === ".cjs") && tsNodeClassification.moduleType === "auto") return;
       if (ext2 === ".mts" || ext2 === ".mjs" || tsNodeClassification.moduleType === "esm" || pkg && pkg.data && pkg.data.type === "module") {
-        const parentPath = module3.parent && module3.parent.filename;
-        const packageJsonPath = pkg ? path24.resolve(pkg.path, "package.json") : null;
-        throw createErrRequireEsm(filename, parentPath, packageJsonPath);
+        const parentPath2 = module3.parent && module3.parent.filename;
+        const packageJsonPath = pkg ? path25.resolve(pkg.path, "package.json") : null;
+        throw createErrRequireEsm(filename, parentPath2, packageJsonPath);
       }
     }
     module2.exports = {
@@ -59661,10 +59661,10 @@ var require_base = __commonJS({
       }
       return components;
     }
-    function clonePath(path24) {
+    function clonePath(path25) {
       return {
-        newPos: path24.newPos,
-        components: path24.components.slice(0)
+        newPos: path25.newPos,
+        components: path25.components.slice(0)
       };
     }
   }
@@ -61361,8 +61361,8 @@ ${module_1.builtinModules.filter((name) => !name.startsWith("_") && !name.includ
     }
     exports2.createRepl = createRepl;
     var EvalState = class {
-      constructor(path24) {
-        this.path = path24;
+      constructor(path25) {
+        this.path = path25;
         this.input = "";
         this.output = "";
         this.version = 0;
@@ -61371,23 +61371,23 @@ ${module_1.builtinModules.filter((name) => !name.startsWith("_") && !name.includ
     };
     exports2.EvalState = EvalState;
     function createEvalAwarePartialHost(state, composeWith) {
-      function readFile(path24) {
-        if (path24 === state.path)
+      function readFile(path25) {
+        if (path25 === state.path)
           return state.input;
         if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.readFile)
-          return composeWith.readFile(path24);
+          return composeWith.readFile(path25);
         try {
-          return (0, fs_1.readFileSync)(path24, "utf8");
+          return (0, fs_1.readFileSync)(path25, "utf8");
         } catch (err) {
         }
       }
-      function fileExists(path24) {
-        if (path24 === state.path)
+      function fileExists(path25) {
+        if (path25 === state.path)
           return true;
         if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.fileExists)
-          return composeWith.fileExists(path24);
+          return composeWith.fileExists(path25);
         try {
-          const stats = (0, fs_1.statSync)(path24);
+          const stats = (0, fs_1.statSync)(path25);
           return stats.isFile() || stats.isFIFO();
         } catch (err) {
           return false;
@@ -62242,16 +62242,16 @@ var require_resolve_uri_umd = __commonJS({
       }
       function parseFileUrl(input) {
         const match2 = fileRegex.exec(input);
-        const path24 = match2[2];
-        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path24) ? path24 : "/" + path24, match2[3] || "", match2[4] || "");
+        const path25 = match2[2];
+        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path25) ? path25 : "/" + path25, match2[3] || "", match2[4] || "");
       }
-      function makeUrl(scheme, user, host, port, path24, query, hash) {
+      function makeUrl(scheme, user, host, port, path25, query, hash) {
         return {
           scheme,
           user,
           host,
           port,
-          path: path24,
+          path: path25,
           query,
           hash,
           type: 7
@@ -62281,11 +62281,11 @@ var require_resolve_uri_umd = __commonJS({
         url2.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
         return url2;
       }
-      function stripPathFilename(path24) {
-        if (path24.endsWith("/.."))
-          return path24;
-        const index = path24.lastIndexOf("/");
-        return path24.slice(0, index + 1);
+      function stripPathFilename(path25) {
+        if (path25.endsWith("/.."))
+          return path25;
+        const index = path25.lastIndexOf("/");
+        return path25.slice(0, index + 1);
       }
       function mergePaths(url2, base) {
         normalizePath(base, base.type);
@@ -62323,14 +62323,14 @@ var require_resolve_uri_umd = __commonJS({
           pieces[pointer++] = piece;
           positive++;
         }
-        let path24 = "";
+        let path25 = "";
         for (let i = 1; i < pointer; i++) {
-          path24 += "/" + pieces[i];
+          path25 += "/" + pieces[i];
         }
-        if (!path24 || addTrailingSlash && !path24.endsWith("/..")) {
-          path24 += "/";
+        if (!path25 || addTrailingSlash && !path25.endsWith("/..")) {
+          path25 += "/";
         }
-        url2.path = path24;
+        url2.path = path25;
       }
       function resolve(input, base) {
         if (!input && !base)
@@ -62371,13 +62371,13 @@ var require_resolve_uri_umd = __commonJS({
           case 3:
             return queryHash;
           case 4: {
-            const path24 = url2.path.slice(1);
-            if (!path24)
+            const path25 = url2.path.slice(1);
+            if (!path25)
               return queryHash || ".";
-            if (isRelative(base || input) && !isRelative(path24)) {
-              return "./" + path24 + queryHash;
+            if (isRelative(base || input) && !isRelative(path25)) {
+              return "./" + path25 + queryHash;
             }
-            return path24 + queryHash;
+            return path25 + queryHash;
           }
           case 5:
             return url2.path + queryHash;
@@ -62406,11 +62406,11 @@ var require_trace_mapping_umd = __commonJS({
           base += "/";
         return resolveUri__default["default"](input, base);
       }
-      function stripFilename(path24) {
-        if (!path24)
+      function stripFilename(path25) {
+        if (!path25)
           return "";
-        const index = path24.lastIndexOf("/");
-        return path24.slice(0, index + 1);
+        const index = path25.lastIndexOf("/");
+        return path25.slice(0, index + 1);
       }
       const COLUMN = 0;
       const SOURCES_INDEX = 1;
@@ -62815,14 +62815,14 @@ var require_trace_mapping_umd = __commonJS({
 var require_source_map_support = __commonJS({
   "node_modules/@cspotcode/source-map-support/source-map-support.js"(exports2, module2) {
     var { TraceMap, originalPositionFor, AnyMap } = require_trace_mapping_umd();
-    var path24 = require("path");
+    var path25 = require("path");
     var { fileURLToPath: fileURLToPath3, pathToFileURL } = require("url");
     var util3 = require("util");
-    var fs20;
+    var fs21;
     try {
-      fs20 = require("fs");
-      if (!fs20.existsSync || !fs20.readFileSync) {
-        fs20 = null;
+      fs21 = require("fs");
+      if (!fs21.existsSync || !fs21.readFileSync) {
+        fs21 = null;
       }
     } catch (err) {
     }
@@ -62960,27 +62960,27 @@ var require_source_map_support = __commonJS({
       };
     }
     var retrieveFile = handlerExec(sharedData.retrieveFileHandlers, sharedData.internalRetrieveFileHandlers);
-    sharedData.internalRetrieveFileHandlers.push(function(path25) {
-      path25 = path25.trim();
-      if (/^file:/.test(path25)) {
-        path25 = path25.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    sharedData.internalRetrieveFileHandlers.push(function(path26) {
+      path26 = path26.trim();
+      if (/^file:/.test(path26)) {
+        path26 = path26.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : (
             // file:///C:/dir/file -> C:/dir/file
             "/"
           );
         });
       }
-      const key = getCacheKey(path25);
+      const key = getCacheKey(path26);
       if (hasFileContentsCacheFromKey(key)) {
         return getFileContentsCacheFromKey(key);
       }
       var contents = "";
       try {
-        if (!fs20) {
+        if (!fs21) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
-            path25,
+            path26,
             /** async */
             false
           );
@@ -62988,12 +62988,12 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs20.existsSync(path25)) {
-          contents = fs20.readFileSync(path25, "utf8");
+        } else if (fs21.existsSync(path26)) {
+          contents = fs21.readFileSync(path26, "utf8");
         }
       } catch (er) {
       }
-      return setFileContentsCache(path25, contents);
+      return setFileContentsCache(path26, contents);
     });
     function supportRelativeURL(file, url2) {
       if (!file) return url2;
@@ -63002,12 +63002,12 @@ var require_source_map_support = __commonJS({
           if (isAbsoluteUrl(url2) || isSchemeRelativeUrl(url2)) {
             return new URL(url2, file).toString();
           }
-          if (path24.isAbsolute(url2)) {
+          if (path25.isAbsolute(url2)) {
             return new URL(pathToFileURL(url2), file).toString();
           }
           return new URL(url2.replace(/\\/g, "/"), file).toString();
         }
-        if (path24.isAbsolute(file)) {
+        if (path25.isAbsolute(file)) {
           if (isFileUrl(url2)) {
             return fileURLToPath3(url2);
           }
@@ -63017,15 +63017,15 @@ var require_source_map_support = __commonJS({
           if (isAbsoluteUrl(url2)) {
             return url2;
           }
-          if (path24.isAbsolute(url2)) {
-            return path24.normalize(url2);
+          if (path25.isAbsolute(url2)) {
+            return path25.normalize(url2);
           }
-          return path24.join(file, "..", decodeURI(url2));
+          return path25.join(file, "..", decodeURI(url2));
         }
         if (isAbsoluteUrl(url2) || isSchemeRelativeUrl(url2)) {
           return url2;
         }
-        return path24.join(file, "..", url2);
+        return path25.join(file, "..", url2);
       } catch (e) {
         return url2;
       }
@@ -63034,8 +63034,8 @@ var require_source_map_support = __commonJS({
       try {
         if (isAbsoluteUrl(matchStyleOf) || isSchemeRelativeUrl(matchStyleOf)) {
           if (isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) return pathOrUrl;
-          if (path24.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
-        } else if (path24.isAbsolute(matchStyleOf)) {
+          if (path25.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
+        } else if (path25.isAbsolute(matchStyleOf)) {
           if (isAbsoluteUrl(pathOrUrl) || isSchemeRelativeUrl(pathOrUrl)) {
             return fileURLToPath3(new URL(pathOrUrl, "file://"));
           }
@@ -63284,7 +63284,7 @@ var require_source_map_support = __commonJS({
     }
     var kIsNodeError = void 0;
     try {
-      path24.resolve(123);
+      path25.resolve(123);
     } catch (e) {
       const symbols = Object.getOwnPropertySymbols(e);
       const symbol = symbols.find(function(s) {
@@ -63330,9 +63330,9 @@ var require_source_map_support = __commonJS({
         var column = +match2[3];
         var contents = getFileContentsCache(source);
         const sourceAsPath = tryFileURLToPath(source);
-        if (!contents && fs20 && fs20.existsSync(sourceAsPath)) {
+        if (!contents && fs21 && fs21.existsSync(sourceAsPath)) {
           try {
-            contents = fs20.readFileSync(sourceAsPath, "utf8");
+            contents = fs21.readFileSync(sourceAsPath, "utf8");
           } catch (er) {
             contents = "";
           }
@@ -63629,27 +63629,27 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
       const statSupportsThrowIfNoEntry = versionGteLt(process.versions.node, "15.3.0") || versionGteLt(process.versions.node, "14.17.0", "15.0.0");
       const tryStatSync = statSupportsThrowIfNoEntry ? tryStatSyncWithoutErrors : tryStatSyncWithErrors;
       const statsIfNotFound = new Stats();
-      function tryStatSyncWithoutErrors(path24) {
-        const stats = statSync(path24, { throwIfNoEntry: false });
+      function tryStatSyncWithoutErrors(path25) {
+        const stats = statSync(path25, { throwIfNoEntry: false });
         if (stats != null) return stats;
         return statsIfNotFound;
       }
-      function tryStatSyncWithErrors(path24) {
+      function tryStatSyncWithErrors(path25) {
         try {
-          return statSync(path24);
+          return statSync(path25);
         } catch {
           return statsIfNotFound;
         }
       }
-      function getPackageConfig(path24, specifier, base) {
-        const existing = packageJSONCache.get(path24);
+      function getPackageConfig(path25, specifier, base) {
+        const existing = packageJSONCache.get(path25);
         if (existing !== void 0) {
           return existing;
         }
-        const source = packageJsonReader.read(path24).string;
+        const source = packageJsonReader.read(path25).string;
         if (source === void 0) {
           const packageConfig2 = {
-            pjsonPath: path24,
+            pjsonPath: path25,
             exists: false,
             main: void 0,
             name: void 0,
@@ -63657,7 +63657,7 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
             exports: void 0,
             imports: void 0
           };
-          packageJSONCache.set(path24, packageConfig2);
+          packageJSONCache.set(path25, packageConfig2);
           return packageConfig2;
         }
         let packageJSON;
@@ -63665,7 +63665,7 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
           packageJSON = JSONParse(source);
         } catch (error) {
           throw new ERR_INVALID_PACKAGE_CONFIG(
-            path24,
+            path25,
             (base ? `"${specifier}" from ` : "") + fileURLToPath3(base || specifier),
             error.message
           );
@@ -63677,7 +63677,7 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
         if (typeof name !== "string") name = void 0;
         if (type !== "module" && type !== "commonjs") type = "none";
         const packageConfig = {
-          pjsonPath: path24,
+          pjsonPath: path25,
           exists: true,
           main,
           name,
@@ -63685,7 +63685,7 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
           exports: exports3,
           imports
         };
-        packageJSONCache.set(path24, packageConfig);
+        packageJSONCache.set(path25, packageConfig);
         return packageConfig;
       }
       function getPackageScopeConfig(resolved) {
@@ -63801,10 +63801,10 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
             fileURLToPath3(base)
           );
         if (experimentalSpecifierResolution === "node") {
-          const path25 = fileURLToPath3(resolved);
+          const path26 = fileURLToPath3(resolved);
           let file2 = resolveExtensionsWithTryExactName(resolved);
           if (file2 !== void 0) return file2;
-          if (!StringPrototypeEndsWith(path25, "/")) {
+          if (!StringPrototypeEndsWith(path26, "/")) {
             file2 = resolveIndex(new URL3(`${resolved}/`));
             if (file2 !== void 0) return file2;
           } else {
@@ -63817,15 +63817,15 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
           );
         }
         const file = resolveReplacementExtensions(resolved) || resolved;
-        const path24 = fileURLToPath3(file);
-        const stats = tryStatSync(StringPrototypeEndsWith(path24, "/") ? StringPrototypeSlice(path24, -1) : path24);
+        const path25 = fileURLToPath3(file);
+        const stats = tryStatSync(StringPrototypeEndsWith(path25, "/") ? StringPrototypeSlice(path25, -1) : path25);
         if (stats.isDirectory()) {
-          const err = new ERR_UNSUPPORTED_DIR_IMPORT(path24, fileURLToPath3(base));
+          const err = new ERR_UNSUPPORTED_DIR_IMPORT(path25, fileURLToPath3(base));
           err.url = String(resolved);
           throw err;
         } else if (!stats.isFile()) {
           throw new ERR_MODULE_NOT_FOUND(
-            path24 || resolved.pathname,
+            path25 || resolved.pathname,
             fileURLToPath3(base),
             "module"
           );
@@ -64872,15 +64872,15 @@ ${diagnosticText}`);
           environment: "node",
           retrieveFile(pathOrUrl) {
             var _a3;
-            let path24 = pathOrUrl;
-            if (experimentalEsmLoader && path24.startsWith("file://")) {
+            let path25 = pathOrUrl;
+            if (experimentalEsmLoader && path25.startsWith("file://")) {
               try {
-                path24 = (0, url_1.fileURLToPath)(path24);
+                path25 = (0, url_1.fileURLToPath)(path25);
               } catch (e) {
               }
             }
-            path24 = (0, util_1.normalizeSlashes)(path24);
-            return ((_a3 = outputCache.get(path24)) === null || _a3 === void 0 ? void 0 : _a3.content) || "";
+            path25 = (0, util_1.normalizeSlashes)(path25);
+            return ((_a3 = outputCache.get(path25)) === null || _a3 === void 0 ? void 0 : _a3.content) || "";
           },
           redirectConflictingLibrary: true,
           onConflictingLibraryRedirect(request, parent, isMain, options2, redirectedRequest) {
@@ -64906,10 +64906,10 @@ ${diagnosticText}`);
       if (configDiagnosticList.length)
         reportTSError(configDiagnosticList);
       const jsxEmitPreserve = config.options.jsx === ts.JsxEmit.Preserve;
-      function getEmitExtension(path24) {
-        const lastDotIndex = path24.lastIndexOf(".");
+      function getEmitExtension(path25) {
+        const lastDotIndex = path25.lastIndexOf(".");
         if (lastDotIndex >= 0) {
-          const ext2 = path24.slice(lastDotIndex);
+          const ext2 = path25.slice(lastDotIndex);
           switch (ext2) {
             case ".js":
             case ".ts":
@@ -65124,14 +65124,14 @@ This is usually the result of a faulty configuration or import. Make sure there
             const diagnosticList = filterDiagnostics(diagnostics, diagnosticFilters);
             if (diagnosticList.length)
               reportTSError(diagnosticList);
-            const result = builderProgram.emit(sourceFile, (path24, file, writeByteOrderMark) => {
-              if (path24.endsWith(".map")) {
+            const result = builderProgram.emit(sourceFile, (path25, file, writeByteOrderMark) => {
+              if (path25.endsWith(".map")) {
                 outMap = file;
               } else {
                 outText = file;
               }
               if (options.emit)
-                sys.writeFile(path24, file, writeByteOrderMark);
+                sys.writeFile(path25, file, writeByteOrderMark);
             }, void 0, void 0, customTransformers);
             if (result.emitSkipped) {
               return [void 0, void 0, true];
@@ -65296,8 +65296,8 @@ This is usually the result of a faulty configuration or import. Make sure there
     function createIgnore(ignoreBaseDir, ignore) {
       return (fileName) => {
         const relname = (0, path_1.relative)(ignoreBaseDir, fileName);
-        const path24 = (0, util_1.normalizeSlashes)(relname);
-        return ignore.some((x) => x.test(path24));
+        const path25 = (0, util_1.normalizeSlashes)(relname);
+        return ignore.some((x) => x.test(path25));
       };
     }
     function registerExtensions(preferTsExts, extensions, service, originalJsHandler) {
@@ -65815,7 +65815,7 @@ var require_has_flag2 = __commonJS({
 var require_supports_colors = __commonJS({
   "node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module2) {
     "use strict";
-    var os7 = require("os");
+    var os9 = require("os");
     var hasFlag = require_has_flag2();
     var env = process.env;
     var forceColor = void 0;
@@ -65853,7 +65853,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os7.release().split(".");
+        var osRelease = os9.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -67121,9 +67121,9 @@ var {
 } = import_index.default;
 // apps/cli/cli.ts
-var import_chalk26 = __toESM(require_source());
-var import_path19 = __toESM(require("path"));
-var import_fs_extra17 = __toESM(require_lib());
+var import_chalk27 = __toESM(require_source());
+var import_path20 = __toESM(require("path"));
+var import_fs_extra18 = __toESM(require_lib());
 // apps/cli/utils/operation-logger.ts
 var import_fs_extra = __toESM(require_lib());
@@ -69480,9 +69480,9 @@ var fetchAsyncQuestionProperty = function(question, prop, answers) {
 // node_modules/inquirer/lib/ui/prompt.js
 var _ = {
-  set: (obj, path24 = "", value2) => {
+  set: (obj, path25 = "", value2) => {
     let pointer = obj;
-    path24.split(".").forEach((key, index, arr) => {
+    path25.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor") return;
       if (index === arr.length - 1) {
         pointer[key] = value2;
@@ -69492,8 +69492,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path24 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path24, regexp).filter(Boolean).reduce(
+  get: (obj, path25 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path25, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res !== null && res !== void 0 ? res[key] : res,
       obj
@@ -70372,9 +70372,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path24, key, dots) {
-  if (!path24) return key;
-  return path24.concat(key).map(function each(token2, i) {
+function renderKey(path25, key, dots) {
+  if (!path25) return key;
+  return path25.concat(key).map(function each(token2, i) {
     token2 = removeBrackets(token2);
     return !dots && i ? "[" + token2 + "]" : token2;
   }).join(dots ? "." : "");
@@ -70422,9 +70422,9 @@ function toFormData(obj, formData, options) {
     }
     return value2;
   }
-  function defaultVisitor(value2, key, path24) {
+  function defaultVisitor(value2, key, path25) {
     let arr = value2;
-    if (value2 && !path24 && typeof value2 === "object") {
+    if (value2 && !path25 && typeof value2 === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value2 = JSON.stringify(value2);
@@ -70443,7 +70443,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value2)) {
       return true;
     }
-    formData.append(renderKey(path24, key, dots), convertValue(value2));
+    formData.append(renderKey(path25, key, dots), convertValue(value2));
     return false;
   }
   const stack = [];
@@ -70452,10 +70452,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value2, path24) {
+  function build(value2, path25) {
     if (utils_default.isUndefined(value2)) return;
     if (stack.indexOf(value2) !== -1) {
-      throw Error("Circular reference detected in " + path24.join("."));
+      throw Error("Circular reference detected in " + path25.join("."));
     }
     stack.push(value2);
     utils_default.forEach(value2, function each(el, key) {
@@ -70463,11 +70463,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path24,
+        path25,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path24 ? path24.concat(key) : [key]);
+        build(el, path25 ? path25.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -70679,7 +70679,7 @@ var platform_default = {
 // node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams(), {
-    visitor: function(value2, key, path24, helpers) {
+    visitor: function(value2, key, path25, helpers) {
       if (platform_default.isNode && utils_default.isBuffer(value2)) {
         this.append(key, value2.toString("base64"));
         return false;
@@ -70709,11 +70709,11 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path24, value2, target, index) {
-    let name = path24[index++];
+  function buildPath(path25, value2, target, index) {
+    let name = path25[index++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path24.length;
+    const isLast = index >= path25.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -70726,7 +70726,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path24, value2, target[name], index);
+    const result = buildPath(path25, value2, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -72048,9 +72048,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path24;
+    let path25;
     try {
-      path24 = buildURL(
+      path25 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -72068,7 +72068,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path: path24,
+      path: path25,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -72304,14 +72304,14 @@ var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PUR
 var cookies_default = platform_default.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
-    write(name, value2, expires, path24, domain, secure, sameSite) {
+    write(name, value2, expires, path25, domain, secure, sameSite) {
       if (typeof document === "undefined") return;
       const cookie = [`${name}=${encodeURIComponent(value2)}`];
       if (utils_default.isNumber(expires)) {
         cookie.push(`expires=${new Date(expires).toUTCString()}`);
       }
-      if (utils_default.isString(path24)) {
-        cookie.push(`path=${path24}`);
+      if (utils_default.isString(path25)) {
+        cookie.push(`path=${path25}`);
       }
       if (utils_default.isString(domain)) {
         cookie.push(`domain=${domain}`);
@@ -81993,12 +81993,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path24) {
-    if (!path24) {
+  resolve(path25) {
+    if (!path25) {
       return this;
     }
-    const rootPath = this.getRootString(path24);
-    const dir = path24.substring(rootPath.length);
+    const rootPath = this.getRootString(path25);
+    const dir = path25.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -82750,8 +82750,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path24) {
-    return import_node_path2.win32.parse(path24).root;
+  getRootString(path25) {
+    return import_node_path2.win32.parse(path25).root;
   }
   /**
    * @internal
@@ -82797,8 +82797,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path24) {
-    return path24.startsWith("/") ? "/" : "";
+  getRootString(path25) {
+    return path25.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -82847,8 +82847,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs20 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs20);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs21 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs21);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -82887,11 +82887,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path24 = this.cwd) {
-    if (typeof path24 === "string") {
-      path24 = this.cwd.resolve(path24);
+  depth(path25 = this.cwd) {
+    if (typeof path25 === "string") {
+      path25 = this.cwd.resolve(path25);
     }
-    return path24.depth();
+    return path25.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -83378,9 +83378,9 @@ var PathScurryBase = class {
     process3();
     return results;
   }
-  chdir(path24 = this.cwd) {
+  chdir(path25 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path24 === "string" ? this.cwd.resolve(path24) : path24;
+    this.cwd = typeof path25 === "string" ? this.cwd.resolve(path25) : path25;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -83406,8 +83406,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs20) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
+  newRoot(fs21) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -83435,8 +83435,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs20) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
+  newRoot(fs21) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -83736,8 +83736,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path24, n]) => [
-      path24,
+    return [...this.store.entries()].map(([path25, n]) => [
+      path25,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -83942,9 +83942,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path24, opts) {
+  constructor(patterns, path25, opts) {
     this.patterns = patterns;
-    this.path = path24;
+    this.path = path25;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -83963,11 +83963,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path24) {
-    return this.seen.has(path24) || !!this.#ignore?.ignored?.(path24);
+  #ignored(path25) {
+    return this.seen.has(path25) || !!this.#ignore?.ignored?.(path25);
   }
-  #childrenIgnored(path24) {
-    return !!this.#ignore?.childrenIgnored?.(path24);
+  #childrenIgnored(path25) {
+    return !!this.#ignore?.childrenIgnored?.(path25);
   }
   // backpressure mechanism
   pause() {
@@ -84182,8 +84182,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path24, opts) {
-    super(patterns, path24, opts);
+  constructor(patterns, path25, opts) {
+    super(patterns, path25, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -84220,8 +84220,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path24, opts) {
-    super(patterns, path24, opts);
+  constructor(patterns, path25, opts) {
+    super(patterns, path25, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -84703,8 +84703,8 @@ var CsvManager = class {
   /**
    * Set nested value in object using dot notation (e.g., "parent.child.key")
    */
-  setNestedValue(obj, path24, value2) {
-    const keys = path24.split(".");
+  setNestedValue(obj, path25, value2) {
+    const keys = path25.split(".");
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
       const key = keys[i];
@@ -85811,7 +85811,7 @@ var import_xml2js = __toESM(require_xml2js());
 var import_chalk19 = __toESM(require_source());
 var import_ora5 = __toESM(require_ora());
 var import_path12 = __toESM(require("path"));
-var import_os = __toESM(require("os"));
+var import_os2 = __toESM(require("os"));
 // apps/cli/utils/csv.ts
 var import_chalk17 = __toESM(require_source());
@@ -85820,6 +85820,45 @@ var import_csv_writer3 = __toESM(require_dist());
 var import_fs_extra9 = __toESM(require_lib());
 var import_path10 = __toESM(require("path"));
 var CsvManager2 = class {
+  /**
+   * Write a standard HubDoc mapping CSV (the `;`-delimited format consumed by
+   * readMappingFile / the `import` command). Used by the plugin-import bridge so
+   * downloaded files round-trip into the standard importer without a delimiter
+   * mismatch (arrayToCsv produces comma-separated output, which readMappingFile
+   * — separator ';' — cannot parse).
+   */
+  async writeStandardMapping(rows, outputPath) {
+    const csvWriter = (0, import_csv_writer3.createObjectCsvWriter)({
+      path: outputPath,
+      fieldDelimiter: ";",
+      header: [
+        { id: "filePath", title: "File Path" },
+        { id: "targetFolder", title: "Target Folder" },
+        { id: "workspace", title: "Workspace" },
+        { id: "metadata", title: "Metadata (key: value, parent.child: value)" },
+        { id: "permissions", title: "Permissions (users:r:email1,email2 | users:w:admin | groups:Group Name)" },
+        { id: "autoClassify", title: "Auto Classify" },
+        { id: "status", title: "Status" },
+        { id: "progress", title: "Progress (%)" },
+        { id: "error", title: "Error" },
+        { id: "documentId", title: "Document ID" },
+        { id: "bulkUploadId", title: "Bulk Upload ID" }
+      ]
+    });
+    await csvWriter.writeRecords(rows.map((r) => ({
+      filePath: r.filePath,
+      targetFolder: r.targetFolder || "",
+      workspace: r.workspace || "",
+      metadata: r.metadata || "",
+      permissions: r.permissions || "",
+      autoClassify: "false",
+      status: "pending",
+      progress: "0",
+      error: "",
+      documentId: "",
+      bulkUploadId: ""
+    })));
+  }
   async generateMappingFile(sourceDir, outputPath = "mapping.csv") {
     const files2 = await this.getAllFiles(sourceDir);
     const mappingData = files2.map((filePath) => ({
@@ -85995,8 +86034,8 @@ var CsvManager2 = class {
   /**
    * Set nested value in object using dot notation (e.g., "parent.child.key")
    */
-  setNestedValue(obj, path24, value2) {
-    const keys = path24.split(".");
+  setNestedValue(obj, path25, value2) {
+    const keys = path25.split(".");
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
       const key = keys[i];
@@ -86116,7 +86155,8 @@ var CsvManager2 = class {
     return new Promise((resolve, reject) => {
       const results = [];
       import_fs_extra9.default.createReadStream(filePath).pipe((0, import_csv_parser3.default)({
-        separator: ";",
+        // Plugin mapping is written comma-separated by arrayToCsv(); read it the same way.
+        separator: ",",
         mapHeaders: ({ header }) => header.trim()
       })).on("data", (data) => results.push(data)).on("end", () => resolve(results)).on("error", reject);
     });
@@ -86279,12 +86319,37 @@ var CsvManager2 = class {
 var import_chalk18 = __toESM(require_source());
 var import_fs_extra10 = __toESM(require_lib());
 var import_path11 = __toESM(require("path"));
+var import_os = __toESM(require("os"));
 var PluginManager2 = class {
-  constructor(pluginsDir = "./plugins") {
+  constructor(pluginsDir = "./plugins", connectionsFile) {
     this.plugins = /* @__PURE__ */ new Map();
     this.connections = /* @__PURE__ */ new Map();
     this.tsNodeRegistered = false;
     this.pluginsDir = import_path11.default.resolve(pluginsDir);
+    this.connectionsFile = connectionsFile ?? process.env.HUBDOC_CONNECTIONS_FILE ?? import_path11.default.join(import_os.default.homedir(), ".hubdoc-connections.json");
+    this.loadConnections();
+  }
+  /** Load persisted connections from disk (best-effort; ignores a missing/corrupt store). */
+  loadConnections() {
+    try {
+      if (import_fs_extra10.default.existsSync(this.connectionsFile)) {
+        const list = import_fs_extra10.default.readJsonSync(this.connectionsFile);
+        for (const c of list) this.connections.set(c.id, c);
+      }
+    } catch {
+    }
+  }
+  /** Persist the current connections to disk. */
+  saveConnections() {
+    try {
+      import_fs_extra10.default.writeJsonSync(
+        this.connectionsFile,
+        Array.from(this.connections.values()),
+        { spaces: 2 }
+      );
+    } catch (e) {
+      console.error(import_chalk18.default.yellow(`\u26A0\uFE0F  Could not persist connections: ${e.message}`));
+    }
   }
   /**
    * Register ts-node to allow loading TypeScript files
@@ -86428,6 +86493,7 @@ var PluginManager2 = class {
     if (isConnected) {
       await plugin.plugin.initialize(config);
       this.connections.set(id, connection);
+      this.saveConnections();
       console.log(import_chalk18.default.green(`\u2705 Connection established: ${name}`));
     } else {
       console.error(import_chalk18.default.red(`\u274C Failed to connect: ${name}`));
@@ -86458,6 +86524,7 @@ var PluginManager2 = class {
         await plugin.plugin.destroy();
       }
       this.connections.delete(id);
+      this.saveConnections();
       console.log(import_chalk18.default.blue(`\u{1F5D1}\uFE0F  Connection removed: ${connection.name}`));
     }
   }
@@ -86632,7 +86699,7 @@ var PluginImportService = class {
       lastModified: /* @__PURE__ */ new Date(),
       metadata: mapping.metadata
     }));
-    const workingDir = tempDir || import_path12.default.join(import_os.default.tmpdir(), "hubdoc-tools", "plugin-import");
+    const workingDir = tempDir || import_path12.default.join(import_os2.default.tmpdir(), "hubdoc-tools", "plugin-import");
     const downloadSpinner = (0, import_ora5.default)(`Downloading ${sources.length} files from ${connection.name}...`).start();
     const importResults = await plugin.plugin.import(
       connection.config,
@@ -86680,11 +86747,11 @@ var PluginImportService = class {
       sourceSize: source.size,
       sourceMimeType: source.mimeType,
       sourceLastModified: source.lastModified.toISOString(),
-      targetFolder: "",
-      // To be filled by user
+      // Pre-fill from the source's classification when the plugin provides it; still editable.
+      targetFolder: source.targetFolder || "",
       workspace: "",
       // To be filled by user
-      domain: "",
+      domain: source.domain || "",
       planClassement: "",
       metadata: source.metadata ? JSON.stringify(source.metadata) : "",
       readPermissions: "",
@@ -86731,30 +86798,21 @@ var PluginImportService = class {
    * Create HubDoc-compatible mapping from plugin results
    */
   async createHubDocMapping(importResults, originalMappings, outputFile) {
-    const mappingData = importResults.map((result) => {
+    const rows = importResults.map((result) => {
       const originalMapping = originalMappings.find((m) => m.sourceId === result.source.id);
+      const permParts = [];
+      if (originalMapping?.readPermissions) permParts.push(originalMapping.readPermissions);
+      if (originalMapping?.writePermissions) permParts.push(originalMapping.writePermissions);
       return {
         filePath: result.localPath || "",
         targetFolder: originalMapping?.targetFolder || "",
         workspace: originalMapping?.workspace || "",
-        domain: originalMapping?.domain || "",
-        planClassement: originalMapping?.planClassement || "",
+        // parseMetadata accepts legacy JSON, so the rich plugin metadata survives.
         metadata: originalMapping?.metadata ? JSON.stringify(originalMapping.metadata) : "",
-        readPermissions: originalMapping?.readPermissions || "",
-        writePermissions: originalMapping?.writePermissions || ""
+        permissions: permParts.join(" | ")
       };
     });
-    const csvContent = this.csvManager.arrayToCsv(mappingData, [
-      { id: "filePath", title: "File Path" },
-      { id: "targetFolder", title: "Target Folder" },
-      { id: "workspace", title: "Workspace" },
-      { id: "domain", title: "Domain" },
-      { id: "planClassement", title: "Plan Classement" },
-      { id: "metadata", title: "Metadata (JSON)" },
-      { id: "readPermissions", title: "Read Permissions (users:user1,user2|groups:group1,group2)" },
-      { id: "writePermissions", title: "Write Permissions (users:user1,user2|groups:group1,group2)" }
-    ]);
-    await this.csvManager.writeCsv(outputFile, csvContent);
+    await this.csvManager.writeStandardMapping(rows, outputFile);
   }
   /**
    * Group mappings by connection ID
@@ -87141,7 +87199,7 @@ async function handlePluginImport(mappingFile, options) {
 }
 // apps/cli/cli/handlers/auth-handlers.ts
-var import_os4 = __toESM(require("os"));
+var import_os5 = __toESM(require("os"));
 var import_path15 = __toESM(require("path"));
 var import_fs_extra13 = __toESM(require_lib());
 var import_chalk24 = __toESM(require_source());
@@ -87183,8 +87241,8 @@ function truncate(value2, max) {
   if (!max || value2.length <= max) return value2;
   return value2.slice(0, max - 1) + "\u2026";
 }
-function get(obj, path24) {
-  return path24.split(".").reduce((acc, k) => acc == null ? acc : acc[k], obj);
+function get(obj, path25) {
+  return path25.split(".").reduce((acc, k) => acc == null ? acc : acc[k], obj);
 }
 function printTable(rows, columns) {
   if (!rows || rows.length === 0) {
@@ -87286,7 +87344,7 @@ function output(opts) {
 }
 // apps/cli/cli/llm/api-context.ts
-var import_os2 = __toESM(require("os"));
+var import_os3 = __toESM(require("os"));
 // apps/cli/api/configuration.ts
 var Configuration2 = class {
@@ -87396,7 +87454,7 @@ async function resolveToken(config) {
   return null;
 }
 async function buildApiContext(out) {
-  const globalConfig = await new ConfigManager(import_os2.default.homedir()).loadConfig();
+  const globalConfig = await new ConfigManager(import_os3.default.homedir()).loadConfig();
   const cwdConfig = await new ConfigManager().loadConfig();
   const config = cwdConfig ?? globalConfig;
   if (!config || !config.apiUrl) {
@@ -87426,7 +87484,7 @@ async function buildApiContext(out) {
 }
 // apps/cli/services/device-auth-service.ts
-var import_os3 = __toESM(require("os"));
+var import_os4 = __toESM(require("os"));
 var DEVICE_START_PATH = "/api/v1/cli/auth/device";
 var DEVICE_POLL_PATH = "/api/v1/cli/auth/device/poll";
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -87439,7 +87497,7 @@ var DeviceAuthService = class {
         Accept: "application/json",
         // The parenthetical platform is what the backend uses to name the
         // generated PAT ("hubdoc-cli (darwin)"), via CliSession#pat_name_for.
-        "User-Agent": `hubdoc-cli/${version} (${import_os3.default.platform()})`
+        "User-Agent": `hubdoc-cli/${version} (${import_os4.default.platform()})`
       }
     });
   }
@@ -87586,7 +87644,7 @@ async function handleTokenSet(token2, opts) {
     out.fail(new Error("Token cannot be empty"));
   }
   const trimmed = token2.trim();
-  const configManager = new ConfigManager(import_os4.default.homedir());
+  const configManager = new ConfigManager(import_os5.default.homedir());
   const existing = await configManager.loadConfig() || {};
   const apiUrl = opts.apiUrl || existing.apiUrl || process.env.HUBDOC_API_URL || "http://localhost:3000";
   if (opts.keychain) {
@@ -87626,14 +87684,14 @@ async function handleTokenSet(token2, opts) {
   await configManager.saveConfig(next);
   out.ok("Token saved", { apiUrl, storage: "config", tokenLength: trimmed.length });
 }
-var DEVICE_SESSION_FILE = import_path15.default.join(import_os4.default.homedir(), ".hubdoc-tools", "device-session.json");
+var DEVICE_SESSION_FILE = import_path15.default.join(import_os5.default.homedir(), ".hubdoc-tools", "device-session.json");
 async function resolveApiUrl(opts) {
   if (opts.apiUrl) return opts.apiUrl;
-  const config = await new ConfigManager(import_os4.default.homedir()).loadConfig();
+  const config = await new ConfigManager(import_os5.default.homedir()).loadConfig();
   return config?.apiUrl || process.env.HUBDOC_API_URL;
 }
 async function persistDeviceToken(apiUrl, token2) {
-  const configManager = new ConfigManager(import_os4.default.homedir());
+  const configManager = new ConfigManager(import_os5.default.homedir());
   const existing = await configManager.loadConfig() || {};
   const next = {
     ...existing,
@@ -87763,7 +87821,7 @@ async function handleTokenOpen(opts) {
   const out = output(opts);
   let apiUrl = opts.apiUrl || process.env.HUBDOC_API_URL;
   if (!apiUrl) {
-    const configManager = new ConfigManager(import_os4.default.homedir());
+    const configManager = new ConfigManager(import_os5.default.homedir());
     const config = await configManager.loadConfig();
     apiUrl = config?.apiUrl;
   }
@@ -87783,7 +87841,7 @@ async function handleTokenOpen(opts) {
 }
 // apps/cli/cli/handlers/skill-handlers.ts
-var import_os5 = __toESM(require("os"));
+var import_os6 = __toESM(require("os"));
 var import_path16 = __toESM(require("path"));
 var import_fs_extra14 = __toESM(require_lib());
@@ -87888,7 +87946,7 @@ so you can relay the code before blocking.
 function resolveSkillsDir(opts) {
   if (opts.path) return import_path16.default.resolve(opts.path);
   if (opts.project) return import_path16.default.join(process.cwd(), ".claude", "skills");
-  return import_path16.default.join(import_os5.default.homedir(), ".claude", "skills");
+  return import_path16.default.join(import_os6.default.homedir(), ".claude", "skills");
 }
 async function handleSkillInstall(opts) {
   const out = output(opts);
@@ -89097,6 +89155,520 @@ async function handleSearch(query, opts) {
   }
 }
+// apps/cli/cli/handlers/mount-handlers.ts
+var import_chalk26 = __toESM(require_source());
+// apps/cli/cli/fuse/hubdoc-fs.ts
+var import_fs_extra16 = __toESM(require_lib());
+var import_os7 = __toESM(require("os"));
+var import_path18 = __toESM(require("path"));
+var import_crypto2 = __toESM(require("crypto"));
+var import_form_data4 = __toESM(require_form_data());
+var DIR_MODE = 16877;
+var FILE_MODE = 33188;
+var HubdocFs = class {
+  constructor(ctx, root, opts = {}) {
+    this.ctx = ctx;
+    this.root = root;
+    this.opts = opts;
+    this.nodes = /* @__PURE__ */ new Map();
+    this.handles = /* @__PURE__ */ new Map();
+    this.nextFd = 10;
+    this.fuse = null;
+    this.ttlMs = opts.ttlMs ?? 3e4;
+    const host = (() => {
+      try {
+        return new URL(ctx.baseUrl).host;
+      } catch {
+        return "instance";
+      }
+    })();
+    this.cacheDir = opts.cacheDir ?? import_path18.default.join(
+      process.env.XDG_CACHE_HOME || import_path18.default.join(import_os7.default.homedir(), ".cache"),
+      "hubdoc-mount",
+      host
+    );
+    import_fs_extra16.default.ensureDirSync(this.cacheDir);
+    this.nodes.set("/", this.rootNode());
+  }
+  // --- node model ----------------------------------------------------------
+  rootNode() {
+    const now = /* @__PURE__ */ new Date();
+    if (this.root.mode === "workspace") {
+      return { kind: "dir", hub: "workspace", name: "/", id: this.root.workspaceId, workspaceId: this.root.workspaceId, size: 0, mtime: now };
+    }
+    if (this.root.mode === "folder") {
+      return { kind: "dir", hub: "folder", name: "/", id: this.root.folderId, workspaceId: this.root.workspaceId, folderId: this.root.folderId, size: 0, mtime: now };
+    }
+    return { kind: "dir", hub: "root", name: "/", size: 0, mtime: now };
+  }
+  log(...args) {
+    if (this.opts.verbose) console.error("[mount]", ...args);
+  }
+  fresh(node) {
+    return node.loadedAt !== void 0 && Date.now() - node.loadedAt < this.ttlMs;
+  }
+  /** Resolve a fuse path to a node, lazily loading ancestors as needed. */
+  async resolve(p) {
+    if (p === "/") return this.nodes.get("/");
+    const segments = p.split("/").filter(Boolean);
+    let curPath = "";
+    let node = this.nodes.get("/");
+    for (const seg of segments) {
+      if (node.kind !== "dir") return null;
+      await this.ensureChildren(node, curPath || "/");
+      const childPath = (curPath || "") + "/" + seg;
+      const child = this.nodes.get(childPath);
+      if (!child) return null;
+      node = child;
+      curPath = childPath;
+    }
+    return node;
+  }
+  /** Populate a directory node's children from the API (respecting the TTL). */
+  async ensureChildren(node, nodePath) {
+    if (node.kind !== "dir") return;
+    if (node.children && this.fresh(node)) return;
+    const children2 = /* @__PURE__ */ new Map();
+    const base = nodePath === "/" ? "" : nodePath;
+    if (node.hub === "root") {
+      const ws = await this.listWorkspaces();
+      for (const w of ws) {
+        const name = this.uniqueName(children2, w.label || w.id);
+        const childPath = base + "/" + name;
+        this.nodes.set(childPath, {
+          kind: "dir",
+          hub: "workspace",
+          name,
+          id: w.id,
+          workspaceId: w.id,
+          size: 0,
+          mtime: parseDate(w.updated_at)
+        });
+        children2.set(name, childPath);
+      }
+    } else {
+      const ws = node.workspaceId;
+      const folderId = node.hub === "folder" ? node.folderId : void 0;
+      const folders2 = await this.listFolders(ws, folderId);
+      for (const f of folders2) {
+        const name = this.uniqueName(children2, f.name);
+        const childPath = base + "/" + name;
+        this.nodes.set(childPath, {
+          kind: "dir",
+          hub: "folder",
+          name,
+          id: f.id,
+          workspaceId: f.workspace_id || ws,
+          folderId: f.id,
+          size: 0,
+          mtime: parseDate(f.updated_at)
+        });
+        children2.set(name, childPath);
+      }
+      const docs = await this.listDocuments(ws, folderId);
+      for (const d of docs) {
+        const name = this.uniqueName(children2, d.name);
+        const childPath = base + "/" + name;
+        const existing = this.nodes.get(childPath);
+        this.nodes.set(childPath, {
+          kind: "file",
+          hub: "file",
+          name,
+          id: d.id,
+          workspaceId: d.workspace_id || ws,
+          folderId: d.documents_folder_id || folderId,
+          size: d.byte_size ?? d.file_size ?? existing?.size ?? 0,
+          mtime: parseDate(d.updated_at),
+          // keep a still-valid local cache across refreshes
+          cachePath: existing?.cachePath,
+          downloaded: existing?.downloaded
+        });
+        children2.set(name, childPath);
+      }
+    }
+    node.children = children2;
+    node.loadedAt = Date.now();
+  }
+  uniqueName(children2, raw) {
+    const safe = (raw || "sans-nom").replace(/\//g, "\u2215");
+    if (!children2.has(safe)) return safe;
+    const ext2 = import_path18.default.extname(safe);
+    const stem = safe.slice(0, safe.length - ext2.length);
+    let i = 2;
+    while (children2.has(`${stem} (${i})${ext2}`)) i++;
+    return `${stem} (${i})${ext2}`;
+  }
+  // --- API helpers (all via the shared axios, relative /api/v1 paths) -------
+  async listWorkspaces() {
+    const res = await this.ctx.axios.get("/api/v1/documents/workspaces", { params: { per_page: 1e3 } });
+    return res.data;
+  }
+  async listFolders(workspaceId, parentFolderId) {
+    const res = await this.ctx.axios.get("/api/v1/documents/folders", {
+      params: { workspace_id: workspaceId, documents_folder_id: parentFolderId, per_page: 1e3 }
+    });
+    const all3 = res.data;
+    return all3.filter((f) => (f.documents_folder_id ?? null) === (parentFolderId ?? null));
+  }
+  async listDocuments(workspaceId, folderId) {
+    const res = await this.ctx.axios.get("/api/v1/documents/documents", {
+      params: { workspace_id: workspaceId, documents_folder_id: folderId, per_page: 1e3 }
+    });
+    const all3 = res.data;
+    return all3.filter((d) => (d.documents_folder_id ?? null) === (folderId ?? null));
+  }
+  cacheFileFor(node) {
+    if (!node.cachePath) {
+      const key = node.id || import_crypto2.default.randomBytes(8).toString("hex");
+      node.cachePath = import_path18.default.join(this.cacheDir, key);
+    }
+    return node.cachePath;
+  }
+  async download(node) {
+    if (node.downloaded && node.cachePath && await import_fs_extra16.default.pathExists(node.cachePath)) return;
+    const dest = this.cacheFileFor(node);
+    const res = await this.ctx.axios.get(`/api/v1/documents/documents/${node.id}/blob`, { responseType: "stream" });
+    await new Promise((resolve, reject) => {
+      const w = import_fs_extra16.default.createWriteStream(dest);
+      res.data.pipe(w);
+      w.on("finish", () => resolve());
+      w.on("error", reject);
+      res.data.on("error", reject);
+    });
+    node.downloaded = true;
+    node.size = (await import_fs_extra16.default.stat(dest)).size;
+  }
+  async uploadNew(node) {
+    const local = this.cacheFileFor(node);
+    const form = new import_form_data4.default();
+    form.append("uploaded_file", import_fs_extra16.default.createReadStream(local), {
+      filename: node.name,
+      contentType: "application/octet-stream"
+    });
+    if (node.folderId) form.append("documents_folder_id", node.folderId);
+    else if (node.workspaceId) form.append("workspace_id", node.workspaceId);
+    if (node.name.toLowerCase().endsWith(".md")) {
+      this.log(`\u26A0\uFE0F  ${node.name}: write-back markdown \u2014 voir caveat collab #508`);
+    }
+    const res = await this.ctx.axios.post("/api/v1/documents/documents", form, {
+      headers: form.getHeaders(),
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity
+    });
+    const created = res.data?.document ?? res.data;
+    if (created?.id) node.id = created.id;
+    node.isNew = false;
+    node.size = (await import_fs_extra16.default.stat(local)).size;
+  }
+  async uploadUpdate(node) {
+    const local = this.cacheFileFor(node);
+    const form = new import_form_data4.default();
+    form.append("uploaded_file", import_fs_extra16.default.createReadStream(local), {
+      filename: node.name,
+      contentType: "application/octet-stream"
+    });
+    await this.ctx.axios.patch(`/api/v1/documents/documents/${node.id}`, form, {
+      headers: form.getHeaders(),
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity
+    });
+    node.size = (await import_fs_extra16.default.stat(local)).size;
+  }
+  invalidateParent(p) {
+    const parent = this.nodes.get(parentPath(p));
+    if (parent) parent.loadedAt = 0;
+  }
+  // --- FUSE ops ------------------------------------------------------------
+  ops() {
+    const Fuse = this.fuse;
+    const ro = !!this.opts.readOnly;
+    const uid = process.getuid ? process.getuid() : 0;
+    const gid = process.getgid ? process.getgid() : 0;
+    const wrap = (fn) => (...args) => {
+      const cb = args[args.length - 1];
+      fn(...args).catch((err) => {
+        this.log("op error", err?.message || err);
+        cb(typeof err?.errno === "number" ? err.errno : Fuse.EIO);
+      });
+    };
+    return {
+      init: (cb) => cb(0),
+      getattr: wrap(async (p, cb) => {
+        const node = await this.resolve(p);
+        if (!node) return cb(Fuse.ENOENT);
+        const isDir = node.kind === "dir";
+        cb(0, {
+          mtime: node.mtime,
+          atime: node.mtime,
+          ctime: node.mtime,
+          size: isDir ? 4096 : node.size,
+          mode: isDir ? DIR_MODE : FILE_MODE,
+          uid,
+          gid,
+          nlink: 1,
+          blocks: Math.ceil((isDir ? 4096 : node.size) / 512)
+        });
+      }),
+      readdir: wrap(async (p, cb) => {
+        const node = await this.resolve(p);
+        if (!node) return cb(Fuse.ENOENT);
+        if (node.kind !== "dir") return cb(Fuse.ENOTDIR);
+        await this.ensureChildren(node, p);
+        cb(0, [".", "..", ...Array.from(node.children.keys())]);
+      }),
+      open: wrap(async (p, flags, cb) => {
+        const node = await this.resolve(p);
+        if (!node) return cb(Fuse.ENOENT);
+        if (node.kind !== "file") return cb(Fuse.EISDIR);
+        const write = (flags & 3) !== 0;
+        if (write && ro) return cb(Fuse.EACCES);
+        if (node.id) await this.download(node);
+        const localFd = await import_fs_extra16.default.open(this.cacheFileFor(node), "r+").catch(async () => import_fs_extra16.default.open(this.cacheFileFor(node), "w+"));
+        const fd = this.nextFd++;
+        this.handles.set(fd, { node, localFd, write });
+        cb(0, fd);
+      }),
+      read: wrap(async (_p, fd, buf, len, pos, cb) => {
+        const h = this.handles.get(fd);
+        if (!h) return cb(Fuse.EBADF);
+        const { bytesRead } = await import_fs_extra16.default.read(h.localFd, buf, 0, len, pos);
+        cb(bytesRead);
+      }),
+      write: wrap(async (_p, fd, buf, len, pos, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const h = this.handles.get(fd);
+        if (!h) return cb(Fuse.EBADF);
+        const { bytesWritten } = await import_fs_extra16.default.write(h.localFd, buf, 0, len, pos);
+        h.node.dirty = true;
+        cb(bytesWritten);
+      }),
+      truncate: wrap(async (p, size, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const node = await this.resolve(p);
+        if (!node || node.kind !== "file") return cb(Fuse.ENOENT);
+        if (node.id) await this.download(node);
+        await import_fs_extra16.default.truncate(this.cacheFileFor(node), size);
+        node.dirty = true;
+        node.size = size;
+        cb(0);
+      }),
+      create: wrap(async (p, _mode, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const parent = await this.resolve(parentPath(p));
+        if (!parent || parent.kind !== "dir") return cb(Fuse.ENOENT);
+        if (parent.hub === "root") return cb(Fuse.EPERM);
+        const name = import_path18.default.basename(p);
+        const node = {
+          kind: "file",
+          hub: "file",
+          name,
+          workspaceId: parent.workspaceId,
+          folderId: parent.hub === "folder" ? parent.folderId : void 0,
+          size: 0,
+          mtime: /* @__PURE__ */ new Date(),
+          isNew: true,
+          dirty: true,
+          downloaded: true
+        };
+        await import_fs_extra16.default.writeFile(this.cacheFileFor(node), Buffer.alloc(0));
+        this.nodes.set(p, node);
+        parent.children?.set(name, p);
+        const localFd = await import_fs_extra16.default.open(node.cachePath, "r+");
+        const fd = this.nextFd++;
+        this.handles.set(fd, { node, localFd, write: true });
+        cb(0, fd);
+      }),
+      release: wrap(async (_p, fd, cb) => {
+        const h = this.handles.get(fd);
+        if (!h) return cb(0);
+        this.handles.delete(fd);
+        try {
+          await import_fs_extra16.default.close(h.localFd);
+        } catch {
+        }
+        if (h.node.dirty && !ro) {
+          if (h.node.isNew || !h.node.id) await this.uploadNew(h.node);
+          else await this.uploadUpdate(h.node);
+          h.node.dirty = false;
+          h.node.mtime = /* @__PURE__ */ new Date();
+        }
+        cb(0);
+      }),
+      flush: (_p, _fd, cb) => cb(0),
+      fsync: (_p, _fd, _datasync, cb) => cb(0),
+      unlink: wrap(async (p, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const node = await this.resolve(p);
+        if (!node || node.kind !== "file") return cb(Fuse.ENOENT);
+        if (node.id) await this.ctx.axios.delete(`/api/v1/documents/documents/${node.id}`);
+        if (node.cachePath) await import_fs_extra16.default.remove(node.cachePath).catch(() => {
+        });
+        this.nodes.delete(p);
+        this.invalidateParent(p);
+        cb(0);
+      }),
+      mkdir: wrap(async (p, _mode, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const parent = await this.resolve(parentPath(p));
+        if (!parent || parent.kind !== "dir" || parent.hub === "root") return cb(Fuse.EPERM);
+        const name = import_path18.default.basename(p);
+        const body = { name };
+        if (parent.hub === "folder") body.documents_folder_id = parent.folderId;
+        if (parent.workspaceId) body.workspace_id = parent.workspaceId;
+        const res = await this.ctx.axios.post("/api/v1/documents/folders", body);
+        const created = res.data?.folder ?? res.data;
+        this.nodes.set(p, {
+          kind: "dir",
+          hub: "folder",
+          name,
+          id: created.id,
+          workspaceId: parent.workspaceId,
+          folderId: created.id,
+          size: 0,
+          mtime: /* @__PURE__ */ new Date()
+        });
+        parent.children?.set(name, p);
+        cb(0);
+      }),
+      rmdir: wrap(async (p, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const node = await this.resolve(p);
+        if (!node || node.kind !== "dir") return cb(Fuse.ENOENT);
+        if (node.hub !== "folder" || !node.id) return cb(Fuse.EPERM);
+        await this.ctx.axios.delete(`/api/v1/documents/folders/${node.id}`);
+        this.nodes.delete(p);
+        this.invalidateParent(p);
+        cb(0);
+      }),
+      rename: wrap(async (src, dest, cb) => {
+        if (ro) return cb(Fuse.EACCES);
+        const node = await this.resolve(src);
+        if (!node) return cb(Fuse.ENOENT);
+        const newParent = await this.resolve(parentPath(dest));
+        if (!newParent || newParent.kind !== "dir" || newParent.hub === "root") return cb(Fuse.EPERM);
+        const newName = import_path18.default.basename(dest);
+        const newFolderId = newParent.hub === "folder" ? newParent.folderId : null;
+        const resource = node.kind === "file" ? "documents" : "folders";
+        if (!node.id) return cb(Fuse.EPERM);
+        await this.ctx.axios.patch(`/api/v1/documents/${resource}/${node.id}`, {
+          name: newName,
+          documents_folder_id: newFolderId
+        });
+        this.nodes.delete(src);
+        node.name = newName;
+        node.folderId = node.kind === "file" ? newFolderId ?? void 0 : node.folderId;
+        node.workspaceId = newParent.workspaceId;
+        this.nodes.set(dest, node);
+        this.invalidateParent(src);
+        this.invalidateParent(dest);
+        cb(0);
+      }),
+      // no-op metadata ops so editors/copies don't fail
+      chmod: (_p, _m, cb) => cb(0),
+      chown: (_p, _u, _g, cb) => cb(0),
+      utimens: (_p, _a, _m, cb) => cb(0)
+    };
+  }
+  // --- mount lifecycle -----------------------------------------------------
+  async mount(mountPath) {
+    let Fuse;
+    try {
+      Fuse = require("@cocalc/fuse-native");
+    } catch (e) {
+      throw new Error(
+        "Le module natif FUSE n'est pas install\xE9. Installe-le :\n  npm install @cocalc/fuse-native\n  (Linux : apt install fuse3 ; macOS : macFUSE depuis https://macfuse.io)"
+      );
+    }
+    this.fuse = Fuse;
+    await import_fs_extra16.default.ensureDir(mountPath);
+    const fuse = new Fuse(mountPath, this.ops(), {
+      force: true,
+      mkdir: true,
+      displayFolder: "Hubdoc",
+      // macOS shows the volume name in Finder
+      ...process.platform === "darwin" ? { volname: "Hubdoc" } : {}
+    });
+    await new Promise((resolve, reject) => fuse.mount((err) => err ? reject(err) : resolve()));
+    const unmount = () => new Promise((resolve) => {
+      Fuse.unmount(mountPath, () => resolve());
+    });
+    return unmount;
+  }
+};
+function parentPath(p) {
+  const parent = import_path18.default.posix.dirname(p);
+  return parent === "." ? "/" : parent;
+}
+function parseDate(v) {
+  const d = v ? new Date(v) : /* @__PURE__ */ new Date();
+  return isNaN(d.getTime()) ? /* @__PURE__ */ new Date() : d;
+}
+// apps/cli/cli/handlers/mount-handlers.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function handleMount(argA, argB, opts) {
+  const out = output(opts);
+  const ctx = await buildApiContext(out);
+  let mountDir;
+  let root;
+  if (opts.all) {
+    mountDir = requireDir(argA, out);
+    root = { mode: "all" };
+  } else if (opts.folder) {
+    mountDir = requireDir(argA, out);
+    const res = await ctx.axios.get(`/api/v1/documents/folders/${opts.folder}`);
+    const f = res.data?.folder ?? res.data;
+    if (!f?.id) out.fail(new Error(`Dossier introuvable : ${opts.folder}`));
+    root = { mode: "folder", folderId: f.id, workspaceId: f.workspace_id, name: f.name };
+  } else {
+    if (!argB) out.fail(new Error("Usage : hubdoc mount <workspace> <dossier>  (ou --all / --folder <id> <dossier>)"));
+    mountDir = argB;
+    const target = argA;
+    const list = (await ctx.axios.get("/api/v1/documents/workspaces", { params: { per_page: 1e3 } })).data;
+    const ws = UUID_RE.test(target) ? list.find((w) => w.id === target) : list.find((w) => (w.label || "").toLowerCase() === target.toLowerCase());
+    if (!ws) out.fail(new Error(`Workspace introuvable : "${target}". Liste : hubdoc workspaces list`));
+    root = { mode: "workspace", workspaceId: ws.id, label: ws.label };
+  }
+  const mountOpts = {
+    readOnly: !!opts.readOnly,
+    verbose: !!opts.verbose,
+    ttlMs: opts.ttl ? Math.max(1e3, parseInt(opts.ttl, 10) * 1e3) : void 0
+  };
+  const fsImpl = new HubdocFs(ctx, root, mountOpts);
+  const label = root.mode === "all" ? "tous les workspaces" : root.mode === "workspace" ? `workspace \xAB ${root.label} \xBB` : `dossier \xAB ${root.name} \xBB`;
+  console.error(import_chalk26.default.blue(`\u26F0\uFE0F  Montage du ${label} sur ${import_chalk26.default.bold(mountDir)}${opts.readOnly ? " (lecture seule)" : ""}\u2026`));
+  let unmount;
+  try {
+    unmount = await fsImpl.mount(mountDir);
+  } catch (e) {
+    out.fail(e);
+    return;
+  }
+  console.error(import_chalk26.default.green(`\u2705 Mont\xE9. Ctrl-C pour d\xE9monter.`));
+  let unmounting = false;
+  const cleanup = async () => {
+    if (unmounting) return;
+    unmounting = true;
+    console.error(import_chalk26.default.yellow("\n\u23CF\uFE0F  D\xE9montage\u2026"));
+    try {
+      await unmount();
+      console.error(import_chalk26.default.green("\u2705 D\xE9mont\xE9."));
+    } catch (e) {
+      console.error(import_chalk26.default.red(`\xC9chec du d\xE9montage : ${e?.message}. Force : fusermount3 -u ${mountDir} (ou umount).`));
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+function requireDir(dir, out) {
+  if (!dir) out.fail(new Error("Indique le dossier de montage. Ex : hubdoc mount --all ~/hubdoc"));
+  return dir;
+}
 // apps/cli/cli/handlers/composed-document-handlers.ts
 var BASE = "/api/v1/documents/composed_documents";
 var LIST_COLUMNS = [
@@ -89237,8 +89809,8 @@ async function handleComposedExport(id, opts) {
 }
 // apps/cli/cli/handlers/part-handlers.ts
-var import_fs_extra16 = __toESM(require_lib());
-var import_path18 = __toESM(require("path"));
+var import_fs_extra17 = __toESM(require_lib());
+var import_path19 = __toESM(require("path"));
 var partsBase = (cdId) => `/api/v1/documents/composed_documents/${encodeURIComponent(cdId)}/parts`;
 var PART_COLUMNS = [
   { header: "ID", key: "id" },
@@ -89291,11 +89863,11 @@ async function handlePartsUpdate(id, opts) {
   const body = {};
   if (opts.content !== void 0) body.content = opts.content;
   if (opts.contentFile !== void 0) {
-    const resolved = import_path18.default.resolve(opts.contentFile);
-    if (!await import_fs_extra16.default.pathExists(resolved)) {
+    const resolved = import_path19.default.resolve(opts.contentFile);
+    if (!await import_fs_extra17.default.pathExists(resolved)) {
       out.fail(new Error(`Content file not found: ${opts.contentFile}`));
     }
-    body.content = await import_fs_extra16.default.readFile(resolved, "utf8");
+    body.content = await import_fs_extra17.default.readFile(resolved, "utf8");
   }
   if (opts.status !== void 0) body.status = opts.status;
   if (opts.title !== void 0) body.title = opts.title;
@@ -89830,15 +90402,15 @@ async function handlePermissionsShow(id, opts) {
 // apps/cli/cli.ts
 var getVersion = () => {
   try {
-    if (true) return "1.7.0";
+    if (true) return "1.8.0";
   } catch {
   }
   for (const candidate of [
-    import_path19.default.join(__dirname, "package.json"),
-    import_path19.default.join(__dirname, "..", "package.json")
+    import_path20.default.join(__dirname, "package.json"),
+    import_path20.default.join(__dirname, "..", "package.json")
   ]) {
     try {
-      return import_fs_extra17.default.readJsonSync(candidate).version;
+      return import_fs_extra18.default.readJsonSync(candidate).version;
     } catch {
     }
   }
@@ -89858,18 +90430,18 @@ program2.command("run").description("Run HubDoc tool with engine selection (lega
     if (options.interactive || (!options.engine || options.engine === "filesystem")) {
       selectedEngine = await runEngineSelection(options.interactive);
     }
-    console.log(import_chalk26.default.blue(`\u{1F680} Starting HubDoc Tool with ${selectedEngine} engine...`));
+    console.log(import_chalk27.default.blue(`\u{1F680} Starting HubDoc Tool with ${selectedEngine} engine...`));
     logger.log("INFO", "INIT", selectedEngine, `Starting HubDoc Tool with ${selectedEngine} engine`, {
       options: { ...options, logFile: logger.getLogPath() }
     });
     await handleEngineOperation(selectedEngine, options, logger);
     logger.completeOperation(true);
-    console.log(import_chalk26.default.green(`\u2705 Operation completed. Log: ${logger.getLogPath()}`));
+    console.log(import_chalk27.default.green(`\u2705 Operation completed. Log: ${logger.getLogPath()}`));
   } catch (error) {
     logger.log("ERROR", "FAILED", options.engine || "unknown", `Operation failed: ${error.message}`, { error: error.stack });
     logger.completeOperation(false);
-    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
-    console.error(import_chalk26.default.gray(`\u{1F4C4} Check log file: ${logger.getLogPath()}`));
+    console.error(import_chalk27.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk27.default.gray(`\u{1F4C4} Check log file: ${logger.getLogPath()}`));
     process.exit(1);
   }
 });
@@ -89883,7 +90455,7 @@ Examples:
   try {
     await handleGenerateMapping(sourceDir, options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89898,7 +90470,7 @@ Examples:
   try {
     await handleImport(options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Import failed: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Import failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89906,7 +90478,7 @@ program2.command("export").description("Export documents from HubDoc").option("-
   try {
     await handleExport(options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Export failed: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Export failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89914,7 +90486,7 @@ program2.command("plugins").description("Manage document source plugins").action
   try {
     await handlePlugins();
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89922,7 +90494,7 @@ program2.command("connect").description("Create a connection to an external docu
   try {
     await handleConnect(plugin, options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Failed to create connection: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Failed to create connection: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89930,7 +90502,7 @@ program2.command("plugin-scan").description("Scan external source and generate m
   try {
     await handlePluginScan(connectionId, options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Plugin scan failed: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Plugin scan failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89938,7 +90510,7 @@ program2.command("plugin-import").description("Import documents from external so
   try {
     await handlePluginImport(mappingFile, options);
   } catch (error) {
-    console.error(import_chalk26.default.red(`\u274C Plugin import failed: ${error.message}`));
+    console.error(import_chalk27.default.red(`\u274C Plugin import failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -90028,6 +90600,9 @@ files.command("delete <id>").description("Delete a document").option("--yes", "S
 program2.command("search <query>").description("Hybrid search (FTS + semantic + RRF) across accessible content").option("--entity-type <type>", "Restrict to one of: files, folders, workspaces").option("--workspace <id>", "Restrict to one workspace").option("--limit <n>", "Max results (server caps at 100)").action(async (query, options) => {
   await handleSearch(query, withGlobals(options));
 });
+program2.command("mount <target> [dir]").description("Monte un workspace/dossier Hubdoc en local via FUSE (voir docs/mount.md)").option("--all", "Monte tous les workspaces (chacun = un sous-dossier) ; <target> = dossier de montage").option("--folder <id>", "Monte un dossier pr\xE9cis par son id ; <target> = dossier de montage").option("--read-only", "Montage en lecture seule (pas de write-back)").option("--ttl <seconds>", "TTL du cache d\u2019arborescence en secondes (d\xE9faut 30)").option("--verbose", "Logs d\xE9taill\xE9s des op\xE9rations FUSE").action(async (target, dir, options) => {
+  await handleMount(target, dir, withGlobals(options));
+});
 var composed = program2.command("composed-documents").alias("composed").description("Manage composed documents (Markdown/Typst editorial pipeline)");
 composed.command("ls").description("List composed documents").option("--workspace <id>").option("--folder <id>").option("--status <status>").option("--page <n>").option("--per-page <n>").action(async (options) => {
   await handleComposedList(withGlobals(options));