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

@sinoia/hubdoc-tools 1.6.1 → 1.7.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 +1146 -760
package/package.json +1 -1

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 path22 = require("path");
-    var fs18 = require("fs");
+    var path24 = require("path");
+    var fs20 = 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 = path22.resolve(baseDir, baseName);
-          if (fs18.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path22.extname(baseName))) return void 0;
-          const foundExt = sourceExt.find((ext2) => fs18.existsSync(`${localBin}${ext2}`));
+          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}`));
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
         }
@@ -1763,23 +1763,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs20.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path22.resolve(path22.dirname(resolvedScriptPath), executableDir);
+          executableDir = path24.resolve(path24.dirname(resolvedScriptPath), executableDir);
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path22.basename(this._scriptPath, path22.extname(this._scriptPath));
+            const legacyName = path24.basename(this._scriptPath, path24.extname(this._scriptPath));
             if (legacyName !== this._name) {
               localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
             }
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path22.extname(executableFile));
+        launchWithNode = sourceExt.includes(path24.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 = path22.basename(filename, path22.extname(filename));
+        this._name = path24.basename(filename, path24.extname(filename));
         return this;
       }
       /**
@@ -2576,9 +2576,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {string|null|Command}
        */
-      executableDir(path23) {
-        if (path23 === void 0) return this._executableDir;
-        this._executableDir = path23;
+      executableDir(path25) {
+        if (path25 === void 0) return this._executableDir;
+        this._executableDir = path25;
         return this;
       }
       /**
@@ -3638,15 +3638,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path22 = [graph[toModel].parent, toModel];
+      const path24 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path22.unshift(graph[cur].parent);
+        path24.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path22;
+      fn.conversion = path24;
       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 os5 = require("os");
+    var os7 = 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 = os5.release().split(".");
+        const osRelease = os7.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(chalk26, styles) {
+    function buildStyle(chalk27, 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 = chalk26;
+      let current = chalk27;
       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 = (chalk26, temporary) => {
+    module2.exports = (chalk27, 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(chalk26, styles)(string));
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk27, 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(chalk26, styles)(chunk.join("")));
+          chunks.push(buildStyle(chalk27, styles)(chunk.join("")));
           chunk = [];
           styles.pop();
         } else {
@@ -4168,16 +4168,16 @@ var require_source = __commonJS({
       }
     };
     var chalkFactory = (options) => {
-      const chalk27 = {};
-      applyOptions(chalk27, options);
-      chalk27.template = (...arguments_) => chalkTag(chalk27.template, ...arguments_);
-      Object.setPrototypeOf(chalk27, Chalk.prototype);
-      Object.setPrototypeOf(chalk27.template, chalk27);
-      chalk27.template.constructor = () => {
+      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 = () => {
         throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
       };
-      chalk27.template.Instance = ChalkClass;
-      return chalk27.template;
+      chalk28.template.Instance = ChalkClass;
+      return chalk28.template;
     };
     function Chalk(options) {
       return chalkFactory(options);
@@ -4288,7 +4288,7 @@ var require_source = __commonJS({
       return openAll + string + closeAll;
     };
     var template;
-    var chalkTag = (chalk27, ...strings) => {
+    var chalkTag = (chalk28, ...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(chalk27, parts2.join(""));
+      return template(chalk28, parts2.join(""));
     };
     Object.defineProperties(Chalk.prototype, styles);
-    var chalk26 = Chalk();
-    chalk26.supportsColor = stdoutColor;
-    chalk26.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
-    chalk26.stderr.supportsColor = stderrColor;
-    module2.exports = chalk26;
+    var chalk27 = Chalk();
+    chalk27.supportsColor = stdoutColor;
+    chalk27.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk27.stderr.supportsColor = stderrColor;
+    module2.exports = chalk27;
   }
 });
@@ -4369,54 +4369,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs18) {
+    function patch(fs20) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs18);
-      }
-      if (!fs18.lutimes) {
-        patchLutimes(fs18);
-      }
-      fs18.chown = chownFix(fs18.chown);
-      fs18.fchown = chownFix(fs18.fchown);
-      fs18.lchown = chownFix(fs18.lchown);
-      fs18.chmod = chmodFix(fs18.chmod);
-      fs18.fchmod = chmodFix(fs18.fchmod);
-      fs18.lchmod = chmodFix(fs18.lchmod);
-      fs18.chownSync = chownFixSync(fs18.chownSync);
-      fs18.fchownSync = chownFixSync(fs18.fchownSync);
-      fs18.lchownSync = chownFixSync(fs18.lchownSync);
-      fs18.chmodSync = chmodFixSync(fs18.chmodSync);
-      fs18.fchmodSync = chmodFixSync(fs18.fchmodSync);
-      fs18.lchmodSync = chmodFixSync(fs18.lchmodSync);
-      fs18.stat = statFix(fs18.stat);
-      fs18.fstat = statFix(fs18.fstat);
-      fs18.lstat = statFix(fs18.lstat);
-      fs18.statSync = statFixSync(fs18.statSync);
-      fs18.fstatSync = statFixSync(fs18.fstatSync);
-      fs18.lstatSync = statFixSync(fs18.lstatSync);
-      if (fs18.chmod && !fs18.lchmod) {
-        fs18.lchmod = function(path22, mode, cb) {
+        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) {
           if (cb) process.nextTick(cb);
         };
-        fs18.lchmodSync = function() {
+        fs20.lchmodSync = function() {
         };
       }
-      if (fs18.chown && !fs18.lchown) {
-        fs18.lchown = function(path22, uid, gid, cb) {
+      if (fs20.chown && !fs20.lchown) {
+        fs20.lchown = function(path24, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs18.lchownSync = function() {
+        fs20.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs18.rename = typeof fs18.rename !== "function" ? fs18.rename : (function(fs$rename) {
+        fs20.rename = typeof fs20.rename !== "function" ? fs20.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() {
-                  fs18.stat(to, function(stater, st) {
+                  fs20.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;
-        })(fs18.rename);
+        })(fs20.rename);
       }
-      fs18.read = typeof fs18.read !== "function" ? fs18.read : (function(fs$read) {
+      fs20.read = typeof fs20.read !== "function" ? fs20.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(fs18, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs18, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs20, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read3, fs$read);
         return read3;
-      })(fs18.read);
-      fs18.readSync = typeof fs18.readSync !== "function" ? fs18.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs20.read);
+      fs20.readSync = typeof fs20.readSync !== "function" ? fs20.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs18, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs20, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4467,11 +4467,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs18.readSync);
-      function patchLchmod(fs19) {
-        fs19.lchmod = function(path22, mode, callback) {
-          fs19.open(
-            path22,
+      })(fs20.readSync);
+      function patchLchmod(fs21) {
+        fs21.lchmod = function(path24, mode, callback) {
+          fs21.open(
+            path24,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -4479,80 +4479,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs19.fchmod(fd, mode, function(err2) {
-                fs19.close(fd, function(err22) {
+              fs21.fchmod(fd, mode, function(err2) {
+                fs21.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs19.lchmodSync = function(path22, mode) {
-          var fd = fs19.openSync(path22, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs21.lchmodSync = function(path24, mode) {
+          var fd = fs21.openSync(path24, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs19.fchmodSync(fd, mode);
+            ret = fs21.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs19.closeSync(fd);
+                fs21.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs19.closeSync(fd);
+              fs21.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs19) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs19.futimes) {
-          fs19.lutimes = function(path22, at, mt, cb) {
-            fs19.open(path22, constants.O_SYMLINK, function(er, fd) {
+      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) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs19.futimes(fd, at, mt, function(er2) {
-                fs19.close(fd, function(er22) {
+              fs21.futimes(fd, at, mt, function(er2) {
+                fs21.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs19.lutimesSync = function(path22, at, mt) {
-            var fd = fs19.openSync(path22, constants.O_SYMLINK);
+          fs21.lutimesSync = function(path24, at, mt) {
+            var fd = fs21.openSync(path24, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs19.futimesSync(fd, at, mt);
+              ret = fs21.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs19.closeSync(fd);
+                  fs21.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs19.closeSync(fd);
+                fs21.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs19.futimes) {
-          fs19.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs21.futimes) {
+          fs21.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs19.lutimesSync = function() {
+          fs21.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs18, target, mode, function(er) {
+          return orig.call(fs20, 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(fs18, target, mode);
+            return orig.call(fs20, 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(fs18, target, uid, gid, function(er) {
+          return orig.call(fs20, 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(fs18, target, uid, gid);
+            return orig.call(fs20, 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(fs18, target, options, callback) : orig.call(fs18, target, callback);
+          return options ? orig.call(fs20, target, options, callback) : orig.call(fs20, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs18, target, options) : orig.call(fs18, target);
+          var stats = options ? orig.call(fs20, target, options) : orig.call(fs20, 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(fs18) {
+    function legacy(fs20) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path22, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path22, options);
+      function ReadStream(path24, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path24, options);
         Stream2.call(this);
         var self2 = this;
-        this.path = path22;
+        this.path = path24;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -4679,7 +4679,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs18.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs20.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(path22, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path22, options);
+      function WriteStream(path24, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path24, options);
         Stream2.call(this);
-        this.path = path22;
+        this.path = path24;
         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 = fs18.open;
+          this._open = fs20.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 fs18 = require("fs");
+    var fs20 = 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 (!fs18[gracefulQueue]) {
+    if (!fs20[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs18, queue);
-      fs18.close = (function(fs$close) {
+      publishQueue(fs20, queue);
+      fs20.close = (function(fs$close) {
         function close3(fd, cb) {
-          return fs$close.call(fs18, fd, function(err) {
+          return fs$close.call(fs20, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -4802,48 +4802,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close3;
-      })(fs18.close);
-      fs18.closeSync = (function(fs$closeSync) {
+      })(fs20.close);
+      fs20.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs18, arguments);
+          fs$closeSync.apply(fs20, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs18.closeSync);
+      })(fs20.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs18[gracefulQueue]);
-          require("assert").equal(fs18[gracefulQueue].length, 0);
+          debug(fs20[gracefulQueue]);
+          require("assert").equal(fs20[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs18[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs18));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs18.__patched) {
-      module2.exports = patch(fs18);
-      fs18.__patched = true;
-    }
-    function patch(fs19) {
-      polyfills(fs19);
-      fs19.gracefulify = patch;
-      fs19.createReadStream = createReadStream3;
-      fs19.createWriteStream = createWriteStream;
-      var fs$readFile = fs19.readFile;
-      fs19.readFile = readFile;
-      function readFile(path22, options, cb) {
+      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) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path22, options, cb);
-        function go$readFile(path23, options2, cb2, startTime) {
-          return fs$readFile(path23, options2, function(err) {
+        return go$readFile(path24, options, cb);
+        function go$readFile(path25, options2, cb2, startTime) {
+          return fs$readFile(path25, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path23, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path25, 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 = fs19.writeFile;
-      fs19.writeFile = writeFile;
-      function writeFile(path22, data, options, cb) {
+      var fs$writeFile = fs21.writeFile;
+      fs21.writeFile = writeFile;
+      function writeFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path22, data, options, cb);
-        function go$writeFile(path23, data2, options2, cb2, startTime) {
-          return fs$writeFile(path23, data2, options2, function(err) {
+        return go$writeFile(path24, data, options, cb);
+        function go$writeFile(path25, data2, options2, cb2, startTime) {
+          return fs$writeFile(path25, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path23, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path25, 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 = fs19.appendFile;
+      var fs$appendFile = fs21.appendFile;
       if (fs$appendFile)
-        fs19.appendFile = appendFile;
-      function appendFile(path22, data, options, cb) {
+        fs21.appendFile = appendFile;
+      function appendFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path22, data, options, cb);
-        function go$appendFile(path23, data2, options2, cb2, startTime) {
-          return fs$appendFile(path23, data2, options2, function(err) {
+        return go$appendFile(path24, data, options, cb);
+        function go$appendFile(path25, data2, options2, cb2, startTime) {
+          return fs$appendFile(path25, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path23, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path25, 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 = fs19.copyFile;
+      var fs$copyFile = fs21.copyFile;
       if (fs$copyFile)
-        fs19.copyFile = copyFile;
+        fs21.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 = fs19.readdir;
-      fs19.readdir = readdir2;
+      var fs$readdir = fs21.readdir;
+      fs21.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path22, options, cb) {
+      function readdir2(path24, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path23, options2, cb2, startTime) {
-          return fs$readdir(path23, fs$readdirCallback(
-            path23,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path25, options2, cb2, startTime) {
+          return fs$readdir(path25, fs$readdirCallback(
+            path25,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path23, options2, cb2, startTime) {
-          return fs$readdir(path23, options2, fs$readdirCallback(
-            path23,
+        } : function go$readdir2(path25, options2, cb2, startTime) {
+          return fs$readdir(path25, options2, fs$readdirCallback(
+            path25,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path22, options, cb);
-        function fs$readdirCallback(path23, options2, cb2, startTime) {
+        return go$readdir(path24, options, cb);
+        function fs$readdirCallback(path25, options2, cb2, startTime) {
           return function(err, files2) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path23, options2, cb2],
+                [path25, 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(fs19);
+        var legStreams = legacy(fs21);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs19.ReadStream;
+      var fs$ReadStream = fs21.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs19.WriteStream;
+      var fs$WriteStream = fs21.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs19, "ReadStream", {
+      Object.defineProperty(fs21, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -4972,7 +4972,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs19, "WriteStream", {
+      Object.defineProperty(fs21, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -4983,7 +4983,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs19, "FileReadStream", {
+      Object.defineProperty(fs21, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -4994,7 +4994,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs19, "FileWriteStream", {
+      Object.defineProperty(fs21, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5004,7 +5004,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path22, options) {
+      function ReadStream(path24, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -5024,7 +5024,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path22, options) {
+      function WriteStream(path24, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -5042,22 +5042,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream3(path22, options) {
-        return new fs19.ReadStream(path22, options);
+      function createReadStream3(path24, options) {
+        return new fs21.ReadStream(path24, options);
       }
-      function createWriteStream(path22, options) {
-        return new fs19.WriteStream(path22, options);
+      function createWriteStream(path24, options) {
+        return new fs21.WriteStream(path24, options);
       }
-      var fs$open = fs19.open;
-      fs19.open = open3;
-      function open3(path22, flags, mode, cb) {
+      var fs$open = fs21.open;
+      fs21.open = open3;
+      function open3(path24, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path22, flags, mode, cb);
-        function go$open(path23, flags2, mode2, cb2, startTime) {
-          return fs$open(path23, flags2, mode2, function(err, fd) {
+        return go$open(path24, flags, mode, cb);
+        function go$open(path25, flags2, mode2, cb2, startTime) {
+          return fs$open(path25, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path23, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path25, 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 fs19;
+      return fs21;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs18[gracefulQueue].push(elem);
+      fs20[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs18[gracefulQueue].length; ++i) {
-        if (fs18[gracefulQueue][i].length > 2) {
-          fs18[gracefulQueue][i][3] = now;
-          fs18[gracefulQueue][i][4] = 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;
         }
       }
       retry();
@@ -5086,9 +5086,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs18[gracefulQueue].length === 0)
+      if (fs20[gracefulQueue].length === 0)
         return;
-      var elem = fs18[gracefulQueue].shift();
+      var elem = fs20[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 {
-          fs18[gracefulQueue].push(elem);
+          fs20[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 fs18 = require_graceful_fs();
+    var fs20 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -5166,26 +5166,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs18[key] === "function";
+      return typeof fs20[key] === "function";
     });
-    Object.assign(exports2, fs18);
+    Object.assign(exports2, fs20);
     api.forEach((method) => {
-      exports2[method] = u(fs18[method]);
+      exports2[method] = u(fs20[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs18.exists(filename, callback);
+        return fs20.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs18.exists(filename, resolve);
+        return fs20.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs18.read(fd, buffer, offset, length, position, callback);
+        return fs20.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs18.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs20.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 fs18.write(fd, buffer, ...args);
+        return fs20.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs18.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs20.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 fs18.readv(fd, buffers, ...args);
+        return fs20.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs18.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs20.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 fs18.writev(fd, buffers, ...args);
+        return fs20.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs18.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs20.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs18.realpath.native === "function") {
-      exports2.realpath.native = u(fs18.realpath.native);
+    if (typeof fs20.realpath.native === "function") {
+      exports2.realpath.native = u(fs20.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 path22 = require("path");
+    var path24 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path22.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path24.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 fs18 = require_fs();
+    var fs20 = 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 fs18.mkdir(dir, {
+      return fs20.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs18.mkdirSync(dir, {
+      return fs20.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 fs18 = require_fs();
-    function pathExists3(path22) {
-      return fs18.access(path22).then(() => true).catch(() => false);
+    var fs20 = require_fs();
+    function pathExists3(path24) {
+      return fs20.access(path24).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists3),
-      pathExistsSync: fs18.existsSync
+      pathExistsSync: fs20.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 fs18 = require_fs();
+    var fs20 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path22, atime, mtime) {
-      const fd = await fs18.open(path22, "r+");
+    async function utimesMillis(path24, atime, mtime) {
+      const fd = await fs20.open(path24, "r+");
       let closeErr = null;
       try {
-        await fs18.futimes(fd, atime, mtime);
+        await fs20.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs18.close(fd);
+          await fs20.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -5339,10 +5339,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path22, atime, mtime) {
-      const fd = fs18.openSync(path22, "r+");
-      fs18.futimesSync(fd, atime, mtime);
-      return fs18.closeSync(fd);
+    function utimesMillisSync(path24, atime, mtime) {
+      const fd = fs20.openSync(path24, "r+");
+      fs20.futimesSync(fd, atime, mtime);
+      return fs20.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 fs18 = require_fs();
-    var path22 = require("path");
+    var fs20 = require_fs();
+    var path24 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs18.stat(file, { bigint: true }) : (file) => fs18.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs20.stat(file, { bigint: true }) : (file) => fs20.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) => fs18.statSync(file, { bigint: true }) : (file) => fs18.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs20.statSync(file, { bigint: true }) : (file) => fs20.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 = path22.basename(src);
-          const destBaseName = path22.basename(dest);
+          const srcBaseName = path24.basename(src);
+          const destBaseName = path24.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 = path22.basename(src);
-          const destBaseName = path22.basename(dest);
+          const srcBaseName = path24.basename(src);
+          const destBaseName = path24.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 = path22.resolve(path22.dirname(src));
-      const destParent = path22.resolve(path22.dirname(dest));
-      if (destParent === srcParent || destParent === path22.parse(destParent).root) return;
+      const srcParent = path24.resolve(path24.dirname(src));
+      const destParent = path24.resolve(path24.dirname(dest));
+      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs18.stat(destParent, { bigint: true });
+        destStat = await fs20.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 = path22.resolve(path22.dirname(src));
-      const destParent = path22.resolve(path22.dirname(dest));
-      if (destParent === srcParent || destParent === path22.parse(destParent).root) return;
+      const srcParent = path24.resolve(path24.dirname(src));
+      const destParent = path24.resolve(path24.dirname(dest));
+      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs18.statSync(destParent, { bigint: true });
+        destStat = fs20.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 = path22.resolve(src).split(path22.sep).filter((i) => i);
-      const destArr = path22.resolve(dest).split(path22.sep).filter((i) => i);
+      const srcArr = path24.resolve(src).split(path24.sep).filter((i) => i);
+      const destArr = path24.resolve(dest).split(path24.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 fs18 = require_fs();
-    var path22 = require("path");
+    var fs20 = require_fs();
+    var path24 = 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 = path22.dirname(dest);
+      const destParent = path24.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 ? fs18.stat : fs18.lstat;
+      const statFn = opts.dereference ? fs20.stat : fs20.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 fs18.unlink(dest);
+        await fs20.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 fs18.copyFile(src, dest);
+      await fs20.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs18.stat(src);
+        const updatedSrcStat = await fs20.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs18.chmod(dest, srcStat.mode);
+      return fs20.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs18.chmod(dest, srcMode | 128);
+      return fs20.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs18.mkdir(dest);
+        await fs20.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs18.opendir(src), async (item) => {
-        const srcItem = path22.join(src, item.name);
-        const destItem = path22.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs20.opendir(src), async (item) => {
+        const srcItem = path24.join(src, item.name);
+        const destItem = path24.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 fs18.chmod(dest, srcStat.mode);
+        await fs20.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs18.readlink(src);
+      let resolvedSrc = await fs20.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path22.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs18.symlink(resolvedSrc, dest);
+        return fs20.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs18.readlink(dest);
+        resolvedDest = await fs20.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs18.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs20.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path22.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path24.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 fs18.unlink(dest);
-      return fs18.symlink(resolvedSrc, dest);
+      await fs20.unlink(dest);
+      return fs20.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 fs18 = require_graceful_fs();
-    var path22 = require("path");
+    var fs20 = require_graceful_fs();
+    var path24 = 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 = path22.dirname(dest);
-      if (!fs18.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path24.dirname(dest);
+      if (!fs20.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs18.statSync : fs18.lstatSync;
+      const statSync = opts.dereference ? fs20.statSync : fs20.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) {
-        fs18.unlinkSync(dest);
+        fs20.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs18.copyFileSync(src, dest);
+      fs20.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 fs18.chmodSync(dest, srcMode);
+      return fs20.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs18.statSync(src);
+      const updatedSrcStat = fs20.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) {
-      fs18.mkdirSync(dest);
+      fs20.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs18.opendirSync(src);
+      const dir = fs20.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 = path22.join(src, item);
-      const destItem = path22.join(dest, item);
+      const srcItem = path24.join(src, item);
+      const destItem = path24.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 = fs18.readlinkSync(src);
+      let resolvedSrc = fs20.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path22.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs18.symlinkSync(resolvedSrc, dest);
+        return fs20.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs18.readlinkSync(dest);
+          resolvedDest = fs20.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs18.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs20.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path22.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path24.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) {
-      fs18.unlinkSync(dest);
-      return fs18.symlinkSync(resolvedSrc, dest);
+      fs20.unlinkSync(dest);
+      return fs20.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 fs18 = require_graceful_fs();
+    var fs20 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path22, callback) {
-      fs18.rm(path22, { recursive: true, force: true }, callback);
+    function remove(path24, callback) {
+      fs20.rm(path24, { recursive: true, force: true }, callback);
     }
-    function removeSync(path22) {
-      fs18.rmSync(path22, { recursive: true, force: true });
+    function removeSync(path24) {
+      fs20.rmSync(path24, { 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 fs18 = require_fs();
-    var path22 = require("path");
+    var fs20 = require_fs();
+    var path24 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs18.readdir(dir);
+        items = await fs20.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path22.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path24.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs18.readdirSync(dir);
+        items = fs20.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path22.join(dir, item);
+        item = path24.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 path22 = require("path");
-    var fs18 = require_fs();
+    var path24 = require("path");
+    var fs20 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs18.stat(file);
+        stats = await fs20.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path22.dirname(file);
+      const dir = path24.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs18.stat(dir);
+        dirStats = await fs20.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs18.writeFile(file, "");
+          await fs20.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs18.writeFile(file, "");
+        await fs20.writeFile(file, "");
       } else {
-        await fs18.readdir(dir);
+        await fs20.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs18.statSync(file);
+        stats = fs20.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path22.dirname(file);
+      const dir = path24.dirname(file);
       try {
-        if (!fs18.statSync(dir).isDirectory()) {
-          fs18.readdirSync(dir);
+        if (!fs20.statSync(dir).isDirectory()) {
+          fs20.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs18.writeFileSync(file, "");
+      fs20.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 path22 = require("path");
-    var fs18 = require_fs();
+    var path24 = require("path");
+    var fs20 = 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 fs18.lstat(dstpath);
+        dstStat = await fs20.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs18.lstat(srcpath);
+        srcStat = await fs20.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path22.dirname(dstpath);
+      const dir = path24.dirname(dstpath);
       const dirExists = await pathExists3(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs18.link(srcpath, dstpath);
+      await fs20.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs18.lstatSync(dstpath);
+        dstStat = fs20.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs18.lstatSync(srcpath);
+        const srcStat = fs20.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path22.dirname(dstpath);
-      const dirExists = fs18.existsSync(dir);
-      if (dirExists) return fs18.linkSync(srcpath, dstpath);
+      const dir = path24.dirname(dstpath);
+      const dirExists = fs20.existsSync(dir);
+      if (dirExists) return fs20.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs18.linkSync(srcpath, dstpath);
+      return fs20.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 path22 = require("path");
-    var fs18 = require_fs();
+    var path24 = require("path");
+    var fs20 = require_fs();
     var { pathExists: pathExists3 } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path22.isAbsolute(srcpath)) {
+      if (path24.isAbsolute(srcpath)) {
         try {
-          await fs18.lstat(srcpath);
+          await fs20.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 = path22.dirname(dstpath);
-      const relativeToDst = path22.join(dstdir, srcpath);
+      const dstdir = path24.dirname(dstpath);
+      const relativeToDst = path24.join(dstdir, srcpath);
       const exists = await pathExists3(relativeToDst);
       if (exists) {
         return {
@@ -5988,39 +5988,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs18.lstat(srcpath);
+        await fs20.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path22.relative(dstdir, srcpath)
+        toDst: path24.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path22.isAbsolute(srcpath)) {
-        const exists2 = fs18.existsSync(srcpath);
+      if (path24.isAbsolute(srcpath)) {
+        const exists2 = fs20.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path22.dirname(dstpath);
-      const relativeToDst = path22.join(dstdir, srcpath);
-      const exists = fs18.existsSync(relativeToDst);
+      const dstdir = path24.dirname(dstpath);
+      const relativeToDst = path24.join(dstdir, srcpath);
+      const exists = fs20.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs18.existsSync(srcpath);
+      const srcExists = fs20.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path22.relative(dstdir, srcpath)
+        toDst: path24.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 fs18 = require_fs();
+    var fs20 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs18.lstat(srcpath);
+        stats = await fs20.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -6050,7 +6050,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs18.lstatSync(srcpath);
+        stats = fs20.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 path22 = require("path");
-    var fs18 = require_fs();
+    var path24 = require("path");
+    var fs20 = 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 fs18.lstat(dstpath);
+        stats = await fs20.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs18.stat(srcpath),
-          fs18.stat(dstpath)
+          fs20.stat(srcpath),
+          fs20.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 = path22.dirname(dstpath);
+      const dir = path24.dirname(dstpath);
       if (!await pathExists3(dir)) {
         await mkdirs(dir);
       }
-      return fs18.symlink(srcpath, dstpath, toType);
+      return fs20.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs18.lstatSync(dstpath);
+        stats = fs20.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs18.statSync(srcpath);
-        const dstStat = fs18.statSync(dstpath);
+        const srcStat = fs20.statSync(srcpath);
+        const dstStat = fs20.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path22.dirname(dstpath);
-      const exists = fs18.existsSync(dir);
-      if (exists) return fs18.symlinkSync(srcpath, dstpath, type);
+      const dir = path24.dirname(dstpath);
+      const exists = fs20.existsSync(dir);
+      if (exists) return fs20.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs18.symlinkSync(srcpath, dstpath, type);
+      return fs20.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 fs18 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs18.readFile)(file, options);
+      let data = await universalify.fromCallback(fs20.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 fs18 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs18.readFileSync(file, options);
+        let content = fs20.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 fs18 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs18.writeFile)(file, str, options);
+      await universalify.fromCallback(fs20.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync2(file, obj, options = {}) {
-      const fs18 = options.fs || _fs;
+      const fs20 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs18.writeFileSync(file, str, options);
+      return fs20.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 fs18 = require_fs();
-    var path22 = require("path");
+    var fs20 = require_fs();
+    var path24 = require("path");
     var mkdir = require_mkdirs();
     var pathExists3 = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path22.dirname(file);
+      const dir = path24.dirname(file);
       if (!await pathExists3(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs18.writeFile(file, data, encoding);
+      return fs20.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
-      const dir = path22.dirname(file);
-      if (!fs18.existsSync(dir)) {
+      const dir = path24.dirname(file);
+      if (!fs20.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs18.writeFileSync(file, ...args);
+      fs20.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 fs18 = require_fs();
-    var path22 = require("path");
+    var fs20 = require_fs();
+    var path24 = 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 = path22.dirname(dest);
-      const parsedParentPath = path22.parse(destParent);
+      const destParent = path24.dirname(dest);
+      const parsedParentPath = path24.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -6361,7 +6361,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs18.rename(src, dest);
+        await fs20.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 fs18 = require_graceful_fs();
-    var path22 = require("path");
+    var fs20 = require_graceful_fs();
+    var path24 = 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(path22.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path24.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path22.dirname(dest);
-      const parsedPath = path22.parse(parent);
+      const parent = path24.dirname(dest);
+      const parsedPath = path24.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 (fs18.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs20.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs18.renameSync(src, dest);
+        fs20.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 chalk26 = require_source();
+    var chalk27 = require_source();
     var isUnicodeSupported2 = require_is_unicode_supported();
     var main = {
-      info: chalk26.blue("\u2139"),
-      success: chalk26.green("\u2714"),
-      warning: chalk26.yellow("\u26A0"),
-      error: chalk26.red("\u2716")
+      info: chalk27.blue("\u2139"),
+      success: chalk27.green("\u2714"),
+      warning: chalk27.yellow("\u26A0"),
+      error: chalk27.red("\u2716")
     };
     var fallback = {
-      info: chalk26.blue("i"),
-      success: chalk26.green("\u221A"),
-      warning: chalk26.yellow("\u203C"),
-      error: chalk26.red("\xD7")
+      info: chalk27.blue("i"),
+      success: chalk27.green("\u221A"),
+      warning: chalk27.yellow("\u203C"),
+      error: chalk27.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 chalk26 = require_source();
+    var chalk27 = 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 = chalk26[this.color](frame);
+          frame = chalk27[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 fs18 = (0, node_1.default)();
+      const fs20 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs18.closeSync(fd);
+          fs20.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 = fs18.openSync(filepath, "r");
+        fd = fs20.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs18.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs20.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -27609,22 +27609,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs18.readFile(filepath, handler);
+      fs20.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs18 = (0, node_1.default)();
+      const fs20 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs18.openSync(filepath, "r");
+        const fd = fs20.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs18.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs20.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs18.closeSync(fd);
+        fs20.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs18.readFileSync(filepath));
+      return (0, exports2.detect)(fs20.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -40388,11 +40388,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path22) {
-      if (!path22 || typeof path22 !== "string") {
+    function lookup(path24) {
+      if (!path24 || typeof path24 !== "string") {
         return false;
       }
-      var extension2 = extname3("x." + path22).toLowerCase().substr(1);
+      var extension2 = extname3("x." + path24).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -41497,11 +41497,11 @@ var require_form_data = __commonJS({
     "use strict";
     var CombinedStream = require_combined_stream();
     var util3 = require("util");
-    var path22 = require("path");
+    var path24 = require("path");
     var http4 = require("http");
     var https2 = require("https");
     var parseUrl = require("url").parse;
-    var fs18 = require("fs");
+    var fs20 = require("fs");
     var Stream2 = require("stream").Stream;
     var crypto4 = require("crypto");
     var mime = require_mime_types();
@@ -41568,7 +41568,7 @@ var require_form_data = __commonJS({
         if (value2.end != void 0 && value2.end != Infinity && value2.start != void 0) {
           callback(null, value2.end + 1 - (value2.start ? value2.start : 0));
         } else {
-          fs18.stat(value2.path, function(err, stat3) {
+          fs20.stat(value2.path, function(err, stat3) {
             if (err) {
               callback(err);
               return;
@@ -41625,11 +41625,11 @@ var require_form_data = __commonJS({
     FormData5.prototype._getContentDisposition = function(value2, options) {
       var filename;
       if (typeof options.filepath === "string") {
-        filename = path22.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path24.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value2 && (value2.name || value2.path)) {
-        filename = path22.basename(options.filename || value2 && (value2.name || value2.path));
+        filename = path24.basename(options.filename || value2 && (value2.name || value2.path));
       } else if (value2 && value2.readable && hasOwn(value2, "httpVersion")) {
-        filename = path22.basename(value2.client._httpMessage.path || "");
+        filename = path24.basename(value2.client._httpMessage.path || "");
       }
       if (filename) {
         return 'filename="' + filename + '"';
@@ -43115,9 +43115,9 @@ var require_package = __commonJS({
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs18 = require("fs");
-    var path22 = require("path");
-    var os5 = require("os");
+    var fs20 = require("fs");
+    var path24 = require("path");
+    var os7 = require("os");
     var crypto4 = require("crypto");
     var packageJson = require_package();
     var version = packageJson.version;
@@ -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 (fs18.existsSync(filepath)) {
+            if (fs20.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 = path22.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
       }
-      if (fs18.existsSync(possibleVaultPath)) {
+      if (fs20.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path22.join(os5.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path24.join(os7.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 = path22.resolve(process.cwd(), ".env");
+      const dotenvPath = path24.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 path23 of optionPaths) {
+      for (const path25 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs18.readFileSync(path23, { encoding }));
+          const parsed = DotenvModule.parse(fs20.readFileSync(path25, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path23} ${e.message}`);
+            _debug(`Failed to load ${path25} ${e.message}`);
           }
           lastError = e;
         }
@@ -43302,7 +43302,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path22.relative(process.cwd(), filePath);
+            const relative = path24.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -44287,11 +44287,11 @@ var require_file_writer = __commonJS({
     var FileWriter = (
       /** @class */
       (function() {
-        function FileWriter2(path22, append2, encoding) {
+        function FileWriter2(path24, append2, encoding) {
           if (encoding === void 0) {
             encoding = DEFAULT_ENCODING;
           }
-          this.path = path22;
+          this.path = path24;
           this.append = append2;
           this.encoding = encoding;
         }
@@ -44431,13 +44431,13 @@ var require_csv_writer = __commonJS({
     var CsvWriter = (
       /** @class */
       (function() {
-        function CsvWriter2(csvStringifier, path22, encoding, append2) {
+        function CsvWriter2(csvStringifier, path24, encoding, append2) {
           if (append2 === void 0) {
             append2 = DEFAULT_INITIAL_APPEND_FLAG;
           }
           this.csvStringifier = csvStringifier;
           this.append = append2;
-          this.fileWriter = new file_writer_1.FileWriter(path22, this.append, encoding);
+          this.fileWriter = new file_writer_1.FileWriter(path24, 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 path22 = require("path");
-    var fs18 = require("fs");
+    var path24 = require("path");
+    var fs20 = require("fs");
     function createRequire(filename) {
       if (!filename) {
         filename = process.cwd();
       }
       if (isDir(filename)) {
-        filename = path22.join(filename, "index.js");
+        filename = path24.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(path22.dirname(filename));
+      mod.paths = nativeModule.Module._nodeModulePaths(path24.dirname(filename));
       mod._compile("module.exports = require;", filename);
       return mod.exports;
     }
-    function isDir(path23) {
+    function isDir(path25) {
       try {
-        const stat3 = fs18.lstatSync(path23);
+        const stat3 = fs20.lstatSync(path25);
         return stat3.isDirectory();
       } catch (e) {
         return false;
@@ -50750,17 +50750,17 @@ var require_v8_compile_cache = __commonJS({
     "use strict";
     var Module = require("module");
     var crypto4 = require("crypto");
-    var fs18 = require("fs");
-    var path22 = require("path");
+    var fs20 = require("fs");
+    var path24 = require("path");
     var vm = require("vm");
-    var os5 = require("os");
+    var os7 = require("os");
     var hasOwnProperty2 = Object.prototype.hasOwnProperty;
     var FileSystemBlobStore = class {
       constructor(directory, prefix) {
         const name = prefix ? slashEscape(prefix + ".") : "";
-        this._blobFilename = path22.join(directory, name + "BLOB");
-        this._mapFilename = path22.join(directory, name + "MAP");
-        this._lockFilename = path22.join(directory, name + "LOCK");
+        this._blobFilename = path24.join(directory, name + "BLOB");
+        this._mapFilename = path24.join(directory, name + "MAP");
+        this._lockFilename = path24.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);
-          fs18.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
+          fs20.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
         } catch (error) {
           return false;
         }
         try {
-          fs18.writeFileSync(this._blobFilename, blobToStore);
-          fs18.writeFileSync(this._mapFilename, mapToStore);
+          fs20.writeFileSync(this._blobFilename, blobToStore);
+          fs20.writeFileSync(this._mapFilename, mapToStore);
         } finally {
-          fs18.unlinkSync(this._lockFilename);
+          fs20.unlinkSync(this._lockFilename);
         }
         return true;
       }
       _load() {
         try {
-          this._storedBlob = fs18.readFileSync(this._blobFilename);
-          this._storedMap = JSON.parse(fs18.readFileSync(this._mapFilename));
+          this._storedBlob = fs20.readFileSync(this._blobFilename);
+          this._storedMap = JSON.parse(fs20.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 = path22.dirname(filename);
+          const dirname = path24.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);
@@ -50948,18 +50948,18 @@ var require_v8_compile_cache = __commonJS({
       }
     };
     function mkdirpSync(p_) {
-      _mkdirpSync(path22.resolve(p_), 511);
+      _mkdirpSync(path24.resolve(p_), 511);
     }
     function _mkdirpSync(p, mode) {
       try {
-        fs18.mkdirSync(p, mode);
+        fs20.mkdirSync(p, mode);
       } catch (err0) {
         if (err0.code === "ENOENT") {
-          _mkdirpSync(path22.dirname(p));
+          _mkdirpSync(path24.dirname(p));
           _mkdirpSync(p);
         } else {
           try {
-            const stat3 = fs18.statSync(p);
+            const stat3 = fs20.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 = path22.join(os5.tmpdir(), dirname, version);
+      const cacheDir = path24.join(os7.tmpdir(), dirname, version);
       return cacheDir;
     }
     function getMainName() {
@@ -51199,11 +51199,11 @@ var require_ts_internals = __commonJS({
       }
       return { getExtendsConfigPath };
     }
-    function isRootedDiskPath(path22) {
-      return (0, path_1.isAbsolute)(path22);
+    function isRootedDiskPath(path24) {
+      return (0, path_1.isAbsolute)(path24);
     }
-    function combinePaths(path22, ...paths) {
-      return (0, util_1.normalizeSlashes)((0, path_1.resolve)(path22, ...paths.filter((path23) => path23)));
+    function combinePaths(path24, ...paths) {
+      return (0, util_1.normalizeSlashes)((0, path_1.resolve)(path24, ...paths.filter((path25) => path25)));
     }
     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(path22, currentDirectory) {
-      return reducePathComponents(getPathComponents(path22, currentDirectory));
+    function getNormalizedPathComponents(path24, currentDirectory) {
+      return reducePathComponents(getPathComponents(path24, currentDirectory));
     }
-    function getPathComponents(path22, currentDirectory = "") {
-      path22 = combinePaths(currentDirectory, path22);
-      return pathComponents(path22, getRootLength(path22));
+    function getPathComponents(path24, currentDirectory = "") {
+      path24 = combinePaths(currentDirectory, path24);
+      return pathComponents(path24, getRootLength(path24));
     }
     function reducePathComponents(components) {
       if (!some(components))
@@ -51283,64 +51283,64 @@ var require_ts_internals = __commonJS({
       }
       return reduced;
     }
-    function getRootLength(path22) {
-      const rootLength = getEncodedRootLength(path22);
+    function getRootLength(path24) {
+      const rootLength = getEncodedRootLength(path24);
       return rootLength < 0 ? ~rootLength : rootLength;
     }
-    function getEncodedRootLength(path22) {
-      if (!path22)
+    function getEncodedRootLength(path24) {
+      if (!path24)
         return 0;
-      const ch0 = path22.charCodeAt(0);
+      const ch0 = path24.charCodeAt(0);
       if (ch0 === 47 || ch0 === 92) {
-        if (path22.charCodeAt(1) !== ch0)
+        if (path24.charCodeAt(1) !== ch0)
           return 1;
-        const p1 = path22.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+        const p1 = path24.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
         if (p1 < 0)
-          return path22.length;
+          return path24.length;
         return p1 + 1;
       }
-      if (isVolumeCharacter(ch0) && path22.charCodeAt(1) === 58) {
-        const ch2 = path22.charCodeAt(2);
+      if (isVolumeCharacter(ch0) && path24.charCodeAt(1) === 58) {
+        const ch2 = path24.charCodeAt(2);
         if (ch2 === 47 || ch2 === 92)
           return 3;
-        if (path22.length === 2)
+        if (path24.length === 2)
           return 2;
       }
-      const schemeEnd = path22.indexOf(urlSchemeSeparator);
+      const schemeEnd = path24.indexOf(urlSchemeSeparator);
       if (schemeEnd !== -1) {
         const authorityStart = schemeEnd + urlSchemeSeparator.length;
-        const authorityEnd = path22.indexOf(directorySeparator, authorityStart);
+        const authorityEnd = path24.indexOf(directorySeparator, authorityStart);
         if (authorityEnd !== -1) {
-          const scheme = path22.slice(0, schemeEnd);
-          const authority = path22.slice(authorityStart, authorityEnd);
-          if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path22.charCodeAt(authorityEnd + 1))) {
-            const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path22, authorityEnd + 2);
+          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);
             if (volumeSeparatorEnd !== -1) {
-              if (path22.charCodeAt(volumeSeparatorEnd) === 47) {
+              if (path24.charCodeAt(volumeSeparatorEnd) === 47) {
                 return ~(volumeSeparatorEnd + 1);
               }
-              if (volumeSeparatorEnd === path22.length) {
+              if (volumeSeparatorEnd === path24.length) {
                 return ~volumeSeparatorEnd;
               }
             }
           }
           return ~(authorityEnd + 1);
         }
-        return ~path22.length;
+        return ~path24.length;
       }
       return 0;
     }
-    function hasTrailingDirectorySeparator(path22) {
-      return path22.length > 0 && isAnyDirectorySeparator(path22.charCodeAt(path22.length - 1));
+    function hasTrailingDirectorySeparator(path24) {
+      return path24.length > 0 && isAnyDirectorySeparator(path24.charCodeAt(path24.length - 1));
     }
     function isAnyDirectorySeparator(charCode) {
       return charCode === 47 || charCode === 92;
     }
-    function removeTrailingDirectorySeparator(path22) {
-      if (hasTrailingDirectorySeparator(path22)) {
-        return path22.substr(0, path22.length - 1);
+    function removeTrailingDirectorySeparator(path24) {
+      if (hasTrailingDirectorySeparator(path24)) {
+        return path24.substr(0, path24.length - 1);
       }
-      return path22;
+      return path24;
     }
     var directorySeparator = "/";
     var altDirectorySeparator = "\\";
@@ -51373,9 +51373,9 @@ var require_ts_internals = __commonJS({
       }
       return false;
     }
-    function pathComponents(path22, rootLength) {
-      const root = path22.substring(0, rootLength);
-      const rest = path22.substring(rootLength).split(directorySeparator);
+    function pathComponents(path24, rootLength) {
+      const root = path24.substring(0, rootLength);
+      const rest = path24.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((path22) => tsconfigRelativeResolver(path22, false));
+          options.require = options.require.map((path24) => tsconfigRelativeResolver(path24, 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(path22) {
-        const matched = matchPatterns(patternTypePairs, (_2) => _2.pattern, path22);
+      function classifyModuleNonCached(path24) {
+        const matched = matchPatterns(patternTypePairs, (_2) => _2.pattern, path24);
         if (matched)
           return classifications[matched.type];
         return auto;
       }
       const classifyModule = (0, util_1.cachedLookup)(classifyModuleNonCached);
-      function classifyModuleAuto(path22) {
+      function classifyModuleAuto(path24) {
         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 fs18 = require("fs");
+    var fs20 = require("fs");
     var { versionGteLt } = require_util2();
-    function internalModuleReadJSON(path22) {
+    function internalModuleReadJSON(path24) {
       let string;
       try {
-        string = fs18.readFileSync(path22, "utf8");
+        string = fs20.readFileSync(path24, "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(path22) {
-      const stat3 = fs18.statSync(path22, { throwIfNoEntry: false });
+    function internalModuleStat(path24) {
+      const stat3 = fs20.statSync(path24, { throwIfNoEntry: false });
       if (!stat3) return -1;
       if (stat3.isFile()) return 0;
       if (stat3.isDirectory()) return 1;
     }
-    function internalModuleStatInefficient(path22) {
+    function internalModuleStatInefficient(path24) {
       try {
-        const stat3 = fs18.statSync(path22);
+        const stat3 = fs20.statSync(path24);
         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 path22 = require("path");
+    var path24 = 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((path23, base, type = "package") => {
-        return `Cannot find ${type} '${path23}' imported from ${base}`;
+      ERR_MODULE_NOT_FOUND: createErrorCtor((path25, base, type = "package") => {
+        return `Cannot find ${type} '${path25}' 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")),
@@ -52402,11 +52402,11 @@ var require_node_internal_errors = __commonJS({
       return err;
     }
     function getErrRequireEsmMessage(filename, parentPath = null, packageJsonPath = null) {
-      const ext2 = path22.extname(filename);
+      const ext2 = path24.extname(filename);
       let msg = `Must use import to load ES Module: ${filename}`;
       if (parentPath && packageJsonPath) {
-        const path23 = require("path");
-        const basename3 = path23.basename(filename) === path23.basename(parentPath) ? filename : path23.basename(filename);
+        const path25 = require("path");
+        const basename3 = path25.basename(filename) === path25.basename(parentPath) ? filename : path25.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.
@@ -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 fs18 = require("fs");
-    var path22 = require("path");
-    var { sep: sep2 } = path22;
+    var fs20 = require("fs");
+    var path24 = require("path");
+    var { sep: sep2 } = path24;
     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 = path22.toNamespacedPath(filename);
+      filename = path24.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 = path22.resolve(requestPath, "package.json");
+      const jsonPath = path24.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(path22.resolve(requestPath, "index"), exts, isMain);
+          return tryExtensions(path24.resolve(requestPath, "index"), exts, isMain);
         }
-        const filename = path22.resolve(requestPath, pkg);
-        let actual = tryReplacementExtensions(filename, isMain) || tryFile(filename, isMain) || tryExtensions(filename, exts, isMain) || tryExtensions(path22.resolve(filename, "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);
         if (actual === false) {
-          actual = tryExtensions(path22.resolve(requestPath, "index"), exts, isMain);
+          actual = tryExtensions(path24.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 = path22.resolve(requestPath, "package.json");
+            err.path = path24.resolve(requestPath, "package.json");
             err.requestPath = originalPath;
             throw err;
           } else {
-            const jsonPath = path22.resolve(requestPath, "package.json");
+            const jsonPath = path24.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 path22.resolve(requestPath);
+          return path24.resolve(requestPath);
         }
         return toRealPath(requestPath);
       }
       function toRealPath(requestPath) {
-        return fs18.realpathSync(requestPath, {
+        return fs20.realpathSync(requestPath, {
           // [internalFS.realpathCacheKey]: realpathCache
         });
       }
@@ -52635,7 +52635,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
           return parent.filename;
         } else if (parent.id === "<repl>" || parent.id === "internal/preload") {
           try {
-            return process.cwd() + path22.sep;
+            return process.cwd() + path24.sep;
           } catch {
             return false;
           }
@@ -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 = path22.resolve(nmPath, name);
+        const pkgPath = path24.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 = path22.isAbsolute(request);
+        const absoluteRequest = path24.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 = path22.resolve(curPath, request);
+          const _basePath = path24.resolve(curPath, request);
           let filename;
           const [rc, basePath] = statReplacementExtensions(_basePath);
           if (!trailingSlash) {
             if (rc === 0) {
               if (!isMain) {
                 if (preserveSymlinks) {
-                  filename = path22.resolve(basePath);
+                  filename = path24.resolve(basePath);
                 } else {
                   filename = toRealPath(basePath);
                 }
               } else if (preserveSymlinksMain) {
-                filename = path22.resolve(basePath);
+                filename = path24.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 path23 = options.paths[i];
-                fakeParent.paths = Module._nodeModulePaths(path23);
+                const path25 = options.paths[i];
+                fakeParent.paths = Module._nodeModulePaths(path25);
                 const lookupPaths = Module._resolveLookupPaths(request, fakeParent);
                 for (let j = 0; j < lookupPaths.length; j++) {
                   if (!ArrayPrototypeIncludes(paths, lookupPaths[j]))
@@ -52843,15 +52843,15 @@ var require_node_internal_modules_cjs_loader = __commonJS({
           return actual;
         const err = createEsmNotFoundErr(
           filename,
-          path22.resolve(pkgPath, "package.json")
+          path24.resolve(pkgPath, "package.json")
         );
         throw err;
       }
-      function createEsmNotFoundErr(request, path23) {
+      function createEsmNotFoundErr(request, path25) {
         const err = new Error(`Cannot find module '${request}'`);
         err.code = "MODULE_NOT_FOUND";
-        if (path23)
-          err.path = path23;
+        if (path25)
+          err.path = path25;
         return err;
       }
       return {
@@ -52868,7 +52868,7 @@ var require_node_internal_modules_cjs_loader = __commonJS({
       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 ? path22.resolve(pkg.path, "package.json") : null;
+        const packageJsonPath = pkg ? path24.resolve(pkg.path, "package.json") : null;
         throw createErrRequireEsm(filename, parentPath, packageJsonPath);
       }
     }
@@ -59661,10 +59661,10 @@ var require_base = __commonJS({
       }
       return components;
     }
-    function clonePath(path22) {
+    function clonePath(path24) {
       return {
-        newPos: path22.newPos,
-        components: path22.components.slice(0)
+        newPos: path24.newPos,
+        components: path24.components.slice(0)
       };
     }
   }
@@ -61361,8 +61361,8 @@ ${module_1.builtinModules.filter((name) => !name.startsWith("_") && !name.includ
     }
     exports2.createRepl = createRepl;
     var EvalState = class {
-      constructor(path22) {
-        this.path = path22;
+      constructor(path24) {
+        this.path = path24;
         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(path22) {
-        if (path22 === state.path)
+      function readFile(path24) {
+        if (path24 === state.path)
           return state.input;
         if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.readFile)
-          return composeWith.readFile(path22);
+          return composeWith.readFile(path24);
         try {
-          return (0, fs_1.readFileSync)(path22, "utf8");
+          return (0, fs_1.readFileSync)(path24, "utf8");
         } catch (err) {
         }
       }
-      function fileExists(path22) {
-        if (path22 === state.path)
+      function fileExists(path24) {
+        if (path24 === state.path)
           return true;
         if (composeWith === null || composeWith === void 0 ? void 0 : composeWith.fileExists)
-          return composeWith.fileExists(path22);
+          return composeWith.fileExists(path24);
         try {
-          const stats = (0, fs_1.statSync)(path22);
+          const stats = (0, fs_1.statSync)(path24);
           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 path22 = match2[2];
-        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path22) ? path22 : "/" + path22, match2[3] || "", match2[4] || "");
+        const path24 = match2[2];
+        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path24) ? path24 : "/" + path24, match2[3] || "", match2[4] || "");
       }
-      function makeUrl(scheme, user, host, port, path22, query, hash) {
+      function makeUrl(scheme, user, host, port, path24, query, hash) {
         return {
           scheme,
           user,
           host,
           port,
-          path: path22,
+          path: path24,
           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(path22) {
-        if (path22.endsWith("/.."))
-          return path22;
-        const index = path22.lastIndexOf("/");
-        return path22.slice(0, index + 1);
+      function stripPathFilename(path24) {
+        if (path24.endsWith("/.."))
+          return path24;
+        const index = path24.lastIndexOf("/");
+        return path24.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 path22 = "";
+        let path24 = "";
         for (let i = 1; i < pointer; i++) {
-          path22 += "/" + pieces[i];
+          path24 += "/" + pieces[i];
         }
-        if (!path22 || addTrailingSlash && !path22.endsWith("/..")) {
-          path22 += "/";
+        if (!path24 || addTrailingSlash && !path24.endsWith("/..")) {
+          path24 += "/";
         }
-        url2.path = path22;
+        url2.path = path24;
       }
       function resolve(input, base) {
         if (!input && !base)
@@ -62371,13 +62371,13 @@ var require_resolve_uri_umd = __commonJS({
           case 3:
             return queryHash;
           case 4: {
-            const path22 = url2.path.slice(1);
-            if (!path22)
+            const path24 = url2.path.slice(1);
+            if (!path24)
               return queryHash || ".";
-            if (isRelative(base || input) && !isRelative(path22)) {
-              return "./" + path22 + queryHash;
+            if (isRelative(base || input) && !isRelative(path24)) {
+              return "./" + path24 + queryHash;
             }
-            return path22 + queryHash;
+            return path24 + 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(path22) {
-        if (!path22)
+      function stripFilename(path24) {
+        if (!path24)
           return "";
-        const index = path22.lastIndexOf("/");
-        return path22.slice(0, index + 1);
+        const index = path24.lastIndexOf("/");
+        return path24.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 path22 = require("path");
+    var path24 = require("path");
     var { fileURLToPath: fileURLToPath3, pathToFileURL } = require("url");
     var util3 = require("util");
-    var fs18;
+    var fs20;
     try {
-      fs18 = require("fs");
-      if (!fs18.existsSync || !fs18.readFileSync) {
-        fs18 = null;
+      fs20 = require("fs");
+      if (!fs20.existsSync || !fs20.readFileSync) {
+        fs20 = null;
       }
     } catch (err) {
     }
@@ -62960,27 +62960,27 @@ var require_source_map_support = __commonJS({
       };
     }
     var retrieveFile = handlerExec(sharedData.retrieveFileHandlers, sharedData.internalRetrieveFileHandlers);
-    sharedData.internalRetrieveFileHandlers.push(function(path23) {
-      path23 = path23.trim();
-      if (/^file:/.test(path23)) {
-        path23 = path23.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    sharedData.internalRetrieveFileHandlers.push(function(path25) {
+      path25 = path25.trim();
+      if (/^file:/.test(path25)) {
+        path25 = path25.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : (
             // file:///C:/dir/file -> C:/dir/file
             "/"
           );
         });
       }
-      const key = getCacheKey(path23);
+      const key = getCacheKey(path25);
       if (hasFileContentsCacheFromKey(key)) {
         return getFileContentsCacheFromKey(key);
       }
       var contents = "";
       try {
-        if (!fs18) {
+        if (!fs20) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
-            path23,
+            path25,
             /** async */
             false
           );
@@ -62988,12 +62988,12 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs18.existsSync(path23)) {
-          contents = fs18.readFileSync(path23, "utf8");
+        } else if (fs20.existsSync(path25)) {
+          contents = fs20.readFileSync(path25, "utf8");
         }
       } catch (er) {
       }
-      return setFileContentsCache(path23, contents);
+      return setFileContentsCache(path25, 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 (path22.isAbsolute(url2)) {
+          if (path24.isAbsolute(url2)) {
             return new URL(pathToFileURL(url2), file).toString();
           }
           return new URL(url2.replace(/\\/g, "/"), file).toString();
         }
-        if (path22.isAbsolute(file)) {
+        if (path24.isAbsolute(file)) {
           if (isFileUrl(url2)) {
             return fileURLToPath3(url2);
           }
@@ -63017,15 +63017,15 @@ var require_source_map_support = __commonJS({
           if (isAbsoluteUrl(url2)) {
             return url2;
           }
-          if (path22.isAbsolute(url2)) {
-            return path22.normalize(url2);
+          if (path24.isAbsolute(url2)) {
+            return path24.normalize(url2);
           }
-          return path22.join(file, "..", decodeURI(url2));
+          return path24.join(file, "..", decodeURI(url2));
         }
         if (isAbsoluteUrl(url2) || isSchemeRelativeUrl(url2)) {
           return url2;
         }
-        return path22.join(file, "..", url2);
+        return path24.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 (path22.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
-        } else if (path22.isAbsolute(matchStyleOf)) {
+          if (path24.isAbsolute(pathOrUrl)) return pathToFileURL(pathOrUrl).toString();
+        } else if (path24.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 {
-      path22.resolve(123);
+      path24.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 && fs18 && fs18.existsSync(sourceAsPath)) {
+        if (!contents && fs20 && fs20.existsSync(sourceAsPath)) {
           try {
-            contents = fs18.readFileSync(sourceAsPath, "utf8");
+            contents = fs20.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(path22) {
-        const stats = statSync(path22, { throwIfNoEntry: false });
+      function tryStatSyncWithoutErrors(path24) {
+        const stats = statSync(path24, { throwIfNoEntry: false });
         if (stats != null) return stats;
         return statsIfNotFound;
       }
-      function tryStatSyncWithErrors(path22) {
+      function tryStatSyncWithErrors(path24) {
         try {
-          return statSync(path22);
+          return statSync(path24);
         } catch {
           return statsIfNotFound;
         }
       }
-      function getPackageConfig(path22, specifier, base) {
-        const existing = packageJSONCache.get(path22);
+      function getPackageConfig(path24, specifier, base) {
+        const existing = packageJSONCache.get(path24);
         if (existing !== void 0) {
           return existing;
         }
-        const source = packageJsonReader.read(path22).string;
+        const source = packageJsonReader.read(path24).string;
         if (source === void 0) {
           const packageConfig2 = {
-            pjsonPath: path22,
+            pjsonPath: path24,
             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(path22, packageConfig2);
+          packageJSONCache.set(path24, 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(
-            path22,
+            path24,
             (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: path22,
+          pjsonPath: path24,
           exists: true,
           main,
           name,
@@ -63685,7 +63685,7 @@ Update this package.json to use a subpath pattern like "${match2}*".`,
           exports: exports3,
           imports
         };
-        packageJSONCache.set(path22, packageConfig);
+        packageJSONCache.set(path24, 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 path23 = fileURLToPath3(resolved);
+          const path25 = fileURLToPath3(resolved);
           let file2 = resolveExtensionsWithTryExactName(resolved);
           if (file2 !== void 0) return file2;
-          if (!StringPrototypeEndsWith(path23, "/")) {
+          if (!StringPrototypeEndsWith(path25, "/")) {
             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 path22 = fileURLToPath3(file);
-        const stats = tryStatSync(StringPrototypeEndsWith(path22, "/") ? StringPrototypeSlice(path22, -1) : path22);
+        const path24 = fileURLToPath3(file);
+        const stats = tryStatSync(StringPrototypeEndsWith(path24, "/") ? StringPrototypeSlice(path24, -1) : path24);
         if (stats.isDirectory()) {
-          const err = new ERR_UNSUPPORTED_DIR_IMPORT(path22, fileURLToPath3(base));
+          const err = new ERR_UNSUPPORTED_DIR_IMPORT(path24, fileURLToPath3(base));
           err.url = String(resolved);
           throw err;
         } else if (!stats.isFile()) {
           throw new ERR_MODULE_NOT_FOUND(
-            path22 || resolved.pathname,
+            path24 || resolved.pathname,
             fileURLToPath3(base),
             "module"
           );
@@ -64872,15 +64872,15 @@ ${diagnosticText}`);
           environment: "node",
           retrieveFile(pathOrUrl) {
             var _a3;
-            let path22 = pathOrUrl;
-            if (experimentalEsmLoader && path22.startsWith("file://")) {
+            let path24 = pathOrUrl;
+            if (experimentalEsmLoader && path24.startsWith("file://")) {
               try {
-                path22 = (0, url_1.fileURLToPath)(path22);
+                path24 = (0, url_1.fileURLToPath)(path24);
               } catch (e) {
               }
             }
-            path22 = (0, util_1.normalizeSlashes)(path22);
-            return ((_a3 = outputCache.get(path22)) === null || _a3 === void 0 ? void 0 : _a3.content) || "";
+            path24 = (0, util_1.normalizeSlashes)(path24);
+            return ((_a3 = outputCache.get(path24)) === 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(path22) {
-        const lastDotIndex = path22.lastIndexOf(".");
+      function getEmitExtension(path24) {
+        const lastDotIndex = path24.lastIndexOf(".");
         if (lastDotIndex >= 0) {
-          const ext2 = path22.slice(lastDotIndex);
+          const ext2 = path24.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, (path22, file, writeByteOrderMark) => {
-              if (path22.endsWith(".map")) {
+            const result = builderProgram.emit(sourceFile, (path24, file, writeByteOrderMark) => {
+              if (path24.endsWith(".map")) {
                 outMap = file;
               } else {
                 outText = file;
               }
               if (options.emit)
-                sys.writeFile(path22, file, writeByteOrderMark);
+                sys.writeFile(path24, 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 path22 = (0, util_1.normalizeSlashes)(relname);
-        return ignore.some((x) => x.test(path22));
+        const path24 = (0, util_1.normalizeSlashes)(relname);
+        return ignore.some((x) => x.test(path24));
       };
     }
     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 os5 = require("os");
+    var os7 = 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 = os5.release().split(".");
+        var osRelease = os7.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_chalk25 = __toESM(require_source());
-var import_path17 = __toESM(require("path"));
-var import_fs_extra15 = __toESM(require_lib());
+var import_chalk26 = __toESM(require_source());
+var import_path19 = __toESM(require("path"));
+var import_fs_extra17 = __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, path22 = "", value2) => {
+  set: (obj, path24 = "", value2) => {
     let pointer = obj;
-    path22.split(".").forEach((key, index, arr) => {
+    path24.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, path22 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path22, regexp).filter(Boolean).reduce(
+  get: (obj, path24 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path24, 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(path22, key, dots) {
-  if (!path22) return key;
-  return path22.concat(key).map(function each(token2, i) {
+function renderKey(path24, key, dots) {
+  if (!path24) return key;
+  return path24.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, path22) {
+  function defaultVisitor(value2, key, path24) {
     let arr = value2;
-    if (value2 && !path22 && typeof value2 === "object") {
+    if (value2 && !path24 && 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(path22, key, dots), convertValue(value2));
+    formData.append(renderKey(path24, key, dots), convertValue(value2));
     return false;
   }
   const stack = [];
@@ -70452,10 +70452,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value2, path22) {
+  function build(value2, path24) {
     if (utils_default.isUndefined(value2)) return;
     if (stack.indexOf(value2) !== -1) {
-      throw Error("Circular reference detected in " + path22.join("."));
+      throw Error("Circular reference detected in " + path24.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,
-        path22,
+        path24,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path22 ? path22.concat(key) : [key]);
+        build(el, path24 ? path24.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, path22, helpers) {
+    visitor: function(value2, key, path24, 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(path22, value2, target, index) {
-    let name = path22[index++];
+  function buildPath(path24, value2, target, index) {
+    let name = path24[index++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path22.length;
+    const isLast = index >= path24.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(path22, value2, target[name], index);
+    const result = buildPath(path24, 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 path22;
+    let path24;
     try {
-      path22 = buildURL(
+      path24 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -72068,7 +72068,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path: path22,
+      path: path24,
       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, path22, domain, secure, sameSite) {
+    write(name, value2, expires, path24, 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(path22)) {
-        cookie.push(`path=${path22}`);
+      if (utils_default.isString(path24)) {
+        cookie.push(`path=${path24}`);
       }
       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(path22) {
-    if (!path22) {
+  resolve(path24) {
+    if (!path24) {
       return this;
     }
-    const rootPath = this.getRootString(path22);
-    const dir = path22.substring(rootPath.length);
+    const rootPath = this.getRootString(path24);
+    const dir = path24.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(path22) {
-    return import_node_path2.win32.parse(path22).root;
+  getRootString(path24) {
+    return import_node_path2.win32.parse(path24).root;
   }
   /**
    * @internal
@@ -82797,8 +82797,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path22) {
-    return path22.startsWith("/") ? "/" : "";
+  getRootString(path24) {
+    return path24.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -82847,8 +82847,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs18 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs18);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs20 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs20);
     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(path22 = this.cwd) {
-    if (typeof path22 === "string") {
-      path22 = this.cwd.resolve(path22);
+  depth(path24 = this.cwd) {
+    if (typeof path24 === "string") {
+      path24 = this.cwd.resolve(path24);
     }
-    return path22.depth();
+    return path24.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -83378,9 +83378,9 @@ var PathScurryBase = class {
     process3();
     return results;
   }
-  chdir(path22 = this.cwd) {
+  chdir(path24 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path22 === "string" ? this.cwd.resolve(path22) : path22;
+    this.cwd = typeof path24 === "string" ? this.cwd.resolve(path24) : path24;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -83406,8 +83406,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs18) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
+  newRoot(fs20) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -83435,8 +83435,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs18) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
+  newRoot(fs20) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs20 });
   }
   /**
    * 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(([path22, n]) => [
-      path22,
+    return [...this.store.entries()].map(([path24, n]) => [
+      path24,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -83942,9 +83942,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path22, opts) {
+  constructor(patterns, path24, opts) {
     this.patterns = patterns;
-    this.path = path22;
+    this.path = path24;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -83963,11 +83963,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path22) {
-    return this.seen.has(path22) || !!this.#ignore?.ignored?.(path22);
+  #ignored(path24) {
+    return this.seen.has(path24) || !!this.#ignore?.ignored?.(path24);
   }
-  #childrenIgnored(path22) {
-    return !!this.#ignore?.childrenIgnored?.(path22);
+  #childrenIgnored(path24) {
+    return !!this.#ignore?.childrenIgnored?.(path24);
   }
   // backpressure mechanism
   pause() {
@@ -84182,8 +84182,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path22, opts) {
-    super(patterns, path22, opts);
+  constructor(patterns, path24, opts) {
+    super(patterns, path24, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -84220,8 +84220,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path22, opts) {
-    super(patterns, path22, opts);
+  constructor(patterns, path24, opts) {
+    super(patterns, path24, 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, path22, value2) {
-    const keys = path22.split(".");
+  setNestedValue(obj, path24, value2) {
+    const keys = path24.split(".");
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
       const key = keys[i];
@@ -85995,8 +85995,8 @@ var CsvManager2 = class {
   /**
    * Set nested value in object using dot notation (e.g., "parent.child.key")
    */
-  setNestedValue(obj, path22, value2) {
-    const keys = path22.split(".");
+  setNestedValue(obj, path24, value2) {
+    const keys = path24.split(".");
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
       const key = keys[i];
@@ -87141,7 +87141,10 @@ async function handlePluginImport(mappingFile, options) {
 }
 // apps/cli/cli/handlers/auth-handlers.ts
-var import_os3 = __toESM(require("os"));
+var import_os4 = __toESM(require("os"));
+var import_path15 = __toESM(require("path"));
+var import_fs_extra13 = __toESM(require_lib());
+var import_chalk24 = __toESM(require_source());
 var import_child_process4 = require("child_process");
 // apps/cli/cli/output/index.ts
@@ -87180,8 +87183,8 @@ function truncate(value2, max) {
   if (!max || value2.length <= max) return value2;
   return value2.slice(0, max - 1) + "\u2026";
 }
-function get(obj, path22) {
-  return path22.split(".").reduce((acc, k) => acc == null ? acc : acc[k], obj);
+function get(obj, path24) {
+  return path24.split(".").reduce((acc, k) => acc == null ? acc : acc[k], obj);
 }
 function printTable(rows, columns) {
   if (!rows || rows.length === 0) {
@@ -87422,6 +87425,110 @@ async function buildApiContext(out) {
   };
 }
+// apps/cli/services/device-auth-service.ts
+var import_os3 = __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));
+var DeviceAuthService = class {
+  constructor(apiUrl, version = "cli") {
+    const base = apiUrl.startsWith("http") ? apiUrl : `https://${apiUrl}`;
+    this.client = axios_default.create({
+      baseURL: base.replace(/\/$/, ""),
+      headers: {
+        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()})`
+      }
+    });
+  }
+  /** POST /api/v1/cli/auth/device — open a new device authorization session. */
+  async start() {
+    try {
+      const res = await this.client.post(DEVICE_START_PATH);
+      return res.data;
+    } catch (err) {
+      if (err?.response) {
+        const data = err.response.data || {};
+        throw new Error(
+          `Failed to start device flow: ${data.error || err.response.status} ${data.error_description || ""}`.trim()
+        );
+      }
+      throw new Error(`Failed to start device flow: ${err.message}`);
+    }
+  }
+  /** POST /api/v1/cli/auth/device/poll — one poll attempt, mapped to a PollResult. */
+  async pollOnce(deviceCode) {
+    try {
+      const res = await this.client.post(DEVICE_POLL_PATH, {
+        device_code: deviceCode
+      });
+      return { status: "ok", token: res.data };
+    } catch (err) {
+      const data = err?.response?.data;
+      const code = data?.error;
+      switch (code) {
+        case "authorization_pending":
+          return { status: "pending" };
+        case "slow_down":
+          return { status: "slow_down" };
+        case "access_denied":
+          return { status: "denied", error: code };
+        case "expired_token":
+          return { status: "expired", error: code };
+        case "already_consumed":
+          return { status: "consumed", error: code };
+        default:
+          if (err?.response) {
+            throw new Error(
+              `Device poll failed: ${code || err.response.status} ${data?.error_description || ""}`.trim()
+            );
+          }
+          throw new Error(`Device poll failed: ${err.message}`);
+      }
+    }
+  }
+  /**
+   * Poll until the user approves, the code expires, or the timeout is hit.
+   * Honors `slow_down` by widening the interval (RFC 8628 §3.5).
+   */
+  async pollUntilDone(deviceCode, opts) {
+    const sleep = opts.sleep || defaultSleep;
+    let intervalMs = Math.max(1, opts.interval) * 1e3;
+    const caps = [Date.now() + opts.expiresIn * 1e3];
+    if (opts.timeoutMs != null) caps.push(Date.now() + opts.timeoutMs);
+    const deadline = Math.min(...caps);
+    for (; ; ) {
+      const result = await this.pollOnce(deviceCode);
+      switch (result.status) {
+        case "ok":
+          return result.token;
+        case "pending":
+          break;
+        case "slow_down":
+          intervalMs += 5e3;
+          break;
+        case "denied":
+          throw new Error("Device authorization was denied or revoked.");
+        case "expired":
+          throw new Error("Device code expired. Run `hubdoc login --start` again.");
+        case "consumed":
+          throw new Error(
+            "This device code was already used. Run `hubdoc login --start` again."
+          );
+      }
+      opts.onTick?.();
+      if (Date.now() + intervalMs >= deadline) {
+        throw new Error(
+          "Timed out waiting for device approval. Run `hubdoc login --start` again."
+        );
+      }
+      await sleep(intervalMs);
+    }
+  }
+};
 // apps/cli/cli/handlers/auth-handlers.ts
 function decodeJwtPayload(token2) {
   const parts2 = token2.split(".");
@@ -87479,7 +87586,7 @@ async function handleTokenSet(token2, opts) {
     out.fail(new Error("Token cannot be empty"));
   }
   const trimmed = token2.trim();
-  const configManager = new ConfigManager(import_os3.default.homedir());
+  const configManager = new ConfigManager(import_os4.default.homedir());
   const existing = await configManager.loadConfig() || {};
   const apiUrl = opts.apiUrl || existing.apiUrl || process.env.HUBDOC_API_URL || "http://localhost:3000";
   if (opts.keychain) {
@@ -87519,6 +87626,134 @@ 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");
+async function resolveApiUrl(opts) {
+  if (opts.apiUrl) return opts.apiUrl;
+  const config = await new ConfigManager(import_os4.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 existing = await configManager.loadConfig() || {};
+  const next = {
+    ...existing,
+    apiUrl,
+    token: token2.access_token,
+    tokenType: token2.token_type || "Bearer",
+    tokenExpiresIn: token2.expires_in,
+    tokenGenerated: (/* @__PURE__ */ new Date()).toISOString(),
+    // Device flow yields a long-lived PAT — no refresh token to keep.
+    refreshToken: void 0
+  };
+  await configManager.saveConfig(next);
+}
+function parseTimeoutMs(timeout) {
+  if (!timeout) return void 0;
+  const seconds = Number(timeout);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : void 0;
+}
+async function handleLogin(opts) {
+  const out = output(opts);
+  if (opts.poll) {
+    await handleLoginPoll(out, opts);
+    return;
+  }
+  const apiUrl = await resolveApiUrl(opts);
+  if (!apiUrl) {
+    out.fail(new Error("No API URL configured. Pass --api-url=... or set HUBDOC_API_URL."));
+  }
+  const service = new DeviceAuthService(apiUrl);
+  let start;
+  try {
+    start = await service.start();
+  } catch (err) {
+    out.fail(err);
+  }
+  if (opts.start) {
+    const pending = {
+      apiUrl,
+      deviceCode: start.device_code,
+      userCode: start.user_code,
+      expiresAt: new Date(Date.now() + start.expires_in * 1e3).toISOString(),
+      interval: start.interval
+    };
+    await import_fs_extra13.default.outputJson(DEVICE_SESSION_FILE, pending, { spaces: 2 });
+    out.ok(
+      "Device authorization started. Approve it in a browser, then run `hubdoc login --poll`.",
+      {
+        user_code: start.user_code,
+        verification_uri_complete: start.verification_uri_complete,
+        verification_uri: start.verification_uri,
+        expires_in: start.expires_in,
+        interval: start.interval
+      }
+    );
+    return;
+  }
+  printActivationPrompt(out, opts, start.user_code, start.verification_uri_complete);
+  try {
+    const token2 = await service.pollUntilDone(start.device_code, {
+      interval: start.interval,
+      expiresIn: start.expires_in,
+      timeoutMs: parseTimeoutMs(opts.timeout)
+    });
+    await persistDeviceToken(apiUrl, token2);
+    out.ok("Logged in to HubDoc.", {
+      apiUrl,
+      user: token2.user,
+      tokenExpiresIn: token2.expires_in,
+      storage: "config"
+    });
+  } catch (err) {
+    out.fail(err);
+  }
+}
+async function handleLoginPoll(out, opts) {
+  let pending;
+  try {
+    pending = await import_fs_extra13.default.readJson(DEVICE_SESSION_FILE);
+  } catch {
+    out.fail(new Error("No pending device session. Run `hubdoc login --start` first."));
+  }
+  const remainingMs = new Date(pending.expiresAt).getTime() - Date.now();
+  if (remainingMs <= 0) {
+    await import_fs_extra13.default.remove(DEVICE_SESSION_FILE).catch(() => void 0);
+    out.fail(new Error("Device session expired. Run `hubdoc login --start` again."));
+  }
+  const service = new DeviceAuthService(pending.apiUrl);
+  try {
+    const token2 = await service.pollUntilDone(pending.deviceCode, {
+      interval: pending.interval || 5,
+      expiresIn: Math.ceil(remainingMs / 1e3),
+      timeoutMs: parseTimeoutMs(opts.timeout)
+    });
+    await persistDeviceToken(pending.apiUrl, token2);
+    await import_fs_extra13.default.remove(DEVICE_SESSION_FILE).catch(() => void 0);
+    out.ok("Logged in to HubDoc.", {
+      apiUrl: pending.apiUrl,
+      user: token2.user,
+      tokenExpiresIn: token2.expires_in,
+      storage: "config"
+    });
+  } catch (err) {
+    out.fail(err);
+  }
+}
+function printActivationPrompt(out, opts, userCode, verificationUri) {
+  if (opts.json) {
+    process.stderr.write(
+      `Open ${verificationUri} and confirm the code ${userCode}
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    "\n" + import_chalk24.default.bold("To sign in to HubDoc:\n") + `  1. Open ${import_chalk24.default.cyan(verificationUri)}
+  2. Confirm the code ${import_chalk24.default.bold.yellow(userCode)}
+` + import_chalk24.default.gray("Waiting for approval... (Ctrl+C to abort)\n")
+  );
+}
 function platformOpenCommand(url2) {
   if (process.platform === "darwin") return `open "${url2}"`;
   if (process.platform === "win32") return `start "" "${url2}"`;
@@ -87528,7 +87763,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_os3.default.homedir());
+    const configManager = new ConfigManager(import_os4.default.homedir());
     const config = await configManager.loadConfig();
     apiUrl = config?.apiUrl;
   }
@@ -87547,6 +87782,147 @@ async function handleTokenOpen(opts) {
   out.ok(`Opened ${url2}`, { url: url2 });
 }
+// apps/cli/cli/handlers/skill-handlers.ts
+var import_os5 = __toESM(require("os"));
+var import_path16 = __toESM(require("path"));
+var import_fs_extra14 = __toESM(require_lib());
+// apps/cli/cli/skills/hubdoc-auth-skill.ts
+var HUBDOC_AUTH_SKILL_NAME = "hubdoc-auth";
+var HUBDOC_AUTH_SKILL_FILENAME = "SKILL.md";
+var HUBDOC_AUTH_SKILL_CONTENT = `---
+name: hubdoc-auth
+description: >-
+  Authenticate the HubDoc CLI (\`hubdoc\`) from a shell with no browser \u2014 e.g. an
+  AI agent behind a chatbot. Use when the user wants to log in / sign in to
+  HubDoc, when a \`hubdoc\` command fails with "No API token configured" or a 401,
+  or when a token has expired. Drives the OAuth 2.0 Device Authorization Grant:
+  relay a short code + URL to the user, then poll until they approve.
+---
+# HubDoc headless login (device flow)
+The \`hubdoc\` CLI talks to a HubDoc instance using a bearer token stored in
+\`~/.hubdoc-config.json\`. On a machine with no browser you cannot run the normal
+OAuth redirect flow, so use the **device authorization grant**: the CLI shows a
+short code and a URL, the human approves it from any already-logged-in browser
+(phone, laptop, \u2026), and the CLI picks up a Personal Access Token.
+## When to use
+- The user asks to "log in", "sign in", "connect" to HubDoc.
+- A \`hubdoc\` command returns \`No API token configured\`, \`401\`, or \`403\`.
+- The stored token has expired (device-flow PATs last ~30 days).
+## Prerequisites
+- The \`hubdoc\` CLI is on \`PATH\` (verify with \`hubdoc --version\`).
+- The target instance is known via \`HUBDOC_API_URL\` **or** passed as
+  \`--api-url https://<instance>\`. If neither is set, ask the user which HubDoc
+  instance to connect to before starting.
+## Procedure (two phases \u2014 do not skip the relay step)
+1. **Start the session** and capture the code:
+   \`\`\`bash
+   hubdoc login --start --json
+   \`\`\`
+   This prints a JSON object like:
+   \`\`\`json
+   {
+     "ok": true,
+     "data": {
+       "user_code": "WDJB-MJHT",
+       "verification_uri_complete": "https://<instance>/cli/activation/new?code=WDJB-MJHT",
+       "verification_uri": "https://<instance>/cli/activation/new",
+       "expires_in": 600,
+       "interval": 5
+     }
+   }
+   \`\`\`
+2. **Relay to the user.** Show them the \`verification_uri_complete\` link and the
+   \`user_code\`, and ask them to open it in a browser where they are logged in to
+   HubDoc and confirm the code. Example message:
+   > Open **https://<instance>/cli/activation/new?code=WDJB-MJHT** in your
+   > browser and confirm the code **WDJB-MJHT** to finish signing in.
+3. **Poll until approved.** This blocks until the user confirms (or the code
+   expires, ~10 min):
+   \`\`\`bash
+   hubdoc login --poll --json
+   \`\`\`
+   On success it prints \`{ "ok": true, ... }\` and the token is saved to
+   \`~/.hubdoc-config.json\`. If it reports the session expired or was denied,
+   start over at step 1.
+4. **Verify** the session works:
+   \`\`\`bash
+   hubdoc whoami --json
+   \`\`\`
+## One-shot variant (interactive humans only)
+\`hubdoc login\` (no flag) prints the code and blocks until approval in a single
+command. Prefer the two-phase \`--start\` / \`--poll\` flow when acting as an agent
+so you can relay the code before blocking.
+## Notes
+- The token is a long-lived Personal Access Token named \`hubdoc-cli (<os>)\`,
+  visible and revocable at \`https://<instance>/profile/personal-access-tokens\`.
+- There is no refresh token: when it expires, just run the flow again.
+- After authenticating, use the CLI normally \u2014 \`hubdoc --help\` lists commands
+  (\`hubdoc workspaces ls\`, \`hubdoc files ...\`, \`hubdoc import ...\`, etc.). Add
+  \`--json\` to any command for machine-readable output.
+`;
+// apps/cli/cli/handlers/skill-handlers.ts
+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");
+}
+async function handleSkillInstall(opts) {
+  const out = output(opts);
+  const skillsDir = resolveSkillsDir(opts);
+  const skillDir = import_path16.default.join(skillsDir, HUBDOC_AUTH_SKILL_NAME);
+  const target = import_path16.default.join(skillDir, HUBDOC_AUTH_SKILL_FILENAME);
+  if (await import_fs_extra14.default.pathExists(target) && !opts.force) {
+    out.fail(
+      new Error(
+        `Skill already installed at ${target}. Re-run with --force to overwrite.`
+      )
+    );
+  }
+  try {
+    await import_fs_extra14.default.outputFile(target, HUBDOC_AUTH_SKILL_CONTENT);
+  } catch (err) {
+    out.fail(new Error(`Failed to write skill: ${err.message}`));
+  }
+  out.ok(`Installed the ${HUBDOC_AUTH_SKILL_NAME} skill`, {
+    skill: HUBDOC_AUTH_SKILL_NAME,
+    path: target,
+    scope: opts.path ? "custom" : opts.project ? "project" : "user",
+    hint: 'Restart Claude Code (or reload skills) to pick it up, then ask it to "log in to HubDoc".'
+  });
+}
+async function handleSkillShow(opts) {
+  const out = output(opts);
+  if (opts.json) {
+    out.show({ skill: HUBDOC_AUTH_SKILL_NAME, content: HUBDOC_AUTH_SKILL_CONTENT });
+    return;
+  }
+  process.stdout.write(HUBDOC_AUTH_SKILL_CONTENT);
+}
 // apps/cli/cli/handlers/workspace-handlers.ts
 var WORKSPACE_COLUMNS = [
   { header: "ID", key: "id" },
@@ -87797,15 +88173,15 @@ async function handleFoldersDelete(id, opts) {
 }
 // apps/cli/cli/handlers/file-handlers.ts
-var import_fs_extra13 = __toESM(require_lib());
-var import_path15 = __toESM(require("path"));
+var import_fs_extra15 = __toESM(require_lib());
+var import_path17 = __toESM(require("path"));
 var import_form_data3 = __toESM(require_form_data());
 // apps/cli/services/chunked-uploader.ts
-var import_chalk24 = __toESM(require_source());
+var import_chalk25 = __toESM(require_source());
 var crypto3 = __toESM(require("crypto"));
-var fs14 = __toESM(require_lib());
-var path18 = __toESM(require("path"));
+var fs16 = __toESM(require_lib());
+var path20 = __toESM(require("path"));
 // apps/cli/api/base.ts
 var BASE_PATH2 = "http://localhost:3000".replace(/\/+$/, "");
@@ -88204,14 +88580,14 @@ var ChunkedUploader2 = class _ChunkedUploader {
   async uploadFile(options) {
     const { filePath, workspaceId, folderId, metadata, chunkSize, onProgress } = options;
     try {
-      if (!await fs14.pathExists(filePath)) {
+      if (!await fs16.pathExists(filePath)) {
         throw new Error(`File not found: ${filePath}`);
       }
-      const stats = await fs14.stat(filePath);
+      const stats = await fs16.stat(filePath);
       const fileSize = stats.size;
-      const filename = path18.basename(filePath);
+      const filename = path20.basename(filePath);
       const contentType = this.getContentType(filePath);
-      console.log(import_chalk24.default.blue(`\u{1F4E6} Preparing chunked upload for ${filename} (${this.formatBytes(fileSize)})`));
+      console.log(import_chalk25.default.blue(`\u{1F4E6} Preparing chunked upload for ${filename} (${this.formatBytes(fileSize)})`));
       const session = await this.initializeSession(
         filename,
         fileSize,
@@ -88221,7 +88597,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
         folderId,
         metadata
       );
-      console.log(import_chalk24.default.cyan(`   Session created: ${session.upload_id} (${session.total_chunks} chunks)`));
+      console.log(import_chalk25.default.cyan(`   Session created: ${session.upload_id} (${session.total_chunks} chunks)`));
       const chunks = this.prepareChunks(fileSize, session.chunk_size);
       const uploadProgress = {
         uploadId: session.upload_id,
@@ -88240,11 +88616,11 @@ var ChunkedUploader2 = class _ChunkedUploader {
         uploadProgress,
         onProgress
       );
-      console.log(import_chalk24.default.cyan(`   Calculating checksum...`));
+      console.log(import_chalk25.default.cyan(`   Calculating checksum...`));
       const checksum = await this.calculateMD5(filePath);
-      console.log(import_chalk24.default.cyan(`   Finalizing upload...`));
+      console.log(import_chalk25.default.cyan(`   Finalizing upload...`));
       const result = await this.completeUpload(session.upload_id, checksum);
-      console.log(import_chalk24.default.green(`\u2705 Chunked upload completed: ${filename}`));
+      console.log(import_chalk25.default.green(`\u2705 Chunked upload completed: ${filename}`));
       uploadProgress.status = "completed";
       uploadProgress.progress = 100;
       if (onProgress) {
@@ -88256,7 +88632,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
         objectKey: result.object_key
       };
     } catch (error) {
-      console.error(import_chalk24.default.red(`\u274C Chunked upload failed: ${error.message}`));
+      console.error(import_chalk25.default.red(`\u274C Chunked upload failed: ${error.message}`));
       return {
         success: false,
         uploadId: "",
@@ -88324,7 +88700,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
         if (onProgress) {
           onProgress({ ...progress });
         }
-        console.log(import_chalk24.default.gray(`   Chunk ${chunk.index}/${chunks.length} uploaded (${progress.progress.toFixed(1)}%)`));
+        console.log(import_chalk25.default.gray(`   Chunk ${chunk.index}/${chunks.length} uploaded (${progress.progress.toFixed(1)}%)`));
       }).catch((error) => {
         throw new Error(`Chunk ${chunk.index} upload failed: ${error.message}`);
       }).finally(() => {
@@ -88345,11 +88721,11 @@ var ChunkedUploader2 = class _ChunkedUploader {
     for (let attempt = 0; attempt <= _ChunkedUploader.MAX_RETRY_PER_CHUNK; attempt++) {
       try {
         const buffer = Buffer.alloc(chunk.size);
-        const fd = await fs14.open(filePath, "r");
+        const fd = await fs16.open(filePath, "r");
         try {
-          await fs14.read(fd, buffer, 0, chunk.size, chunk.start);
+          await fs16.read(fd, buffer, 0, chunk.size, chunk.start);
         } finally {
-          await fs14.close(fd);
+          await fs16.close(fd);
         }
         await this.axiosClient.patch(
           `/api/v1/documents/chunked_uploads/${uploadId}/chunks/${chunk.index}`,
@@ -88364,7 +88740,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
       } catch (error) {
         lastError = error;
         if (attempt < _ChunkedUploader.MAX_RETRY_PER_CHUNK) {
-          console.log(import_chalk24.default.yellow(`   \u26A0\uFE0F  Chunk ${chunk.index} failed, retrying (${attempt + 1}/${_ChunkedUploader.MAX_RETRY_PER_CHUNK})...`));
+          console.log(import_chalk25.default.yellow(`   \u26A0\uFE0F  Chunk ${chunk.index} failed, retrying (${attempt + 1}/${_ChunkedUploader.MAX_RETRY_PER_CHUNK})...`));
           await this.sleep(1e3 * (attempt + 1));
         }
       }
@@ -88394,7 +88770,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
   async calculateMD5(filePath) {
     return new Promise((resolve, reject) => {
       const hash = crypto3.createHash("md5");
-      const stream5 = fs14.createReadStream(filePath);
+      const stream5 = fs16.createReadStream(filePath);
       stream5.on("data", (data) => hash.update(data));
       stream5.on("end", () => resolve(hash.digest("base64")));
       stream5.on("error", reject);
@@ -88404,7 +88780,7 @@ var ChunkedUploader2 = class _ChunkedUploader {
    * Get content type from file extension
    */
   getContentType(filePath) {
-    const ext2 = path18.extname(filePath).toLowerCase();
+    const ext2 = path20.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".pdf": "application/pdf",
       ".doc": "application/msword",
@@ -88487,7 +88863,7 @@ async function handleFilesShow(id, opts) {
 }
 async function uploadDirect(ctx, filePath, fileName, opts, metadata) {
   const form = new import_form_data3.default();
-  form.append("uploaded_file", import_fs_extra13.default.createReadStream(filePath), {
+  form.append("uploaded_file", import_fs_extra15.default.createReadStream(filePath), {
     filename: fileName,
     contentType: "application/octet-stream"
   });
@@ -88532,18 +88908,18 @@ async function uploadChunked(ctx, filePath, opts, metadata, out) {
 async function handleFilesUpload(filePath, opts) {
   const out = output(opts);
   const ctx = await buildApiContext(out);
-  const resolved = import_path15.default.resolve(filePath);
-  if (!await import_fs_extra13.default.pathExists(resolved)) {
+  const resolved = import_path17.default.resolve(filePath);
+  if (!await import_fs_extra15.default.pathExists(resolved)) {
     out.fail(new Error(`File not found: ${filePath}`));
   }
-  const stats = await import_fs_extra13.default.stat(resolved);
+  const stats = await import_fs_extra15.default.stat(resolved);
   if (!stats.isFile()) {
     out.fail(new Error(`Not a regular file: ${filePath}`));
   }
   if (!opts.folder && !opts.workspace) {
     out.note("No --folder or --workspace specified; server will use defaults");
   }
-  const fileName = (opts.name || import_path15.default.basename(resolved)).normalize("NFC");
+  const fileName = (opts.name || import_path17.default.basename(resolved)).normalize("NFC");
   const metadata = parseJsonOpt3("metadata", opts.metadata, out);
   const useChunked = !!opts.chunked || stats.size >= CHUNKED_THRESHOLD;
   try {
@@ -88562,8 +88938,8 @@ async function handleFilesUpload(filePath, opts) {
   }
 }
 async function streamToFile(stream5, targetPath) {
-  await import_fs_extra13.default.ensureDir(import_path15.default.dirname(import_path15.default.resolve(targetPath)));
-  const writer = import_fs_extra13.default.createWriteStream(targetPath);
+  await import_fs_extra15.default.ensureDir(import_path17.default.dirname(import_path17.default.resolve(targetPath)));
+  const writer = import_fs_extra15.default.createWriteStream(targetPath);
   stream5.pipe(writer);
   await new Promise((resolve, reject) => {
     writer.on("finish", resolve);
@@ -88582,7 +88958,7 @@ async function handleFilesDownload(id, opts) {
     out.fail(err);
   }
   const fileName = meta?.name || `document-${id}`;
-  const targetPath = import_path15.default.resolve(opts.to || fileName);
+  const targetPath = import_path17.default.resolve(opts.to || fileName);
   try {
     const res = await ctx.axios.get(`/api/v1/documents/documents/${id}/blob`, {
       responseType: "stream"
@@ -88861,8 +89237,8 @@ async function handleComposedExport(id, opts) {
 }
 // apps/cli/cli/handlers/part-handlers.ts
-var import_fs_extra14 = __toESM(require_lib());
-var import_path16 = __toESM(require("path"));
+var import_fs_extra16 = __toESM(require_lib());
+var import_path18 = __toESM(require("path"));
 var partsBase = (cdId) => `/api/v1/documents/composed_documents/${encodeURIComponent(cdId)}/parts`;
 var PART_COLUMNS = [
   { header: "ID", key: "id" },
@@ -88915,11 +89291,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_path16.default.resolve(opts.contentFile);
-    if (!await import_fs_extra14.default.pathExists(resolved)) {
+    const resolved = import_path18.default.resolve(opts.contentFile);
+    if (!await import_fs_extra16.default.pathExists(resolved)) {
       out.fail(new Error(`Content file not found: ${opts.contentFile}`));
     }
-    body.content = await import_fs_extra14.default.readFile(resolved, "utf8");
+    body.content = await import_fs_extra16.default.readFile(resolved, "utf8");
   }
   if (opts.status !== void 0) body.status = opts.status;
   if (opts.title !== void 0) body.title = opts.title;
@@ -89454,15 +89830,15 @@ async function handlePermissionsShow(id, opts) {
 // apps/cli/cli.ts
 var getVersion = () => {
   try {
-    if (true) return "1.6.1";
+    if (true) return "1.7.0";
   } catch {
   }
   for (const candidate of [
-    import_path17.default.join(__dirname, "package.json"),
-    import_path17.default.join(__dirname, "..", "package.json")
+    import_path19.default.join(__dirname, "package.json"),
+    import_path19.default.join(__dirname, "..", "package.json")
   ]) {
     try {
-      return import_fs_extra15.default.readJsonSync(candidate).version;
+      return import_fs_extra17.default.readJsonSync(candidate).version;
     } catch {
     }
   }
@@ -89482,18 +89858,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_chalk25.default.blue(`\u{1F680} Starting HubDoc Tool with ${selectedEngine} engine...`));
+    console.log(import_chalk26.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_chalk25.default.green(`\u2705 Operation completed. Log: ${logger.getLogPath()}`));
+    console.log(import_chalk26.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_chalk25.default.red(`\u274C Error: ${error.message}`));
-    console.error(import_chalk25.default.gray(`\u{1F4C4} Check log file: ${logger.getLogPath()}`));
+    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk26.default.gray(`\u{1F4C4} Check log file: ${logger.getLogPath()}`));
     process.exit(1);
   }
 });
@@ -89507,7 +89883,7 @@ Examples:
   try {
     await handleGenerateMapping(sourceDir, options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89522,7 +89898,7 @@ Examples:
   try {
     await handleImport(options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Import failed: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Import failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89530,7 +89906,7 @@ program2.command("export").description("Export documents from HubDoc").option("-
   try {
     await handleExport(options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Export failed: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Export failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89538,7 +89914,7 @@ program2.command("plugins").description("Manage document source plugins").action
   try {
     await handlePlugins();
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Error: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89546,7 +89922,7 @@ program2.command("connect").description("Create a connection to an external docu
   try {
     await handleConnect(plugin, options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Failed to create connection: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Failed to create connection: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89554,7 +89930,7 @@ program2.command("plugin-scan").description("Scan external source and generate m
   try {
     await handlePluginScan(connectionId, options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Plugin scan failed: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Plugin scan failed: ${error.message}`));
     process.exit(1);
   }
 });
@@ -89562,13 +89938,16 @@ program2.command("plugin-import").description("Import documents from external so
   try {
     await handlePluginImport(mappingFile, options);
   } catch (error) {
-    console.error(import_chalk25.default.red(`\u274C Plugin import failed: ${error.message}`));
+    console.error(import_chalk26.default.red(`\u274C Plugin import failed: ${error.message}`));
     process.exit(1);
   }
 });
 program2.command("whoami").description("Show the authenticated user (LLM-friendly)").action(async (options) => {
   await handleWhoami(withGlobals(options));
 });
+program2.command("login").description("Sign in via OAuth device flow (no browser needed on this machine)").option("--device", "Use the device authorization grant (default)").option("--start", "Open a device session, print the code, then exit (for agents)").option("--poll", "Resume the pending device session and wait for approval").option("--timeout <seconds>", "Max seconds to wait for approval while polling").option("--api-url <url>", "API URL (defaults to current config or HUBDOC_API_URL)").action(async (options) => {
+  await handleLogin(withGlobals(options));
+});
 var token = program2.command("token").description("Manage API tokens");
 token.command("set <token>").description("Persist an API token (config file by default, OS keychain with --keychain)").option("--api-url <url>", "API URL (defaults to current config or HUBDOC_API_URL)").option("--keychain", "Store in OS keychain via keytar (Keychain / libsecret / Credential Vault) instead of plaintext config").action(async (tokenValue, options) => {
   await handleTokenSet(tokenValue, withGlobals(options));
@@ -89576,6 +89955,13 @@ token.command("set <token>").description("Persist an API token (config file by d
 token.command("open").description("Open the Corex Personal Access Tokens UI in the default browser").option("--api-url <url>", "API URL (defaults to current config or HUBDOC_API_URL)").action(async (options) => {
   await handleTokenOpen(withGlobals(options));
 });
+var skill = program2.command("skill").description("Manage the bundled Claude Code skill");
+skill.command("install").description("Install the hubdoc-auth skill into ~/.claude/skills (or a project)").option("--project", "Install into ./.claude/skills instead of the user home").option("--path <dir>", "Explicit skills directory (overrides --project)").option("--force", "Overwrite an existing SKILL.md").action(async (options) => {
+  await handleSkillInstall(withGlobals(options));
+});
+skill.command("show").description("Print the hubdoc-auth skill markdown").action(async (options) => {
+  await handleSkillShow(withGlobals(options));
+});
 var workspaces = program2.command("workspaces").description("Manage workspaces");
 workspaces.command("ls").description("List workspaces").action(async (options) => {
   await handleWorkspacesList(withGlobals(options));