@aws-cdk/integ-runner 2.197.13 → 2.197.14

package/lib/index.js

@@ -3543,9 +3543,9 @@ var require_graceful_fs = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/fs/index.js
+// ../../../node_modules/fs-extra/lib/fs/index.js
 var require_fs = __commonJS({
-  "node_modules/fs-extra/lib/fs/index.js"(exports2) {
+  "../../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
     var fs3 = require_graceful_fs();
@@ -3556,6 +3556,7 @@ var require_fs = __commonJS({
       "chown",
       "close",
       "copyFile",
+      "cp",
       "fchmod",
       "fchown",
       "fdatasync",
@@ -3563,8 +3564,10 @@ var require_fs = __commonJS({
       "fsync",
       "ftruncate",
       "futimes",
+      "glob",
       "lchmod",
       "lchown",
+      "lutimes",
       "link",
       "lstat",
       "mkdir",
@@ -3579,6 +3582,7 @@ var require_fs = __commonJS({
       "rm",
       "rmdir",
       "stat",
+      "statfs",
       "symlink",
       "truncate",
       "unlink",
@@ -3587,12 +3591,7 @@ var require_fs = __commonJS({
     ].filter((key) => {
       return typeof fs3[key] === "function";
     });
-    Object.keys(fs3).forEach((key) => {
-      if (key === "promises") {
-        return;
-      }
-      exports2[key] = fs3[key];
-    });
+    Object.assign(exports2, fs3);
     api.forEach((method) => {
       exports2[method] = u(fs3[method]);
     });
@@ -3626,45 +3625,46 @@ var require_fs = __commonJS({
         });
       });
     };
-    if (typeof fs3.writev === "function") {
-      exports2.writev = function(fd, buffers, ...args) {
-        if (typeof args[args.length - 1] === "function") {
-          return fs3.writev(fd, buffers, ...args);
-        }
-        return new Promise((resolve3, reject) => {
-          fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
-            if (err) return reject(err);
-            resolve3({ bytesWritten, buffers: buffers2 });
-          });
+    exports2.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs3.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve3, reject) => {
+        fs3.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err) return reject(err);
+          resolve3({ bytesRead, buffers: buffers2 });
         });
-      };
-    }
+      });
+    };
+    exports2.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs3.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve3, reject) => {
+        fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err) return reject(err);
+          resolve3({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
     if (typeof fs3.realpath.native === "function") {
       exports2.realpath.native = u(fs3.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
     }
   }
 });
 
-// ../../../node_modules/at-least-node/index.js
-var require_at_least_node = __commonJS({
-  "../../../node_modules/at-least-node/index.js"(exports2, module2) {
-    module2.exports = (r) => {
-      const n = process.versions.node.split(".").map((x) => parseInt(x, 10));
-      r = r.split(".").map((x) => parseInt(x, 10));
-      return n[0] > r[0] || n[0] === r[0] && (n[1] > r[1] || n[1] === r[1] && n[2] >= r[2]);
-    };
-  }
-});
-
-// node_modules/fs-extra/lib/mkdirs/make-dir.js
-var require_make_dir = __commonJS({
-  "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+// ../../../node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "../../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
     var path3 = require("path");
-    var atLeastNode = require_at_least_node();
-    var useNativeRecursiveOption = atLeastNode("10.12.0");
-    var checkPath = /* @__PURE__ */ __name((pth) => {
+    module2.exports.checkPath = /* @__PURE__ */ __name(function checkPath(pth) {
       if (process.platform === "win32") {
         const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path3.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
@@ -3674,102 +3674,40 @@ var require_make_dir = __commonJS({
         }
       }
     }, "checkPath");
-    var processOptions = /* @__PURE__ */ __name((options) => {
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = /* @__PURE__ */ __name((options) => {
       const defaults = { mode: 511 };
-      if (typeof options === "number") options = { mode: options };
-      return { ...defaults, ...options };
-    }, "processOptions");
-    var permissionError = /* @__PURE__ */ __name((pth) => {
-      const error2 = new Error(`operation not permitted, mkdir '${pth}'`);
-      error2.code = "EPERM";
-      error2.errno = -4048;
-      error2.path = pth;
-      error2.syscall = "mkdir";
-      return error2;
-    }, "permissionError");
-    module2.exports.makeDir = async (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      if (useNativeRecursiveOption) {
-        const pth = path3.resolve(input);
-        return fs3.mkdir(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-      }
-      const make = /* @__PURE__ */ __name(async (pth) => {
-        try {
-          await fs3.mkdir(pth, options.mode);
-        } catch (error2) {
-          if (error2.code === "EPERM") {
-            throw error2;
-          }
-          if (error2.code === "ENOENT") {
-            if (path3.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error2.message.includes("null bytes")) {
-              throw error2;
-            }
-            await make(path3.dirname(pth));
-            return make(pth);
-          }
-          try {
-            const stats = await fs3.stat(pth);
-            if (!stats.isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch {
-            throw error2;
-          }
-        }
-      }, "make");
-      return make(path3.resolve(input));
+      if (typeof options === "number") return options;
+      return { ...defaults, ...options }.mode;
+    }, "getMode");
+    module2.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs3.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
     };
-    module2.exports.makeDirSync = (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      if (useNativeRecursiveOption) {
-        const pth = path3.resolve(input);
-        return fs3.mkdirSync(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-      }
-      const make = /* @__PURE__ */ __name((pth) => {
-        try {
-          fs3.mkdirSync(pth, options.mode);
-        } catch (error2) {
-          if (error2.code === "EPERM") {
-            throw error2;
-          }
-          if (error2.code === "ENOENT") {
-            if (path3.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error2.message.includes("null bytes")) {
-              throw error2;
-            }
-            make(path3.dirname(pth));
-            return make(pth);
-          }
-          try {
-            if (!fs3.statSync(pth).isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch {
-            throw error2;
-          }
-        }
-      }, "make");
-      return make(path3.resolve(input));
+    module2.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs3.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
     };
   }
 });
 
-// node_modules/fs-extra/lib/mkdirs/index.js
+// ../../../node_modules/fs-extra/lib/mkdirs/index.js
 var require_mkdirs = __commonJS({
-  "node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
     var { makeDir: _makeDir, makeDirSync } = require_make_dir();
@@ -3786,20 +3724,44 @@ var require_mkdirs = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/util/utimes.js
+// ../../../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs3 = require_fs();
+    function pathExists(path3) {
+      return fs3.access(path3).then(() => true).catch(() => false);
+    }
+    __name(pathExists, "pathExists");
+    module2.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs3.existsSync
+    };
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/util/utimes.js
 var require_utimes = __commonJS({
-  "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_graceful_fs();
-    function utimesMillis(path3, atime, mtime, callback) {
-      fs3.open(path3, "r+", (err, fd) => {
-        if (err) return callback(err);
-        fs3.futimes(fd, atime, mtime, (futimesErr) => {
-          fs3.close(fd, (closeErr) => {
-            if (callback) callback(futimesErr || closeErr);
-          });
-        });
-      });
+    var fs3 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path3, atime, mtime) {
+      const fd = await fs3.open(path3, "r+");
+      let closeErr = null;
+      try {
+        await fs3.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs3.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
     }
     __name(utimesMillis, "utimesMillis");
     function utimesMillisSync(path3, atime, mtime) {
@@ -3809,38 +3771,36 @@ var require_utimes = __commonJS({
     }
     __name(utimesMillisSync, "utimesMillisSync");
     module2.exports = {
-      utimesMillis,
+      utimesMillis: u(utimesMillis),
       utimesMillisSync
     };
   }
 });
 
-// node_modules/fs-extra/lib/util/stat.js
+// ../../../node_modules/fs-extra/lib/util/stat.js
 var require_stat = __commonJS({
-  "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
     var fs3 = require_fs();
     var path3 = require("path");
-    var util2 = require("util");
-    var atLeastNode = require_at_least_node();
-    var nodeSupportsBigInt = atLeastNode("10.5.0");
-    var stat2 = /* @__PURE__ */ __name((file) => nodeSupportsBigInt ? fs3.stat(file, { bigint: true }) : fs3.stat(file), "stat");
-    var statSync = /* @__PURE__ */ __name((file) => nodeSupportsBigInt ? fs3.statSync(file, { bigint: true }) : fs3.statSync(file), "statSync");
-    function getStats(src, dest) {
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs3.stat(file, { bigint: true }) : (file) => fs3.lstat(file, { bigint: true });
       return Promise.all([
-        stat2(src),
-        stat2(dest).catch((err) => {
+        statFunc(src),
+        statFunc(dest).catch((err) => {
           if (err.code === "ENOENT") return null;
           throw err;
         })
       ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
     }
     __name(getStats, "getStats");
-    function getStatsSync(src, dest) {
+    function getStatsSync(src, dest, opts) {
       let destStat;
-      const srcStat = statSync(src);
+      const statFunc = opts.dereference ? (file) => fs3.statSync(file, { bigint: true }) : (file) => fs3.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
       try {
-        destStat = statSync(dest);
+        destStat = statFunc(dest);
       } catch (err) {
         if (err.code === "ENOENT") return { srcStat, destStat: null };
         throw err;
@@ -3848,24 +3808,47 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     __name(getStatsSync, "getStatsSync");
-    function checkPaths(src, dest, funcName, cb) {
-      util2.callbackify(getStats)(src, dest, (err, stats) => {
-        if (err) return cb(err);
-        const { srcStat, destStat } = stats;
-        if (destStat && areIdentical(srcStat, destStat)) {
-          return cb(new Error("Source and destination must not be the same."));
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path3.basename(src);
+          const destBaseName = path3.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() && isSrcSubdir(src, dest)) {
-          return cb(new Error(errMsg(src, dest, funcName)));
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
         }
-        return cb(null, { srcStat, destStat });
-      });
+        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 };
     }
     __name(checkPaths, "checkPaths");
-    function checkPathsSync(src, dest, funcName) {
-      const { srcStat, destStat } = getStatsSync(src, dest);
-      if (destStat && areIdentical(srcStat, destStat)) {
-        throw new Error("Source and destination must not be the same.");
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path3.basename(src);
+          const destBaseName = path3.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));
@@ -3873,22 +3856,21 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     __name(checkPathsSync, "checkPathsSync");
-    function checkParentPaths(src, srcStat, dest, funcName, cb) {
+    async function checkParentPaths(src, srcStat, dest, funcName) {
       const srcParent = path3.resolve(path3.dirname(src));
       const destParent = path3.resolve(path3.dirname(dest));
-      if (destParent === srcParent || destParent === path3.parse(destParent).root) return cb();
-      const callback = /* @__PURE__ */ __name((err, destStat) => {
-        if (err) {
-          if (err.code === "ENOENT") return cb();
-          return cb(err);
-        }
-        if (areIdentical(srcStat, destStat)) {
-          return cb(new Error(errMsg(src, dest, funcName)));
-        }
-        return checkParentPaths(src, srcStat, destParent, funcName, cb);
-      }, "callback");
-      if (nodeSupportsBigInt) fs3.stat(destParent, { bigint: true }, callback);
-      else fs3.stat(destParent, callback);
+      if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = await fs3.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);
     }
     __name(checkParentPaths, "checkParentPaths");
     function checkParentPathsSync(src, srcStat, dest, funcName) {
@@ -3897,7 +3879,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = statSync(destParent);
+        destStat = fs3.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -3909,21 +3891,13 @@ var require_stat = __commonJS({
     }
     __name(checkParentPathsSync, "checkParentPathsSync");
     function areIdentical(srcStat, destStat) {
-      if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
-        if (nodeSupportsBigInt || destStat.ino < Number.MAX_SAFE_INTEGER) {
-          return true;
-        }
-        if (destStat.size === srcStat.size && destStat.mode === srcStat.mode && destStat.nlink === srcStat.nlink && destStat.atimeMs === srcStat.atimeMs && destStat.mtimeMs === srcStat.mtimeMs && destStat.ctimeMs === srcStat.ctimeMs && destStat.birthtimeMs === srcStat.birthtimeMs) {
-          return true;
-        }
-      }
-      return false;
+      return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     __name(areIdentical, "areIdentical");
     function isSrcSubdir(src, dest) {
       const srcArr = path3.resolve(src).split(path3.sep).filter((i) => i);
       const destArr = path3.resolve(dest).split(path3.sep).filter((i) => i);
-      return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
+      return srcArr.every((cur, i) => destArr[i] === cur);
     }
     __name(isSrcSubdir, "isSrcSubdir");
     function errMsg(src, dest, funcName) {
@@ -3931,18 +3905,186 @@ var require_stat = __commonJS({
     }
     __name(errMsg, "errMsg");
     module2.exports = {
-      checkPaths,
+      // checkPaths
+      checkPaths: u(checkPaths),
       checkPathsSync,
-      checkParentPaths,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
       checkParentPathsSync,
-      isSrcSubdir
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/util/async.js
+var require_async = __commonJS({
+  "../../../node_modules/fs-extra/lib/util/async.js"(exports2, module2) {
+    "use strict";
+    async function asyncIteratorConcurrentProcess(iterator, fn) {
+      const promises = [];
+      for await (const item of iterator) {
+        promises.push(
+          fn(item).then(
+            () => null,
+            (err) => err ?? new Error("unknown error")
+          )
+        );
+      }
+      await Promise.all(
+        promises.map(
+          (promise) => promise.then((possibleErr) => {
+            if (possibleErr !== null) throw possibleErr;
+          })
+        )
+      );
+    }
+    __name(asyncIteratorConcurrentProcess, "asyncIteratorConcurrentProcess");
+    module2.exports = {
+      asyncIteratorConcurrentProcess
     };
   }
 });
 
-// node_modules/fs-extra/lib/copy-sync/copy-sync.js
+// ../../../node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require_fs();
+    var path3 = require("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat2 = require_stat();
+    var { asyncIteratorConcurrentProcess } = require_async();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await 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 = path3.dirname(dest);
+      const dirExists = await pathExists(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    __name(copy, "copy");
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter) return true;
+      return opts.filter(src, dest);
+    }
+    __name(runFilter, "runFilter");
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs3.stat : fs3.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}`);
+    }
+    __name(getStatsAndPerformCopy, "getStatsAndPerformCopy");
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs3.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    __name(onFile, "onFile");
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs3.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs3.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs3.chmod(dest, srcStat.mode);
+    }
+    __name(copyFile, "copyFile");
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    __name(fileIsNotWritable, "fileIsNotWritable");
+    function makeFileWritable(dest, srcMode) {
+      return fs3.chmod(dest, srcMode | 128);
+    }
+    __name(makeFileWritable, "makeFileWritable");
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs3.mkdir(dest);
+      }
+      await asyncIteratorConcurrentProcess(await fs3.opendir(src), async (item) => {
+        const srcItem = path3.join(src, item.name);
+        const destItem = path3.join(dest, item.name);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (include) {
+          const { destStat: destStat2 } = await stat2.checkPaths(srcItem, destItem, "copy", opts);
+          await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+        }
+      });
+      if (!destStat) {
+        await fs3.chmod(dest, srcStat.mode);
+      }
+    }
+    __name(onDir, "onDir");
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs3.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs3.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs3.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path3.resolve(process.cwd(), resolvedDest);
+      }
+      if (resolvedSrc !== 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 fs3.unlink(dest);
+      return fs3.symlink(resolvedSrc, dest);
+    }
+    __name(onLink, "onLink");
+    module2.exports = copy;
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/copy/copy-sync.js
 var require_copy_sync = __commonJS({
-  "node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
     var fs3 = require_graceful_fs();
     var path3 = require("path");
@@ -3957,33 +4099,29 @@ 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 { srcStat, destStat } = stat2.checkPathsSync(src, dest, "copy");
+      const { srcStat, destStat } = stat2.checkPathsSync(src, dest, "copy", opts);
       stat2.checkParentPathsSync(src, srcStat, dest, "copy");
-      return handleFilterAndCopy(destStat, src, dest, opts);
-    }
-    __name(copySync, "copySync");
-    function handleFilterAndCopy(destStat, src, dest, opts) {
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path3.dirname(dest);
       if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
-      return startCopy(destStat, src, dest, opts);
-    }
-    __name(handleFilterAndCopy, "handleFilterAndCopy");
-    function startCopy(destStat, src, dest, opts) {
-      if (opts.filter && !opts.filter(src, dest)) return;
       return getStats(destStat, src, dest, opts);
     }
-    __name(startCopy, "startCopy");
+    __name(copySync, "copySync");
     function getStats(destStat, src, dest, opts) {
       const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
       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}`);
     }
     __name(getStats, "getStats");
     function onFile(srcStat, destStat, src, dest, opts) {
@@ -4030,9 +4168,6 @@ var require_copy_sync = __commonJS({
     __name(setDestTimestamps, "setDestTimestamps");
     function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
-      if (destStat && !destStat.isDirectory()) {
-        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
-      }
       return copyDir(src, dest, opts);
     }
     __name(onDir, "onDir");
@@ -4043,14 +4178,23 @@ var require_copy_sync = __commonJS({
     }
     __name(mkDirAndCopy, "mkDirAndCopy");
     function copyDir(src, dest, opts) {
-      fs3.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      const dir = fs3.opendirSync(src);
+      try {
+        let dirent;
+        while ((dirent = dir.readSync()) !== null) {
+          copyDirItem(dirent.name, src, dest, opts);
+        }
+      } finally {
+        dir.closeSync();
+      }
     }
     __name(copyDir, "copyDir");
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path3.join(src, item);
       const destItem = path3.join(dest, item);
-      const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy");
-      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);
     }
     __name(copyDirItem, "copyDirItem");
     function onLink(destStat, src, dest, opts) {
@@ -4071,563 +4215,77 @@ var require_copy_sync = __commonJS({
         if (opts.dereference) {
           resolvedDest = path3.resolve(process.cwd(), resolvedDest);
         }
-        if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
-          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-        }
-        if (fs3.statSync(dest).isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
-          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
-        }
-        return copyLink(resolvedSrc, dest);
-      }
-    }
-    __name(onLink, "onLink");
-    function copyLink(resolvedSrc, dest) {
-      fs3.unlinkSync(dest);
-      return fs3.symlinkSync(resolvedSrc, dest);
-    }
-    __name(copyLink, "copyLink");
-    module2.exports = copySync;
-  }
-});
-
-// node_modules/fs-extra/lib/copy-sync/index.js
-var require_copy_sync2 = __commonJS({
-  "node_modules/fs-extra/lib/copy-sync/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      copySync: require_copy_sync()
-    };
-  }
-});
-
-// node_modules/fs-extra/lib/path-exists/index.js
-var require_path_exists = __commonJS({
-  "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
-    "use strict";
-    var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    function pathExists(path3) {
-      return fs3.access(path3).then(() => true).catch(() => false);
-    }
-    __name(pathExists, "pathExists");
-    module2.exports = {
-      pathExists: u(pathExists),
-      pathExistsSync: fs3.existsSync
-    };
-  }
-});
-
-// node_modules/fs-extra/lib/copy/copy.js
-var require_copy = __commonJS({
-  "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
-    "use strict";
-    var fs3 = require_graceful_fs();
-    var path3 = require("path");
-    var mkdirs = require_mkdirs().mkdirs;
-    var pathExists = require_path_exists().pathExists;
-    var utimesMillis = require_utimes().utimesMillis;
-    var stat2 = require_stat();
-    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`);
-      }
-      stat2.checkPaths(src, dest, "copy", (err, stats) => {
-        if (err) return cb(err);
-        const { srcStat, destStat } = stats;
-        stat2.checkParentPaths(src, srcStat, dest, "copy", (err2) => {
-          if (err2) return cb(err2);
-          if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb);
-          return checkParentDir(destStat, src, dest, opts, cb);
-        });
-      });
-    }
-    __name(copy, "copy");
-    function checkParentDir(destStat, src, dest, opts, cb) {
-      const destParent = path3.dirname(dest);
-      pathExists(destParent, (err, dirExists) => {
-        if (err) return cb(err);
-        if (dirExists) return startCopy(destStat, src, dest, opts, cb);
-        mkdirs(destParent, (err2) => {
-          if (err2) return cb(err2);
-          return startCopy(destStat, src, dest, opts, cb);
-        });
-      });
-    }
-    __name(checkParentDir, "checkParentDir");
-    function handleFilter(onInclude, destStat, src, dest, opts, cb) {
-      Promise.resolve(opts.filter(src, dest)).then((include) => {
-        if (include) return onInclude(destStat, src, dest, opts, cb);
-        return cb();
-      }, (error2) => cb(error2));
-    }
-    __name(handleFilter, "handleFilter");
-    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);
-    }
-    __name(startCopy, "startCopy");
-    function getStats(destStat, src, dest, opts, cb) {
-      const stat3 = opts.dereference ? fs3.stat : fs3.lstat;
-      stat3(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);
-      });
-    }
-    __name(getStats, "getStats");
-    function onFile(srcStat, destStat, src, dest, opts, cb) {
-      if (!destStat) return copyFile(srcStat, src, dest, opts, cb);
-      return mayCopyFile(srcStat, src, dest, opts, cb);
-    }
-    __name(onFile, "onFile");
-    function mayCopyFile(srcStat, src, dest, opts, cb) {
-      if (opts.overwrite) {
-        fs3.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();
-    }
-    __name(mayCopyFile, "mayCopyFile");
-    function copyFile(srcStat, src, dest, opts, cb) {
-      fs3.copyFile(src, dest, (err) => {
-        if (err) return cb(err);
-        if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
-        return setDestMode(dest, srcStat.mode, cb);
-      });
-    }
-    __name(copyFile, "copyFile");
-    function handleTimestampsAndMode(srcMode, src, dest, cb) {
-      if (fileIsNotWritable(srcMode)) {
-        return makeFileWritable(dest, srcMode, (err) => {
-          if (err) return cb(err);
-          return setDestTimestampsAndMode(srcMode, src, dest, cb);
-        });
-      }
-      return setDestTimestampsAndMode(srcMode, src, dest, cb);
-    }
-    __name(handleTimestampsAndMode, "handleTimestampsAndMode");
-    function fileIsNotWritable(srcMode) {
-      return (srcMode & 128) === 0;
-    }
-    __name(fileIsNotWritable, "fileIsNotWritable");
-    function makeFileWritable(dest, srcMode, cb) {
-      return setDestMode(dest, srcMode | 128, cb);
-    }
-    __name(makeFileWritable, "makeFileWritable");
-    function setDestTimestampsAndMode(srcMode, src, dest, cb) {
-      setDestTimestamps(src, dest, (err) => {
-        if (err) return cb(err);
-        return setDestMode(dest, srcMode, cb);
-      });
-    }
-    __name(setDestTimestampsAndMode, "setDestTimestampsAndMode");
-    function setDestMode(dest, srcMode, cb) {
-      return fs3.chmod(dest, srcMode, cb);
-    }
-    __name(setDestMode, "setDestMode");
-    function setDestTimestamps(src, dest, cb) {
-      fs3.stat(src, (err, updatedSrcStat) => {
-        if (err) return cb(err);
-        return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
-      });
-    }
-    __name(setDestTimestamps, "setDestTimestamps");
-    function onDir(srcStat, destStat, src, dest, opts, cb) {
-      if (!destStat) return mkDirAndCopy(srcStat.mode, 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);
-    }
-    __name(onDir, "onDir");
-    function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-      fs3.mkdir(dest, (err) => {
-        if (err) return cb(err);
-        copyDir(src, dest, opts, (err2) => {
-          if (err2) return cb(err2);
-          return setDestMode(dest, srcMode, cb);
-        });
-      });
-    }
-    __name(mkDirAndCopy, "mkDirAndCopy");
-    function copyDir(src, dest, opts, cb) {
-      fs3.readdir(src, (err, items) => {
-        if (err) return cb(err);
-        return copyDirItems(items, src, dest, opts, cb);
-      });
-    }
-    __name(copyDir, "copyDir");
-    function copyDirItems(items, src, dest, opts, cb) {
-      const item = items.pop();
-      if (!item) return cb();
-      return copyDirItem(items, item, src, dest, opts, cb);
-    }
-    __name(copyDirItems, "copyDirItems");
-    function copyDirItem(items, item, src, dest, opts, cb) {
-      const srcItem = path3.join(src, item);
-      const destItem = path3.join(dest, item);
-      stat2.checkPaths(srcItem, destItem, "copy", (err, stats) => {
-        if (err) return cb(err);
-        const { destStat } = stats;
-        startCopy(destStat, srcItem, destItem, opts, (err2) => {
-          if (err2) return cb(err2);
-          return copyDirItems(items, src, dest, opts, cb);
-        });
-      });
-    }
-    __name(copyDirItem, "copyDirItem");
-    function onLink(destStat, src, dest, opts, cb) {
-      fs3.readlink(src, (err, resolvedSrc) => {
-        if (err) return cb(err);
-        if (opts.dereference) {
-          resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
-        }
-        if (!destStat) {
-          return fs3.symlink(resolvedSrc, dest, cb);
-        } else {
-          fs3.readlink(dest, (err2, resolvedDest) => {
-            if (err2) {
-              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest, cb);
-              return cb(err2);
-            }
-            if (opts.dereference) {
-              resolvedDest = path3.resolve(process.cwd(), resolvedDest);
-            }
-            if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
-              return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
-            }
-            if (destStat.isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
-              return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
-            }
-            return copyLink(resolvedSrc, dest, cb);
-          });
-        }
-      });
-    }
-    __name(onLink, "onLink");
-    function copyLink(resolvedSrc, dest, cb) {
-      fs3.unlink(dest, (err) => {
-        if (err) return cb(err);
-        return fs3.symlink(resolvedSrc, dest, cb);
-      });
-    }
-    __name(copyLink, "copyLink");
-    module2.exports = copy;
-  }
-});
-
-// node_modules/fs-extra/lib/copy/index.js
-var require_copy2 = __commonJS({
-  "node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
-    "use strict";
-    var u = require_universalify().fromCallback;
-    module2.exports = {
-      copy: u(require_copy())
-    };
-  }
-});
-
-// node_modules/fs-extra/lib/remove/rimraf.js
-var require_rimraf = __commonJS({
-  "node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) {
-    "use strict";
-    var fs3 = require_graceful_fs();
-    var path3 = 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] || fs3[m];
-        m = m + "Sync";
-        options[m] = options[m] || fs3[m];
-      });
-      options.maxBusyTries = options.maxBusyTries || 3;
-    }
-    __name(defaults, "defaults");
-    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, /* @__PURE__ */ __name(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);
-      }, "CB"));
-    }
-    __name(rimraf, "rimraf");
-    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);
-            }
+        if (resolvedSrc !== resolvedDest) {
+          if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
+            throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
           }
-          return cb(er2);
-        });
-      });
-    }
-    __name(rimraf_, "rimraf_");
-    function fixWinEPERM(p, options, er, cb) {
-      assert(p);
-      assert(options);
-      assert(typeof cb === "function");
-      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);
-            }
-          });
-        }
-      });
-    }
-    __name(fixWinEPERM, "fixWinEPERM");
-    function fixWinEPERMSync(p, options, er) {
-      let stats;
-      assert(p);
-      assert(options);
-      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);
-      }
-    }
-    __name(fixWinEPERMSync, "fixWinEPERMSync");
-    function rmdir(p, options, originalEr, cb) {
-      assert(p);
-      assert(options);
-      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);
-        }
-      });
-    }
-    __name(rmdir, "rmdir");
-    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(path3.join(p, f), options, (er2) => {
-            if (errState) {
-              return;
-            }
-            if (er2) return cb(errState = er2);
-            if (--n === 0) {
-              options.rmdir(p, cb);
-            }
-          });
-        });
-      });
-    }
-    __name(rmkids, "rmkids");
-    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);
-      }
-    }
-    __name(rimrafSync, "rimrafSync");
-    function rmdirSync(p, options, originalEr) {
-      assert(p);
-      assert(options);
-      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;
-        }
-      }
-    }
-    __name(rmdirSync, "rmdirSync");
-    function rmkidsSync(p, options) {
-      assert(p);
-      assert(options);
-      options.readdirSync(p).forEach((f) => rimrafSync(path3.join(p, f), options));
-      if (isWindows) {
-        const startTime = Date.now();
-        do {
-          try {
-            const ret = options.rmdirSync(p, options);
-            return ret;
-          } catch {
+          if (stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+            throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
           }
-        } while (Date.now() - startTime < 500);
-      } else {
-        const ret = options.rmdirSync(p, options);
-        return ret;
+        }
+        return copyLink(resolvedSrc, dest);
       }
     }
-    __name(rmkidsSync, "rmkidsSync");
-    module2.exports = rimraf;
-    rimraf.sync = rimrafSync;
+    __name(onLink, "onLink");
+    function copyLink(resolvedSrc, dest) {
+      fs3.unlinkSync(dest);
+      return fs3.symlinkSync(resolvedSrc, dest);
+    }
+    __name(copyLink, "copyLink");
+    module2.exports = copySync;
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module2.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
   }
 });
 
-// node_modules/fs-extra/lib/remove/index.js
+// ../../../node_modules/fs-extra/lib/remove/index.js
 var require_remove = __commonJS({
-  "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
+    var fs3 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    var rimraf = require_rimraf();
+    function remove(path3, callback) {
+      fs3.rm(path3, { recursive: true, force: true }, callback);
+    }
+    __name(remove, "remove");
+    function removeSync(path3) {
+      fs3.rmSync(path3, { recursive: true, force: true });
+    }
+    __name(removeSync, "removeSync");
     module2.exports = {
-      remove: u(rimraf),
-      removeSync: rimraf.sync
+      remove: u(remove),
+      removeSync
     };
   }
 });
 
-// node_modules/fs-extra/lib/empty/index.js
+// ../../../node_modules/fs-extra/lib/empty/index.js
 var require_empty = __commonJS({
-  "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    var fs3 = require_graceful_fs();
+    var u = require_universalify().fromPromise;
+    var fs3 = require_fs();
     var path3 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
-    var emptyDir = u(/* @__PURE__ */ __name(function emptyDir2(dir, callback) {
-      callback = callback || function() {
-      };
-      fs3.readdir(dir, (err, items) => {
-        if (err) return mkdir.mkdirs(dir, callback);
-        items = items.map((item) => path3.join(dir, item));
-        deleteItem();
-        function deleteItem() {
-          const item = items.pop();
-          if (!item) return callback();
-          remove.remove(item, (err2) => {
-            if (err2) return callback(err2);
-            deleteItem();
-          });
-        }
-        __name(deleteItem, "deleteItem");
-      });
+    var emptyDir = u(/* @__PURE__ */ __name(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs3.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path3.join(dir, item))));
     }, "emptyDir"));
     function emptyDirSync(dir) {
       let items;
@@ -4651,43 +4309,39 @@ var require_empty = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/ensure/file.js
+// ../../../node_modules/fs-extra/lib/ensure/file.js
 var require_file = __commonJS({
-  "node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs3 = require_graceful_fs();
+    var fs3 = require_fs();
     var mkdir = require_mkdirs();
-    function createFile(file, callback) {
-      function makeFile() {
-        fs3.writeFile(file, "", (err) => {
-          if (err) return callback(err);
-          callback();
-        });
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs3.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path3.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs3.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs3.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs3.writeFile(file, "");
+      } else {
+        await fs3.readdir(dir);
       }
-      __name(makeFile, "makeFile");
-      fs3.stat(file, (err, stats) => {
-        if (!err && stats.isFile()) return callback();
-        const dir = path3.dirname(file);
-        fs3.stat(dir, (err2, stats2) => {
-          if (err2) {
-            if (err2.code === "ENOENT") {
-              return mkdir.mkdirs(dir, (err3) => {
-                if (err3) return callback(err3);
-                makeFile();
-              });
-            }
-            return callback(err2);
-          }
-          if (stats2.isDirectory()) makeFile();
-          else {
-            fs3.readdir(dir, (err3) => {
-              if (err3) return callback(err3);
-            });
-          }
-        });
-      });
     }
     __name(createFile, "createFile");
     function createFileSync(file) {
@@ -4716,49 +4370,47 @@ var require_file = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/ensure/link.js
+// ../../../node_modules/fs-extra/lib/ensure/link.js
 var require_link = __commonJS({
-  "node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs3 = require_graceful_fs();
+    var fs3 = require_fs();
     var mkdir = require_mkdirs();
-    var pathExists = require_path_exists().pathExists;
-    function createLink(srcpath, dstpath, callback) {
-      function makeLink(srcpath2, dstpath2) {
-        fs3.link(srcpath2, dstpath2, (err) => {
-          if (err) return callback(err);
-          callback(null);
-        });
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs3.lstat(dstpath);
+      } catch {
       }
-      __name(makeLink, "makeLink");
-      pathExists(dstpath, (err, destinationExists) => {
-        if (err) return callback(err);
-        if (destinationExists) return callback(null);
-        fs3.lstat(srcpath, (err2) => {
-          if (err2) {
-            err2.message = err2.message.replace("lstat", "ensureLink");
-            return callback(err2);
-          }
-          const dir = path3.dirname(dstpath);
-          pathExists(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 fs3.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat)) return;
+      const dir = path3.dirname(dstpath);
+      const dirExists = await pathExists(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs3.link(srcpath, dstpath);
     }
     __name(createLink, "createLink");
     function createLinkSync(srcpath, dstpath) {
-      const destinationExists = fs3.existsSync(dstpath);
-      if (destinationExists) return void 0;
+      let dstStat;
       try {
-        fs3.lstatSync(srcpath);
+        dstStat = fs3.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs3.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -4777,106 +4429,101 @@ var require_link = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/ensure/symlink-paths.js
+// ../../../node_modules/fs-extra/lib/ensure/symlink-paths.js
 var require_symlink_paths = __commonJS({
-  "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path3 = require("path");
-    var fs3 = require_graceful_fs();
-    var pathExists = require_path_exists().pathExists;
-    function symlinkPaths(srcpath, dstpath, callback) {
+    var fs3 = require_fs();
+    var { pathExists } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
       if (path3.isAbsolute(srcpath)) {
-        return fs3.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 = path3.dirname(dstpath);
-        const relativeToDst = path3.join(dstdir, srcpath);
-        return pathExists(relativeToDst, (err, exists) => {
-          if (err) return callback(err);
-          if (exists) {
-            return callback(null, {
-              toCwd: relativeToDst,
-              toDst: srcpath
-            });
-          } else {
-            return fs3.lstat(srcpath, (err2) => {
-              if (err2) {
-                err2.message = err2.message.replace("lstat", "ensureSymlink");
-                return callback(err2);
-              }
-              return callback(null, {
-                toCwd: srcpath,
-                toDst: path3.relative(dstdir, srcpath)
-              });
-            });
-          }
-        });
+        try {
+          await fs3.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path3.dirname(dstpath);
+      const relativeToDst = path3.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs3.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
       }
+      return {
+        toCwd: srcpath,
+        toDst: path3.relative(dstdir, srcpath)
+      };
     }
     __name(symlinkPaths, "symlinkPaths");
     function symlinkPathsSync(srcpath, dstpath) {
-      let exists;
       if (path3.isAbsolute(srcpath)) {
-        exists = fs3.existsSync(srcpath);
-        if (!exists) throw new Error("absolute srcpath does not exist");
+        const exists2 = fs3.existsSync(srcpath);
+        if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
-      } else {
-        const dstdir = path3.dirname(dstpath);
-        const relativeToDst = path3.join(dstdir, srcpath);
-        exists = fs3.existsSync(relativeToDst);
-        if (exists) {
-          return {
-            toCwd: relativeToDst,
-            toDst: srcpath
-          };
-        } else {
-          exists = fs3.existsSync(srcpath);
-          if (!exists) throw new Error("relative srcpath does not exist");
-          return {
-            toCwd: srcpath,
-            toDst: path3.relative(dstdir, srcpath)
-          };
-        }
       }
+      const dstdir = path3.dirname(dstpath);
+      const relativeToDst = path3.join(dstdir, srcpath);
+      const exists = fs3.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs3.existsSync(srcpath);
+      if (!srcExists) throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path3.relative(dstdir, srcpath)
+      };
     }
     __name(symlinkPathsSync, "symlinkPathsSync");
     module2.exports = {
-      symlinkPaths,
+      symlinkPaths: u(symlinkPaths),
       symlinkPathsSync
     };
   }
 });
 
-// node_modules/fs-extra/lib/ensure/symlink-type.js
+// ../../../node_modules/fs-extra/lib/ensure/symlink-type.js
 var require_symlink_type = __commonJS({
-  "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_graceful_fs();
-    function symlinkType(srcpath, type, callback) {
-      callback = typeof type === "function" ? type : callback;
-      type = typeof type === "function" ? false : type;
-      if (type) return callback(null, type);
-      fs3.lstat(srcpath, (err, stats) => {
-        if (err) return callback(null, "file");
-        type = stats && stats.isDirectory() ? "dir" : "file";
-        callback(null, type);
-      });
+    var fs3 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = await fs3.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
     }
     __name(symlinkType, "symlinkType");
     function symlinkTypeSync(srcpath, type) {
-      let stats;
       if (type) return type;
+      let stats;
       try {
         stats = fs3.lstatSync(srcpath);
       } catch {
@@ -4886,57 +4533,78 @@ var require_symlink_type = __commonJS({
     }
     __name(symlinkTypeSync, "symlinkTypeSync");
     module2.exports = {
-      symlinkType,
+      symlinkType: u(symlinkType),
       symlinkTypeSync
     };
   }
 });
 
-// node_modules/fs-extra/lib/ensure/symlink.js
+// ../../../node_modules/fs-extra/lib/ensure/symlink.js
 var require_symlink = __commonJS({
-  "node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs3 = require_graceful_fs();
-    var _mkdirs = require_mkdirs();
-    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 pathExists = require_path_exists().pathExists;
-    function createSymlink(srcpath, dstpath, type, callback) {
-      callback = typeof type === "function" ? type : callback;
-      type = typeof type === "function" ? false : type;
-      pathExists(dstpath, (err, destinationExists) => {
-        if (err) return callback(err);
-        if (destinationExists) return callback(null);
-        symlinkPaths(srcpath, dstpath, (err2, relative2) => {
-          if (err2) return callback(err2);
-          srcpath = relative2.toDst;
-          symlinkType(relative2.toCwd, type, (err3, type2) => {
-            if (err3) return callback(err3);
-            const dir = path3.dirname(dstpath);
-            pathExists(dir, (err4, dirExists) => {
-              if (err4) return callback(err4);
-              if (dirExists) return fs3.symlink(srcpath, dstpath, type2, callback);
-              mkdirs(dir, (err5) => {
-                if (err5) return callback(err5);
-                fs3.symlink(srcpath, dstpath, type2, callback);
-              });
-            });
-          });
-        });
-      });
+    var fs3 = require_fs();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs3.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        let srcStat;
+        if (path3.isAbsolute(srcpath)) {
+          srcStat = await fs3.stat(srcpath);
+        } else {
+          const dstdir = path3.dirname(dstpath);
+          const relativeToDst = path3.join(dstdir, srcpath);
+          try {
+            srcStat = await fs3.stat(relativeToDst);
+          } catch {
+            srcStat = await fs3.stat(srcpath);
+          }
+        }
+        const dstStat = await fs3.stat(dstpath);
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative2 = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative2.toDst;
+      const toType = await symlinkType(relative2.toCwd, type);
+      const dir = path3.dirname(dstpath);
+      if (!await pathExists(dir)) {
+        await mkdirs(dir);
+      }
+      return fs3.symlink(srcpath, dstpath, toType);
     }
     __name(createSymlink, "createSymlink");
     function createSymlinkSync(srcpath, dstpath, type) {
-      const destinationExists = fs3.existsSync(dstpath);
-      if (destinationExists) return void 0;
+      let stats;
+      try {
+        stats = fs3.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        let srcStat;
+        if (path3.isAbsolute(srcpath)) {
+          srcStat = fs3.statSync(srcpath);
+        } else {
+          const dstdir = path3.dirname(dstpath);
+          const relativeToDst = path3.join(dstdir, srcpath);
+          try {
+            srcStat = fs3.statSync(relativeToDst);
+          } catch {
+            srcStat = fs3.statSync(srcpath);
+          }
+        }
+        const dstStat = fs3.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat)) return;
+      }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
@@ -4954,35 +4622,35 @@ var require_symlink = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/ensure/index.js
+// ../../../node_modules/fs-extra/lib/ensure/index.js
 var require_ensure = __commonJS({
-  "node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
     "use strict";
-    var file = require_file();
-    var link = require_link();
-    var symlink = require_symlink();
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
     module2.exports = {
       // file
-      createFile: file.createFile,
-      createFileSync: file.createFileSync,
-      ensureFile: file.createFile,
-      ensureFileSync: file.createFileSync,
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
       // link
-      createLink: link.createLink,
-      createLinkSync: link.createLinkSync,
-      ensureLink: link.createLink,
-      ensureLinkSync: link.createLinkSync,
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
       // symlink
-      createSymlink: symlink.createSymlink,
-      createSymlinkSync: symlink.createSymlinkSync,
-      ensureSymlink: symlink.createSymlink,
-      ensureSymlinkSync: symlink.createSymlinkSync
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
     };
   }
 });
 
 // ../../../node_modules/jsonfile/utils.js
-var require_utils = __commonJS({
+var require_utils2 = __commonJS({
   "../../../node_modules/jsonfile/utils.js"(exports2, module2) {
     function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
       const EOF = finalEOL ? EOL : "";
@@ -5009,7 +4677,7 @@ var require_jsonfile = __commonJS({
       _fs = require("fs");
     }
     var universalify = require_universalify();
-    var { stringify, stripBom } = require_utils();
+    var { stringify, stripBom } = require_utils2();
     async function _readFile(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
@@ -5075,9 +4743,9 @@ var require_jsonfile = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/json/jsonfile.js
+// ../../../node_modules/fs-extra/lib/json/jsonfile.js
 var require_jsonfile2 = __commonJS({
-  "node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
     "use strict";
     var jsonFile = require_jsonfile();
     module2.exports = {
@@ -5090,37 +4758,28 @@ var require_jsonfile2 = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/output/index.js
-var require_output = __commonJS({
-  "node_modules/fs-extra/lib/output/index.js"(exports2, module2) {
+// ../../../node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "../../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
-    var fs3 = require_graceful_fs();
+    var u = require_universalify().fromPromise;
+    var fs3 = require_fs();
     var path3 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
-    function outputFile(file, data, encoding, callback) {
-      if (typeof encoding === "function") {
-        callback = encoding;
-        encoding = "utf8";
-      }
+    async function outputFile(file, data, encoding = "utf-8") {
       const dir = path3.dirname(file);
-      pathExists(dir, (err, itDoes) => {
-        if (err) return callback(err);
-        if (itDoes) return fs3.writeFile(file, data, encoding, callback);
-        mkdir.mkdirs(dir, (err2) => {
-          if (err2) return callback(err2);
-          fs3.writeFile(file, data, encoding, callback);
-        });
-      });
+      if (!await pathExists(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs3.writeFile(file, data, encoding);
     }
     __name(outputFile, "outputFile");
     function outputFileSync(file, ...args) {
       const dir = path3.dirname(file);
-      if (fs3.existsSync(dir)) {
-        return fs3.writeFileSync(file, ...args);
+      if (!fs3.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
       }
-      mkdir.mkdirsSync(dir);
       fs3.writeFileSync(file, ...args);
     }
     __name(outputFileSync, "outputFileSync");
@@ -5131,12 +4790,12 @@ var require_output = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/json/output-json.js
+// ../../../node_modules/fs-extra/lib/json/output-json.js
 var require_output_json = __commonJS({
-  "node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
     "use strict";
-    var { stringify } = require_utils();
-    var { outputFile } = require_output();
+    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);
@@ -5146,12 +4805,12 @@ var require_output_json = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/json/output-json-sync.js
+// ../../../node_modules/fs-extra/lib/json/output-json-sync.js
 var require_output_json_sync = __commonJS({
-  "node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
     "use strict";
-    var { stringify } = require_utils();
-    var { outputFileSync } = require_output();
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
     function outputJsonSync(file, data, options) {
       const str = stringify(data, options);
       outputFileSync(file, str, options);
@@ -5161,9 +4820,9 @@ var require_output_json_sync = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/json/index.js
+// ../../../node_modules/fs-extra/lib/json/index.js
 var require_json = __commonJS({
-  "node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
     var jsonFile = require_jsonfile2();
@@ -5179,26 +4838,88 @@ var require_json = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/move-sync/move-sync.js
+// ../../../node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require_fs();
+    var path3 = require("path");
+    var { copy } = require_copy2();
+    var { remove } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    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 = path3.dirname(dest);
+      const parsedParentPath = path3.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    __name(move, "move");
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove(dest);
+        } else if (await pathExists(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs3.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    __name(doRename, "doRename");
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove(src);
+    }
+    __name(moveAcrossDevice, "moveAcrossDevice");
+    module2.exports = move;
+  }
+});
+
+// ../../../node_modules/fs-extra/lib/move/move-sync.js
 var require_move_sync = __commonJS({
-  "node_modules/fs-extra/lib/move-sync/move-sync.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
     var fs3 = require_graceful_fs();
     var path3 = require("path");
-    var copySync = require_copy_sync2().copySync;
+    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;
-      const { srcStat } = stat2.checkPathsSync(src, dest, "move");
+      const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
       stat2.checkParentPathsSync(src, srcStat, dest, "move");
-      mkdirpSync(path3.dirname(dest));
-      return doRename(src, dest, overwrite);
+      if (!isParentRoot(dest)) mkdirpSync(path3.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
     }
     __name(moveSync, "moveSync");
-    function doRename(src, dest, overwrite) {
+    function isParentRoot(dest) {
+      const parent = path3.dirname(dest);
+      const parsedPath = path3.parse(parent);
+      return parsedPath.root === parent;
+    }
+    __name(isParentRoot, "isParentRoot");
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase) return rename(src, dest, overwrite);
       if (overwrite) {
         removeSync(dest);
         return rename(src, dest, overwrite);
@@ -5219,7 +4940,8 @@ var require_move_sync = __commonJS({
     function moveAcrossDevice(src, dest, overwrite) {
       const opts = {
         overwrite,
-        errorOnExist: true
+        errorOnExist: true,
+        preserveTimestamps: true
       };
       copySync(src, dest, opts);
       return removeSync(src);
@@ -5229,122 +4951,36 @@ var require_move_sync = __commonJS({
   }
 });
 
-// node_modules/fs-extra/lib/move-sync/index.js
-var require_move_sync2 = __commonJS({
-  "node_modules/fs-extra/lib/move-sync/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      moveSync: require_move_sync()
-    };
-  }
-});
-
-// node_modules/fs-extra/lib/move/move.js
-var require_move = __commonJS({
-  "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
-    "use strict";
-    var fs3 = require_graceful_fs();
-    var path3 = require("path");
-    var copy = require_copy2().copy;
-    var remove = require_remove().remove;
-    var mkdirp = require_mkdirs().mkdirp;
-    var pathExists = require_path_exists().pathExists;
-    var stat2 = require_stat();
-    function move(src, dest, opts, cb) {
-      if (typeof opts === "function") {
-        cb = opts;
-        opts = {};
-      }
-      const overwrite = opts.overwrite || opts.clobber || false;
-      stat2.checkPaths(src, dest, "move", (err, stats) => {
-        if (err) return cb(err);
-        const { srcStat } = stats;
-        stat2.checkParentPaths(src, srcStat, dest, "move", (err2) => {
-          if (err2) return cb(err2);
-          mkdirp(path3.dirname(dest), (err3) => {
-            if (err3) return cb(err3);
-            return doRename(src, dest, overwrite, cb);
-          });
-        });
-      });
-    }
-    __name(move, "move");
-    function doRename(src, dest, overwrite, cb) {
-      if (overwrite) {
-        return remove(dest, (err) => {
-          if (err) return cb(err);
-          return rename(src, dest, overwrite, cb);
-        });
-      }
-      pathExists(dest, (err, destExists) => {
-        if (err) return cb(err);
-        if (destExists) return cb(new Error("dest already exists."));
-        return rename(src, dest, overwrite, cb);
-      });
-    }
-    __name(doRename, "doRename");
-    function rename(src, dest, overwrite, cb) {
-      fs3.rename(src, dest, (err) => {
-        if (!err) return cb();
-        if (err.code !== "EXDEV") return cb(err);
-        return moveAcrossDevice(src, dest, overwrite, cb);
-      });
-    }
-    __name(rename, "rename");
-    function moveAcrossDevice(src, dest, overwrite, cb) {
-      const opts = {
-        overwrite,
-        errorOnExist: true
-      };
-      copy(src, dest, opts, (err) => {
-        if (err) return cb(err);
-        return remove(src, cb);
-      });
-    }
-    __name(moveAcrossDevice, "moveAcrossDevice");
-    module2.exports = move;
-  }
-});
-
-// node_modules/fs-extra/lib/move/index.js
+// ../../../node_modules/fs-extra/lib/move/index.js
 var require_move2 = __commonJS({
-  "node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
     "use strict";
-    var u = require_universalify().fromCallback;
+    var u = require_universalify().fromPromise;
     module2.exports = {
-      move: u(require_move())
+      move: u(require_move()),
+      moveSync: require_move_sync()
     };
   }
 });
 
-// node_modules/fs-extra/lib/index.js
+// ../../../node_modules/fs-extra/lib/index.js
 var require_lib = __commonJS({
-  "node_modules/fs-extra/lib/index.js"(exports2, module2) {
+  "../../../node_modules/fs-extra/lib/index.js"(exports2, module2) {
     "use strict";
     module2.exports = {
       // Export promiseified graceful-fs:
       ...require_fs(),
       // Export extra methods:
-      ...require_copy_sync2(),
       ...require_copy2(),
       ...require_empty(),
       ...require_ensure(),
       ...require_json(),
       ...require_mkdirs(),
-      ...require_move_sync2(),
       ...require_move2(),
-      ...require_output(),
+      ...require_output_file(),
       ...require_path_exists(),
       ...require_remove()
     };
-    var fs3 = require("fs");
-    if (Object.getOwnPropertyDescriptor(fs3, "promises")) {
-      Object.defineProperty(module2.exports, "promises", {
-        get() {
-          return fs3.promises;
-        }
-      });
-    }
   }
 });