wp-studio 1.7.7-alpha1

package/dist/cli/index-BXRYeCYG.js

@@ -0,0 +1,1393 @@
+import { x as requireGracefulFs, y as getDefaultExportFromCjs } from "./appdata-07CF2rhg.js";
+import path from "path";
+import fs$2 from "fs";
+var fs$1 = {};
+var universalify = {};
+var hasRequiredUniversalify;
+function requireUniversalify() {
+  if (hasRequiredUniversalify) return universalify;
+  hasRequiredUniversalify = 1;
+  universalify.fromCallback = function(fn) {
+    return Object.defineProperty(function(...args) {
+      if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+      else {
+        return new Promise((resolve, reject) => {
+          args.push((err, res) => err != null ? reject(err) : resolve(res));
+          fn.apply(this, args);
+        });
+      }
+    }, "name", { value: fn.name });
+  };
+  universalify.fromPromise = function(fn) {
+    return Object.defineProperty(function(...args) {
+      const cb = args[args.length - 1];
+      if (typeof cb !== "function") return fn.apply(this, args);
+      else {
+        args.pop();
+        fn.apply(this, args).then((r) => cb(null, r), cb);
+      }
+    }, "name", { value: fn.name });
+  };
+  return universalify;
+}
+var hasRequiredFs;
+function requireFs() {
+  if (hasRequiredFs) return fs$1;
+  hasRequiredFs = 1;
+  (function(exports$1) {
+    const u = requireUniversalify().fromCallback;
+    const fs2 = requireGracefulFs();
+    const 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 fs2[key] === "function";
+    });
+    Object.assign(exports$1, fs2);
+    api.forEach((method) => {
+      exports$1[method] = u(fs2[method]);
+    });
+    exports$1.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs2.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs2.exists(filename, resolve);
+      });
+    };
+    exports$1.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs2.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports$1.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs2.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports$1.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs2.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports$1.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs2.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs2.realpath.native === "function") {
+      exports$1.realpath.native = u(fs2.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  })(fs$1);
+  return fs$1;
+}
+var makeDir = {};
+var utils$1 = {};
+var hasRequiredUtils$1;
+function requireUtils$1() {
+  if (hasRequiredUtils$1) return utils$1;
+  hasRequiredUtils$1 = 1;
+  const path$1 = path;
+  utils$1.checkPath = function checkPath(pth) {
+    if (process.platform === "win32") {
+      const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path$1.parse(pth).root, ""));
+      if (pathHasInvalidWinCharacters) {
+        const error = new Error(`Path contains invalid characters: ${pth}`);
+        error.code = "EINVAL";
+        throw error;
+      }
+    }
+  };
+  return utils$1;
+}
+var hasRequiredMakeDir;
+function requireMakeDir() {
+  if (hasRequiredMakeDir) return makeDir;
+  hasRequiredMakeDir = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const { checkPath } = /* @__PURE__ */ requireUtils$1();
+  const getMode = (options) => {
+    const defaults = { mode: 511 };
+    if (typeof options === "number") return options;
+    return { ...defaults, ...options }.mode;
+  };
+  makeDir.makeDir = async (dir, options) => {
+    checkPath(dir);
+    return fs2.mkdir(dir, {
+      mode: getMode(options),
+      recursive: true
+    });
+  };
+  makeDir.makeDirSync = (dir, options) => {
+    checkPath(dir);
+    return fs2.mkdirSync(dir, {
+      mode: getMode(options),
+      recursive: true
+    });
+  };
+  return makeDir;
+}
+var mkdirs;
+var hasRequiredMkdirs;
+function requireMkdirs() {
+  if (hasRequiredMkdirs) return mkdirs;
+  hasRequiredMkdirs = 1;
+  const u = requireUniversalify().fromPromise;
+  const { makeDir: _makeDir, makeDirSync } = /* @__PURE__ */ requireMakeDir();
+  const makeDir2 = u(_makeDir);
+  mkdirs = {
+    mkdirs: makeDir2,
+    mkdirsSync: makeDirSync,
+    // alias
+    mkdirp: makeDir2,
+    mkdirpSync: makeDirSync,
+    ensureDir: makeDir2,
+    ensureDirSync: makeDirSync
+  };
+  return mkdirs;
+}
+var pathExists_1;
+var hasRequiredPathExists;
+function requirePathExists() {
+  if (hasRequiredPathExists) return pathExists_1;
+  hasRequiredPathExists = 1;
+  const u = requireUniversalify().fromPromise;
+  const fs2 = /* @__PURE__ */ requireFs();
+  function pathExists(path2) {
+    return fs2.access(path2).then(() => true).catch(() => false);
+  }
+  pathExists_1 = {
+    pathExists: u(pathExists),
+    pathExistsSync: fs2.existsSync
+  };
+  return pathExists_1;
+}
+var utimes;
+var hasRequiredUtimes;
+function requireUtimes() {
+  if (hasRequiredUtimes) return utimes;
+  hasRequiredUtimes = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const u = requireUniversalify().fromPromise;
+  async function utimesMillis(path2, atime, mtime) {
+    const fd = await fs2.open(path2, "r+");
+    let closeErr = null;
+    try {
+      await fs2.futimes(fd, atime, mtime);
+    } finally {
+      try {
+        await fs2.close(fd);
+      } catch (e) {
+        closeErr = e;
+      }
+    }
+    if (closeErr) {
+      throw closeErr;
+    }
+  }
+  function utimesMillisSync(path2, atime, mtime) {
+    const fd = fs2.openSync(path2, "r+");
+    fs2.futimesSync(fd, atime, mtime);
+    return fs2.closeSync(fd);
+  }
+  utimes = {
+    utimesMillis: u(utimesMillis),
+    utimesMillisSync
+  };
+  return utimes;
+}
+var stat;
+var hasRequiredStat;
+function requireStat() {
+  if (hasRequiredStat) return stat;
+  hasRequiredStat = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const path$1 = path;
+  const u = requireUniversalify().fromPromise;
+  function getStats(src, dest, opts) {
+    const statFunc = opts.dereference ? (file2) => fs2.stat(file2, { bigint: true }) : (file2) => fs2.lstat(file2, { bigint: true });
+    return Promise.all([
+      statFunc(src),
+      statFunc(dest).catch((err) => {
+        if (err.code === "ENOENT") return null;
+        throw err;
+      })
+    ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+  }
+  function getStatsSync(src, dest, opts) {
+    let destStat;
+    const statFunc = opts.dereference ? (file2) => fs2.statSync(file2, { bigint: true }) : (file2) => fs2.lstatSync(file2, { bigint: true });
+    const srcStat = statFunc(src);
+    try {
+      destStat = statFunc(dest);
+    } catch (err) {
+      if (err.code === "ENOENT") return { srcStat, destStat: null };
+      throw err;
+    }
+    return { srcStat, destStat };
+  }
+  async function checkPaths(src, dest, funcName, opts) {
+    const { srcStat, destStat } = await getStats(src, dest, opts);
+    if (destStat) {
+      if (areIdentical(srcStat, destStat)) {
+        const srcBaseName = path$1.basename(src);
+        const destBaseName = path$1.basename(dest);
+        if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+          return { srcStat, destStat, isChangingCase: true };
+        }
+        throw new Error("Source and destination must not be the same.");
+      }
+      if (srcStat.isDirectory() && !destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+      }
+      if (!srcStat.isDirectory() && destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+      }
+    }
+    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+      throw new Error(errMsg(src, dest, funcName));
+    }
+    return { srcStat, destStat };
+  }
+  function checkPathsSync(src, dest, funcName, opts) {
+    const { srcStat, destStat } = getStatsSync(src, dest, opts);
+    if (destStat) {
+      if (areIdentical(srcStat, destStat)) {
+        const srcBaseName = path$1.basename(src);
+        const destBaseName = path$1.basename(dest);
+        if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+          return { srcStat, destStat, isChangingCase: true };
+        }
+        throw new Error("Source and destination must not be the same.");
+      }
+      if (srcStat.isDirectory() && !destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+      }
+      if (!srcStat.isDirectory() && destStat.isDirectory()) {
+        throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+      }
+    }
+    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+      throw new Error(errMsg(src, dest, funcName));
+    }
+    return { srcStat, destStat };
+  }
+  async function checkParentPaths(src, srcStat, dest, funcName) {
+    const srcParent = path$1.resolve(path$1.dirname(src));
+    const destParent = path$1.resolve(path$1.dirname(dest));
+    if (destParent === srcParent || destParent === path$1.parse(destParent).root) return;
+    let destStat;
+    try {
+      destStat = await fs2.stat(destParent, { bigint: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    if (areIdentical(srcStat, destStat)) {
+      throw new Error(errMsg(src, dest, funcName));
+    }
+    return checkParentPaths(src, srcStat, destParent, funcName);
+  }
+  function checkParentPathsSync(src, srcStat, dest, funcName) {
+    const srcParent = path$1.resolve(path$1.dirname(src));
+    const destParent = path$1.resolve(path$1.dirname(dest));
+    if (destParent === srcParent || destParent === path$1.parse(destParent).root) return;
+    let destStat;
+    try {
+      destStat = fs2.statSync(destParent, { bigint: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    if (areIdentical(srcStat, destStat)) {
+      throw new Error(errMsg(src, dest, funcName));
+    }
+    return checkParentPathsSync(src, 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(src, dest) {
+    const srcArr = path$1.resolve(src).split(path$1.sep).filter((i) => i);
+    const destArr = path$1.resolve(dest).split(path$1.sep).filter((i) => i);
+    return srcArr.every((cur, i) => destArr[i] === cur);
+  }
+  function errMsg(src, dest, funcName) {
+    return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+  }
+  stat = {
+    // checkPaths
+    checkPaths: u(checkPaths),
+    checkPathsSync,
+    // checkParent
+    checkParentPaths: u(checkParentPaths),
+    checkParentPathsSync,
+    // Misc
+    isSrcSubdir,
+    areIdentical
+  };
+  return stat;
+}
+var async;
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  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;
+        })
+      )
+    );
+  }
+  async = {
+    asyncIteratorConcurrentProcess
+  };
+  return async;
+}
+var copy_1;
+var hasRequiredCopy$1;
+function requireCopy$1() {
+  if (hasRequiredCopy$1) return copy_1;
+  hasRequiredCopy$1 = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const path$1 = path;
+  const { mkdirs: mkdirs2 } = /* @__PURE__ */ requireMkdirs();
+  const { pathExists } = /* @__PURE__ */ requirePathExists();
+  const { utimesMillis } = /* @__PURE__ */ requireUtimes();
+  const stat2 = /* @__PURE__ */ requireStat();
+  const { asyncIteratorConcurrentProcess } = /* @__PURE__ */ requireAsync();
+  async function copy2(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 = path$1.dirname(dest);
+    const dirExists = await pathExists(destParent);
+    if (!dirExists) {
+      await mkdirs2(destParent);
+    }
+    await getStatsAndPerformCopy(destStat, src, dest, opts);
+  }
+  async function runFilter(src, dest, opts) {
+    if (!opts.filter) return true;
+    return opts.filter(src, dest);
+  }
+  async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+    const statFn = opts.dereference ? fs2.stat : fs2.lstat;
+    const srcStat = await statFn(src);
+    if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+    if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+    if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+    if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+    if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+    throw new Error(`Unknown file: ${src}`);
+  }
+  async function onFile(srcStat, destStat, src, dest, opts) {
+    if (!destStat) return copyFile(srcStat, src, dest, opts);
+    if (opts.overwrite) {
+      await fs2.unlink(dest);
+      return copyFile(srcStat, src, dest, opts);
+    }
+    if (opts.errorOnExist) {
+      throw new Error(`'${dest}' already exists`);
+    }
+  }
+  async function copyFile(srcStat, src, dest, opts) {
+    await fs2.copyFile(src, dest);
+    if (opts.preserveTimestamps) {
+      if (fileIsNotWritable(srcStat.mode)) {
+        await makeFileWritable(dest, srcStat.mode);
+      }
+      const updatedSrcStat = await fs2.stat(src);
+      await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    return fs2.chmod(dest, srcStat.mode);
+  }
+  function fileIsNotWritable(srcMode) {
+    return (srcMode & 128) === 0;
+  }
+  function makeFileWritable(dest, srcMode) {
+    return fs2.chmod(dest, srcMode | 128);
+  }
+  async function onDir(srcStat, destStat, src, dest, opts) {
+    if (!destStat) {
+      await fs2.mkdir(dest);
+    }
+    await asyncIteratorConcurrentProcess(await fs2.opendir(src), async (item) => {
+      const srcItem = path$1.join(src, item.name);
+      const destItem = path$1.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 fs2.chmod(dest, srcStat.mode);
+    }
+  }
+  async function onLink(destStat, src, dest, opts) {
+    let resolvedSrc = await fs2.readlink(src);
+    if (opts.dereference) {
+      resolvedSrc = path$1.resolve(process.cwd(), resolvedSrc);
+    }
+    if (!destStat) {
+      return fs2.symlink(resolvedSrc, dest);
+    }
+    let resolvedDest = null;
+    try {
+      resolvedDest = await fs2.readlink(dest);
+    } catch (e) {
+      if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs2.symlink(resolvedSrc, dest);
+      throw e;
+    }
+    if (opts.dereference) {
+      resolvedDest = path$1.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 fs2.unlink(dest);
+    return fs2.symlink(resolvedSrc, dest);
+  }
+  copy_1 = copy2;
+  return copy_1;
+}
+var copySync_1;
+var hasRequiredCopySync;
+function requireCopySync() {
+  if (hasRequiredCopySync) return copySync_1;
+  hasRequiredCopySync = 1;
+  const fs2 = requireGracefulFs();
+  const path$1 = path;
+  const mkdirsSync = requireMkdirs().mkdirsSync;
+  const utimesMillisSync = requireUtimes().utimesMillisSync;
+  const stat2 = /* @__PURE__ */ requireStat();
+  function copySync(src, dest, opts) {
+    if (typeof opts === "function") {
+      opts = { filter: opts };
+    }
+    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") {
+      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", opts);
+    stat2.checkParentPathsSync(src, srcStat, dest, "copy");
+    if (opts.filter && !opts.filter(src, dest)) return;
+    const destParent = path$1.dirname(dest);
+    if (!fs2.existsSync(destParent)) mkdirsSync(destParent);
+    return getStats(destStat, src, dest, opts);
+  }
+  function getStats(destStat, src, dest, opts) {
+    const statSync = opts.dereference ? fs2.statSync : fs2.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}`);
+  }
+  function onFile(srcStat, destStat, src, dest, opts) {
+    if (!destStat) return copyFile(srcStat, src, dest, opts);
+    return mayCopyFile(srcStat, src, dest, opts);
+  }
+  function mayCopyFile(srcStat, src, dest, opts) {
+    if (opts.overwrite) {
+      fs2.unlinkSync(dest);
+      return copyFile(srcStat, src, dest, opts);
+    } else if (opts.errorOnExist) {
+      throw new Error(`'${dest}' already exists`);
+    }
+  }
+  function copyFile(srcStat, src, dest, opts) {
+    fs2.copyFileSync(src, dest);
+    if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+    return setDestMode(dest, srcStat.mode);
+  }
+  function handleTimestamps(srcMode, src, dest) {
+    if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+    return setDestTimestamps(src, dest);
+  }
+  function fileIsNotWritable(srcMode) {
+    return (srcMode & 128) === 0;
+  }
+  function makeFileWritable(dest, srcMode) {
+    return setDestMode(dest, srcMode | 128);
+  }
+  function setDestMode(dest, srcMode) {
+    return fs2.chmodSync(dest, srcMode);
+  }
+  function setDestTimestamps(src, dest) {
+    const updatedSrcStat = fs2.statSync(src);
+    return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+  }
+  function onDir(srcStat, destStat, src, dest, opts) {
+    if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+    return copyDir(src, dest, opts);
+  }
+  function mkDirAndCopy(srcMode, src, dest, opts) {
+    fs2.mkdirSync(dest);
+    copyDir(src, dest, opts);
+    return setDestMode(dest, srcMode);
+  }
+  function copyDir(src, dest, opts) {
+    const dir = fs2.opendirSync(src);
+    try {
+      let dirent;
+      while ((dirent = dir.readSync()) !== null) {
+        copyDirItem(dirent.name, src, dest, opts);
+      }
+    } finally {
+      dir.closeSync();
+    }
+  }
+  function copyDirItem(item, src, dest, opts) {
+    const srcItem = path$1.join(src, item);
+    const destItem = path$1.join(dest, item);
+    if (opts.filter && !opts.filter(srcItem, destItem)) return;
+    const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
+    return getStats(destStat, srcItem, destItem, opts);
+  }
+  function onLink(destStat, src, dest, opts) {
+    let resolvedSrc = fs2.readlinkSync(src);
+    if (opts.dereference) {
+      resolvedSrc = path$1.resolve(process.cwd(), resolvedSrc);
+    }
+    if (!destStat) {
+      return fs2.symlinkSync(resolvedSrc, dest);
+    } else {
+      let resolvedDest;
+      try {
+        resolvedDest = fs2.readlinkSync(dest);
+      } catch (err) {
+        if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs2.symlinkSync(resolvedSrc, dest);
+        throw err;
+      }
+      if (opts.dereference) {
+        resolvedDest = path$1.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}'.`);
+        }
+      }
+      return copyLink(resolvedSrc, dest);
+    }
+  }
+  function copyLink(resolvedSrc, dest) {
+    fs2.unlinkSync(dest);
+    return fs2.symlinkSync(resolvedSrc, dest);
+  }
+  copySync_1 = copySync;
+  return copySync_1;
+}
+var copy;
+var hasRequiredCopy;
+function requireCopy() {
+  if (hasRequiredCopy) return copy;
+  hasRequiredCopy = 1;
+  const u = requireUniversalify().fromPromise;
+  copy = {
+    copy: u(/* @__PURE__ */ requireCopy$1()),
+    copySync: /* @__PURE__ */ requireCopySync()
+  };
+  return copy;
+}
+var remove_1;
+var hasRequiredRemove;
+function requireRemove() {
+  if (hasRequiredRemove) return remove_1;
+  hasRequiredRemove = 1;
+  const fs2 = requireGracefulFs();
+  const u = requireUniversalify().fromCallback;
+  function remove(path2, callback) {
+    fs2.rm(path2, { recursive: true, force: true }, callback);
+  }
+  function removeSync(path2) {
+    fs2.rmSync(path2, { recursive: true, force: true });
+  }
+  remove_1 = {
+    remove: u(remove),
+    removeSync
+  };
+  return remove_1;
+}
+var empty;
+var hasRequiredEmpty;
+function requireEmpty() {
+  if (hasRequiredEmpty) return empty;
+  hasRequiredEmpty = 1;
+  const u = requireUniversalify().fromPromise;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const path$1 = path;
+  const mkdir = /* @__PURE__ */ requireMkdirs();
+  const remove = /* @__PURE__ */ requireRemove();
+  const emptyDir = u(async function emptyDir2(dir) {
+    let items;
+    try {
+      items = await fs2.readdir(dir);
+    } catch {
+      return mkdir.mkdirs(dir);
+    }
+    return Promise.all(items.map((item) => remove.remove(path$1.join(dir, item))));
+  });
+  function emptyDirSync(dir) {
+    let items;
+    try {
+      items = fs2.readdirSync(dir);
+    } catch {
+      return mkdir.mkdirsSync(dir);
+    }
+    items.forEach((item) => {
+      item = path$1.join(dir, item);
+      remove.removeSync(item);
+    });
+  }
+  empty = {
+    emptyDirSync,
+    emptydirSync: emptyDirSync,
+    emptyDir,
+    emptydir: emptyDir
+  };
+  return empty;
+}
+var file;
+var hasRequiredFile;
+function requireFile() {
+  if (hasRequiredFile) return file;
+  hasRequiredFile = 1;
+  const u = requireUniversalify().fromPromise;
+  const path$1 = path;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const mkdir = /* @__PURE__ */ requireMkdirs();
+  async function createFile(file2) {
+    let stats;
+    try {
+      stats = await fs2.stat(file2);
+    } catch {
+    }
+    if (stats && stats.isFile()) return;
+    const dir = path$1.dirname(file2);
+    let dirStats = null;
+    try {
+      dirStats = await fs2.stat(dir);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        await mkdir.mkdirs(dir);
+        await fs2.writeFile(file2, "");
+        return;
+      } else {
+        throw err;
+      }
+    }
+    if (dirStats.isDirectory()) {
+      await fs2.writeFile(file2, "");
+    } else {
+      await fs2.readdir(dir);
+    }
+  }
+  function createFileSync(file2) {
+    let stats;
+    try {
+      stats = fs2.statSync(file2);
+    } catch {
+    }
+    if (stats && stats.isFile()) return;
+    const dir = path$1.dirname(file2);
+    try {
+      if (!fs2.statSync(dir).isDirectory()) {
+        fs2.readdirSync(dir);
+      }
+    } catch (err) {
+      if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+      else throw err;
+    }
+    fs2.writeFileSync(file2, "");
+  }
+  file = {
+    createFile: u(createFile),
+    createFileSync
+  };
+  return file;
+}
+var link;
+var hasRequiredLink;
+function requireLink() {
+  if (hasRequiredLink) return link;
+  hasRequiredLink = 1;
+  const u = requireUniversalify().fromPromise;
+  const path$1 = path;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const mkdir = /* @__PURE__ */ requireMkdirs();
+  const { pathExists } = /* @__PURE__ */ requirePathExists();
+  const { areIdentical } = /* @__PURE__ */ requireStat();
+  async function createLink(srcpath, dstpath) {
+    let dstStat;
+    try {
+      dstStat = await fs2.lstat(dstpath);
+    } catch {
+    }
+    let srcStat;
+    try {
+      srcStat = await fs2.lstat(srcpath);
+    } catch (err) {
+      err.message = err.message.replace("lstat", "ensureLink");
+      throw err;
+    }
+    if (dstStat && areIdentical(srcStat, dstStat)) return;
+    const dir = path$1.dirname(dstpath);
+    const dirExists = await pathExists(dir);
+    if (!dirExists) {
+      await mkdir.mkdirs(dir);
+    }
+    await fs2.link(srcpath, dstpath);
+  }
+  function createLinkSync(srcpath, dstpath) {
+    let dstStat;
+    try {
+      dstStat = fs2.lstatSync(dstpath);
+    } catch {
+    }
+    try {
+      const srcStat = fs2.lstatSync(srcpath);
+      if (dstStat && areIdentical(srcStat, dstStat)) return;
+    } catch (err) {
+      err.message = err.message.replace("lstat", "ensureLink");
+      throw err;
+    }
+    const dir = path$1.dirname(dstpath);
+    const dirExists = fs2.existsSync(dir);
+    if (dirExists) return fs2.linkSync(srcpath, dstpath);
+    mkdir.mkdirsSync(dir);
+    return fs2.linkSync(srcpath, dstpath);
+  }
+  link = {
+    createLink: u(createLink),
+    createLinkSync
+  };
+  return link;
+}
+var symlinkPaths_1;
+var hasRequiredSymlinkPaths;
+function requireSymlinkPaths() {
+  if (hasRequiredSymlinkPaths) return symlinkPaths_1;
+  hasRequiredSymlinkPaths = 1;
+  const path$1 = path;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const { pathExists } = /* @__PURE__ */ requirePathExists();
+  const u = requireUniversalify().fromPromise;
+  async function symlinkPaths(srcpath, dstpath) {
+    if (path$1.isAbsolute(srcpath)) {
+      try {
+        await fs2.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: srcpath
+      };
+    }
+    const dstdir = path$1.dirname(dstpath);
+    const relativeToDst = path$1.join(dstdir, srcpath);
+    const exists = await pathExists(relativeToDst);
+    if (exists) {
+      return {
+        toCwd: relativeToDst,
+        toDst: srcpath
+      };
+    }
+    try {
+      await fs2.lstat(srcpath);
+    } catch (err) {
+      err.message = err.message.replace("lstat", "ensureSymlink");
+      throw err;
+    }
+    return {
+      toCwd: srcpath,
+      toDst: path$1.relative(dstdir, srcpath)
+    };
+  }
+  function symlinkPathsSync(srcpath, dstpath) {
+    if (path$1.isAbsolute(srcpath)) {
+      const exists2 = fs2.existsSync(srcpath);
+      if (!exists2) throw new Error("absolute srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: srcpath
+      };
+    }
+    const dstdir = path$1.dirname(dstpath);
+    const relativeToDst = path$1.join(dstdir, srcpath);
+    const exists = fs2.existsSync(relativeToDst);
+    if (exists) {
+      return {
+        toCwd: relativeToDst,
+        toDst: srcpath
+      };
+    }
+    const srcExists = fs2.existsSync(srcpath);
+    if (!srcExists) throw new Error("relative srcpath does not exist");
+    return {
+      toCwd: srcpath,
+      toDst: path$1.relative(dstdir, srcpath)
+    };
+  }
+  symlinkPaths_1 = {
+    symlinkPaths: u(symlinkPaths),
+    symlinkPathsSync
+  };
+  return symlinkPaths_1;
+}
+var symlinkType_1;
+var hasRequiredSymlinkType;
+function requireSymlinkType() {
+  if (hasRequiredSymlinkType) return symlinkType_1;
+  hasRequiredSymlinkType = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const u = requireUniversalify().fromPromise;
+  async function symlinkType(srcpath, type) {
+    if (type) return type;
+    let stats;
+    try {
+      stats = await fs2.lstat(srcpath);
+    } catch {
+      return "file";
+    }
+    return stats && stats.isDirectory() ? "dir" : "file";
+  }
+  function symlinkTypeSync(srcpath, type) {
+    if (type) return type;
+    let stats;
+    try {
+      stats = fs2.lstatSync(srcpath);
+    } catch {
+      return "file";
+    }
+    return stats && stats.isDirectory() ? "dir" : "file";
+  }
+  symlinkType_1 = {
+    symlinkType: u(symlinkType),
+    symlinkTypeSync
+  };
+  return symlinkType_1;
+}
+var symlink;
+var hasRequiredSymlink;
+function requireSymlink() {
+  if (hasRequiredSymlink) return symlink;
+  hasRequiredSymlink = 1;
+  const u = requireUniversalify().fromPromise;
+  const path$1 = path;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const { mkdirs: mkdirs2, mkdirsSync } = /* @__PURE__ */ requireMkdirs();
+  const { symlinkPaths, symlinkPathsSync } = /* @__PURE__ */ requireSymlinkPaths();
+  const { symlinkType, symlinkTypeSync } = /* @__PURE__ */ requireSymlinkType();
+  const { pathExists } = /* @__PURE__ */ requirePathExists();
+  const { areIdentical } = /* @__PURE__ */ requireStat();
+  async function createSymlink(srcpath, dstpath, type) {
+    let stats;
+    try {
+      stats = await fs2.lstat(dstpath);
+    } catch {
+    }
+    if (stats && stats.isSymbolicLink()) {
+      const [srcStat, dstStat] = await Promise.all([
+        fs2.stat(srcpath),
+        fs2.stat(dstpath)
+      ]);
+      if (areIdentical(srcStat, dstStat)) return;
+    }
+    const relative = await symlinkPaths(srcpath, dstpath);
+    srcpath = relative.toDst;
+    const toType = await symlinkType(relative.toCwd, type);
+    const dir = path$1.dirname(dstpath);
+    if (!await pathExists(dir)) {
+      await mkdirs2(dir);
+    }
+    return fs2.symlink(srcpath, dstpath, toType);
+  }
+  function createSymlinkSync(srcpath, dstpath, type) {
+    let stats;
+    try {
+      stats = fs2.lstatSync(dstpath);
+    } catch {
+    }
+    if (stats && stats.isSymbolicLink()) {
+      const srcStat = fs2.statSync(srcpath);
+      const dstStat = fs2.statSync(dstpath);
+      if (areIdentical(srcStat, dstStat)) return;
+    }
+    const relative = symlinkPathsSync(srcpath, dstpath);
+    srcpath = relative.toDst;
+    type = symlinkTypeSync(relative.toCwd, type);
+    const dir = path$1.dirname(dstpath);
+    const exists = fs2.existsSync(dir);
+    if (exists) return fs2.symlinkSync(srcpath, dstpath, type);
+    mkdirsSync(dir);
+    return fs2.symlinkSync(srcpath, dstpath, type);
+  }
+  symlink = {
+    createSymlink: u(createSymlink),
+    createSymlinkSync
+  };
+  return symlink;
+}
+var ensure;
+var hasRequiredEnsure;
+function requireEnsure() {
+  if (hasRequiredEnsure) return ensure;
+  hasRequiredEnsure = 1;
+  const { createFile, createFileSync } = /* @__PURE__ */ requireFile();
+  const { createLink, createLinkSync } = /* @__PURE__ */ requireLink();
+  const { createSymlink, createSymlinkSync } = /* @__PURE__ */ requireSymlink();
+  ensure = {
+    // file
+    createFile,
+    createFileSync,
+    ensureFile: createFile,
+    ensureFileSync: createFileSync,
+    // link
+    createLink,
+    createLinkSync,
+    ensureLink: createLink,
+    ensureLinkSync: createLinkSync,
+    // symlink
+    createSymlink,
+    createSymlinkSync,
+    ensureSymlink: createSymlink,
+    ensureSymlinkSync: createSymlinkSync
+  };
+  return ensure;
+}
+var utils;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+    const EOF = finalEOL ? EOL : "";
+    const str = JSON.stringify(obj, replacer, spaces);
+    return str.replace(/\n/g, EOL) + EOF;
+  }
+  function stripBom(content) {
+    if (Buffer.isBuffer(content)) content = content.toString("utf8");
+    return content.replace(/^\uFEFF/, "");
+  }
+  utils = { stringify, stripBom };
+  return utils;
+}
+var jsonfile_1;
+var hasRequiredJsonfile$1;
+function requireJsonfile$1() {
+  if (hasRequiredJsonfile$1) return jsonfile_1;
+  hasRequiredJsonfile$1 = 1;
+  let _fs;
+  try {
+    _fs = requireGracefulFs();
+  } catch (_) {
+    _fs = fs$2;
+  }
+  const universalify2 = requireUniversalify();
+  const { stringify, stripBom } = requireUtils();
+  async function _readFile(file2, options = {}) {
+    if (typeof options === "string") {
+      options = { encoding: options };
+    }
+    const fs2 = options.fs || _fs;
+    const shouldThrow = "throws" in options ? options.throws : true;
+    let data = await universalify2.fromCallback(fs2.readFile)(file2, options);
+    data = stripBom(data);
+    let obj;
+    try {
+      obj = JSON.parse(data, options ? options.reviver : null);
+    } catch (err) {
+      if (shouldThrow) {
+        err.message = `${file2}: ${err.message}`;
+        throw err;
+      } else {
+        return null;
+      }
+    }
+    return obj;
+  }
+  const readFile = universalify2.fromPromise(_readFile);
+  function readFileSync(file2, options = {}) {
+    if (typeof options === "string") {
+      options = { encoding: options };
+    }
+    const fs2 = options.fs || _fs;
+    const shouldThrow = "throws" in options ? options.throws : true;
+    try {
+      let content = fs2.readFileSync(file2, options);
+      content = stripBom(content);
+      return JSON.parse(content, options.reviver);
+    } catch (err) {
+      if (shouldThrow) {
+        err.message = `${file2}: ${err.message}`;
+        throw err;
+      } else {
+        return null;
+      }
+    }
+  }
+  async function _writeFile(file2, obj, options = {}) {
+    const fs2 = options.fs || _fs;
+    const str = stringify(obj, options);
+    await universalify2.fromCallback(fs2.writeFile)(file2, str, options);
+  }
+  const writeFile = universalify2.fromPromise(_writeFile);
+  function writeFileSync(file2, obj, options = {}) {
+    const fs2 = options.fs || _fs;
+    const str = stringify(obj, options);
+    return fs2.writeFileSync(file2, str, options);
+  }
+  const jsonfile2 = {
+    readFile,
+    readFileSync,
+    writeFile,
+    writeFileSync
+  };
+  jsonfile_1 = jsonfile2;
+  return jsonfile_1;
+}
+var jsonfile;
+var hasRequiredJsonfile;
+function requireJsonfile() {
+  if (hasRequiredJsonfile) return jsonfile;
+  hasRequiredJsonfile = 1;
+  const jsonFile = requireJsonfile$1();
+  jsonfile = {
+    // jsonfile exports
+    readJson: jsonFile.readFile,
+    readJsonSync: jsonFile.readFileSync,
+    writeJson: jsonFile.writeFile,
+    writeJsonSync: jsonFile.writeFileSync
+  };
+  return jsonfile;
+}
+var outputFile_1;
+var hasRequiredOutputFile;
+function requireOutputFile() {
+  if (hasRequiredOutputFile) return outputFile_1;
+  hasRequiredOutputFile = 1;
+  const u = requireUniversalify().fromPromise;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const path$1 = path;
+  const mkdir = /* @__PURE__ */ requireMkdirs();
+  const pathExists = requirePathExists().pathExists;
+  async function outputFile(file2, data, encoding = "utf-8") {
+    const dir = path$1.dirname(file2);
+    if (!await pathExists(dir)) {
+      await mkdir.mkdirs(dir);
+    }
+    return fs2.writeFile(file2, data, encoding);
+  }
+  function outputFileSync(file2, ...args) {
+    const dir = path$1.dirname(file2);
+    if (!fs2.existsSync(dir)) {
+      mkdir.mkdirsSync(dir);
+    }
+    fs2.writeFileSync(file2, ...args);
+  }
+  outputFile_1 = {
+    outputFile: u(outputFile),
+    outputFileSync
+  };
+  return outputFile_1;
+}
+var outputJson_1;
+var hasRequiredOutputJson;
+function requireOutputJson() {
+  if (hasRequiredOutputJson) return outputJson_1;
+  hasRequiredOutputJson = 1;
+  const { stringify } = requireUtils();
+  const { outputFile } = /* @__PURE__ */ requireOutputFile();
+  async function outputJson(file2, data, options = {}) {
+    const str = stringify(data, options);
+    await outputFile(file2, str, options);
+  }
+  outputJson_1 = outputJson;
+  return outputJson_1;
+}
+var outputJsonSync_1;
+var hasRequiredOutputJsonSync;
+function requireOutputJsonSync() {
+  if (hasRequiredOutputJsonSync) return outputJsonSync_1;
+  hasRequiredOutputJsonSync = 1;
+  const { stringify } = requireUtils();
+  const { outputFileSync } = /* @__PURE__ */ requireOutputFile();
+  function outputJsonSync(file2, data, options) {
+    const str = stringify(data, options);
+    outputFileSync(file2, str, options);
+  }
+  outputJsonSync_1 = outputJsonSync;
+  return outputJsonSync_1;
+}
+var json;
+var hasRequiredJson;
+function requireJson() {
+  if (hasRequiredJson) return json;
+  hasRequiredJson = 1;
+  const u = requireUniversalify().fromPromise;
+  const jsonFile = /* @__PURE__ */ requireJsonfile();
+  jsonFile.outputJson = u(/* @__PURE__ */ requireOutputJson());
+  jsonFile.outputJsonSync = /* @__PURE__ */ requireOutputJsonSync();
+  jsonFile.outputJSON = jsonFile.outputJson;
+  jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+  jsonFile.writeJSON = jsonFile.writeJson;
+  jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+  jsonFile.readJSON = jsonFile.readJson;
+  jsonFile.readJSONSync = jsonFile.readJsonSync;
+  json = jsonFile;
+  return json;
+}
+var move_1;
+var hasRequiredMove$1;
+function requireMove$1() {
+  if (hasRequiredMove$1) return move_1;
+  hasRequiredMove$1 = 1;
+  const fs2 = /* @__PURE__ */ requireFs();
+  const path$1 = path;
+  const { copy: copy2 } = /* @__PURE__ */ requireCopy();
+  const { remove } = /* @__PURE__ */ requireRemove();
+  const { mkdirp } = /* @__PURE__ */ requireMkdirs();
+  const { pathExists } = /* @__PURE__ */ requirePathExists();
+  const stat2 = /* @__PURE__ */ requireStat();
+  async function move2(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 = path$1.dirname(dest);
+    const parsedParentPath = path$1.parse(destParent);
+    if (parsedParentPath.root !== destParent) {
+      await mkdirp(destParent);
+    }
+    return doRename(src, dest, overwrite, isChangingCase);
+  }
+  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 fs2.rename(src, dest);
+    } catch (err) {
+      if (err.code !== "EXDEV") {
+        throw err;
+      }
+      await moveAcrossDevice(src, dest, overwrite);
+    }
+  }
+  async function moveAcrossDevice(src, dest, overwrite) {
+    const opts = {
+      overwrite,
+      errorOnExist: true,
+      preserveTimestamps: true
+    };
+    await copy2(src, dest, opts);
+    return remove(src);
+  }
+  move_1 = move2;
+  return move_1;
+}
+var moveSync_1;
+var hasRequiredMoveSync;
+function requireMoveSync() {
+  if (hasRequiredMoveSync) return moveSync_1;
+  hasRequiredMoveSync = 1;
+  const fs2 = requireGracefulFs();
+  const path$1 = path;
+  const copySync = requireCopy().copySync;
+  const removeSync = requireRemove().removeSync;
+  const mkdirpSync = requireMkdirs().mkdirpSync;
+  const stat2 = /* @__PURE__ */ requireStat();
+  function moveSync(src, dest, opts) {
+    opts = opts || {};
+    const overwrite = opts.overwrite || opts.clobber || false;
+    const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
+    stat2.checkParentPathsSync(src, srcStat, dest, "move");
+    if (!isParentRoot(dest)) mkdirpSync(path$1.dirname(dest));
+    return doRename(src, dest, overwrite, isChangingCase);
+  }
+  function isParentRoot(dest) {
+    const parent = path$1.dirname(dest);
+    const parsedPath = path$1.parse(parent);
+    return parsedPath.root === parent;
+  }
+  function doRename(src, dest, overwrite, isChangingCase) {
+    if (isChangingCase) return rename(src, dest, overwrite);
+    if (overwrite) {
+      removeSync(dest);
+      return rename(src, dest, overwrite);
+    }
+    if (fs2.existsSync(dest)) throw new Error("dest already exists.");
+    return rename(src, dest, overwrite);
+  }
+  function rename(src, dest, overwrite) {
+    try {
+      fs2.renameSync(src, dest);
+    } catch (err) {
+      if (err.code !== "EXDEV") throw err;
+      return moveAcrossDevice(src, dest, overwrite);
+    }
+  }
+  function moveAcrossDevice(src, dest, overwrite) {
+    const opts = {
+      overwrite,
+      errorOnExist: true,
+      preserveTimestamps: true
+    };
+    copySync(src, dest, opts);
+    return removeSync(src);
+  }
+  moveSync_1 = moveSync;
+  return moveSync_1;
+}
+var move;
+var hasRequiredMove;
+function requireMove() {
+  if (hasRequiredMove) return move;
+  hasRequiredMove = 1;
+  const u = requireUniversalify().fromPromise;
+  move = {
+    move: u(/* @__PURE__ */ requireMove$1()),
+    moveSync: /* @__PURE__ */ requireMoveSync()
+  };
+  return move;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  lib = {
+    // Export promiseified graceful-fs:
+    .../* @__PURE__ */ requireFs(),
+    // Export extra methods:
+    .../* @__PURE__ */ requireCopy(),
+    .../* @__PURE__ */ requireEmpty(),
+    .../* @__PURE__ */ requireEnsure(),
+    .../* @__PURE__ */ requireJson(),
+    .../* @__PURE__ */ requireMkdirs(),
+    .../* @__PURE__ */ requireMove(),
+    .../* @__PURE__ */ requireOutputFile(),
+    .../* @__PURE__ */ requirePathExists(),
+    .../* @__PURE__ */ requireRemove()
+  };
+  return lib;
+}
+var libExports = /* @__PURE__ */ requireLib();
+const fs = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+export {
+  fs as f
+};