@pnpm/exe 11.0.7 → 11.0.9

package/dist/worker.js

@@ -5829,6 +5829,1305 @@ var init_lib5 = __esm({
   }
 });
 
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/fs/index.js
+var require_fs2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/fs/index.js"(exports) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs13 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "cp",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "glob",
+      "lchmod",
+      "lchown",
+      "lutimes",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "statfs",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs13[key] === "function";
+    });
+    Object.assign(exports, fs13);
+    api.forEach((method) => {
+      exports[method] = u(fs13[method]);
+    });
+    exports.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs13.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs13.exists(filename, resolve);
+      });
+    };
+    exports.read = function(fd, buffer, offset, length, position3, callback) {
+      if (typeof callback === "function") {
+        return fs13.read(fd, buffer, offset, length, position3, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs13.read(fd, buffer, offset, length, position3, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs13.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs13.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs13.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs13.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 fs13.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs13.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs13.realpath.native === "function") {
+      exports.realpath.native = u(fs13.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils3 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
+    "use strict";
+    var path17 = __require("path");
+    module.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path17.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var { checkPath } = require_utils3();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number") return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs13.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs13.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir2();
+    var makeDir = u(_makeDir);
+    module.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs13 = require_fs2();
+    function pathExists(path17) {
+      return fs13.access(path17).then(() => true).catch(() => false);
+    }
+    module.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs13.existsSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path17, atime, mtime) {
+      const fd = await fs13.open(path17, "r+");
+      let error = null;
+      try {
+        await fs13.futimes(fd, atime, mtime);
+      } catch (futimesErr) {
+        error = futimesErr;
+      } finally {
+        try {
+          await fs13.close(fd);
+        } catch (closeErr) {
+          if (!error) error = closeErr;
+        }
+      }
+      if (error) {
+        throw error;
+      }
+    }
+    function utimesMillisSync(path17, atime, mtime) {
+      const fd = fs13.openSync(path17, "r+");
+      let error = null;
+      try {
+        fs13.futimesSync(fd, atime, mtime);
+      } catch (futimesErr) {
+        error = futimesErr;
+      } finally {
+        try {
+          fs13.closeSync(fd);
+        } catch (closeErr) {
+          if (!error) error = closeErr;
+        }
+      }
+      if (error) {
+        throw error;
+      }
+    }
+    module.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/stat.js
+var require_stat2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var path17 = __require("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src2, dest, opts2) {
+      const statFunc = opts2.dereference ? (file) => fs13.stat(file, { bigint: true }) : (file) => fs13.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src2),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT") return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src2, dest, opts2) {
+      let destStat;
+      const statFunc = opts2.dereference ? (file) => fs13.statSync(file, { bigint: true }) : (file) => fs13.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src2);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT") return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src2, dest, funcName, opts2) {
+      const { srcStat, destStat } = await getStats(src2, dest, opts2);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path17.basename(src2);
+          const destBaseName = path17.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 '${src2}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
+        throw new Error(errMsg(src2, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src2, dest, funcName, opts2) {
+      const { srcStat, destStat } = getStatsSync(src2, dest, opts2);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path17.basename(src2);
+          const destBaseName = path17.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 '${src2}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
+        throw new Error(errMsg(src2, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src2, srcStat, dest, funcName) {
+      const srcParent = path17.resolve(path17.dirname(src2));
+      const destParent = path17.resolve(path17.dirname(dest));
+      if (destParent === srcParent || destParent === path17.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = await fs13.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src2, dest, funcName));
+      }
+      return checkParentPaths(src2, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src2, srcStat, dest, funcName) {
+      const srcParent = path17.resolve(path17.dirname(src2));
+      const destParent = path17.resolve(path17.dirname(dest));
+      if (destParent === srcParent || destParent === path17.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = fs13.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src2, dest, funcName));
+      }
+      return checkParentPathsSync(src2, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src2, dest) {
+      const srcArr = path17.resolve(src2).split(path17.sep).filter((i) => i);
+      const destArr = path17.resolve(dest).split(path17.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src2, dest, funcName) {
+      return `Cannot ${funcName} '${src2}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/async.js
+var require_async2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/util/async.js"(exports, module) {
+    "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;
+          })
+        )
+      );
+    }
+    module.exports = {
+      asyncIteratorConcurrentProcess
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/copy.js
+var require_copy3 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var path17 = __require("path");
+    var { mkdirs } = require_mkdirs2();
+    var { pathExists } = require_path_exists2();
+    var { utimesMillis } = require_utimes2();
+    var stat = require_stat2();
+    var { asyncIteratorConcurrentProcess } = require_async2();
+    async function copy2(src2, dest, opts2 = {}) {
+      if (typeof opts2 === "function") {
+        opts2 = { filter: opts2 };
+      }
+      opts2.clobber = "clobber" in opts2 ? !!opts2.clobber : true;
+      opts2.overwrite = "overwrite" in opts2 ? !!opts2.overwrite : opts2.clobber;
+      if (opts2.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 stat.checkPaths(src2, dest, "copy", opts2);
+      await stat.checkParentPaths(src2, srcStat, dest, "copy");
+      const include = await runFilter(src2, dest, opts2);
+      if (!include) return;
+      const destParent = path17.dirname(dest);
+      const dirExists = await pathExists(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src2, dest, opts2);
+    }
+    async function runFilter(src2, dest, opts2) {
+      if (!opts2.filter) return true;
+      return opts2.filter(src2, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src2, dest, opts2) {
+      const statFn = opts2.dereference ? fs13.stat : fs13.lstat;
+      const srcStat = await statFn(src2);
+      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
+      if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
+      if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
+      if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
+      throw new Error(`Unknown file: ${src2}`);
+    }
+    async function onFile(srcStat, destStat, src2, dest, opts2) {
+      if (!destStat) return copyFile(srcStat, src2, dest, opts2);
+      if (opts2.overwrite) {
+        await fs13.unlink(dest);
+        return copyFile(srcStat, src2, dest, opts2);
+      }
+      if (opts2.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src2, dest, opts2) {
+      await fs13.copyFile(src2, dest);
+      if (opts2.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs13.stat(src2);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs13.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs13.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src2, dest, opts2) {
+      if (!destStat) {
+        await fs13.mkdir(dest);
+      }
+      await asyncIteratorConcurrentProcess(await fs13.opendir(src2), async (item) => {
+        const srcItem = path17.join(src2, item.name);
+        const destItem = path17.join(dest, item.name);
+        const include = await runFilter(srcItem, destItem, opts2);
+        if (include) {
+          const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts2);
+          await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts2);
+        }
+      });
+      if (!destStat) {
+        await fs13.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src2, dest, opts2) {
+      let resolvedSrc = await fs13.readlink(src2);
+      if (opts2.dereference) {
+        resolvedSrc = path17.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs13.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs13.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs13.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts2.dereference) {
+        resolvedDest = path17.resolve(process.cwd(), resolvedDest);
+      }
+      if (resolvedSrc !== resolvedDest) {
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+      }
+      await fs13.unlink(dest);
+      return fs13.symlink(resolvedSrc, dest);
+    }
+    module.exports = copy2;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
+    "use strict";
+    var fs13 = require_graceful_fs();
+    var path17 = __require("path");
+    var mkdirsSync = require_mkdirs2().mkdirsSync;
+    var utimesMillisSync = require_utimes2().utimesMillisSync;
+    var stat = require_stat2();
+    function copySync2(src2, dest, opts2) {
+      if (typeof opts2 === "function") {
+        opts2 = { filter: opts2 };
+      }
+      opts2 = opts2 || {};
+      opts2.clobber = "clobber" in opts2 ? !!opts2.clobber : true;
+      opts2.overwrite = "overwrite" in opts2 ? !!opts2.overwrite : opts2.clobber;
+      if (opts2.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-WARN0002"
+        );
+      }
+      const { srcStat, destStat } = stat.checkPathsSync(src2, dest, "copy", opts2);
+      stat.checkParentPathsSync(src2, srcStat, dest, "copy");
+      if (opts2.filter && !opts2.filter(src2, dest)) return;
+      const destParent = path17.dirname(dest);
+      if (!fs13.existsSync(destParent)) mkdirsSync(destParent);
+      return getStats(destStat, src2, dest, opts2);
+    }
+    function getStats(destStat, src2, dest, opts2) {
+      const statSync = opts2.dereference ? fs13.statSync : fs13.lstatSync;
+      const srcStat = statSync(src2);
+      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
+      else if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
+      else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
+      else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
+      throw new Error(`Unknown file: ${src2}`);
+    }
+    function onFile(srcStat, destStat, src2, dest, opts2) {
+      if (!destStat) return copyFile(srcStat, src2, dest, opts2);
+      return mayCopyFile(srcStat, src2, dest, opts2);
+    }
+    function mayCopyFile(srcStat, src2, dest, opts2) {
+      if (opts2.overwrite) {
+        fs13.unlinkSync(dest);
+        return copyFile(srcStat, src2, dest, opts2);
+      } else if (opts2.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src2, dest, opts2) {
+      fs13.copyFileSync(src2, dest);
+      if (opts2.preserveTimestamps) handleTimestamps(srcStat.mode, src2, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src2, dest) {
+      if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src2, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs13.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src2, dest) {
+      const updatedSrcStat = fs13.statSync(src2);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src2, dest, opts2) {
+      if (!destStat) return mkDirAndCopy(srcStat.mode, src2, dest, opts2);
+      return copyDir(src2, dest, opts2);
+    }
+    function mkDirAndCopy(srcMode, src2, dest, opts2) {
+      fs13.mkdirSync(dest);
+      copyDir(src2, dest, opts2);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src2, dest, opts2) {
+      const dir = fs13.opendirSync(src2);
+      try {
+        let dirent;
+        while ((dirent = dir.readSync()) !== null) {
+          copyDirItem(dirent.name, src2, dest, opts2);
+        }
+      } finally {
+        dir.closeSync();
+      }
+    }
+    function copyDirItem(item, src2, dest, opts2) {
+      const srcItem = path17.join(src2, item);
+      const destItem = path17.join(dest, item);
+      if (opts2.filter && !opts2.filter(srcItem, destItem)) return;
+      const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts2);
+      return getStats(destStat, srcItem, destItem, opts2);
+    }
+    function onLink(destStat, src2, dest, opts2) {
+      let resolvedSrc = fs13.readlinkSync(src2);
+      if (opts2.dereference) {
+        resolvedSrc = path17.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs13.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs13.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs13.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts2.dereference) {
+          resolvedDest = path17.resolve(process.cwd(), resolvedDest);
+        }
+        if (resolvedSrc !== resolvedDest) {
+          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+            throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+          }
+          if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+            throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+          }
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs13.unlinkSync(dest);
+      return fs13.symlinkSync(resolvedSrc, dest);
+    }
+    module.exports = copySync2;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/index.js
+var require_copy4 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      copy: u(require_copy3()),
+      copySync: require_copy_sync2()
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/remove/index.js
+var require_remove2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
+    "use strict";
+    var fs13 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove(path17, callback) {
+      fs13.rm(path17, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path17) {
+      fs13.rmSync(path17, { recursive: true, force: true });
+    }
+    module.exports = {
+      remove: u(remove),
+      removeSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/empty/index.js
+var require_empty2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs13 = require_fs2();
+    var path17 = __require("path");
+    var mkdir = require_mkdirs2();
+    var remove = require_remove2();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs13.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path17.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs13.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path17.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/file.js
+var require_file2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path17 = __require("path");
+    var fs13 = require_fs2();
+    var mkdir = require_mkdirs2();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs13.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path17.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs13.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs13.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs13.writeFile(file, "");
+      } else {
+        await fs13.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs13.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path17.dirname(file);
+      try {
+        if (!fs13.statSync(dir).isDirectory()) {
+          fs13.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+        else throw err;
+      }
+      fs13.writeFileSync(file, "");
+    }
+    module.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/link.js
+var require_link2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path17 = __require("path");
+    var fs13 = require_fs2();
+    var mkdir = require_mkdirs2();
+    var { pathExists } = require_path_exists2();
+    var { areIdentical } = require_stat2();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs13.lstat(dstpath, { bigint: true });
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs13.lstat(srcpath, { bigint: true });
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat)) return;
+      const dir = path17.dirname(dstpath);
+      const dirExists = await pathExists(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs13.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs13.lstatSync(dstpath, { bigint: true });
+      } catch {
+      }
+      try {
+        const srcStat = fs13.lstatSync(srcpath, { bigint: true });
+        if (dstStat && areIdentical(srcStat, dstStat)) return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path17.dirname(dstpath);
+      const dirExists = fs13.existsSync(dir);
+      if (dirExists) return fs13.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs13.linkSync(srcpath, dstpath);
+    }
+    module.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
+    "use strict";
+    var path17 = __require("path");
+    var fs13 = require_fs2();
+    var { pathExists } = require_path_exists2();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path17.isAbsolute(srcpath)) {
+        try {
+          await fs13.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path17.dirname(dstpath);
+      const relativeToDst = path17.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs13.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path17.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path17.isAbsolute(srcpath)) {
+        const exists2 = fs13.existsSync(srcpath);
+        if (!exists2) throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path17.dirname(dstpath);
+      const relativeToDst = path17.join(dstdir, srcpath);
+      const exists = fs13.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs13.existsSync(srcpath);
+      if (!srcExists) throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path17.relative(dstdir, srcpath)
+      };
+    }
+    module.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = await fs13.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = fs13.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path17 = __require("path");
+    var fs13 = require_fs2();
+    var { mkdirs, mkdirsSync } = require_mkdirs2();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths2();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type2();
+    var { pathExists } = require_path_exists2();
+    var { areIdentical } = require_stat2();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs13.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        let srcStat;
+        if (path17.isAbsolute(srcpath)) {
+          srcStat = await fs13.stat(srcpath, { bigint: true });
+        } else {
+          const dstdir = path17.dirname(dstpath);
+          const relativeToDst = path17.join(dstdir, srcpath);
+          try {
+            srcStat = await fs13.stat(relativeToDst, { bigint: true });
+          } catch {
+            srcStat = await fs13.stat(srcpath, { bigint: true });
+          }
+        }
+        const dstStat = await fs13.stat(dstpath, { bigint: true });
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative.toDst;
+      const toType = await symlinkType(relative.toCwd, type);
+      const dir = path17.dirname(dstpath);
+      if (!await pathExists(dir)) {
+        await mkdirs(dir);
+      }
+      return fs13.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync2(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs13.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        let srcStat;
+        if (path17.isAbsolute(srcpath)) {
+          srcStat = fs13.statSync(srcpath, { bigint: true });
+        } else {
+          const dstdir = path17.dirname(dstpath);
+          const relativeToDst = path17.join(dstdir, srcpath);
+          try {
+            srcStat = fs13.statSync(relativeToDst, { bigint: true });
+          } catch {
+            srcStat = fs13.statSync(srcpath, { bigint: true });
+          }
+        }
+        const dstStat = fs13.statSync(dstpath, { bigint: true });
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path17.dirname(dstpath);
+      const exists = fs13.existsSync(dir);
+      if (exists) return fs13.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs13.symlinkSync(srcpath, dstpath, type);
+    }
+    module.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync: createSymlinkSync2
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
+    "use strict";
+    var { createFile, createFileSync } = require_file2();
+    var { createLink, createLinkSync } = require_link2();
+    var { createSymlink, createSymlinkSync: createSymlinkSync2 } = require_symlink2();
+    module.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync: createSymlinkSync2,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync2
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile3 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs13 = require_fs2();
+    var path17 = __require("path");
+    var mkdir = require_mkdirs2();
+    var pathExists = require_path_exists2().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path17.dirname(file);
+      if (!await pathExists(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs13.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path17.dirname(file);
+      if (!fs13.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs13.writeFileSync(file, ...args);
+    }
+    module.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file2();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module.exports = outputJson;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file2();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module.exports = outputJsonSync;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/index.js
+var require_json2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/json/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile3();
+    jsonFile.outputJson = u(require_output_json2());
+    jsonFile.outputJsonSync = require_output_json_sync2();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module.exports = jsonFile;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/move.js
+var require_move3 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/move.js"(exports, module) {
+    "use strict";
+    var fs13 = require_fs2();
+    var path17 = __require("path");
+    var { copy: copy2 } = require_copy4();
+    var { remove } = require_remove2();
+    var { mkdirp } = require_mkdirs2();
+    var { pathExists } = require_path_exists2();
+    var stat = require_stat2();
+    async function move(src2, dest, opts2 = {}) {
+      const overwrite = opts2.overwrite || opts2.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat.checkPaths(src2, dest, "move", opts2);
+      await stat.checkParentPaths(src2, srcStat, dest, "move");
+      const destParent = path17.dirname(dest);
+      const parsedParentPath = path17.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src2, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src2, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove(dest);
+        } else if (await pathExists(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs13.rename(src2, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src2, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src2, dest, overwrite) {
+      const opts2 = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy2(src2, dest, opts2);
+      return remove(src2);
+    }
+    module.exports = move;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
+    "use strict";
+    var fs13 = require_graceful_fs();
+    var path17 = __require("path");
+    var copySync2 = require_copy4().copySync;
+    var removeSync = require_remove2().removeSync;
+    var mkdirpSync = require_mkdirs2().mkdirpSync;
+    var stat = require_stat2();
+    function moveSync(src2, dest, opts2) {
+      opts2 = opts2 || {};
+      const overwrite = opts2.overwrite || opts2.clobber || false;
+      const { srcStat, isChangingCase = false } = stat.checkPathsSync(src2, dest, "move", opts2);
+      stat.checkParentPathsSync(src2, srcStat, dest, "move");
+      if (!isParentRoot(dest)) mkdirpSync(path17.dirname(dest));
+      return doRename(src2, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path17.dirname(dest);
+      const parsedPath = path17.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src2, dest, overwrite, isChangingCase) {
+      if (isChangingCase) return rename(src2, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src2, dest, overwrite);
+      }
+      if (fs13.existsSync(dest)) throw new Error("dest already exists.");
+      return rename(src2, dest, overwrite);
+    }
+    function rename(src2, dest, overwrite) {
+      try {
+        fs13.renameSync(src2, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") throw err;
+        return moveAcrossDevice(src2, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src2, dest, overwrite) {
+      const opts2 = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync2(src2, dest, opts2);
+      return removeSync(src2);
+    }
+    module.exports = moveSync;
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/index.js
+var require_move4 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/move/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      move: u(require_move3()),
+      moveSync: require_move_sync2()
+    };
+  }
+});
+
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/index.js
+var require_lib2 = __commonJS({
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/fs-extra/11.3.5/7db7b8254b482200b4fe34058554947e1242ee5fa7e05ff4418e9403104cd8c3/node_modules/fs-extra/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs2(),
+      // Export extra methods:
+      ...require_copy4(),
+      ...require_empty2(),
+      ...require_ensure2(),
+      ...require_json2(),
+      ...require_mkdirs2(),
+      ...require_move4(),
+      ...require_output_file2(),
+      ...require_path_exists2(),
+      ...require_remove2()
+    };
+  }
+});
+
 // ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/lib/truncate.js
 var require_truncate = __commonJS({
   "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/lib/truncate.js"(exports, module) {
@@ -6472,9 +7771,9 @@ var require_node_gyp_build_optional_packages = __commonJS({
   }
 });
 
-// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr-extract/3.0.3/d6336ce79f945cdf8da931bf1fe1eab07de5324f88e43a871c723e26d833f051/node_modules/msgpackr-extract/index.js
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr-extract/3.0.3/dc63a7e9c8306acc1418464548648c97e4a5c8c81989d7240121ad9e55103078/node_modules/msgpackr-extract/index.js
 var require_msgpackr_extract = __commonJS({
-  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr-extract/3.0.3/d6336ce79f945cdf8da931bf1fe1eab07de5324f88e43a871c723e26d833f051/node_modules/msgpackr-extract/index.js"(exports, module) {
+  "../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr-extract/3.0.3/dc63a7e9c8306acc1418464548648c97e4a5c8c81989d7240121ad9e55103078/node_modules/msgpackr-extract/index.js"(exports, module) {
     module.exports = require_node_gyp_build_optional_packages()(__dirname);
   }
 });
@@ -7047,7 +8346,7 @@ import fs9 from "node:fs";
 import path13 from "node:path";
 import util6 from "node:util";
 init_rimraf();
-var import_fs_extra2 = __toESM(require_lib(), 1);
+var import_fs_extra2 = __toESM(require_lib2(), 1);
 
 // ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/make-empty-dir/4.0.0/3607722a2f7d328bdf182e4db3290941113e732fd2d785b1a5837ab89bb24489/node_modules/make-empty-dir/index.js
 init_rimraf();
@@ -7684,7 +8983,7 @@ function createCafsStore(storeDir, opts2) {
 import fs11 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 
-// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/2918100b6a392ecb2828842b3e4ff8b881a5bbeb14d471297b65d8a74fd54701/node_modules/msgpackr/unpack.js
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/46dd53c5eb8ac19961b8dcfdc6cb3c46229e7d03ddda6f31cf5a680868f31b80/node_modules/msgpackr/unpack.js
 var decoder;
 try {
   decoder = new TextDecoder();
@@ -8801,7 +10100,7 @@ function setReadStruct(updatedReadStruct, loadedStructs, saveState3) {
   onSaveState = saveState3;
 }
 
-// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/2918100b6a392ecb2828842b3e4ff8b881a5bbeb14d471297b65d8a74fd54701/node_modules/msgpackr/pack.js
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/46dd53c5eb8ac19961b8dcfdc6cb3c46229e7d03ddda6f31cf5a680868f31b80/node_modules/msgpackr/pack.js
 var textEncoder;
 try {
   textEncoder = new TextEncoder();
@@ -9867,7 +11166,7 @@ var REUSE_BUFFER_MODE = 512;
 var RESET_BUFFER_MODE = 1024;
 var RESERVE_START_SPACE = 2048;
 
-// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/2918100b6a392ecb2828842b3e4ff8b881a5bbeb14d471297b65d8a74fd54701/node_modules/msgpackr/struct.js
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/46dd53c5eb8ac19961b8dcfdc6cb3c46229e7d03ddda6f31cf5a680868f31b80/node_modules/msgpackr/struct.js
 var ASCII = 3;
 var NUMBER = 0;
 var UTF8 = 2;
@@ -10582,7 +11881,7 @@ function prepareStructures2(structures, packr2) {
 }
 setReadStruct(readStruct2, onLoadedStructures2, saveState2);
 
-// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/2918100b6a392ecb2828842b3e4ff8b881a5bbeb14d471297b65d8a74fd54701/node_modules/msgpackr/node-index.js
+// ../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/msgpackr/1.11.8/46dd53c5eb8ac19961b8dcfdc6cb3c46229e7d03ddda6f31cf5a680868f31b80/node_modules/msgpackr/node-index.js
 import { createRequire } from "module";
 var nativeAccelerationDisabled = process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED !== void 0 && process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === "true";
 if (!nativeAccelerationDisabled) {