@vercel/next 4.2.18 → 4.3.1

package/dist/index.js

@@ -1185,42 +1185,40 @@ var require_find_up = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/universalify@0.1.2/node_modules/universalify/index.js
+// ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
 var require_universalify = __commonJS({
-  "../../node_modules/.pnpm/universalify@0.1.2/node_modules/universalify/index.js"(exports) {
+  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
     "use strict";
     exports.fromCallback = function(fn) {
-      return Object.defineProperty(function() {
-        if (typeof arguments[arguments.length - 1] === "function")
-          fn.apply(this, arguments);
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function")
+          fn.apply(this, args);
         else {
           return new Promise((resolve, reject) => {
-            arguments[arguments.length] = (err, res) => {
-              if (err)
-                return reject(err);
-              resolve(res);
-            };
-            arguments.length++;
-            fn.apply(this, arguments);
+            fn.call(
+              this,
+              ...args,
+              (err, res) => err != null ? reject(err) : resolve(res)
+            );
           });
         }
       }, "name", { value: fn.name });
     };
     exports.fromPromise = function(fn) {
-      return Object.defineProperty(function() {
-        const cb = arguments[arguments.length - 1];
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
         if (typeof cb !== "function")
-          return fn.apply(this, arguments);
+          return fn.apply(this, args);
         else
-          fn.apply(this, arguments).then((r) => cb(null, r), cb);
+          fn.apply(this, args.slice(0, -1)).then((r) => cb(null, r), cb);
       }, "name", { value: fn.name });
     };
   }
 });
 
-// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module2) {
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module2) {
     var constants = require("constants");
     var origCwd = process.cwd;
     var cwd = null;
@@ -1292,7 +1290,7 @@ var require_polyfills = __commonJS({
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
-              if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
                   fs5.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
@@ -1534,9 +1532,9 @@ var require_polyfills = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/legacy-streams.js
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
 var require_legacy_streams = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
     function legacy(fs5) {
@@ -1633,9 +1631,9 @@ var require_legacy_streams = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/clone.js
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
 var require_clone = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/clone.js"(exports, module2) {
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module2) {
     "use strict";
     module2.exports = clone;
     var getPrototypeOf = Object.getPrototypeOf || function(obj) {
@@ -1656,9 +1654,9 @@ var require_clone = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/graceful-fs.js
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
     var fs5 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
@@ -2026,9 +2024,9 @@ var require_graceful_fs = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/fs/index.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js
 var require_fs = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
     var fs5 = require_graceful_fs();
@@ -2046,18 +2044,20 @@ var require_fs = __commonJS({
       "fsync",
       "ftruncate",
       "futimes",
-      "lchown",
       "lchmod",
+      "lchown",
       "link",
       "lstat",
       "mkdir",
       "mkdtemp",
       "open",
-      "readFile",
+      "opendir",
       "readdir",
+      "readFile",
       "readlink",
       "realpath",
       "rename",
+      "rm",
       "rmdir",
       "stat",
       "symlink",
@@ -2068,12 +2068,7 @@ var require_fs = __commonJS({
     ].filter((key) => {
       return typeof fs5[key] === "function";
     });
-    Object.keys(fs5).forEach((key) => {
-      if (key === "promises") {
-        return;
-      }
-      exports[key] = fs5[key];
-    });
+    Object.assign(exports, fs5);
     api.forEach((method) => {
       exports[method] = u(fs5[method]);
     });
@@ -2109,269 +2104,438 @@ var require_fs = __commonJS({
         });
       });
     };
+    exports.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs5.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs5.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs5.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs5.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs5.realpath.native === "function") {
+      exports.realpath.native = u(fs5.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/win32.js
-var require_win32 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/win32.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module2) {
     "use strict";
     var path5 = require("path");
-    function getRootPath(p) {
-      p = path5.normalize(path5.resolve(p)).split(path5.sep);
-      if (p.length > 0)
-        return p[0];
-      return null;
-    }
-    var INVALID_PATH_CHARS = /[<>:"|?*]/;
-    function invalidWin32Path(p) {
-      const rp = getRootPath(p);
-      p = p.replace(rp, "");
-      return INVALID_PATH_CHARS.test(p);
-    }
-    module2.exports = {
-      getRootPath,
-      invalidWin32Path
+    module2.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/mkdirs.js
-var require_mkdirs = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/mkdirs.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var invalidWin32Path = require_win32().invalidWin32Path;
-    var o777 = parseInt("0777", 8);
-    function mkdirs(p, opts, callback, made) {
-      if (typeof opts === "function") {
-        callback = opts;
-        opts = {};
-      } else if (!opts || typeof opts !== "object") {
-        opts = { mode: opts };
-      }
-      if (process.platform === "win32" && invalidWin32Path(p)) {
-        const errInval = new Error(p + " contains invalid WIN32 path characters.");
-        errInval.code = "EINVAL";
-        return callback(errInval);
-      }
-      let mode = opts.mode;
-      const xfs = opts.fs || fs5;
-      if (mode === void 0) {
-        mode = o777 & ~process.umask();
-      }
-      if (!made)
-        made = null;
-      callback = callback || function() {
-      };
-      p = path5.resolve(p);
-      xfs.mkdir(p, mode, (er) => {
-        if (!er) {
-          made = made || p;
-          return callback(null, made);
-        }
-        switch (er.code) {
-          case "ENOENT":
-            if (path5.dirname(p) === p)
-              return callback(er);
-            mkdirs(path5.dirname(p), opts, (er2, made2) => {
-              if (er2)
-                callback(er2, made2);
-              else
-                mkdirs(p, opts, callback, made2);
-            });
-            break;
-          default:
-            xfs.stat(p, (er2, stat2) => {
-              if (er2 || !stat2.isDirectory())
-                callback(er, made);
-              else
-                callback(null, made);
-            });
-            break;
-        }
+    var fs5 = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number")
+        return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module2.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs5.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
       });
-    }
-    module2.exports = mkdirs;
+    };
+    module2.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs5.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js
-var require_mkdirs_sync = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var invalidWin32Path = require_win32().invalidWin32Path;
-    var o777 = parseInt("0777", 8);
-    function mkdirsSync(p, opts, made) {
-      if (!opts || typeof opts !== "object") {
-        opts = { mode: opts };
-      }
-      let mode = opts.mode;
-      const xfs = opts.fs || fs5;
-      if (process.platform === "win32" && invalidWin32Path(p)) {
-        const errInval = new Error(p + " contains invalid WIN32 path characters.");
-        errInval.code = "EINVAL";
-        throw errInval;
-      }
-      if (mode === void 0) {
-        mode = o777 & ~process.umask();
-      }
-      if (!made)
-        made = null;
-      p = path5.resolve(p);
-      try {
-        xfs.mkdirSync(p, mode);
-        made = made || p;
-      } catch (err0) {
-        if (err0.code === "ENOENT") {
-          if (path5.dirname(p) === p)
-            throw err0;
-          made = mkdirsSync(path5.dirname(p), opts, made);
-          mkdirsSync(p, opts, made);
-        } else {
-          let stat2;
-          try {
-            stat2 = xfs.statSync(p);
-          } catch (err1) {
-            throw err0;
-          }
-          if (!stat2.isDirectory())
-            throw err0;
-        }
-      }
-      return made;
-    }
-    module2.exports = mkdirsSync;
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module2.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/index.js
-var require_mkdirs2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    var mkdirs = u(require_mkdirs());
-    var mkdirsSync = require_mkdirs_sync();
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
+    function pathExists2(path5) {
+      return fs5.access(path5).then(() => true).catch(() => false);
+    }
     module2.exports = {
-      mkdirs,
-      mkdirsSync,
-      // alias
-      mkdirp: mkdirs,
-      mkdirpSync: mkdirsSync,
-      ensureDir: mkdirs,
-      ensureDirSync: mkdirsSync
+      pathExists: u(pathExists2),
+      pathExistsSync: fs5.existsSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/util/utimes.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js
 var require_utimes = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    var os = require("os");
-    var path5 = require("path");
-    function hasMillisResSync() {
-      let tmpfile = path5.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
-      tmpfile = path5.join(os.tmpdir(), tmpfile);
-      const d = /* @__PURE__ */ new Date(1435410243862);
-      fs5.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
-      const fd = fs5.openSync(tmpfile, "r+");
-      fs5.futimesSync(fd, d, d);
-      fs5.closeSync(fd);
-      return fs5.statSync(tmpfile).mtime > 1435410243e3;
-    }
-    function hasMillisRes(callback) {
-      let tmpfile = path5.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
-      tmpfile = path5.join(os.tmpdir(), tmpfile);
-      const d = /* @__PURE__ */ new Date(1435410243862);
-      fs5.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
-        if (err)
-          return callback(err);
-        fs5.open(tmpfile, "r+", (err2, fd) => {
-          if (err2)
-            return callback(err2);
-          fs5.futimes(fd, d, d, (err3) => {
-            if (err3)
-              return callback(err3);
-            fs5.close(fd, (err4) => {
-              if (err4)
-                return callback(err4);
-              fs5.stat(tmpfile, (err5, stats) => {
-                if (err5)
-                  return callback(err5);
-                callback(null, stats.mtime > 1435410243e3);
-              });
-            });
-          });
-        });
-      });
-    }
-    function timeRemoveMillis(timestamp) {
-      if (typeof timestamp === "number") {
-        return Math.floor(timestamp / 1e3) * 1e3;
-      } else if (timestamp instanceof Date) {
-        return new Date(Math.floor(timestamp.getTime() / 1e3) * 1e3);
-      } else {
-        throw new Error("fs-extra: timeRemoveMillis() unknown parameter type");
+    var fs5 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path5, atime, mtime) {
+      const fd = await fs5.open(path5, "r+");
+      let closeErr = null;
+      try {
+        await fs5.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs5.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
       }
     }
-    function utimesMillis(path6, atime, mtime, callback) {
-      fs5.open(path6, "r+", (err, fd) => {
-        if (err)
-          return callback(err);
-        fs5.futimes(fd, atime, mtime, (futimesErr) => {
-          fs5.close(fd, (closeErr) => {
-            if (callback)
-              callback(futimesErr || closeErr);
-          });
-        });
-      });
-    }
-    function utimesMillisSync(path6, atime, mtime) {
-      const fd = fs5.openSync(path6, "r+");
+    function utimesMillisSync(path5, atime, mtime) {
+      const fd = fs5.openSync(path5, "r+");
       fs5.futimesSync(fd, atime, mtime);
       return fs5.closeSync(fd);
     }
     module2.exports = {
-      hasMillisRes,
-      hasMillisResSync,
-      timeRemoveMillis,
-      utimesMillis,
+      utimesMillis: u(utimesMillis),
       utimesMillisSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/util/buffer.js
-var require_buffer = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/util/buffer.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
     "use strict";
-    module2.exports = function(size) {
-      if (typeof Buffer.allocUnsafe === "function") {
-        try {
-          return Buffer.allocUnsafe(size);
-        } catch (e) {
-          return new Buffer(size);
+    var fs5 = require_fs();
+    var path5 = require("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs5.stat(file, { bigint: true }) : (file) => fs5.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT")
+            return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs5.statSync(file, { bigint: true }) : (file) => fs5.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path5.basename(src);
+          const destBaseName = path5.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path5.basename(src);
+          const destBaseName = path5.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
         }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src, srcStat, dest, funcName) {
+      const srcParent = path5.resolve(path5.dirname(src));
+      const destParent = path5.resolve(path5.dirname(dest));
+      if (destParent === srcParent || destParent === path5.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = await fs5.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path5.resolve(path5.dirname(src));
+      const destParent = path5.resolve(path5.dirname(dest));
+      if (destParent === srcParent || destParent === path5.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = fs5.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
       }
-      return new Buffer(size);
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path5.resolve(src).split(path5.sep).filter((i) => i);
+      const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module2.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy-sync/copy-sync.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
+    "use strict";
+    var fs5 = require_fs();
+    var path5 = require("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists2();
+    var { utimesMillis } = require_utimes();
+    var stat2 = require_stat();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat2.checkPaths(src, dest, "copy", opts);
+      await stat2.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include)
+        return;
+      const destParent = path5.dirname(dest);
+      const dirExists = await pathExists2(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter)
+        return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs5.stat : fs5.lstat;
+      const srcStat = await statFn(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs5.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs5.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs5.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs5.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs5.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs5.mkdir(dest);
+      }
+      const items = await fs5.readdir(src);
+      await Promise.all(items.map(async (item) => {
+        const srcItem = path5.join(src, item);
+        const destItem = path5.join(dest, item);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (!include)
+          return;
+        const { destStat: destStat2 } = await stat2.checkPaths(srcItem, destItem, "copy", opts);
+        return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+      }));
+      if (!destStat) {
+        await fs5.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs5.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs5.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs5.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN")
+          return fs5.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+      }
+      if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
+      await fs5.unlink(dest);
+      return fs5.symlink(resolvedSrc, dest);
+    }
+    module2.exports = copy;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js
 var require_copy_sync = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module2) {
     "use strict";
     var fs5 = require_graceful_fs();
     var path5 = require("path");
-    var mkdirpSync = require_mkdirs2().mkdirsSync;
-    var utimesSync = require_utimes().utimesMillisSync;
-    var notExist = Symbol("notExist");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat2 = require_stat();
     function copySync(src, dest, opts) {
       if (typeof opts === "function") {
         opts = { filter: opts };
@@ -2380,21 +2544,19 @@ var require_copy_sync = __commonJS({
       opts.clobber = "clobber" in opts ? !!opts.clobber : true;
       opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
       if (opts.preserveTimestamps && process.arch === "ia32") {
-        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
-
-    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
       }
-      const destStat = checkPaths(src, dest);
+      const { srcStat, destStat } = stat2.checkPathsSync(src, dest, "copy", opts);
+      stat2.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path5.dirname(dest);
       if (!fs5.existsSync(destParent))
-        mkdirpSync(destParent);
-      return startCopy(destStat, src, dest, opts);
-    }
-    function startCopy(destStat, src, dest, opts) {
-      if (opts.filter && !opts.filter(src, dest))
-        return;
+        mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
@@ -2406,9 +2568,14 @@ var require_copy_sync = __commonJS({
         return onFile(srcStat, destStat, src, dest, opts);
       else if (srcStat.isSymbolicLink())
         return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
     }
     function onFile(srcStat, destStat, src, dest, opts) {
-      if (destStat === notExist)
+      if (!destStat)
         return copyFile(srcStat, src, dest, opts);
       return mayCopyFile(srcStat, src, dest, opts);
     }
@@ -2421,44 +2588,38 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      if (typeof fs5.copyFileSync === "function") {
-        fs5.copyFileSync(src, dest);
-        fs5.chmodSync(dest, srcStat.mode);
-        if (opts.preserveTimestamps) {
-          return utimesSync(dest, srcStat.atime, srcStat.mtime);
-        }
-        return;
-      }
-      return copyFileFallback(srcStat, src, dest, opts);
-    }
-    function copyFileFallback(srcStat, src, dest, opts) {
-      const BUF_LENGTH = 64 * 1024;
-      const _buff = require_buffer()(BUF_LENGTH);
-      const fdr = fs5.openSync(src, "r");
-      const fdw = fs5.openSync(dest, "w", srcStat.mode);
-      let pos = 0;
-      while (pos < srcStat.size) {
-        const bytesRead = fs5.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs5.writeSync(fdw, _buff, 0, bytesRead);
-        pos += bytesRead;
-      }
+      fs5.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
-        fs5.futimesSync(fdw, srcStat.atime, srcStat.mtime);
-      fs5.closeSync(fdr);
-      fs5.closeSync(fdw);
+        handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode))
+        makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs5.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs5.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
-      if (destStat === notExist)
-        return mkDirAndCopy(srcStat, src, dest, opts);
-      if (destStat && !destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
-      }
+      if (!destStat)
+        return mkDirAndCopy(srcStat.mode, src, dest, opts);
       return copyDir(src, dest, opts);
     }
-    function mkDirAndCopy(srcStat, src, dest, opts) {
+    function mkDirAndCopy(srcMode, src, dest, opts) {
       fs5.mkdirSync(dest);
       copyDir(src, dest, opts);
-      return fs5.chmodSync(dest, srcStat.mode);
+      return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
       fs5.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
@@ -2466,15 +2627,17 @@ var require_copy_sync = __commonJS({
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path5.join(src, item);
       const destItem = path5.join(dest, item);
-      const destStat = checkPaths(srcItem, destItem);
-      return startCopy(destStat, srcItem, destItem, opts);
+      if (opts.filter && !opts.filter(srcItem, destItem))
+        return;
+      const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
+      return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
       let resolvedSrc = fs5.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
       }
-      if (destStat === notExist) {
+      if (!destStat) {
         return fs5.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
@@ -2488,10 +2651,10 @@ var require_copy_sync = __commonJS({
         if (opts.dereference) {
           resolvedDest = path5.resolve(process.cwd(), resolvedDest);
         }
-        if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+        if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs5.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
@@ -2501,612 +2664,64 @@ var require_copy_sync = __commonJS({
       fs5.unlinkSync(dest);
       return fs5.symlinkSync(resolvedSrc, dest);
     }
-    function isSrcSubdir(src, dest) {
-      const srcArray = path5.resolve(src).split(path5.sep);
-      const destArray = path5.resolve(dest).split(path5.sep);
-      return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
-    }
-    function checkStats(src, dest) {
-      const srcStat = fs5.statSync(src);
-      let destStat;
-      try {
-        destStat = fs5.statSync(dest);
-      } catch (err) {
-        if (err.code === "ENOENT")
-          return { srcStat, destStat: notExist };
-        throw err;
-      }
-      return { srcStat, destStat };
-    }
-    function checkPaths(src, dest) {
-      const { srcStat, destStat } = checkStats(src, dest);
-      if (destStat.ino && destStat.ino === srcStat.ino) {
-        throw new Error("Source and destination must not be the same.");
-      }
-      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-        throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`);
-      }
-      return destStat;
-    }
     module2.exports = copySync;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy-sync/index.js
-var require_copy_sync2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy-sync/index.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js"(exports, module2) {
     "use strict";
+    var u = require_universalify().fromPromise;
     module2.exports = {
+      copy: u(require_copy()),
       copySync: require_copy_sync()
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/path-exists/index.js
-var require_path_exists2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
-    "use strict";
-    var u = require_universalify().fromPromise;
-    var fs5 = require_fs();
-    function pathExists2(path5) {
-      return fs5.access(path5).then(() => true).catch(() => false);
-    }
-    module2.exports = {
-      pathExists: u(pathExists2),
-      pathExistsSync: fs5.existsSync
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy/copy.js
-var require_copy = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js"(exports, module2) {
     "use strict";
     var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var mkdirp = require_mkdirs2().mkdirs;
-    var pathExists2 = require_path_exists2().pathExists;
-    var utimes = require_utimes().utimesMillis;
-    var notExist = Symbol("notExist");
-    function copy(src, dest, opts, cb) {
-      if (typeof opts === "function" && !cb) {
-        cb = opts;
-        opts = {};
-      } else if (typeof opts === "function") {
-        opts = { filter: opts };
-      }
-      cb = cb || function() {
-      };
-      opts = opts || {};
-      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
-      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
-      if (opts.preserveTimestamps && process.arch === "ia32") {
-        console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;
-
-    see https://github.com/jprichardson/node-fs-extra/issues/269`);
-      }
-      checkPaths(src, dest, (err, destStat) => {
-        if (err)
-          return cb(err);
-        if (opts.filter)
-          return handleFilter(checkParentDir, destStat, src, dest, opts, cb);
-        return checkParentDir(destStat, src, dest, opts, cb);
-      });
-    }
-    function checkParentDir(destStat, src, dest, opts, cb) {
-      const destParent = path5.dirname(dest);
-      pathExists2(destParent, (err, dirExists) => {
-        if (err)
-          return cb(err);
-        if (dirExists)
-          return startCopy(destStat, src, dest, opts, cb);
-        mkdirp(destParent, (err2) => {
-          if (err2)
-            return cb(err2);
-          return startCopy(destStat, src, dest, opts, cb);
-        });
-      });
-    }
-    function handleFilter(onInclude, destStat, src, dest, opts, cb) {
-      Promise.resolve(opts.filter(src, dest)).then((include) => {
-        if (include) {
-          if (destStat)
-            return onInclude(destStat, src, dest, opts, cb);
-          return onInclude(src, dest, opts, cb);
-        }
-        return cb();
-      }, (error) => cb(error));
-    }
-    function startCopy(destStat, src, dest, opts, cb) {
-      if (opts.filter)
-        return handleFilter(getStats, destStat, src, dest, opts, cb);
-      return getStats(destStat, src, dest, opts, cb);
-    }
-    function getStats(destStat, src, dest, opts, cb) {
-      const stat2 = opts.dereference ? fs5.stat : fs5.lstat;
-      stat2(src, (err, srcStat) => {
-        if (err)
-          return cb(err);
-        if (srcStat.isDirectory())
-          return onDir(srcStat, destStat, src, dest, opts, cb);
-        else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
-          return onFile(srcStat, destStat, src, dest, opts, cb);
-        else if (srcStat.isSymbolicLink())
-          return onLink(destStat, src, dest, opts, cb);
-      });
-    }
-    function onFile(srcStat, destStat, src, dest, opts, cb) {
-      if (destStat === notExist)
-        return copyFile(srcStat, src, dest, opts, cb);
-      return mayCopyFile(srcStat, src, dest, opts, cb);
-    }
-    function mayCopyFile(srcStat, src, dest, opts, cb) {
-      if (opts.overwrite) {
-        fs5.unlink(dest, (err) => {
-          if (err)
-            return cb(err);
-          return copyFile(srcStat, src, dest, opts, cb);
-        });
-      } else if (opts.errorOnExist) {
-        return cb(new Error(`'${dest}' already exists`));
-      } else
-        return cb();
-    }
-    function copyFile(srcStat, src, dest, opts, cb) {
-      if (typeof fs5.copyFile === "function") {
-        return fs5.copyFile(src, dest, (err) => {
-          if (err)
-            return cb(err);
-          return setDestModeAndTimestamps(srcStat, dest, opts, cb);
-        });
-      }
-      return copyFileFallback(srcStat, src, dest, opts, cb);
-    }
-    function copyFileFallback(srcStat, src, dest, opts, cb) {
-      const rs = fs5.createReadStream(src);
-      rs.on("error", (err) => cb(err)).once("open", () => {
-        const ws = fs5.createWriteStream(dest, { mode: srcStat.mode });
-        ws.on("error", (err) => cb(err)).on("open", () => rs.pipe(ws)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
-      });
-    }
-    function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
-      fs5.chmod(dest, srcStat.mode, (err) => {
-        if (err)
-          return cb(err);
-        if (opts.preserveTimestamps) {
-          return utimes(dest, srcStat.atime, srcStat.mtime, cb);
-        }
-        return cb();
-      });
-    }
-    function onDir(srcStat, destStat, src, dest, opts, cb) {
-      if (destStat === notExist)
-        return mkDirAndCopy(srcStat, src, dest, opts, cb);
-      if (destStat && !destStat.isDirectory()) {
-        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
-      }
-      return copyDir(src, dest, opts, cb);
-    }
-    function mkDirAndCopy(srcStat, src, dest, opts, cb) {
-      fs5.mkdir(dest, (err) => {
-        if (err)
-          return cb(err);
-        copyDir(src, dest, opts, (err2) => {
-          if (err2)
-            return cb(err2);
-          return fs5.chmod(dest, srcStat.mode, cb);
-        });
-      });
-    }
-    function copyDir(src, dest, opts, cb) {
-      fs5.readdir(src, (err, items) => {
-        if (err)
-          return cb(err);
-        return copyDirItems(items, src, dest, opts, cb);
-      });
-    }
-    function copyDirItems(items, src, dest, opts, cb) {
-      const item = items.pop();
-      if (!item)
-        return cb();
-      return copyDirItem(items, item, src, dest, opts, cb);
-    }
-    function copyDirItem(items, item, src, dest, opts, cb) {
-      const srcItem = path5.join(src, item);
-      const destItem = path5.join(dest, item);
-      checkPaths(srcItem, destItem, (err, destStat) => {
-        if (err)
-          return cb(err);
-        startCopy(destStat, srcItem, destItem, opts, (err2) => {
-          if (err2)
-            return cb(err2);
-          return copyDirItems(items, src, dest, opts, cb);
-        });
-      });
-    }
-    function onLink(destStat, src, dest, opts, cb) {
-      fs5.readlink(src, (err, resolvedSrc) => {
-        if (err)
-          return cb(err);
-        if (opts.dereference) {
-          resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
-        }
-        if (destStat === notExist) {
-          return fs5.symlink(resolvedSrc, dest, cb);
-        } else {
-          fs5.readlink(dest, (err2, resolvedDest) => {
-            if (err2) {
-              if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
-                return fs5.symlink(resolvedSrc, dest, cb);
-              return cb(err2);
-            }
-            if (opts.dereference) {
-              resolvedDest = path5.resolve(process.cwd(), resolvedDest);
-            }
-            if (isSrcSubdir(resolvedSrc, resolvedDest)) {
-              return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
-            }
-            if (destStat.isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
-              return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
-            }
-            return copyLink(resolvedSrc, dest, cb);
-          });
-        }
-      });
-    }
-    function copyLink(resolvedSrc, dest, cb) {
-      fs5.unlink(dest, (err) => {
-        if (err)
-          return cb(err);
-        return fs5.symlink(resolvedSrc, dest, cb);
-      });
-    }
-    function isSrcSubdir(src, dest) {
-      const srcArray = path5.resolve(src).split(path5.sep);
-      const destArray = path5.resolve(dest).split(path5.sep);
-      return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true);
-    }
-    function checkStats(src, dest, cb) {
-      fs5.stat(src, (err, srcStat) => {
-        if (err)
-          return cb(err);
-        fs5.stat(dest, (err2, destStat) => {
-          if (err2) {
-            if (err2.code === "ENOENT")
-              return cb(null, { srcStat, destStat: notExist });
-            return cb(err2);
-          }
-          return cb(null, { srcStat, destStat });
-        });
-      });
-    }
-    function checkPaths(src, dest, cb) {
-      checkStats(src, dest, (err, stats) => {
-        if (err)
-          return cb(err);
-        const { srcStat, destStat } = stats;
-        if (destStat.ino && destStat.ino === srcStat.ino) {
-          return cb(new Error("Source and destination must not be the same."));
-        }
-        if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-          return cb(new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`));
-        }
-        return cb(null, destStat);
-      });
-    }
-    module2.exports = copy;
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy/index.js
-var require_copy2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/copy/index.js"(exports, module2) {
-    "use strict";
     var u = require_universalify().fromCallback;
-    module2.exports = {
-      copy: u(require_copy())
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/remove/rimraf.js
-var require_rimraf = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
-    "use strict";
-    var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var assert = require("assert");
-    var isWindows = process.platform === "win32";
-    function defaults(options) {
-      const methods = [
-        "unlink",
-        "chmod",
-        "stat",
-        "lstat",
-        "rmdir",
-        "readdir"
-      ];
-      methods.forEach((m) => {
-        options[m] = options[m] || fs5[m];
-        m = m + "Sync";
-        options[m] = options[m] || fs5[m];
-      });
-      options.maxBusyTries = options.maxBusyTries || 3;
-    }
-    function rimraf(p, options, cb) {
-      let busyTries = 0;
-      if (typeof options === "function") {
-        cb = options;
-        options = {};
-      }
-      assert(p, "rimraf: missing path");
-      assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
-      assert.strictEqual(typeof cb, "function", "rimraf: callback function required");
-      assert(options, "rimraf: invalid options argument provided");
-      assert.strictEqual(typeof options, "object", "rimraf: options should be object");
-      defaults(options);
-      rimraf_(p, options, function CB(er) {
-        if (er) {
-          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
-            busyTries++;
-            const time = busyTries * 100;
-            return setTimeout(() => rimraf_(p, options, CB), time);
-          }
-          if (er.code === "ENOENT")
-            er = null;
-        }
-        cb(er);
-      });
-    }
-    function rimraf_(p, options, cb) {
-      assert(p);
-      assert(options);
-      assert(typeof cb === "function");
-      options.lstat(p, (er, st) => {
-        if (er && er.code === "ENOENT") {
-          return cb(null);
-        }
-        if (er && er.code === "EPERM" && isWindows) {
-          return fixWinEPERM(p, options, er, cb);
-        }
-        if (st && st.isDirectory()) {
-          return rmdir(p, options, er, cb);
-        }
-        options.unlink(p, (er2) => {
-          if (er2) {
-            if (er2.code === "ENOENT") {
-              return cb(null);
-            }
-            if (er2.code === "EPERM") {
-              return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
-            }
-            if (er2.code === "EISDIR") {
-              return rmdir(p, options, er2, cb);
-            }
-          }
-          return cb(er2);
-        });
-      });
-    }
-    function fixWinEPERM(p, options, er, cb) {
-      assert(p);
-      assert(options);
-      assert(typeof cb === "function");
-      if (er) {
-        assert(er instanceof Error);
-      }
-      options.chmod(p, 438, (er2) => {
-        if (er2) {
-          cb(er2.code === "ENOENT" ? null : er);
-        } else {
-          options.stat(p, (er3, stats) => {
-            if (er3) {
-              cb(er3.code === "ENOENT" ? null : er);
-            } else if (stats.isDirectory()) {
-              rmdir(p, options, er, cb);
-            } else {
-              options.unlink(p, cb);
-            }
-          });
-        }
-      });
-    }
-    function fixWinEPERMSync(p, options, er) {
-      let stats;
-      assert(p);
-      assert(options);
-      if (er) {
-        assert(er instanceof Error);
-      }
-      try {
-        options.chmodSync(p, 438);
-      } catch (er2) {
-        if (er2.code === "ENOENT") {
-          return;
-        } else {
-          throw er;
-        }
-      }
-      try {
-        stats = options.statSync(p);
-      } catch (er3) {
-        if (er3.code === "ENOENT") {
-          return;
-        } else {
-          throw er;
-        }
-      }
-      if (stats.isDirectory()) {
-        rmdirSync(p, options, er);
-      } else {
-        options.unlinkSync(p);
-      }
-    }
-    function rmdir(p, options, originalEr, cb) {
-      assert(p);
-      assert(options);
-      if (originalEr) {
-        assert(originalEr instanceof Error);
-      }
-      assert(typeof cb === "function");
-      options.rmdir(p, (er) => {
-        if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) {
-          rmkids(p, options, cb);
-        } else if (er && er.code === "ENOTDIR") {
-          cb(originalEr);
-        } else {
-          cb(er);
-        }
-      });
-    }
-    function rmkids(p, options, cb) {
-      assert(p);
-      assert(options);
-      assert(typeof cb === "function");
-      options.readdir(p, (er, files) => {
-        if (er)
-          return cb(er);
-        let n = files.length;
-        let errState;
-        if (n === 0)
-          return options.rmdir(p, cb);
-        files.forEach((f) => {
-          rimraf(path5.join(p, f), options, (er2) => {
-            if (errState) {
-              return;
-            }
-            if (er2)
-              return cb(errState = er2);
-            if (--n === 0) {
-              options.rmdir(p, cb);
-            }
-          });
-        });
-      });
-    }
-    function rimrafSync(p, options) {
-      let st;
-      options = options || {};
-      defaults(options);
-      assert(p, "rimraf: missing path");
-      assert.strictEqual(typeof p, "string", "rimraf: path should be a string");
-      assert(options, "rimraf: missing options");
-      assert.strictEqual(typeof options, "object", "rimraf: options should be object");
-      try {
-        st = options.lstatSync(p);
-      } catch (er) {
-        if (er.code === "ENOENT") {
-          return;
-        }
-        if (er.code === "EPERM" && isWindows) {
-          fixWinEPERMSync(p, options, er);
-        }
-      }
-      try {
-        if (st && st.isDirectory()) {
-          rmdirSync(p, options, null);
-        } else {
-          options.unlinkSync(p);
-        }
-      } catch (er) {
-        if (er.code === "ENOENT") {
-          return;
-        } else if (er.code === "EPERM") {
-          return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
-        } else if (er.code !== "EISDIR") {
-          throw er;
-        }
-        rmdirSync(p, options, er);
-      }
-    }
-    function rmdirSync(p, options, originalEr) {
-      assert(p);
-      assert(options);
-      if (originalEr) {
-        assert(originalEr instanceof Error);
-      }
-      try {
-        options.rmdirSync(p);
-      } catch (er) {
-        if (er.code === "ENOTDIR") {
-          throw originalEr;
-        } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") {
-          rmkidsSync(p, options);
-        } else if (er.code !== "ENOENT") {
-          throw er;
-        }
-      }
+    function remove2(path5, callback) {
+      fs5.rm(path5, { recursive: true, force: true }, callback);
     }
-    function rmkidsSync(p, options) {
-      assert(p);
-      assert(options);
-      options.readdirSync(p).forEach((f) => rimrafSync(path5.join(p, f), options));
-      const retries = isWindows ? 100 : 1;
-      let i = 0;
-      do {
-        let threw = true;
-        try {
-          const ret = options.rmdirSync(p, options);
-          threw = false;
-          return ret;
-        } finally {
-          if (++i < retries && threw)
-            continue;
-        }
-      } while (true);
+    function removeSync(path5) {
+      fs5.rmSync(path5, { recursive: true, force: true });
     }
-    module2.exports = rimraf;
-    rimraf.sync = rimrafSync;
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/remove/index.js
-var require_remove = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/remove/index.js"(exports, module2) {
-    "use strict";
-    var u = require_universalify().fromCallback;
-    var rimraf = require_rimraf();
     module2.exports = {
-      remove: u(rimraf),
-      removeSync: rimraf.sync
+      remove: u(remove2),
+      removeSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/empty/index.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js
 var require_empty = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    var fs5 = require("fs");
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
     var path5 = require("path");
-    var mkdir = require_mkdirs2();
+    var mkdir = require_mkdirs();
     var remove2 = require_remove();
-    var emptyDir = u(function emptyDir2(dir, callback) {
-      callback = callback || function() {
-      };
-      fs5.readdir(dir, (err, items) => {
-        if (err)
-          return mkdir.mkdirs(dir, callback);
-        items = items.map((item) => path5.join(dir, item));
-        deleteItem();
-        function deleteItem() {
-          const item = items.pop();
-          if (!item)
-            return callback();
-          remove2.remove(item, (err2) => {
-            if (err2)
-              return callback(err2);
-            deleteItem();
-          });
-        }
-      });
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs5.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove2.remove(path5.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
         items = fs5.readdirSync(dir);
-      } catch (err) {
+      } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
@@ -3123,51 +2738,59 @@ var require_empty = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/file.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js
 var require_file = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs5 = require_graceful_fs();
-    var mkdir = require_mkdirs2();
-    var pathExists2 = require_path_exists2().pathExists;
-    function createFile(file, callback) {
-      function makeFile() {
-        fs5.writeFile(file, "", (err) => {
-          if (err)
-            return callback(err);
-          callback();
-        });
+    var fs5 = require_fs();
+    var mkdir = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs5.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path5.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs5.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs5.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs5.writeFile(file, "");
+      } else {
+        await fs5.readdir(dir);
       }
-      fs5.stat(file, (err, stats) => {
-        if (!err && stats.isFile())
-          return callback();
-        const dir = path5.dirname(file);
-        pathExists2(dir, (err2, dirExists) => {
-          if (err2)
-            return callback(err2);
-          if (dirExists)
-            return makeFile();
-          mkdir.mkdirs(dir, (err3) => {
-            if (err3)
-              return callback(err3);
-            makeFile();
-          });
-        });
-      });
     }
     function createFileSync(file) {
       let stats;
       try {
         stats = fs5.statSync(file);
-      } catch (e) {
+      } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path5.dirname(file);
-      if (!fs5.existsSync(dir)) {
-        mkdir.mkdirsSync(dir);
+      try {
+        if (!fs5.statSync(dir).isDirectory()) {
+          fs5.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT")
+          mkdir.mkdirsSync(dir);
+        else
+          throw err;
       }
       fs5.writeFileSync(file, "");
     }
@@ -3178,54 +2801,48 @@ var require_file = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/link.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js
 var require_link = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs5 = require_graceful_fs();
-    var mkdir = require_mkdirs2();
-    var pathExists2 = require_path_exists2().pathExists;
-    function createLink(srcpath, dstpath, callback) {
-      function makeLink(srcpath2, dstpath2) {
-        fs5.link(srcpath2, dstpath2, (err) => {
-          if (err)
-            return callback(err);
-          callback(null);
-        });
+    var fs5 = require_fs();
+    var mkdir = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists2();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs5.lstat(dstpath);
+      } catch {
       }
-      pathExists2(dstpath, (err, destinationExists) => {
-        if (err)
-          return callback(err);
-        if (destinationExists)
-          return callback(null);
-        fs5.lstat(srcpath, (err2) => {
-          if (err2) {
-            err2.message = err2.message.replace("lstat", "ensureLink");
-            return callback(err2);
-          }
-          const dir = path5.dirname(dstpath);
-          pathExists2(dir, (err3, dirExists) => {
-            if (err3)
-              return callback(err3);
-            if (dirExists)
-              return makeLink(srcpath, dstpath);
-            mkdir.mkdirs(dir, (err4) => {
-              if (err4)
-                return callback(err4);
-              makeLink(srcpath, dstpath);
-            });
-          });
-        });
-      });
+      let srcStat;
+      try {
+        srcStat = await fs5.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat))
+        return;
+      const dir = path5.dirname(dstpath);
+      const dirExists = await pathExists2(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs5.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
-      const destinationExists = fs5.existsSync(dstpath);
-      if (destinationExists)
-        return void 0;
+      let dstStat;
+      try {
+        dstStat = fs5.lstatSync(dstpath);
+      } catch {
+      }
       try {
-        fs5.lstatSync(srcpath);
+        const srcStat = fs5.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat))
+          return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -3244,1134 +2861,287 @@ var require_link = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
 var require_symlink_paths = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
     "use strict";
     var path5 = require("path");
-    var fs5 = require_graceful_fs();
-    var pathExists2 = require_path_exists2().pathExists;
-    function symlinkPaths(srcpath, dstpath, callback) {
+    var fs5 = require_fs();
+    var { pathExists: pathExists2 } = require_path_exists2();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
       if (path5.isAbsolute(srcpath)) {
-        return fs5.lstat(srcpath, (err) => {
-          if (err) {
-            err.message = err.message.replace("lstat", "ensureSymlink");
-            return callback(err);
-          }
-          return callback(null, {
-            "toCwd": srcpath,
-            "toDst": srcpath
-          });
-        });
-      } else {
-        const dstdir = path5.dirname(dstpath);
-        const relativeToDst = path5.join(dstdir, srcpath);
-        return pathExists2(relativeToDst, (err, exists) => {
-          if (err)
-            return callback(err);
-          if (exists) {
-            return callback(null, {
-              "toCwd": relativeToDst,
-              "toDst": srcpath
-            });
-          } else {
-            return fs5.lstat(srcpath, (err2) => {
-              if (err2) {
-                err2.message = err2.message.replace("lstat", "ensureSymlink");
-                return callback(err2);
-              }
-              return callback(null, {
-                "toCwd": srcpath,
-                "toDst": path5.relative(dstdir, srcpath)
-              });
-            });
-          }
-        });
+        try {
+          await fs5.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
       }
+      const dstdir = path5.dirname(dstpath);
+      const relativeToDst = path5.join(dstdir, srcpath);
+      const exists = await pathExists2(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs5.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path5.relative(dstdir, srcpath)
+      };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      let exists;
       if (path5.isAbsolute(srcpath)) {
-        exists = fs5.existsSync(srcpath);
-        if (!exists)
+        const exists2 = fs5.existsSync(srcpath);
+        if (!exists2)
           throw new Error("absolute srcpath does not exist");
         return {
-          "toCwd": srcpath,
-          "toDst": srcpath
+          toCwd: srcpath,
+          toDst: srcpath
         };
-      } else {
-        const dstdir = path5.dirname(dstpath);
-        const relativeToDst = path5.join(dstdir, srcpath);
-        exists = fs5.existsSync(relativeToDst);
-        if (exists) {
-          return {
-            "toCwd": relativeToDst,
-            "toDst": srcpath
-          };
-        } else {
-          exists = fs5.existsSync(srcpath);
-          if (!exists)
-            throw new Error("relative srcpath does not exist");
-          return {
-            "toCwd": srcpath,
-            "toDst": path5.relative(dstdir, srcpath)
-          };
-        }
       }
+      const dstdir = path5.dirname(dstpath);
+      const relativeToDst = path5.join(dstdir, srcpath);
+      const exists = fs5.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs5.existsSync(srcpath);
+      if (!srcExists)
+        throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path5.relative(dstdir, srcpath)
+      };
     }
     module2.exports = {
-      symlinkPaths,
+      symlinkPaths: u(symlinkPaths),
       symlinkPathsSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink-type.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js
 var require_symlink_type = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    function symlinkType(srcpath, type, callback) {
-      callback = typeof type === "function" ? type : callback;
-      type = typeof type === "function" ? false : type;
+    var fs5 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
       if (type)
-        return callback(null, type);
-      fs5.lstat(srcpath, (err, stats) => {
-        if (err)
-          return callback(null, "file");
-        type = stats && stats.isDirectory() ? "dir" : "file";
-        callback(null, type);
-      });
+        return type;
+      let stats;
+      try {
+        stats = await fs5.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
     }
     function symlinkTypeSync(srcpath, type) {
-      let stats;
       if (type)
         return type;
+      let stats;
       try {
         stats = fs5.lstatSync(srcpath);
-      } catch (e) {
+      } catch {
         return "file";
       }
       return stats && stats.isDirectory() ? "dir" : "file";
     }
     module2.exports = {
-      symlinkType,
+      symlinkType: u(symlinkType),
       symlinkTypeSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js
 var require_symlink = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path5 = require("path");
-    var fs5 = require_graceful_fs();
-    var _mkdirs = require_mkdirs2();
-    var mkdirs = _mkdirs.mkdirs;
-    var mkdirsSync = _mkdirs.mkdirsSync;
-    var _symlinkPaths = require_symlink_paths();
-    var symlinkPaths = _symlinkPaths.symlinkPaths;
-    var symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
-    var _symlinkType = require_symlink_type();
-    var symlinkType = _symlinkType.symlinkType;
-    var symlinkTypeSync = _symlinkType.symlinkTypeSync;
-    var pathExists2 = require_path_exists2().pathExists;
-    function createSymlink(srcpath, dstpath, type, callback) {
-      callback = typeof type === "function" ? type : callback;
-      type = typeof type === "function" ? false : type;
-      pathExists2(dstpath, (err, destinationExists) => {
-        if (err)
-          return callback(err);
-        if (destinationExists)
-          return callback(null);
-        symlinkPaths(srcpath, dstpath, (err2, relative) => {
-          if (err2)
-            return callback(err2);
-          srcpath = relative.toDst;
-          symlinkType(relative.toCwd, type, (err3, type2) => {
-            if (err3)
-              return callback(err3);
-            const dir = path5.dirname(dstpath);
-            pathExists2(dir, (err4, dirExists) => {
-              if (err4)
-                return callback(err4);
-              if (dirExists)
-                return fs5.symlink(srcpath, dstpath, type2, callback);
-              mkdirs(dir, (err5) => {
-                if (err5)
-                  return callback(err5);
-                fs5.symlink(srcpath, dstpath, type2, callback);
-              });
-            });
-          });
-        });
-      });
-    }
-    function createSymlinkSync(srcpath, dstpath, type) {
-      const destinationExists = fs5.existsSync(dstpath);
-      if (destinationExists)
-        return void 0;
-      const relative = symlinkPathsSync(srcpath, dstpath);
+    var fs5 = require_fs();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists: pathExists2 } = require_path_exists2();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs5.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs5.stat(srcpath),
+          fs5.stat(dstpath)
+        ]);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
-      type = symlinkTypeSync(relative.toCwd, type);
+      const toType = await symlinkType(relative.toCwd, type);
       const dir = path5.dirname(dstpath);
-      const exists = fs5.existsSync(dir);
-      if (exists)
-        return fs5.symlinkSync(srcpath, dstpath, type);
-      mkdirsSync(dir);
-      return fs5.symlinkSync(srcpath, dstpath, type);
-    }
-    module2.exports = {
-      createSymlink: u(createSymlink),
-      createSymlinkSync
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/index.js
-var require_ensure = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/ensure/index.js"(exports, module2) {
-    "use strict";
-    var file = require_file();
-    var link = require_link();
-    var symlink = require_symlink();
-    module2.exports = {
-      // file
-      createFile: file.createFile,
-      createFileSync: file.createFileSync,
-      ensureFile: file.createFile,
-      ensureFileSync: file.createFileSync,
-      // link
-      createLink: link.createLink,
-      createLinkSync: link.createLinkSync,
-      ensureLink: link.createLink,
-      ensureLinkSync: link.createLinkSync,
-      // symlink
-      createSymlink: symlink.createSymlink,
-      createSymlinkSync: symlink.createSymlinkSync,
-      ensureSymlink: symlink.createSymlink,
-      ensureSymlinkSync: symlink.createSymlinkSync
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
-var require_polyfills2 = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module2) {
-    var constants = require("constants");
-    var origCwd = process.cwd;
-    var cwd = null;
-    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-    process.cwd = function() {
-      if (!cwd)
-        cwd = origCwd.call(process);
-      return cwd;
-    };
-    try {
-      process.cwd();
-    } catch (er) {
-    }
-    if (typeof process.chdir === "function") {
-      chdir = process.chdir;
-      process.chdir = function(d) {
-        cwd = null;
-        chdir.call(process, d);
-      };
-      if (Object.setPrototypeOf)
-        Object.setPrototypeOf(process.chdir, chdir);
-    }
-    var chdir;
-    module2.exports = patch;
-    function patch(fs5) {
-      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs5);
-      }
-      if (!fs5.lutimes) {
-        patchLutimes(fs5);
-      }
-      fs5.chown = chownFix(fs5.chown);
-      fs5.fchown = chownFix(fs5.fchown);
-      fs5.lchown = chownFix(fs5.lchown);
-      fs5.chmod = chmodFix(fs5.chmod);
-      fs5.fchmod = chmodFix(fs5.fchmod);
-      fs5.lchmod = chmodFix(fs5.lchmod);
-      fs5.chownSync = chownFixSync(fs5.chownSync);
-      fs5.fchownSync = chownFixSync(fs5.fchownSync);
-      fs5.lchownSync = chownFixSync(fs5.lchownSync);
-      fs5.chmodSync = chmodFixSync(fs5.chmodSync);
-      fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
-      fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
-      fs5.stat = statFix(fs5.stat);
-      fs5.fstat = statFix(fs5.fstat);
-      fs5.lstat = statFix(fs5.lstat);
-      fs5.statSync = statFixSync(fs5.statSync);
-      fs5.fstatSync = statFixSync(fs5.fstatSync);
-      fs5.lstatSync = statFixSync(fs5.lstatSync);
-      if (fs5.chmod && !fs5.lchmod) {
-        fs5.lchmod = function(path5, mode, cb) {
-          if (cb)
-            process.nextTick(cb);
-        };
-        fs5.lchmodSync = function() {
-        };
-      }
-      if (fs5.chown && !fs5.lchown) {
-        fs5.lchown = function(path5, uid, gid, cb) {
-          if (cb)
-            process.nextTick(cb);
-        };
-        fs5.lchownSync = function() {
-        };
-      }
-      if (platform === "win32") {
-        fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : function(fs$rename) {
-          function rename(from, to, cb) {
-            var start = Date.now();
-            var backoff = 0;
-            fs$rename(from, to, function CB(er) {
-              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
-                setTimeout(function() {
-                  fs5.stat(to, function(stater, st) {
-                    if (stater && stater.code === "ENOENT")
-                      fs$rename(from, to, CB);
-                    else
-                      cb(er);
-                  });
-                }, backoff);
-                if (backoff < 100)
-                  backoff += 10;
-                return;
-              }
-              if (cb)
-                cb(er);
-            });
-          }
-          if (Object.setPrototypeOf)
-            Object.setPrototypeOf(rename, fs$rename);
-          return rename;
-        }(fs5.rename);
-      }
-      fs5.read = typeof fs5.read !== "function" ? fs5.read : function(fs$read) {
-        function read(fd, buffer, offset, length, position, callback_) {
-          var callback;
-          if (callback_ && typeof callback_ === "function") {
-            var eagCounter = 0;
-            callback = function(er, _, __) {
-              if (er && er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
-              }
-              callback_.apply(this, arguments);
-            };
-          }
-          return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
-        }
-        if (Object.setPrototypeOf)
-          Object.setPrototypeOf(read, fs$read);
-        return read;
-      }(fs5.read);
-      fs5.readSync = typeof fs5.readSync !== "function" ? fs5.readSync : function(fs$readSync) {
-        return function(fd, buffer, offset, length, position) {
-          var eagCounter = 0;
-          while (true) {
-            try {
-              return fs$readSync.call(fs5, fd, buffer, offset, length, position);
-            } catch (er) {
-              if (er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                continue;
-              }
-              throw er;
-            }
-          }
-        };
-      }(fs5.readSync);
-      function patchLchmod(fs6) {
-        fs6.lchmod = function(path5, mode, callback) {
-          fs6.open(
-            path5,
-            constants.O_WRONLY | constants.O_SYMLINK,
-            mode,
-            function(err, fd) {
-              if (err) {
-                if (callback)
-                  callback(err);
-                return;
-              }
-              fs6.fchmod(fd, mode, function(err2) {
-                fs6.close(fd, function(err22) {
-                  if (callback)
-                    callback(err2 || err22);
-                });
-              });
-            }
-          );
-        };
-        fs6.lchmodSync = function(path5, mode) {
-          var fd = fs6.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
-          var threw = true;
-          var ret;
-          try {
-            ret = fs6.fchmodSync(fd, mode);
-            threw = false;
-          } finally {
-            if (threw) {
-              try {
-                fs6.closeSync(fd);
-              } catch (er) {
-              }
-            } else {
-              fs6.closeSync(fd);
-            }
-          }
-          return ret;
-        };
-      }
-      function patchLutimes(fs6) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
-          fs6.lutimes = function(path5, at, mt, cb) {
-            fs6.open(path5, constants.O_SYMLINK, function(er, fd) {
-              if (er) {
-                if (cb)
-                  cb(er);
-                return;
-              }
-              fs6.futimes(fd, at, mt, function(er2) {
-                fs6.close(fd, function(er22) {
-                  if (cb)
-                    cb(er2 || er22);
-                });
-              });
-            });
-          };
-          fs6.lutimesSync = function(path5, at, mt) {
-            var fd = fs6.openSync(path5, constants.O_SYMLINK);
-            var ret;
-            var threw = true;
-            try {
-              ret = fs6.futimesSync(fd, at, mt);
-              threw = false;
-            } finally {
-              if (threw) {
-                try {
-                  fs6.closeSync(fd);
-                } catch (er) {
-                }
-              } else {
-                fs6.closeSync(fd);
-              }
-            }
-            return ret;
-          };
-        } else if (fs6.futimes) {
-          fs6.lutimes = function(_a, _b, _c, cb) {
-            if (cb)
-              process.nextTick(cb);
-          };
-          fs6.lutimesSync = function() {
-          };
-        }
-      }
-      function chmodFix(orig) {
-        if (!orig)
-          return orig;
-        return function(target, mode, cb) {
-          return orig.call(fs5, target, mode, function(er) {
-            if (chownErOk(er))
-              er = null;
-            if (cb)
-              cb.apply(this, arguments);
-          });
-        };
-      }
-      function chmodFixSync(orig) {
-        if (!orig)
-          return orig;
-        return function(target, mode) {
-          try {
-            return orig.call(fs5, target, mode);
-          } catch (er) {
-            if (!chownErOk(er))
-              throw er;
-          }
-        };
-      }
-      function chownFix(orig) {
-        if (!orig)
-          return orig;
-        return function(target, uid, gid, cb) {
-          return orig.call(fs5, target, uid, gid, function(er) {
-            if (chownErOk(er))
-              er = null;
-            if (cb)
-              cb.apply(this, arguments);
-          });
-        };
-      }
-      function chownFixSync(orig) {
-        if (!orig)
-          return orig;
-        return function(target, uid, gid) {
-          try {
-            return orig.call(fs5, target, uid, gid);
-          } catch (er) {
-            if (!chownErOk(er))
-              throw er;
-          }
-        };
-      }
-      function statFix(orig) {
-        if (!orig)
-          return orig;
-        return function(target, options, cb) {
-          if (typeof options === "function") {
-            cb = options;
-            options = null;
-          }
-          function callback(er, stats) {
-            if (stats) {
-              if (stats.uid < 0)
-                stats.uid += 4294967296;
-              if (stats.gid < 0)
-                stats.gid += 4294967296;
-            }
-            if (cb)
-              cb.apply(this, arguments);
-          }
-          return options ? orig.call(fs5, target, options, callback) : orig.call(fs5, target, callback);
-        };
-      }
-      function statFixSync(orig) {
-        if (!orig)
-          return orig;
-        return function(target, options) {
-          var stats = options ? orig.call(fs5, target, options) : orig.call(fs5, target);
-          if (stats) {
-            if (stats.uid < 0)
-              stats.uid += 4294967296;
-            if (stats.gid < 0)
-              stats.gid += 4294967296;
-          }
-          return stats;
-        };
-      }
-      function chownErOk(er) {
-        if (!er)
-          return true;
-        if (er.code === "ENOSYS")
-          return true;
-        var nonroot = !process.getuid || process.getuid() !== 0;
-        if (nonroot) {
-          if (er.code === "EINVAL" || er.code === "EPERM")
-            return true;
-        }
-        return false;
-      }
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams2 = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
-    var Stream = require("stream").Stream;
-    module2.exports = legacy;
-    function legacy(fs5) {
-      return {
-        ReadStream,
-        WriteStream
-      };
-      function ReadStream(path5, options) {
-        if (!(this instanceof ReadStream))
-          return new ReadStream(path5, options);
-        Stream.call(this);
-        var self = this;
-        this.path = path5;
-        this.fd = null;
-        this.readable = true;
-        this.paused = false;
-        this.flags = "r";
-        this.mode = 438;
-        this.bufferSize = 64 * 1024;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.encoding)
-          this.setEncoding(this.encoding);
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.end === void 0) {
-            this.end = Infinity;
-          } else if ("number" !== typeof this.end) {
-            throw TypeError("end must be a Number");
-          }
-          if (this.start > this.end) {
-            throw new Error("start must be <= end");
-          }
-          this.pos = this.start;
-        }
-        if (this.fd !== null) {
-          process.nextTick(function() {
-            self._read();
-          });
-          return;
-        }
-        fs5.open(this.path, this.flags, this.mode, function(err, fd) {
-          if (err) {
-            self.emit("error", err);
-            self.readable = false;
-            return;
-          }
-          self.fd = fd;
-          self.emit("open", fd);
-          self._read();
-        });
-      }
-      function WriteStream(path5, options) {
-        if (!(this instanceof WriteStream))
-          return new WriteStream(path5, options);
-        Stream.call(this);
-        this.path = path5;
-        this.fd = null;
-        this.writable = true;
-        this.flags = "w";
-        this.encoding = "binary";
-        this.mode = 438;
-        this.bytesWritten = 0;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.start < 0) {
-            throw new Error("start must be >= zero");
-          }
-          this.pos = this.start;
-        }
-        this.busy = false;
-        this._queue = [];
-        if (this.fd === null) {
-          this._open = fs5.open;
-          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
-          this.flush();
-        }
-      }
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
-var require_clone2 = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module2) {
-    "use strict";
-    module2.exports = clone;
-    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
-      return obj.__proto__;
-    };
-    function clone(obj) {
-      if (obj === null || typeof obj !== "object")
-        return obj;
-      if (obj instanceof Object)
-        var copy = { __proto__: getPrototypeOf(obj) };
-      else
-        var copy = /* @__PURE__ */ Object.create(null);
-      Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-      });
-      return copy;
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
-var require_graceful_fs2 = __commonJS({
-  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
-    var fs5 = require("fs");
-    var polyfills = require_polyfills2();
-    var legacy = require_legacy_streams2();
-    var clone = require_clone2();
-    var util = require("util");
-    var gracefulQueue;
-    var previousSymbol;
-    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
-      gracefulQueue = Symbol.for("graceful-fs.queue");
-      previousSymbol = Symbol.for("graceful-fs.previous");
-    } else {
-      gracefulQueue = "___graceful-fs.queue";
-      previousSymbol = "___graceful-fs.previous";
-    }
-    function noop() {
-    }
-    function publishQueue(context, queue2) {
-      Object.defineProperty(context, gracefulQueue, {
-        get: function() {
-          return queue2;
-        }
-      });
-    }
-    var debug4 = noop;
-    if (util.debuglog)
-      debug4 = util.debuglog("gfs4");
-    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug4 = function() {
-        var m = util.format.apply(util, arguments);
-        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
-        console.error(m);
-      };
-    if (!fs5[gracefulQueue]) {
-      queue = global[gracefulQueue] || [];
-      publishQueue(fs5, queue);
-      fs5.close = function(fs$close) {
-        function close(fd, cb) {
-          return fs$close.call(fs5, fd, function(err) {
-            if (!err) {
-              resetQueue();
-            }
-            if (typeof cb === "function")
-              cb.apply(this, arguments);
-          });
-        }
-        Object.defineProperty(close, previousSymbol, {
-          value: fs$close
-        });
-        return close;
-      }(fs5.close);
-      fs5.closeSync = function(fs$closeSync) {
-        function closeSync(fd) {
-          fs$closeSync.apply(fs5, arguments);
-          resetQueue();
-        }
-        Object.defineProperty(closeSync, previousSymbol, {
-          value: fs$closeSync
-        });
-        return closeSync;
-      }(fs5.closeSync);
-      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
-        process.on("exit", function() {
-          debug4(fs5[gracefulQueue]);
-          require("assert").equal(fs5[gracefulQueue].length, 0);
-        });
-      }
-    }
-    var queue;
-    if (!global[gracefulQueue]) {
-      publishQueue(global, fs5[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs5));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
-      module2.exports = patch(fs5);
-      fs5.__patched = true;
-    }
-    function patch(fs6) {
-      polyfills(fs6);
-      fs6.gracefulify = patch;
-      fs6.createReadStream = createReadStream;
-      fs6.createWriteStream = createWriteStream;
-      var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile3;
-      function readFile3(path5, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$readFile(path5, options, cb);
-        function go$readFile(path6, options2, cb2, startTime) {
-          return fs$readFile(path6, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile2;
-      function writeFile2(path5, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$writeFile(path5, data, options, cb);
-        function go$writeFile(path6, data2, options2, cb2, startTime) {
-          return fs$writeFile(path6, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$appendFile = fs6.appendFile;
-      if (fs$appendFile)
-        fs6.appendFile = appendFile;
-      function appendFile(path5, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$appendFile(path5, data, options, cb);
-        function go$appendFile(path6, data2, options2, cb2, startTime) {
-          return fs$appendFile(path6, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$copyFile = fs6.copyFile;
-      if (fs$copyFile)
-        fs6.copyFile = copyFile;
-      function copyFile(src, dest, flags, cb) {
-        if (typeof flags === "function") {
-          cb = flags;
-          flags = 0;
-        }
-        return go$copyFile(src, dest, flags, cb);
-        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
-          return fs$copyFile(src2, dest2, flags2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$readdir = fs6.readdir;
-      fs6.readdir = readdir;
-      var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path5, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, fs$readdirCallback(
-            path6,
-            options2,
-            cb2,
-            startTime
-          ));
-        } : function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, options2, fs$readdirCallback(
-            path6,
-            options2,
-            cb2,
-            startTime
-          ));
-        };
-        return go$readdir(path5, options, cb);
-        function fs$readdirCallback(path6, options2, cb2, startTime) {
-          return function(err, files) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([
-                go$readdir,
-                [path6, options2, cb2],
-                err,
-                startTime || Date.now(),
-                Date.now()
-              ]);
-            else {
-              if (files && files.sort)
-                files.sort();
-              if (typeof cb2 === "function")
-                cb2.call(this, err, files);
-            }
-          };
-        }
-      }
-      if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs6);
-        ReadStream = legStreams.ReadStream;
-        WriteStream = legStreams.WriteStream;
-      }
-      var fs$ReadStream = fs6.ReadStream;
-      if (fs$ReadStream) {
-        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-        ReadStream.prototype.open = ReadStream$open;
-      }
-      var fs$WriteStream = fs6.WriteStream;
-      if (fs$WriteStream) {
-        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-        WriteStream.prototype.open = WriteStream$open;
-      }
-      Object.defineProperty(fs6, "ReadStream", {
-        get: function() {
-          return ReadStream;
-        },
-        set: function(val) {
-          ReadStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      Object.defineProperty(fs6, "WriteStream", {
-        get: function() {
-          return WriteStream;
-        },
-        set: function(val) {
-          WriteStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileReadStream = ReadStream;
-      Object.defineProperty(fs6, "FileReadStream", {
-        get: function() {
-          return FileReadStream;
-        },
-        set: function(val) {
-          FileReadStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileWriteStream = WriteStream;
-      Object.defineProperty(fs6, "FileWriteStream", {
-        get: function() {
-          return FileWriteStream;
-        },
-        set: function(val) {
-          FileWriteStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      function ReadStream(path5, options) {
-        if (this instanceof ReadStream)
-          return fs$ReadStream.apply(this, arguments), this;
-        else
-          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
-      }
-      function ReadStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            if (that.autoClose)
-              that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-            that.read();
-          }
-        });
-      }
-      function WriteStream(path5, options) {
-        if (this instanceof WriteStream)
-          return fs$WriteStream.apply(this, arguments), this;
-        else
-          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
-      }
-      function WriteStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-          }
-        });
-      }
-      function createReadStream(path5, options) {
-        return new fs6.ReadStream(path5, options);
-      }
-      function createWriteStream(path5, options) {
-        return new fs6.WriteStream(path5, options);
-      }
-      var fs$open = fs6.open;
-      fs6.open = open;
-      function open(path5, flags, mode, cb) {
-        if (typeof mode === "function")
-          cb = mode, mode = null;
-        return go$open(path5, flags, mode, cb);
-        function go$open(path6, flags2, mode2, cb2, startTime) {
-          return fs$open(path6, flags2, mode2, function(err, fd) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      return fs6;
-    }
-    function enqueue(elem) {
-      debug4("ENQUEUE", elem[0].name, elem[1]);
-      fs5[gracefulQueue].push(elem);
-      retry();
-    }
-    var retryTimer;
-    function resetQueue() {
-      var now = Date.now();
-      for (var i = 0; i < fs5[gracefulQueue].length; ++i) {
-        if (fs5[gracefulQueue][i].length > 2) {
-          fs5[gracefulQueue][i][3] = now;
-          fs5[gracefulQueue][i][4] = now;
-        }
+      if (!await pathExists2(dir)) {
+        await mkdirs(dir);
       }
-      retry();
+      return fs5.symlink(srcpath, dstpath, toType);
     }
-    function retry() {
-      clearTimeout(retryTimer);
-      retryTimer = void 0;
-      if (fs5[gracefulQueue].length === 0)
-        return;
-      var elem = fs5[gracefulQueue].shift();
-      var fn = elem[0];
-      var args = elem[1];
-      var err = elem[2];
-      var startTime = elem[3];
-      var lastTime = elem[4];
-      if (startTime === void 0) {
-        debug4("RETRY", fn.name, args);
-        fn.apply(null, args);
-      } else if (Date.now() - startTime >= 6e4) {
-        debug4("TIMEOUT", fn.name, args);
-        var cb = args.pop();
-        if (typeof cb === "function")
-          cb.call(null, err);
-      } else {
-        var sinceAttempt = Date.now() - lastTime;
-        var sinceStart = Math.max(lastTime - startTime, 1);
-        var desiredDelay = Math.min(sinceStart * 1.2, 100);
-        if (sinceAttempt >= desiredDelay) {
-          debug4("RETRY", fn.name, args);
-          fn.apply(null, args.concat([startTime]));
-        } else {
-          fs5[gracefulQueue].push(elem);
-        }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs5.lstatSync(dstpath);
+      } catch {
       }
-      if (retryTimer === void 0) {
-        retryTimer = setTimeout(retry, 0);
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs5.statSync(srcpath);
+        const dstStat = fs5.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat))
+          return;
       }
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path5.dirname(dstpath);
+      const exists = fs5.existsSync(dir);
+      if (exists)
+        return fs5.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs5.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js"(exports, module2) {
+    "use strict";
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module2.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module2) {
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content))
+        content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
     }
+    module2.exports = { stringify, stripBom };
   }
 });
 
-// ../../node_modules/.pnpm/jsonfile@4.0.0/node_modules/jsonfile/index.js
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
 var require_jsonfile = __commonJS({
-  "../../node_modules/.pnpm/jsonfile@4.0.0/node_modules/jsonfile/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports, module2) {
     var _fs;
     try {
-      _fs = require_graceful_fs2();
+      _fs = require_graceful_fs();
     } catch (_) {
       _fs = require("fs");
     }
-    function readFile3(file, options, callback) {
-      if (callback == null) {
-        callback = options;
-        options = {};
-      }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils2();
+    async function _readFile(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      options = options || {};
-      var fs5 = options.fs || _fs;
-      var shouldThrow = true;
-      if ("throws" in options) {
-        shouldThrow = options.throws;
-      }
-      fs5.readFile(file, options, function(err, data) {
-        if (err)
-          return callback(err);
-        data = stripBom(data);
-        var obj;
-        try {
-          obj = JSON.parse(data, options ? options.reviver : null);
-        } catch (err2) {
-          if (shouldThrow) {
-            err2.message = file + ": " + err2.message;
-            return callback(err2);
-          } else {
-            return callback(null, null);
-          }
+      const fs5 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs5.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
         }
-        callback(null, obj);
-      });
+      }
+      return obj;
     }
-    function readFileSync(file, options) {
-      options = options || {};
+    var readFile3 = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      var fs5 = options.fs || _fs;
-      var shouldThrow = true;
-      if ("throws" in options) {
-        shouldThrow = options.throws;
-      }
+      const fs5 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        var content = fs5.readFileSync(file, options);
+        let content = fs5.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
         if (shouldThrow) {
-          err.message = file + ": " + err.message;
+          err.message = `${file}: ${err.message}`;
           throw err;
         } else {
           return null;
         }
       }
     }
-    function stringify(obj, options) {
-      var spaces;
-      var EOL = "\n";
-      if (typeof options === "object" && options !== null) {
-        if (options.spaces) {
-          spaces = options.spaces;
-        }
-        if (options.EOL) {
-          EOL = options.EOL;
-        }
-      }
-      var str = JSON.stringify(obj, options ? options.replacer : null, spaces);
-      return str.replace(/\n/g, EOL) + EOL;
-    }
-    function writeFile2(file, obj, options, callback) {
-      if (callback == null) {
-        callback = options;
-        options = {};
-      }
-      options = options || {};
-      var fs5 = options.fs || _fs;
-      var str = "";
-      try {
-        str = stringify(obj, options);
-      } catch (err) {
-        if (callback)
-          callback(err, null);
-        return;
-      }
-      fs5.writeFile(file, str, options, callback);
+    async function _writeFile(file, obj, options = {}) {
+      const fs5 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs5.writeFile)(file, str, options);
     }
-    function writeFileSync(file, obj, options) {
-      options = options || {};
-      var fs5 = options.fs || _fs;
-      var str = stringify(obj, options);
+    var writeFile2 = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs5 = options.fs || _fs;
+      const str = stringify(obj, options);
       return fs5.writeFileSync(file, str, options);
     }
-    function stripBom(content) {
-      if (Buffer.isBuffer(content))
-        content = content.toString("utf8");
-      content = content.replace(/^\uFEFF/, "");
-      return content;
-    }
     var jsonfile = {
       readFile: readFile3,
       readFileSync,
@@ -4382,76 +3152,84 @@ var require_jsonfile = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/jsonfile.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js
 var require_jsonfile2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
     var jsonFile = require_jsonfile();
     module2.exports = {
       // jsonfile exports
-      readJson: u(jsonFile.readFile),
+      readJson: jsonFile.readFile,
       readJsonSync: jsonFile.readFileSync,
-      writeJson: u(jsonFile.writeFile),
+      writeJson: jsonFile.writeFile,
       writeJsonSync: jsonFile.writeFileSync
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/output-json.js
-var require_output_json = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/output-json.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module2) {
     "use strict";
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
     var path5 = require("path");
-    var mkdir = require_mkdirs2();
+    var mkdir = require_mkdirs();
     var pathExists2 = require_path_exists2().pathExists;
-    var jsonFile = require_jsonfile2();
-    function outputJson(file, data, options, callback) {
-      if (typeof options === "function") {
-        callback = options;
-        options = {};
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path5.dirname(file);
+      if (!await pathExists2(dir)) {
+        await mkdir.mkdirs(dir);
       }
+      return fs5.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
       const dir = path5.dirname(file);
-      pathExists2(dir, (err, itDoes) => {
-        if (err)
-          return callback(err);
-        if (itDoes)
-          return jsonFile.writeJson(file, data, options, callback);
-        mkdir.mkdirs(dir, (err2) => {
-          if (err2)
-            return callback(err2);
-          jsonFile.writeJson(file, data, options, callback);
-        });
-      });
+      if (!fs5.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs5.writeFileSync(file, ...args);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js"(exports, module2) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
     }
     module2.exports = outputJson;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/output-json-sync.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js
 var require_output_json_sync = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var mkdir = require_mkdirs2();
-    var jsonFile = require_jsonfile2();
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
     function outputJsonSync(file, data, options) {
-      const dir = path5.dirname(file);
-      if (!fs5.existsSync(dir)) {
-        mkdir.mkdirsSync(dir);
-      }
-      jsonFile.writeJsonSync(file, data, options);
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
     }
     module2.exports = outputJsonSync;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/index.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js
 var require_json = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/json/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var jsonFile = require_jsonfile2();
     jsonFile.outputJson = u(require_output_json());
     jsonFile.outputJsonSync = require_output_json_sync();
@@ -4465,261 +3243,145 @@ var require_json = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/move-sync/index.js
-var require_move_sync = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/move-sync/index.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js"(exports, module2) {
     "use strict";
-    var fs5 = require_graceful_fs();
+    var fs5 = require_fs();
     var path5 = require("path");
-    var copySync = require_copy_sync2().copySync;
-    var removeSync = require_remove().removeSync;
-    var mkdirpSync = require_mkdirs2().mkdirsSync;
-    var buffer = require_buffer();
-    function moveSync(src, dest, options) {
-      options = options || {};
-      const overwrite = options.overwrite || options.clobber || false;
-      src = path5.resolve(src);
-      dest = path5.resolve(dest);
-      if (src === dest)
-        return fs5.accessSync(src);
-      if (isSrcSubdir(src, dest))
-        throw new Error(`Cannot move '${src}' into itself '${dest}'.`);
-      mkdirpSync(path5.dirname(dest));
-      tryRenameSync();
-      function tryRenameSync() {
-        if (overwrite) {
-          try {
-            return fs5.renameSync(src, dest);
-          } catch (err) {
-            if (err.code === "ENOTEMPTY" || err.code === "EEXIST" || err.code === "EPERM") {
-              removeSync(dest);
-              options.overwrite = false;
-              return moveSync(src, dest, options);
-            }
-            if (err.code !== "EXDEV")
-              throw err;
-            return moveSyncAcrossDevice(src, dest, overwrite);
-          }
-        } else {
-          try {
-            fs5.linkSync(src, dest);
-            return fs5.unlinkSync(src);
-          } catch (err) {
-            if (err.code === "EXDEV" || err.code === "EISDIR" || err.code === "EPERM" || err.code === "ENOTSUP") {
-              return moveSyncAcrossDevice(src, dest, overwrite);
-            }
-            throw err;
-          }
-        }
+    var { copy } = require_copy2();
+    var { remove: remove2 } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists2();
+    var stat2 = require_stat();
+    async function move(src, dest, opts = {}) {
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat2.checkPaths(src, dest, "move", opts);
+      await stat2.checkParentPaths(src, srcStat, dest, "move");
+      const destParent = path5.dirname(dest);
+      const parsedParentPath = path5.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
       }
+      return doRename(src, dest, overwrite, isChangingCase);
     }
-    function moveSyncAcrossDevice(src, dest, overwrite) {
-      const stat2 = fs5.statSync(src);
-      if (stat2.isDirectory()) {
-        return moveDirSyncAcrossDevice(src, dest, overwrite);
-      } else {
-        return moveFileSyncAcrossDevice(src, dest, overwrite);
-      }
-    }
-    function moveFileSyncAcrossDevice(src, dest, overwrite) {
-      const BUF_LENGTH = 64 * 1024;
-      const _buff = buffer(BUF_LENGTH);
-      const flags = overwrite ? "w" : "wx";
-      const fdr = fs5.openSync(src, "r");
-      const stat2 = fs5.fstatSync(fdr);
-      const fdw = fs5.openSync(dest, flags, stat2.mode);
-      let pos = 0;
-      while (pos < stat2.size) {
-        const bytesRead = fs5.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
-        fs5.writeSync(fdw, _buff, 0, bytesRead);
-        pos += bytesRead;
-      }
-      fs5.closeSync(fdr);
-      fs5.closeSync(fdw);
-      return fs5.unlinkSync(src);
-    }
-    function moveDirSyncAcrossDevice(src, dest, overwrite) {
-      const options = {
-        overwrite: false
-      };
-      if (overwrite) {
-        removeSync(dest);
-        tryCopySync();
-      } else {
-        tryCopySync();
-      }
-      function tryCopySync() {
-        copySync(src, dest, options);
-        return removeSync(src);
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove2(dest);
+        } else if (await pathExists2(dest)) {
+          throw new Error("dest already exists.");
+        }
       }
-    }
-    function isSrcSubdir(src, dest) {
       try {
-        return fs5.statSync(src).isDirectory() && src !== dest && dest.indexOf(src) > -1 && dest.split(path5.dirname(src) + path5.sep)[1].split(path5.sep)[0] === path5.basename(src);
-      } catch (e) {
-        return false;
+        await fs5.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
       }
     }
-    module2.exports = {
-      moveSync
-    };
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove2(src);
+    }
+    module2.exports = move;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/move/index.js
-var require_move = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/move/index.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
     var fs5 = require_graceful_fs();
     var path5 = require("path");
-    var copy = require_copy2().copy;
-    var remove2 = require_remove().remove;
-    var mkdirp = require_mkdirs2().mkdirp;
-    var pathExists2 = require_path_exists2().pathExists;
-    function move(src, dest, opts, cb) {
-      if (typeof opts === "function") {
-        cb = opts;
-        opts = {};
-      }
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat2 = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
       const overwrite = opts.overwrite || opts.clobber || false;
-      src = path5.resolve(src);
-      dest = path5.resolve(dest);
-      if (src === dest)
-        return fs5.access(src, cb);
-      fs5.stat(src, (err, st) => {
-        if (err)
-          return cb(err);
-        if (st.isDirectory() && isSrcSubdir(src, dest)) {
-          return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`));
-        }
-        mkdirp(path5.dirname(dest), (err2) => {
-          if (err2)
-            return cb(err2);
-          return doRename(src, dest, overwrite, cb);
-        });
-      });
-    }
-    function doRename(src, dest, overwrite, cb) {
+      const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
+      stat2.checkParentPathsSync(src, srcStat, dest, "move");
+      if (!isParentRoot(dest))
+        mkdirpSync(path5.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path5.dirname(dest);
+      const parsedPath = path5.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase)
+        return rename(src, dest, overwrite);
       if (overwrite) {
-        return remove2(dest, (err) => {
-          if (err)
-            return cb(err);
-          return rename(src, dest, overwrite, cb);
-        });
+        removeSync(dest);
+        return rename(src, dest, overwrite);
       }
-      pathExists2(dest, (err, destExists) => {
-        if (err)
-          return cb(err);
-        if (destExists)
-          return cb(new Error("dest already exists."));
-        return rename(src, dest, overwrite, cb);
-      });
+      if (fs5.existsSync(dest))
+        throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
     }
-    function rename(src, dest, overwrite, cb) {
-      fs5.rename(src, dest, (err) => {
-        if (!err)
-          return cb();
+    function rename(src, dest, overwrite) {
+      try {
+        fs5.renameSync(src, dest);
+      } catch (err) {
         if (err.code !== "EXDEV")
-          return cb(err);
-        return moveAcrossDevice(src, dest, overwrite, cb);
-      });
+          throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
     }
-    function moveAcrossDevice(src, dest, overwrite, cb) {
+    function moveAcrossDevice(src, dest, overwrite) {
       const opts = {
         overwrite,
-        errorOnExist: true
+        errorOnExist: true,
+        preserveTimestamps: true
       };
-      copy(src, dest, opts, (err) => {
-        if (err)
-          return cb(err);
-        return remove2(src, cb);
-      });
+      copySync(src, dest, opts);
+      return removeSync(src);
     }
-    function isSrcSubdir(src, dest) {
-      const srcArray = src.split(path5.sep);
-      const destArray = dest.split(path5.sep);
-      return srcArray.reduce((acc, current, i) => {
-        return acc && destArray[i] === current;
-      }, true);
-    }
-    module2.exports = {
-      move: u(move)
-    };
+    module2.exports = moveSync;
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/output/index.js
-var require_output = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/output/index.js"(exports, module2) {
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js"(exports, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    var fs5 = require_graceful_fs();
-    var path5 = require("path");
-    var mkdir = require_mkdirs2();
-    var pathExists2 = require_path_exists2().pathExists;
-    function outputFile(file, data, encoding, callback) {
-      if (typeof encoding === "function") {
-        callback = encoding;
-        encoding = "utf8";
-      }
-      const dir = path5.dirname(file);
-      pathExists2(dir, (err, itDoes) => {
-        if (err)
-          return callback(err);
-        if (itDoes)
-          return fs5.writeFile(file, data, encoding, callback);
-        mkdir.mkdirs(dir, (err2) => {
-          if (err2)
-            return callback(err2);
-          fs5.writeFile(file, data, encoding, callback);
-        });
-      });
-    }
-    function outputFileSync(file, ...args) {
-      const dir = path5.dirname(file);
-      if (fs5.existsSync(dir)) {
-        return fs5.writeFileSync(file, ...args);
-      }
-      mkdir.mkdirsSync(dir);
-      fs5.writeFileSync(file, ...args);
-    }
+    var u = require_universalify().fromPromise;
     module2.exports = {
-      outputFile: u(outputFile),
-      outputFileSync
+      move: u(require_move()),
+      moveSync: require_move_sync()
     };
   }
 });
 
-// ../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/index.js
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js
 var require_lib2 = __commonJS({
-  "../../node_modules/.pnpm/fs-extra@7.0.0/node_modules/fs-extra/lib/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js"(exports, module2) {
     "use strict";
-    module2.exports = Object.assign(
-      {},
+    module2.exports = {
       // Export promiseified graceful-fs:
-      require_fs(),
+      ...require_fs(),
       // Export extra methods:
-      require_copy_sync2(),
-      require_copy2(),
-      require_empty(),
-      require_ensure(),
-      require_json(),
-      require_mkdirs2(),
-      require_move_sync(),
-      require_move(),
-      require_output(),
-      require_path_exists2(),
-      require_remove()
-    );
-    var fs5 = require("fs");
-    if (Object.getOwnPropertyDescriptor(fs5, "promises")) {
-      Object.defineProperty(module2.exports, "promises", {
-        get() {
-          return fs5.promises;
-        }
-      });
-    }
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists2(),
+      ...require_remove()
+    };
   }
 });
 
@@ -11698,6 +10360,7 @@ var src_exports = {};
 __export(src_exports, {
   MAX_AGE_ONE_YEAR: () => MAX_AGE_ONE_YEAR,
   build: () => build,
+  diagnostics: () => diagnostics,
   htmlContentType: () => htmlContentType,
   prepareCache: () => prepareCache,
   version: () => version
@@ -12710,7 +11373,8 @@ async function getPageLambdaGroups({
   internalPages,
   pageExtensions,
   inversedAppPathManifest,
-  experimentalAllowBundling
+  experimentalAllowBundling,
+  isRouteHandlers
 }) {
   const groups = [];
   for (const page of pages) {
@@ -12764,7 +11428,7 @@ async function getPageLambdaGroups({
         ...opts,
         isPrerenders: isPrerenderRoute,
         isExperimentalPPR,
-        isApiLambda: !!isApiPage(page),
+        isApiLambda: !!isApiPage(page) || !!isRouteHandlers,
         pseudoLayerBytes: initialPseudoLayer.pseudoLayerBytes,
         pseudoLayerUncompressedBytes: initialPseudoLayerUncompressed,
         pseudoLayer: Object.assign({}, initialPseudoLayer.pseudoLayer)
@@ -14615,7 +13279,8 @@ async function serverBuild({
       initialFileReasons = /* @__PURE__ */ new Map();
       (0, import_build_utils2.debug)("Using next-server.js.nft.json trace from build");
     } else {
-      (0, import_build_utils2.debug)("tracing initial Next.js server files");
+      const serverTraceLabel = `Tracing initial Next.js server files due to missing build trace`;
+      console.time(serverTraceLabel);
       const result = await (0, import_nft.nodeFileTrace)([nextServerFile], {
         base: baseDir,
         cache: {},
@@ -14637,6 +13302,7 @@ async function serverBuild({
       });
       initialFileList = Array.from(result.fileList);
       initialFileReasons = result.reasons;
+      console.timeEnd(serverTraceLabel);
     }
     if (instrumentationHookBuildTrace) {
       initialFileList = initialFileList.concat(
@@ -14849,13 +13515,21 @@ async function serverBuild({
       return pageBuildTraces[page + ".nft.json"] || appBuildTraces[page + ".nft.json"];
     };
     const pathsToTrace = mergedPageKeys.map((page) => {
-      if (!getBuildTraceFile(page)) {
+      const originalPagePath = getOriginalPagePath(page);
+      if (!getBuildTraceFile(originalPagePath)) {
         return lambdaPages[page].fsPath;
       }
     }).filter(Boolean);
     let traceResult;
     let parentFilesMap;
     if (pathsToTrace.length > 0) {
+      const traceLabel = `Tracing entries due to missing build traces:
+${JSON.stringify(
+        pathsToTrace,
+        null,
+        2
+      )}`;
+      console.time(traceLabel);
       traceResult = await (0, import_nft.nodeFileTrace)(pathsToTrace, {
         base: baseDir,
         cache: traceCache,
@@ -14866,6 +13540,7 @@ async function serverBuild({
         traceResult.fileList,
         traceResult.reasons
       );
+      console.timeEnd(traceLabel);
     }
     for (const page of mergedPageKeys) {
       const tracedFiles = {};
@@ -14995,7 +13670,8 @@ async function serverBuild({
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions,
-      inversedAppPathManifest
+      inversedAppPathManifest,
+      isRouteHandlers: true
     });
     const appRouterStreamingActionLambdaGroups = [];
     for (const group of appRouterLambdaGroups) {
@@ -15511,10 +14187,6 @@ async function serverBuild({
   if (appPathRoutesManifest) {
     const edgeFunctions = middleware.edgeFunctions;
     for (const route of Object.values(appPathRoutesManifest)) {
-      const ogRoute = inversedAppPathManifest[route];
-      if (ogRoute.endsWith("/route")) {
-        continue;
-      }
       const pathname = import_path4.default.posix.join(
         "./",
         entryDirectory,
@@ -16272,14 +14944,15 @@ function isLegacyNext(nextVersion) {
   }
   return true;
 }
-var build = async ({
-  files,
-  workPath,
-  repoRootPath,
-  entrypoint,
-  config = {},
-  meta = {}
-}) => {
+var build = async (buildOptions) => {
+  let { workPath, repoRootPath } = buildOptions;
+  const {
+    files,
+    entrypoint,
+    config = {},
+    meta = {},
+    buildCallback
+  } = buildOptions;
   validateEntrypoint(entrypoint);
   let entryDirectory = import_path5.default.dirname(entrypoint);
   let entryPath = import_path5.default.join(workPath, entryDirectory);
@@ -16481,6 +15154,9 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     });
   }
   (0, import_build_utils3.debug)("build command exited");
+  if (buildCallback) {
+    await buildCallback(buildOptions);
+  }
   let buildOutputVersion;
   try {
     const data = await (0, import_fs_extra6.readJSON)(
@@ -18187,6 +16863,33 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     framework: { version: nextVersion }
   };
 };
+var diagnostics = async ({
+  config,
+  entrypoint,
+  workPath,
+  repoRootPath
+}) => {
+  const entryDirectory = import_path5.default.dirname(entrypoint);
+  const entryPath = import_path5.default.join(workPath, entryDirectory);
+  const outputDirectory = import_path5.default.join("./", config.outputDirectory || ".next");
+  const basePath = repoRootPath || workPath;
+  const diagnosticsEntrypoint = import_path5.default.relative(basePath, entryPath);
+  (0, import_build_utils3.debug)(
+    `Reading diagnostics file in diagnosticsEntrypoint=${diagnosticsEntrypoint}`
+  );
+  return {
+    // Collect output in `.next/diagnostics`
+    ...await (0, import_build_utils3.glob)(
+      "diagnostics/*",
+      import_path5.default.join(basePath, diagnosticsEntrypoint, outputDirectory, "diagnostics")
+    ),
+    // Collect `.next/trace` file
+    ...await (0, import_build_utils3.glob)(
+      "trace",
+      import_path5.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
+    )
+  };
+};
 var prepareCache = async ({
   workPath,
   repoRootPath,
@@ -18223,6 +16926,7 @@ var prepareCache = async ({
 0 && (module.exports = {
   MAX_AGE_ONE_YEAR,
   build,
+  diagnostics,
   htmlContentType,
   prepareCache,
   version