vitepress 0.22.0 → 0.22.1

package/dist/node/{serve-9874c5ac.js → serve-c594fc71.js}

@@ -1,24 +1,25 @@
 'use strict';
 
 var vite = require('vite');
-var require$$0$d = require('readline');
+var require$$0$f = require('readline');
 var require$$5 = require('assert');
-var require$$0$b = require('events');
+var require$$0$c = require('events');
 var require$$0$7 = require('stream');
-var require$$0$8 = require('util');
-var require$$0$c = require('buffer');
-var path$p = require('path');
-var fs$v = require('fs');
+var require$$0$9 = require('util');
+var require$$0$e = require('buffer');
+var path$s = require('path');
+var require$$0$8 = require('fs');
 var require$$8 = require('punycode');
 var prism = require('prismjs');
 var url$1 = require('url');
+var require$$0$d = require('child_process');
 var qs = require('querystring');
-var require$$0$9 = require('tty');
+var require$$0$a = require('tty');
 var require$$4 = require('net');
 var require$$7 = require('zlib');
 var require$$0$6 = require('constants');
-var require$$0$a = require('os');
-var require$$0$e = require('http');
+var require$$0$b = require('os');
+var require$$0$g = require('http');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -40,25 +41,26 @@ function _interopNamespace(e) {
 	return Object.freeze(n);
 }
 
-var require$$0__default$7 = /*#__PURE__*/_interopDefaultLegacy(require$$0$d);
+var require$$0__default$9 = /*#__PURE__*/_interopDefaultLegacy(require$$0$f);
 var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
-var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$b);
+var require$$0__default$6 = /*#__PURE__*/_interopDefaultLegacy(require$$0$c);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$7);
+var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$9);
+var require$$0__default$8 = /*#__PURE__*/_interopDefaultLegacy(require$$0$e);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$s);
 var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$8);
-var require$$0__default$6 = /*#__PURE__*/_interopDefaultLegacy(require$$0$c);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$p);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$v);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs$v);
+var require$$0__namespace = /*#__PURE__*/_interopNamespace(require$$0$8);
 var require$$8__default = /*#__PURE__*/_interopDefaultLegacy(require$$8);
 var prism__default = /*#__PURE__*/_interopDefaultLegacy(prism);
+var require$$0__default$7 = /*#__PURE__*/_interopDefaultLegacy(require$$0$d);
 var qs__namespace = /*#__PURE__*/_interopNamespace(qs);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
-var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$9);
+var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$a);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var require$$7__default = /*#__PURE__*/_interopDefaultLegacy(require$$7);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
-var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$a);
-var require$$0__default$8 = /*#__PURE__*/_interopDefaultLegacy(require$$0$e);
+var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$b);
+var require$$0__default$a = /*#__PURE__*/_interopDefaultLegacy(require$$0$g);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -81,7 +83,7 @@ function commonjsRequire (path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
 
-var fs$u = {};
+var fs$x = {};
 
 var universalify$1 = {};
 
@@ -596,12 +598,12 @@ function clone$3 (obj) {
   return copy
 }
 
-var fs$t = fs__default["default"];
+var fs$w = require$$0__default$2["default"];
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone$2 = clone_1;
 
-var util$5 = require$$0__default$2["default"];
+var util$5 = require$$0__default$3["default"];
 
 /* istanbul ignore next - node 0.x polyfill */
 var gracefulQueue;
@@ -638,18 +640,18 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   };
 
 // Once time initialization
-if (!fs$t[gracefulQueue]) {
+if (!fs$w[gracefulQueue]) {
   // This queue can be shared by multiple loaded instances
   var queue$1 = commonjsGlobal[gracefulQueue] || [];
-  publishQueue(fs$t, queue$1);
+  publishQueue(fs$w, queue$1);
 
   // Patch fs.close/closeSync to shared queue version, because we need
   // to retry() whenever a close happens *anywhere* in the program.
   // This is essential when multiple graceful-fs instances are
   // in play at the same time.
-  fs$t.close = (function (fs$close) {
+  fs$w.close = (function (fs$close) {
     function close (fd, cb) {
-      return fs$close.call(fs$t, fd, function (err) {
+      return fs$close.call(fs$w, fd, function (err) {
         // This function uses the graceful-fs shared queue
         if (!err) {
           resetQueue();
@@ -664,12 +666,12 @@ if (!fs$t[gracefulQueue]) {
       value: fs$close
     });
     return close
-  })(fs$t.close);
+  })(fs$w.close);
 
-  fs$t.closeSync = (function (fs$closeSync) {
+  fs$w.closeSync = (function (fs$closeSync) {
     function closeSync (fd) {
       // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs$t, arguments);
+      fs$closeSync.apply(fs$w, arguments);
       resetQueue();
     }
 
@@ -677,24 +679,24 @@ if (!fs$t[gracefulQueue]) {
       value: fs$closeSync
     });
     return closeSync
-  })(fs$t.closeSync);
+  })(fs$w.closeSync);
 
   if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
     process.on('exit', function() {
-      debug$4(fs$t[gracefulQueue]);
-      require$$5__default["default"].equal(fs$t[gracefulQueue].length, 0);
+      debug$4(fs$w[gracefulQueue]);
+      require$$5__default["default"].equal(fs$w[gracefulQueue].length, 0);
     });
   }
 }
 
 if (!commonjsGlobal[gracefulQueue]) {
-  publishQueue(commonjsGlobal, fs$t[gracefulQueue]);
+  publishQueue(commonjsGlobal, fs$w[gracefulQueue]);
 }
 
-var gracefulFs = patch(clone$2(fs$t));
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$t.__patched) {
-    gracefulFs = patch(fs$t);
-    fs$t.__patched = true;
+var gracefulFs = patch(clone$2(fs$w));
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$w.__patched) {
+    gracefulFs = patch(fs$w);
+    fs$w.__patched = true;
 }
 
 function patch (fs) {
@@ -949,7 +951,7 @@ function patch (fs) {
 
 function enqueue (elem) {
   debug$4('ENQUEUE', elem[0].name, elem[1]);
-  fs$t[gracefulQueue].push(elem);
+  fs$w[gracefulQueue].push(elem);
   retry();
 }
 
@@ -961,12 +963,12 @@ var retryTimer;
 // delay between attempts so that we'll retry these jobs sooner
 function resetQueue () {
   var now = Date.now();
-  for (var i = 0; i < fs$t[gracefulQueue].length; ++i) {
+  for (var i = 0; i < fs$w[gracefulQueue].length; ++i) {
     // entries that are only a length of 2 are from an older version, don't
     // bother modifying those since they'll be retried anyway.
-    if (fs$t[gracefulQueue][i].length > 2) {
-      fs$t[gracefulQueue][i][3] = now; // startTime
-      fs$t[gracefulQueue][i][4] = now; // lastTime
+    if (fs$w[gracefulQueue][i].length > 2) {
+      fs$w[gracefulQueue][i][3] = now; // startTime
+      fs$w[gracefulQueue][i][4] = now; // lastTime
     }
   }
   // call retry to make sure we're actively processing the queue
@@ -978,10 +980,10 @@ function retry () {
   clearTimeout(retryTimer);
   retryTimer = undefined;
 
-  if (fs$t[gracefulQueue].length === 0)
+  if (fs$w[gracefulQueue].length === 0)
     return
 
-  var elem = fs$t[gracefulQueue].shift();
+  var elem = fs$w[gracefulQueue].shift();
   var fn = elem[0];
   var args = elem[1];
   // these items may be unset if they were added by an older graceful-fs
@@ -1016,7 +1018,7 @@ function retry () {
     } else {
       // if we can't do this job yet, push it to the end of the queue
       // and let the next iteration check again
-      fs$t[gracefulQueue].push(elem);
+      fs$w[gracefulQueue].push(elem);
     }
   }
 
@@ -1145,19 +1147,19 @@ if (typeof fs.writev === 'function') {
     })
   };
 }
-}(fs$u));
+}(fs$x));
 
 var makeDir$1 = {};
 
 var utils$u = {};
 
-const path$o = path__default["default"];
+const path$r = path__default["default"];
 
 // https://github.com/nodejs/node/issues/8987
 // https://github.com/libuv/libuv/pull/1088
 utils$u.checkPath = function checkPath (pth) {
   if (process.platform === 'win32') {
-    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path$o.parse(pth).root, ''));
+    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path$r.parse(pth).root, ''));
 
     if (pathHasInvalidWinCharacters) {
       const error = new Error(`Path contains invalid characters: ${pth}`);
@@ -1167,7 +1169,7 @@ utils$u.checkPath = function checkPath (pth) {
   }
 };
 
-const fs$s = fs$u;
+const fs$v = fs$x;
 const { checkPath: checkPath$1 } = utils$u;
 
 const getMode = options => {
@@ -1179,7 +1181,7 @@ const getMode = options => {
 makeDir$1.makeDir = async (dir, options) => {
   checkPath$1(dir);
 
-  return fs$s.mkdir(dir, {
+  return fs$v.mkdir(dir, {
     mode: getMode(options),
     recursive: true
   })
@@ -1188,7 +1190,7 @@ makeDir$1.makeDir = async (dir, options) => {
 makeDir$1.makeDirSync = (dir, options) => {
   checkPath$1(dir);
 
-  return fs$s.mkdirSync(dir, {
+  return fs$v.mkdirSync(dir, {
     mode: getMode(options),
     recursive: true
   })
@@ -1208,14 +1210,14 @@ var mkdirs$2 = {
   ensureDirSync: makeDirSync
 };
 
-const fs$r = gracefulFs;
+const fs$u = gracefulFs;
 
 function utimesMillis$1 (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  fs$r.open(path, 'r+', (err, fd) => {
+  fs$u.open(path, 'r+', (err, fd) => {
     if (err) return callback(err)
-    fs$r.futimes(fd, atime, mtime, futimesErr => {
-      fs$r.close(fd, closeErr => {
+    fs$u.futimes(fd, atime, mtime, futimesErr => {
+      fs$u.close(fd, closeErr => {
         if (callback) callback(futimesErr || closeErr);
       });
     });
@@ -1223,9 +1225,9 @@ function utimesMillis$1 (path, atime, mtime, callback) {
 }
 
 function utimesMillisSync$1 (path, atime, mtime) {
-  const fd = fs$r.openSync(path, 'r+');
-  fs$r.futimesSync(fd, atime, mtime);
-  return fs$r.closeSync(fd)
+  const fd = fs$u.openSync(path, 'r+');
+  fs$u.futimesSync(fd, atime, mtime);
+  return fs$u.closeSync(fd)
 }
 
 var utimes = {
@@ -1233,14 +1235,14 @@ var utimes = {
   utimesMillisSync: utimesMillisSync$1
 };
 
-const fs$q = fs$u;
-const path$n = path__default["default"];
-const util$4 = require$$0__default$2["default"];
+const fs$t = fs$x;
+const path$q = path__default["default"];
+const util$4 = require$$0__default$3["default"];
 
 function getStats$2 (src, dest, opts) {
   const statFunc = opts.dereference
-    ? (file) => fs$q.stat(file, { bigint: true })
-    : (file) => fs$q.lstat(file, { bigint: true });
+    ? (file) => fs$t.stat(file, { bigint: true })
+    : (file) => fs$t.lstat(file, { bigint: true });
   return Promise.all([
     statFunc(src),
     statFunc(dest).catch(err => {
@@ -1253,8 +1255,8 @@ function getStats$2 (src, dest, opts) {
 function getStatsSync (src, dest, opts) {
   let destStat;
   const statFunc = opts.dereference
-    ? (file) => fs$q.statSync(file, { bigint: true })
-    : (file) => fs$q.lstatSync(file, { bigint: true });
+    ? (file) => fs$t.statSync(file, { bigint: true })
+    : (file) => fs$t.lstatSync(file, { bigint: true });
   const srcStat = statFunc(src);
   try {
     destStat = statFunc(dest);
@@ -1272,8 +1274,8 @@ function checkPaths (src, dest, funcName, opts, cb) {
 
     if (destStat) {
       if (areIdentical$2(srcStat, destStat)) {
-        const srcBaseName = path$n.basename(src);
-        const destBaseName = path$n.basename(dest);
+        const srcBaseName = path$q.basename(src);
+        const destBaseName = path$q.basename(dest);
         if (funcName === 'move' &&
           srcBaseName !== destBaseName &&
           srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
@@ -1301,8 +1303,8 @@ function checkPathsSync (src, dest, funcName, opts) {
 
   if (destStat) {
     if (areIdentical$2(srcStat, destStat)) {
-      const srcBaseName = path$n.basename(src);
-      const destBaseName = path$n.basename(dest);
+      const srcBaseName = path$q.basename(src);
+      const destBaseName = path$q.basename(dest);
       if (funcName === 'move' &&
         srcBaseName !== destBaseName &&
         srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
@@ -1329,10 +1331,10 @@ function checkPathsSync (src, dest, funcName, opts) {
 // checks the src and dest inodes. It starts from the deepest
 // parent and stops once it reaches the src parent or the root path.
 function checkParentPaths (src, srcStat, dest, funcName, cb) {
-  const srcParent = path$n.resolve(path$n.dirname(src));
-  const destParent = path$n.resolve(path$n.dirname(dest));
-  if (destParent === srcParent || destParent === path$n.parse(destParent).root) return cb()
-  fs$q.stat(destParent, { bigint: true }, (err, destStat) => {
+  const srcParent = path$q.resolve(path$q.dirname(src));
+  const destParent = path$q.resolve(path$q.dirname(dest));
+  if (destParent === srcParent || destParent === path$q.parse(destParent).root) return cb()
+  fs$t.stat(destParent, { bigint: true }, (err, destStat) => {
     if (err) {
       if (err.code === 'ENOENT') return cb()
       return cb(err)
@@ -1345,12 +1347,12 @@ function checkParentPaths (src, srcStat, dest, funcName, cb) {
 }
 
 function checkParentPathsSync (src, srcStat, dest, funcName) {
-  const srcParent = path$n.resolve(path$n.dirname(src));
-  const destParent = path$n.resolve(path$n.dirname(dest));
-  if (destParent === srcParent || destParent === path$n.parse(destParent).root) return
+  const srcParent = path$q.resolve(path$q.dirname(src));
+  const destParent = path$q.resolve(path$q.dirname(dest));
+  if (destParent === srcParent || destParent === path$q.parse(destParent).root) return
   let destStat;
   try {
-    destStat = fs$q.statSync(destParent, { bigint: true });
+    destStat = fs$t.statSync(destParent, { bigint: true });
   } catch (err) {
     if (err.code === 'ENOENT') return
     throw err
@@ -1368,8 +1370,8 @@ function areIdentical$2 (srcStat, destStat) {
 // return true if dest is a subdir of src, otherwise false.
 // It only checks the path strings.
 function isSrcSubdir (src, dest) {
-  const srcArr = path$n.resolve(src).split(path$n.sep).filter(i => i);
-  const destArr = path$n.resolve(dest).split(path$n.sep).filter(i => i);
+  const srcArr = path$q.resolve(src).split(path$q.sep).filter(i => i);
+  const destArr = path$q.resolve(dest).split(path$q.sep).filter(i => i);
   return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)
 }
 
@@ -1386,8 +1388,8 @@ var stat$5 = {
   areIdentical: areIdentical$2
 };
 
-const fs$p = gracefulFs;
-const path$m = path__default["default"];
+const fs$s = gracefulFs;
+const path$p = path__default["default"];
 const mkdirsSync$1 = mkdirs$2.mkdirsSync;
 const utimesMillisSync = utimes.utimesMillisSync;
 const stat$4 = stat$5;
@@ -1414,8 +1416,8 @@ function copySync$2 (src, dest, opts) {
 
 function handleFilterAndCopy (destStat, src, dest, opts) {
   if (opts.filter && !opts.filter(src, dest)) return
-  const destParent = path$m.dirname(dest);
-  if (!fs$p.existsSync(destParent)) mkdirsSync$1(destParent);
+  const destParent = path$p.dirname(dest);
+  if (!fs$s.existsSync(destParent)) mkdirsSync$1(destParent);
   return getStats$1(destStat, src, dest, opts)
 }
 
@@ -1425,7 +1427,7 @@ function startCopy$1 (destStat, src, dest, opts) {
 }
 
 function getStats$1 (destStat, src, dest, opts) {
-  const statSync = opts.dereference ? fs$p.statSync : fs$p.lstatSync;
+  const statSync = opts.dereference ? fs$s.statSync : fs$s.lstatSync;
   const srcStat = statSync(src);
 
   if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts)
@@ -1445,7 +1447,7 @@ function onFile$1 (srcStat, destStat, src, dest, opts) {
 
 function mayCopyFile$1 (srcStat, src, dest, opts) {
   if (opts.overwrite) {
-    fs$p.unlinkSync(dest);
+    fs$s.unlinkSync(dest);
     return copyFile$1(srcStat, src, dest, opts)
   } else if (opts.errorOnExist) {
     throw new Error(`'${dest}' already exists`)
@@ -1453,7 +1455,7 @@ function mayCopyFile$1 (srcStat, src, dest, opts) {
 }
 
 function copyFile$1 (srcStat, src, dest, opts) {
-  fs$p.copyFileSync(src, dest);
+  fs$s.copyFileSync(src, dest);
   if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
   return setDestMode$1(dest, srcStat.mode)
 }
@@ -1475,14 +1477,14 @@ function makeFileWritable$1 (dest, srcMode) {
 }
 
 function setDestMode$1 (dest, srcMode) {
-  return fs$p.chmodSync(dest, srcMode)
+  return fs$s.chmodSync(dest, srcMode)
 }
 
 function setDestTimestamps$1 (src, dest) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  const updatedSrcStat = fs$p.statSync(src);
+  const updatedSrcStat = fs$s.statSync(src);
   return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
 }
 
@@ -1492,43 +1494,43 @@ function onDir$1 (srcStat, destStat, src, dest, opts) {
 }
 
 function mkDirAndCopy$1 (srcMode, src, dest, opts) {
-  fs$p.mkdirSync(dest);
+  fs$s.mkdirSync(dest);
   copyDir$1(src, dest, opts);
   return setDestMode$1(dest, srcMode)
 }
 
 function copyDir$1 (src, dest, opts) {
-  fs$p.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
+  fs$s.readdirSync(src).forEach(item => copyDirItem$1(item, src, dest, opts));
 }
 
 function copyDirItem$1 (item, src, dest, opts) {
-  const srcItem = path$m.join(src, item);
-  const destItem = path$m.join(dest, item);
+  const srcItem = path$p.join(src, item);
+  const destItem = path$p.join(dest, item);
   const { destStat } = stat$4.checkPathsSync(srcItem, destItem, 'copy', opts);
   return startCopy$1(destStat, srcItem, destItem, opts)
 }
 
 function onLink$1 (destStat, src, dest, opts) {
-  let resolvedSrc = fs$p.readlinkSync(src);
+  let resolvedSrc = fs$s.readlinkSync(src);
   if (opts.dereference) {
-    resolvedSrc = path$m.resolve(process.cwd(), resolvedSrc);
+    resolvedSrc = path$p.resolve(process.cwd(), resolvedSrc);
   }
 
   if (!destStat) {
-    return fs$p.symlinkSync(resolvedSrc, dest)
+    return fs$s.symlinkSync(resolvedSrc, dest)
   } else {
     let resolvedDest;
     try {
-      resolvedDest = fs$p.readlinkSync(dest);
+      resolvedDest = fs$s.readlinkSync(dest);
     } catch (err) {
       // dest exists and is a regular file or directory,
       // Windows may throw UNKNOWN error. If dest already exists,
       // fs throws error anyway, so no need to guard against it here.
-      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$p.symlinkSync(resolvedSrc, dest)
+      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$s.symlinkSync(resolvedSrc, dest)
       throw err
     }
     if (opts.dereference) {
-      resolvedDest = path$m.resolve(process.cwd(), resolvedDest);
+      resolvedDest = path$p.resolve(process.cwd(), resolvedDest);
     }
     if (stat$4.isSrcSubdir(resolvedSrc, resolvedDest)) {
       throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
@@ -1537,7 +1539,7 @@ function onLink$1 (destStat, src, dest, opts) {
     // prevent copy if src is a subdir of dest since unlinking
     // dest in this case would result in removing src contents
     // and therefore a broken symlink would be created.
-    if (fs$p.statSync(dest).isDirectory() && stat$4.isSrcSubdir(resolvedDest, resolvedSrc)) {
+    if (fs$s.statSync(dest).isDirectory() && stat$4.isSrcSubdir(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
     return copyLink$1(resolvedSrc, dest)
@@ -1545,8 +1547,8 @@ function onLink$1 (destStat, src, dest, opts) {
 }
 
 function copyLink$1 (resolvedSrc, dest) {
-  fs$p.unlinkSync(dest);
-  return fs$p.symlinkSync(resolvedSrc, dest)
+  fs$s.unlinkSync(dest);
+  return fs$s.symlinkSync(resolvedSrc, dest)
 }
 
 var copySync_1 = copySync$2;
@@ -1556,19 +1558,19 @@ var copySync$1 = {
 };
 
 const u$a = universalify$1.fromPromise;
-const fs$o = fs$u;
+const fs$r = fs$x;
 
 function pathExists$6 (path) {
-  return fs$o.access(path).then(() => true).catch(() => false)
+  return fs$r.access(path).then(() => true).catch(() => false)
 }
 
 var pathExists_1 = {
   pathExists: u$a(pathExists$6),
-  pathExistsSync: fs$o.existsSync
+  pathExistsSync: fs$r.existsSync
 };
 
-const fs$n = gracefulFs;
-const path$l = path__default["default"];
+const fs$q = gracefulFs;
+const path$o = path__default["default"];
 const mkdirs$1 = mkdirs$2.mkdirs;
 const pathExists$5 = pathExists_1.pathExists;
 const utimesMillis = utimes.utimesMillis;
@@ -1606,7 +1608,7 @@ function copy$3 (src, dest, opts, cb) {
 }
 
 function checkParentDir (destStat, src, dest, opts, cb) {
-  const destParent = path$l.dirname(dest);
+  const destParent = path$o.dirname(dest);
   pathExists$5(destParent, (err, dirExists) => {
     if (err) return cb(err)
     if (dirExists) return getStats(destStat, src, dest, opts, cb)
@@ -1630,7 +1632,7 @@ function startCopy (destStat, src, dest, opts, cb) {
 }
 
 function getStats (destStat, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$n.stat : fs$n.lstat;
+  const stat = opts.dereference ? fs$q.stat : fs$q.lstat;
   stat(src, (err, srcStat) => {
     if (err) return cb(err)
 
@@ -1652,7 +1654,7 @@ function onFile (srcStat, destStat, src, dest, opts, cb) {
 
 function mayCopyFile (srcStat, src, dest, opts, cb) {
   if (opts.overwrite) {
-    fs$n.unlink(dest, err => {
+    fs$q.unlink(dest, err => {
       if (err) return cb(err)
       return copyFile(srcStat, src, dest, opts, cb)
     });
@@ -1662,7 +1664,7 @@ function mayCopyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFile (srcStat, src, dest, opts, cb) {
-  fs$n.copyFile(src, dest, err => {
+  fs$q.copyFile(src, dest, err => {
     if (err) return cb(err)
     if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
     return setDestMode(dest, srcStat.mode, cb)
@@ -1698,14 +1700,14 @@ function setDestTimestampsAndMode (srcMode, src, dest, cb) {
 }
 
 function setDestMode (dest, srcMode, cb) {
-  return fs$n.chmod(dest, srcMode, cb)
+  return fs$q.chmod(dest, srcMode, cb)
 }
 
 function setDestTimestamps (src, dest, cb) {
   // The initial srcStat.atime cannot be trusted
   // because it is modified by the read(2) system call
   // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  fs$n.stat(src, (err, updatedSrcStat) => {
+  fs$q.stat(src, (err, updatedSrcStat) => {
     if (err) return cb(err)
     return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
   });
@@ -1717,7 +1719,7 @@ function onDir (srcStat, destStat, src, dest, opts, cb) {
 }
 
 function mkDirAndCopy (srcMode, src, dest, opts, cb) {
-  fs$n.mkdir(dest, err => {
+  fs$q.mkdir(dest, err => {
     if (err) return cb(err)
     copyDir(src, dest, opts, err => {
       if (err) return cb(err)
@@ -1727,7 +1729,7 @@ function mkDirAndCopy (srcMode, src, dest, opts, cb) {
 }
 
 function copyDir (src, dest, opts, cb) {
-  fs$n.readdir(src, (err, items) => {
+  fs$q.readdir(src, (err, items) => {
     if (err) return cb(err)
     return copyDirItems(items, src, dest, opts, cb)
   });
@@ -1740,8 +1742,8 @@ function copyDirItems (items, src, dest, opts, cb) {
 }
 
 function copyDirItem (items, item, src, dest, opts, cb) {
-  const srcItem = path$l.join(src, item);
-  const destItem = path$l.join(dest, item);
+  const srcItem = path$o.join(src, item);
+  const destItem = path$o.join(dest, item);
   stat$3.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
     if (err) return cb(err)
     const { destStat } = stats;
@@ -1753,25 +1755,25 @@ function copyDirItem (items, item, src, dest, opts, cb) {
 }
 
 function onLink (destStat, src, dest, opts, cb) {
-  fs$n.readlink(src, (err, resolvedSrc) => {
+  fs$q.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
     if (opts.dereference) {
-      resolvedSrc = path$l.resolve(process.cwd(), resolvedSrc);
+      resolvedSrc = path$o.resolve(process.cwd(), resolvedSrc);
     }
 
     if (!destStat) {
-      return fs$n.symlink(resolvedSrc, dest, cb)
+      return fs$q.symlink(resolvedSrc, dest, cb)
     } else {
-      fs$n.readlink(dest, (err, resolvedDest) => {
+      fs$q.readlink(dest, (err, resolvedDest) => {
         if (err) {
           // dest exists and is a regular file or directory,
           // Windows may throw UNKNOWN error. If dest already exists,
           // fs throws error anyway, so no need to guard against it here.
-          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$n.symlink(resolvedSrc, dest, cb)
+          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$q.symlink(resolvedSrc, dest, cb)
           return cb(err)
         }
         if (opts.dereference) {
-          resolvedDest = path$l.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path$o.resolve(process.cwd(), resolvedDest);
         }
         if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
           return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
@@ -1790,9 +1792,9 @@ function onLink (destStat, src, dest, opts, cb) {
 }
 
 function copyLink (resolvedSrc, dest, cb) {
-  fs$n.unlink(dest, err => {
+  fs$q.unlink(dest, err => {
     if (err) return cb(err)
-    return fs$n.symlink(resolvedSrc, dest, cb)
+    return fs$q.symlink(resolvedSrc, dest, cb)
   });
 }
 
@@ -1803,11 +1805,11 @@ var copy$2 = {
   copy: u$9(copy_1)
 };
 
-const fs$m = gracefulFs;
-const path$k = path__default["default"];
+const fs$p = gracefulFs;
+const path$n = path__default["default"];
 const assert$1 = require$$5__default["default"];
 
-const isWindows = (process.platform === 'win32');
+const isWindows$1 = (process.platform === 'win32');
 
 function defaults$8 (options) {
   const methods = [
@@ -1819,9 +1821,9 @@ function defaults$8 (options) {
     'readdir'
   ];
   methods.forEach(m => {
-    options[m] = options[m] || fs$m[m];
+    options[m] = options[m] || fs$p[m];
     m = m + 'Sync';
-    options[m] = options[m] || fs$m[m];
+    options[m] = options[m] || fs$p[m];
   });
 
   options.maxBusyTries = options.maxBusyTries || 3;
@@ -1885,7 +1887,7 @@ function rimraf_ (p, options, cb) {
     }
 
     // Windows can EPERM on stat.  Life is suffering.
-    if (er && er.code === 'EPERM' && isWindows) {
+    if (er && er.code === 'EPERM' && isWindows$1) {
       return fixWinEPERM(p, options, er, cb)
     }
 
@@ -1899,7 +1901,7 @@ function rimraf_ (p, options, cb) {
           return cb(null)
         }
         if (er.code === 'EPERM') {
-          return (isWindows)
+          return (isWindows$1)
             ? fixWinEPERM(p, options, er, cb)
             : rmdir(p, options, er, cb)
         }
@@ -2000,7 +2002,7 @@ function rmkids (p, options, cb) {
     if (n === 0) return options.rmdir(p, cb)
 
     files.forEach(f => {
-      rimraf$1(path$k.join(p, f), options, er => {
+      rimraf$1(path$n.join(p, f), options, er => {
         if (errState) {
           return
         }
@@ -2035,7 +2037,7 @@ function rimrafSync (p, options) {
     }
 
     // Windows can EPERM on stat.  Life is suffering.
-    if (er.code === 'EPERM' && isWindows) {
+    if (er.code === 'EPERM' && isWindows$1) {
       fixWinEPERMSync(p, options, er);
     }
   }
@@ -2051,7 +2053,7 @@ function rimrafSync (p, options) {
     if (er.code === 'ENOENT') {
       return
     } else if (er.code === 'EPERM') {
-      return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+      return isWindows$1 ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
     } else if (er.code !== 'EISDIR') {
       throw er
     }
@@ -2079,9 +2081,9 @@ function rmdirSync (p, options, originalEr) {
 function rmkidsSync (p, options) {
   assert$1(p);
   assert$1(options);
-  options.readdirSync(p).forEach(f => rimrafSync(path$k.join(p, f), options));
+  options.readdirSync(p).forEach(f => rimrafSync(path$n.join(p, f), options));
 
-  if (isWindows) {
+  if (isWindows$1) {
     // We only end up here once we got ENOTEMPTY at least once, and
     // at this point, we are guaranteed to have removed all the kids.
     // So, we know that it won't be ENOENT or ENOTDIR or anything else.
@@ -2104,19 +2106,19 @@ function rmkidsSync (p, options) {
 var rimraf_1 = rimraf$1;
 rimraf$1.sync = rimrafSync;
 
-const fs$l = gracefulFs;
+const fs$o = gracefulFs;
 const u$8 = universalify$1.fromCallback;
 const rimraf = rimraf_1;
 
 function remove$3 (path, callback) {
   // Node 14.14.0+
-  if (fs$l.rm) return fs$l.rm(path, { recursive: true, force: true }, callback)
+  if (fs$o.rm) return fs$o.rm(path, { recursive: true, force: true }, callback)
   rimraf(path, callback);
 }
 
 function removeSync$1 (path) {
   // Node 14.14.0+
-  if (fs$l.rmSync) return fs$l.rmSync(path, { recursive: true, force: true })
+  if (fs$o.rmSync) return fs$o.rmSync(path, { recursive: true, force: true })
   rimraf.sync(path);
 }
 
@@ -2126,32 +2128,32 @@ var remove_1 = {
 };
 
 const u$7 = universalify$1.fromPromise;
-const fs$k = fs$u;
-const path$j = path__default["default"];
+const fs$n = fs$x;
+const path$m = path__default["default"];
 const mkdir$3 = mkdirs$2;
 const remove$2 = remove_1;
 
 const emptyDir = u$7(async function emptyDir (dir) {
   let items;
   try {
-    items = await fs$k.readdir(dir);
+    items = await fs$n.readdir(dir);
   } catch {
     return mkdir$3.mkdirs(dir)
   }
 
-  return Promise.all(items.map(item => remove$2.remove(path$j.join(dir, item))))
+  return Promise.all(items.map(item => remove$2.remove(path$m.join(dir, item))))
 });
 
 function emptyDirSync (dir) {
   let items;
   try {
-    items = fs$k.readdirSync(dir);
+    items = fs$n.readdirSync(dir);
   } catch {
     return mkdir$3.mkdirsSync(dir)
   }
 
   items.forEach(item => {
-    item = path$j.join(dir, item);
+    item = path$m.join(dir, item);
     remove$2.removeSync(item);
   });
 }
@@ -2164,22 +2166,22 @@ var empty$1 = {
 };
 
 const u$6 = universalify$1.fromCallback;
-const path$i = path__default["default"];
-const fs$j = gracefulFs;
+const path$l = path__default["default"];
+const fs$m = gracefulFs;
 const mkdir$2 = mkdirs$2;
 
 function createFile (file, callback) {
   function makeFile () {
-    fs$j.writeFile(file, '', err => {
+    fs$m.writeFile(file, '', err => {
       if (err) return callback(err)
       callback();
     });
   }
 
-  fs$j.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
+  fs$m.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
     if (!err && stats.isFile()) return callback()
-    const dir = path$i.dirname(file);
-    fs$j.stat(dir, (err, stats) => {
+    const dir = path$l.dirname(file);
+    fs$m.stat(dir, (err, stats) => {
       if (err) {
         // if the directory doesn't exist, make it
         if (err.code === 'ENOENT') {
@@ -2195,7 +2197,7 @@ function createFile (file, callback) {
       else {
         // parent is not a directory
         // This is just to cause an internal ENOTDIR error to be thrown
-        fs$j.readdir(dir, err => {
+        fs$m.readdir(dir, err => {
           if (err) return callback(err)
         });
       }
@@ -2206,16 +2208,16 @@ function createFile (file, callback) {
 function createFileSync (file) {
   let stats;
   try {
-    stats = fs$j.statSync(file);
+    stats = fs$m.statSync(file);
   } catch {}
   if (stats && stats.isFile()) return
 
-  const dir = path$i.dirname(file);
+  const dir = path$l.dirname(file);
   try {
-    if (!fs$j.statSync(dir).isDirectory()) {
+    if (!fs$m.statSync(dir).isDirectory()) {
       // parent is not a directory
       // This is just to cause an internal ENOTDIR error to be thrown
-      fs$j.readdirSync(dir);
+      fs$m.readdirSync(dir);
     }
   } catch (err) {
     // If the stat call above failed because the directory doesn't exist, create it
@@ -2223,7 +2225,7 @@ function createFileSync (file) {
     else throw err
   }
 
-  fs$j.writeFileSync(file, '');
+  fs$m.writeFileSync(file, '');
 }
 
 var file$1 = {
@@ -2232,29 +2234,29 @@ var file$1 = {
 };
 
 const u$5 = universalify$1.fromCallback;
-const path$h = path__default["default"];
-const fs$i = gracefulFs;
+const path$k = path__default["default"];
+const fs$l = gracefulFs;
 const mkdir$1 = mkdirs$2;
 const pathExists$4 = pathExists_1.pathExists;
 const { areIdentical: areIdentical$1 } = stat$5;
 
 function createLink (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
-    fs$i.link(srcpath, dstpath, err => {
+    fs$l.link(srcpath, dstpath, err => {
       if (err) return callback(err)
       callback(null);
     });
   }
 
-  fs$i.lstat(dstpath, (_, dstStat) => {
-    fs$i.lstat(srcpath, (err, srcStat) => {
+  fs$l.lstat(dstpath, (_, dstStat) => {
+    fs$l.lstat(srcpath, (err, srcStat) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink');
         return callback(err)
       }
       if (dstStat && areIdentical$1(srcStat, dstStat)) return callback(null)
 
-      const dir = path$h.dirname(dstpath);
+      const dir = path$k.dirname(dstpath);
       pathExists$4(dir, (err, dirExists) => {
         if (err) return callback(err)
         if (dirExists) return makeLink(srcpath, dstpath)
@@ -2270,23 +2272,23 @@ function createLink (srcpath, dstpath, callback) {
 function createLinkSync (srcpath, dstpath) {
   let dstStat;
   try {
-    dstStat = fs$i.lstatSync(dstpath);
+    dstStat = fs$l.lstatSync(dstpath);
   } catch {}
 
   try {
-    const srcStat = fs$i.lstatSync(srcpath);
+    const srcStat = fs$l.lstatSync(srcpath);
     if (dstStat && areIdentical$1(srcStat, dstStat)) return
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink');
     throw err
   }
 
-  const dir = path$h.dirname(dstpath);
-  const dirExists = fs$i.existsSync(dir);
-  if (dirExists) return fs$i.linkSync(srcpath, dstpath)
+  const dir = path$k.dirname(dstpath);
+  const dirExists = fs$l.existsSync(dir);
+  if (dirExists) return fs$l.linkSync(srcpath, dstpath)
   mkdir$1.mkdirsSync(dir);
 
-  return fs$i.linkSync(srcpath, dstpath)
+  return fs$l.linkSync(srcpath, dstpath)
 }
 
 var link$4 = {
@@ -2294,8 +2296,8 @@ var link$4 = {
   createLinkSync
 };
 
-const path$g = path__default["default"];
-const fs$h = gracefulFs;
+const path$j = path__default["default"];
+const fs$k = gracefulFs;
 const pathExists$3 = pathExists_1.pathExists;
 
 /**
@@ -2321,8 +2323,8 @@ const pathExists$3 = pathExists_1.pathExists;
  */
 
 function symlinkPaths$1 (srcpath, dstpath, callback) {
-  if (path$g.isAbsolute(srcpath)) {
-    return fs$h.lstat(srcpath, (err) => {
+  if (path$j.isAbsolute(srcpath)) {
+    return fs$k.lstat(srcpath, (err) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureSymlink');
         return callback(err)
@@ -2333,8 +2335,8 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
       })
     })
   } else {
-    const dstdir = path$g.dirname(dstpath);
-    const relativeToDst = path$g.join(dstdir, srcpath);
+    const dstdir = path$j.dirname(dstpath);
+    const relativeToDst = path$j.join(dstdir, srcpath);
     return pathExists$3(relativeToDst, (err, exists) => {
       if (err) return callback(err)
       if (exists) {
@@ -2343,14 +2345,14 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
           toDst: srcpath
         })
       } else {
-        return fs$h.lstat(srcpath, (err) => {
+        return fs$k.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace('lstat', 'ensureSymlink');
             return callback(err)
           }
           return callback(null, {
             toCwd: srcpath,
-            toDst: path$g.relative(dstdir, srcpath)
+            toDst: path$j.relative(dstdir, srcpath)
           })
         })
       }
@@ -2360,28 +2362,28 @@ function symlinkPaths$1 (srcpath, dstpath, callback) {
 
 function symlinkPathsSync$1 (srcpath, dstpath) {
   let exists;
-  if (path$g.isAbsolute(srcpath)) {
-    exists = fs$h.existsSync(srcpath);
+  if (path$j.isAbsolute(srcpath)) {
+    exists = fs$k.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
       toCwd: srcpath,
       toDst: srcpath
     }
   } else {
-    const dstdir = path$g.dirname(dstpath);
-    const relativeToDst = path$g.join(dstdir, srcpath);
-    exists = fs$h.existsSync(relativeToDst);
+    const dstdir = path$j.dirname(dstpath);
+    const relativeToDst = path$j.join(dstdir, srcpath);
+    exists = fs$k.existsSync(relativeToDst);
     if (exists) {
       return {
         toCwd: relativeToDst,
         toDst: srcpath
       }
     } else {
-      exists = fs$h.existsSync(srcpath);
+      exists = fs$k.existsSync(srcpath);
       if (!exists) throw new Error('relative srcpath does not exist')
       return {
         toCwd: srcpath,
-        toDst: path$g.relative(dstdir, srcpath)
+        toDst: path$j.relative(dstdir, srcpath)
       }
     }
   }
@@ -2392,13 +2394,13 @@ var symlinkPaths_1 = {
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$g = gracefulFs;
+const fs$j = gracefulFs;
 
 function symlinkType$1 (srcpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback;
   type = (typeof type === 'function') ? false : type;
   if (type) return callback(null, type)
-  fs$g.lstat(srcpath, (err, stats) => {
+  fs$j.lstat(srcpath, (err, stats) => {
     if (err) return callback(null, 'file')
     type = (stats && stats.isDirectory()) ? 'dir' : 'file';
     callback(null, type);
@@ -2410,7 +2412,7 @@ function symlinkTypeSync$1 (srcpath, type) {
 
   if (type) return type
   try {
-    stats = fs$g.lstatSync(srcpath);
+    stats = fs$j.lstatSync(srcpath);
   } catch {
     return 'file'
   }
@@ -2423,8 +2425,8 @@ var symlinkType_1 = {
 };
 
 const u$4 = universalify$1.fromCallback;
-const path$f = path__default["default"];
-const fs$f = fs$u;
+const path$i = path__default["default"];
+const fs$i = fs$x;
 const _mkdirs = mkdirs$2;
 const mkdirs = _mkdirs.mkdirs;
 const mkdirsSync = _mkdirs.mkdirsSync;
@@ -2445,11 +2447,11 @@ function createSymlink (srcpath, dstpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback;
   type = (typeof type === 'function') ? false : type;
 
-  fs$f.lstat(dstpath, (err, stats) => {
+  fs$i.lstat(dstpath, (err, stats) => {
     if (!err && stats.isSymbolicLink()) {
       Promise.all([
-        fs$f.stat(srcpath),
-        fs$f.stat(dstpath)
+        fs$i.stat(srcpath),
+        fs$i.stat(dstpath)
       ]).then(([srcStat, dstStat]) => {
         if (areIdentical(srcStat, dstStat)) return callback(null)
         _createSymlink(srcpath, dstpath, type, callback);
@@ -2464,13 +2466,13 @@ function _createSymlink (srcpath, dstpath, type, callback) {
     srcpath = relative.toDst;
     symlinkType(relative.toCwd, type, (err, type) => {
       if (err) return callback(err)
-      const dir = path$f.dirname(dstpath);
+      const dir = path$i.dirname(dstpath);
       pathExists$2(dir, (err, dirExists) => {
         if (err) return callback(err)
-        if (dirExists) return fs$f.symlink(srcpath, dstpath, type, callback)
+        if (dirExists) return fs$i.symlink(srcpath, dstpath, type, callback)
         mkdirs(dir, err => {
           if (err) return callback(err)
-          fs$f.symlink(srcpath, dstpath, type, callback);
+          fs$i.symlink(srcpath, dstpath, type, callback);
         });
       });
     });
@@ -2480,22 +2482,22 @@ function _createSymlink (srcpath, dstpath, type, callback) {
 function createSymlinkSync (srcpath, dstpath, type) {
   let stats;
   try {
-    stats = fs$f.lstatSync(dstpath);
+    stats = fs$i.lstatSync(dstpath);
   } catch {}
   if (stats && stats.isSymbolicLink()) {
-    const srcStat = fs$f.statSync(srcpath);
-    const dstStat = fs$f.statSync(dstpath);
+    const srcStat = fs$i.statSync(srcpath);
+    const dstStat = fs$i.statSync(dstpath);
     if (areIdentical(srcStat, dstStat)) return
   }
 
   const relative = symlinkPathsSync(srcpath, dstpath);
   srcpath = relative.toDst;
   type = symlinkTypeSync(relative.toCwd, type);
-  const dir = path$f.dirname(dstpath);
-  const exists = fs$f.existsSync(dir);
-  if (exists) return fs$f.symlinkSync(srcpath, dstpath, type)
+  const dir = path$i.dirname(dstpath);
+  const exists = fs$i.existsSync(dir);
+  if (exists) return fs$i.symlinkSync(srcpath, dstpath, type)
   mkdirsSync(dir);
-  return fs$f.symlinkSync(srcpath, dstpath, type)
+  return fs$i.symlinkSync(srcpath, dstpath, type)
 }
 
 var symlink$1 = {
@@ -2544,7 +2546,7 @@ let _fs;
 try {
   _fs = gracefulFs;
 } catch (_) {
-  _fs = fs__default["default"];
+  _fs = require$$0__default$2["default"];
 }
 const universalify = universalify$1;
 const { stringify: stringify$a, stripBom } = utils$t;
@@ -2640,8 +2642,8 @@ var jsonfile = {
 };
 
 const u$3 = universalify$1.fromCallback;
-const fs$e = gracefulFs;
-const path$e = path__default["default"];
+const fs$h = gracefulFs;
+const path$h = path__default["default"];
 const mkdir = mkdirs$2;
 const pathExists$1 = pathExists_1.pathExists;
 
@@ -2651,26 +2653,26 @@ function outputFile$1 (file, data, encoding, callback) {
     encoding = 'utf8';
   }
 
-  const dir = path$e.dirname(file);
+  const dir = path$h.dirname(file);
   pathExists$1(dir, (err, itDoes) => {
     if (err) return callback(err)
-    if (itDoes) return fs$e.writeFile(file, data, encoding, callback)
+    if (itDoes) return fs$h.writeFile(file, data, encoding, callback)
 
     mkdir.mkdirs(dir, err => {
       if (err) return callback(err)
 
-      fs$e.writeFile(file, data, encoding, callback);
+      fs$h.writeFile(file, data, encoding, callback);
     });
   });
 }
 
 function outputFileSync$1 (file, ...args) {
-  const dir = path$e.dirname(file);
-  if (fs$e.existsSync(dir)) {
-    return fs$e.writeFileSync(file, ...args)
+  const dir = path$h.dirname(file);
+  if (fs$h.existsSync(dir)) {
+    return fs$h.writeFileSync(file, ...args)
   }
   mkdir.mkdirsSync(dir);
-  fs$e.writeFileSync(file, ...args);
+  fs$h.writeFileSync(file, ...args);
 }
 
 var output = {
@@ -2715,8 +2717,8 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json$1 = jsonFile;
 
-const fs$d = gracefulFs;
-const path$d = path__default["default"];
+const fs$g = gracefulFs;
+const path$g = path__default["default"];
 const copySync = copySync$1.copySync;
 const removeSync = remove_1.removeSync;
 const mkdirpSync = mkdirs$2.mkdirpSync;
@@ -2728,13 +2730,13 @@ function moveSync$1 (src, dest, opts) {
 
   const { srcStat, isChangingCase = false } = stat$2.checkPathsSync(src, dest, 'move', opts);
   stat$2.checkParentPathsSync(src, srcStat, dest, 'move');
-  if (!isParentRoot$1(dest)) mkdirpSync(path$d.dirname(dest));
+  if (!isParentRoot$1(dest)) mkdirpSync(path$g.dirname(dest));
   return doRename$1(src, dest, overwrite, isChangingCase)
 }
 
 function isParentRoot$1 (dest) {
-  const parent = path$d.dirname(dest);
-  const parsedPath = path$d.parse(parent);
+  const parent = path$g.dirname(dest);
+  const parsedPath = path$g.parse(parent);
   return parsedPath.root === parent
 }
 
@@ -2744,13 +2746,13 @@ function doRename$1 (src, dest, overwrite, isChangingCase) {
     removeSync(dest);
     return rename$1(src, dest, overwrite)
   }
-  if (fs$d.existsSync(dest)) throw new Error('dest already exists.')
+  if (fs$g.existsSync(dest)) throw new Error('dest already exists.')
   return rename$1(src, dest, overwrite)
 }
 
 function rename$1 (src, dest, overwrite) {
   try {
-    fs$d.renameSync(src, dest);
+    fs$g.renameSync(src, dest);
   } catch (err) {
     if (err.code !== 'EXDEV') throw err
     return moveAcrossDevice$1(src, dest, overwrite)
@@ -2772,8 +2774,8 @@ var moveSync = {
   moveSync: moveSync_1
 };
 
-const fs$c = gracefulFs;
-const path$c = path__default["default"];
+const fs$f = gracefulFs;
+const path$f = path__default["default"];
 const copy$1 = copy$2.copy;
 const remove$1 = remove_1.remove;
 const mkdirp = mkdirs$2.mkdirp;
@@ -2794,7 +2796,7 @@ function move$1 (src, dest, opts, cb) {
     stat$1.checkParentPaths(src, srcStat, dest, 'move', err => {
       if (err) return cb(err)
       if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)
-      mkdirp(path$c.dirname(dest), err => {
+      mkdirp(path$f.dirname(dest), err => {
         if (err) return cb(err)
         return doRename(src, dest, overwrite, isChangingCase, cb)
       });
@@ -2803,8 +2805,8 @@ function move$1 (src, dest, opts, cb) {
 }
 
 function isParentRoot (dest) {
-  const parent = path$c.dirname(dest);
-  const parsedPath = path$c.parse(parent);
+  const parent = path$f.dirname(dest);
+  const parsedPath = path$f.parse(parent);
   return parsedPath.root === parent
 }
 
@@ -2824,7 +2826,7 @@ function doRename (src, dest, overwrite, isChangingCase, cb) {
 }
 
 function rename (src, dest, overwrite, cb) {
-  fs$c.rename(src, dest, err => {
+  fs$f.rename(src, dest, err => {
     if (!err) return cb()
     if (err.code !== 'EXDEV') return cb(err)
     return moveAcrossDevice(src, dest, overwrite, cb)
@@ -2851,7 +2853,7 @@ var move = {
 
 var lib$1 = {
   // Export promiseified graceful-fs:
-  ...fs$u,
+  ...fs$x,
   // Export extra methods:
   ...copySync$1,
   ...copy$2,
@@ -4211,8 +4213,8 @@ var hasFlag$1 = (flag, argv = process.argv) => {
 	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 };
 
-const os = require$$0__default$4["default"];
-const tty = require$$0__default$3["default"];
+const os = require$$0__default$5["default"];
+const tty = require$$0__default$4["default"];
 const hasFlag = hasFlag$1;
 
 const {env} = process;
@@ -4934,10 +4936,10 @@ function isEnoentCodeError(error) {
 }
 errno$1.isEnoentCodeError = isEnoentCodeError;
 
-var fs$b = {};
+var fs$e = {};
 
-Object.defineProperty(fs$b, "__esModule", { value: true });
-fs$b.createDirentFromStats = void 0;
+Object.defineProperty(fs$e, "__esModule", { value: true });
+fs$e.createDirentFromStats = void 0;
 class DirentFromStats$1 {
     constructor(name, stats) {
         this.name = name;
@@ -4953,13 +4955,13 @@ class DirentFromStats$1 {
 function createDirentFromStats$1(name, stats) {
     return new DirentFromStats$1(name, stats);
 }
-fs$b.createDirentFromStats = createDirentFromStats$1;
+fs$e.createDirentFromStats = createDirentFromStats$1;
 
-var path$b = {};
+var path$e = {};
 
-Object.defineProperty(path$b, "__esModule", { value: true });
-path$b.removeLeadingDotSegment = path$b.escape = path$b.makeAbsolute = path$b.unixify = void 0;
-const path$a = path__default["default"];
+Object.defineProperty(path$e, "__esModule", { value: true });
+path$e.removeLeadingDotSegment = path$e.escape = path$e.makeAbsolute = path$e.unixify = void 0;
+const path$d = path__default["default"];
 const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
 /**
@@ -4968,15 +4970,15 @@ const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
 function unixify(filepath) {
     return filepath.replace(/\\/g, '/');
 }
-path$b.unixify = unixify;
+path$e.unixify = unixify;
 function makeAbsolute(cwd, filepath) {
-    return path$a.resolve(cwd, filepath);
+    return path$d.resolve(cwd, filepath);
 }
-path$b.makeAbsolute = makeAbsolute;
-function escape(pattern) {
+path$e.makeAbsolute = makeAbsolute;
+function escape$1(pattern) {
     return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
 }
-path$b.escape = escape;
+path$e.escape = escape$1;
 function removeLeadingDotSegment(entry) {
     // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
     // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
@@ -4988,7 +4990,7 @@ function removeLeadingDotSegment(entry) {
     }
     return entry;
 }
-path$b.removeLeadingDotSegment = removeLeadingDotSegment;
+path$e.removeLeadingDotSegment = removeLeadingDotSegment;
 
 var pattern$1 = {};
 
@@ -5064,7 +5066,7 @@ var isGlob$1 = function isGlob(str, options) {
 
 var isGlob = isGlob$1;
 var pathPosixDirname = path__default["default"].posix.dirname;
-var isWin32 = require$$0__default$4["default"].platform() === 'win32';
+var isWin32 = require$$0__default$5["default"].platform() === 'win32';
 
 var slash$3 = '/';
 var backslash = /\\/g;
@@ -5560,7 +5562,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$2 = require$$0__default$2["default"];
+const util$2 = require$$0__default$3["default"];
 const toRegexRange = toRegexRange_1;
 
 const isObject$5 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -6053,7 +6055,7 @@ const {
  * parse
  */
 
-const parse$e = (input, options = {}) => {
+const parse$g = (input, options = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -6352,12 +6354,12 @@ const parse$e = (input, options = {}) => {
   return ast;
 };
 
-var parse_1$1 = parse$e;
+var parse_1$2 = parse$g;
 
 const stringify$3 = stringify$7;
 const compile$1 = compile_1;
 const expand = expand_1;
-const parse$d = parse_1$1;
+const parse$f = parse_1$2;
 
 /**
  * Expand the given pattern or create a regex-compatible string.
@@ -6409,7 +6411,7 @@ const braces$1 = (input, options = {}) => {
  * @api public
  */
 
-braces$1.parse = (input, options = {}) => parse$d(input, options);
+braces$1.parse = (input, options = {}) => parse$f(input, options);
 
 /**
  * Creates a braces string from an AST, or an AST node.
@@ -6525,7 +6527,7 @@ var braces_1 = braces$1;
 
 var utils$n = {};
 
-const path$9 = path__default["default"];
+const path$c = path__default["default"];
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -6678,7 +6680,7 @@ var constants$3 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: path$9.sep,
+  SEP: path$c.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -7211,7 +7213,7 @@ const syntaxError = (type, char) => {
  * @return {Object}
  */
 
-const parse$c = (input, options) => {
+const parse$e = (input, options) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -8153,7 +8155,7 @@ const parse$c = (input, options) => {
  * impact when none of the fast paths match.
  */
 
-parse$c.fastpaths = (input, options) => {
+parse$e.fastpaths = (input, options) => {
   const opts = { ...options };
   const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
   const len = input.length;
@@ -8240,11 +8242,11 @@ parse$c.fastpaths = (input, options) => {
   return source;
 };
 
-var parse_1 = parse$c;
+var parse_1$1 = parse$e;
 
-const path$8 = path__default["default"];
+const path$b = path__default["default"];
 const scan = scan_1;
-const parse$b = parse_1;
+const parse$d = parse_1$1;
 const utils$k = utils$n;
 const constants$1 = constants$3;
 const isObject$4 = val => val && typeof val === 'object' && !Array.isArray(val);
@@ -8402,7 +8404,7 @@ picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
 
 picomatch$2.matchBase = (input, glob, options, posix = utils$k.isWindows(options)) => {
   const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
-  return regex.test(path$8.basename(input));
+  return regex.test(path$b.basename(input));
 };
 
 /**
@@ -8440,7 +8442,7 @@ picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)
 
 picomatch$2.parse = (pattern, options) => {
   if (Array.isArray(pattern)) return pattern.map(p => picomatch$2.parse(p, options));
-  return parse$b(pattern, { ...options, fastpaths: false });
+  return parse$d(pattern, { ...options, fastpaths: false });
 };
 
 /**
@@ -8533,11 +8535,11 @@ picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = f
   let parsed = { negated: false, fastpaths: true };
 
   if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    parsed.output = parse$b.fastpaths(input, options);
+    parsed.output = parse$d.fastpaths(input, options);
   }
 
   if (!parsed.output) {
-    parsed = parse$b(input, options);
+    parsed = parse$d(input, options);
   }
 
   return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
@@ -8585,7 +8587,7 @@ var picomatch_1 = picomatch$2;
 
 var picomatch$1 = picomatch_1;
 
-const util$1 = require$$0__default$2["default"];
+const util$1 = require$$0__default$3["default"];
 const braces = braces_1;
 const picomatch = picomatch$1;
 const utils$j = utils$n;
@@ -9053,7 +9055,7 @@ var micromatch_1 = micromatch$1;
 
 Object.defineProperty(pattern$1, "__esModule", { value: true });
 pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
-const path$7 = path__default["default"];
+const path$a = path__default["default"];
 const globParent = globParent$1;
 const micromatch = micromatch_1;
 const GLOBSTAR = '**';
@@ -9158,7 +9160,7 @@ function endsWithSlashGlobStar(pattern) {
 }
 pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
 function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path$7.basename(pattern);
+    const basename = path$a.basename(pattern);
     return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
 }
 pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
@@ -9246,10 +9248,10 @@ const array = array$1;
 utils$s.array = array;
 const errno = errno$1;
 utils$s.errno = errno;
-const fs$a = fs$b;
-utils$s.fs = fs$a;
-const path$6 = path$b;
-utils$s.path = path$6;
+const fs$d = fs$e;
+utils$s.fs = fs$d;
+const path$9 = path$e;
+utils$s.path = path$9;
 const pattern = pattern$1;
 utils$s.pattern = pattern;
 const stream$3 = stream$4;
@@ -9381,10 +9383,10 @@ function callSuccessCallback$2(callback, result) {
     callback(null, result);
 }
 
-var sync$7 = {};
+var sync$a = {};
 
-Object.defineProperty(sync$7, "__esModule", { value: true });
-sync$7.read = void 0;
+Object.defineProperty(sync$a, "__esModule", { value: true });
+sync$a.read = void 0;
 function read$2(path, settings) {
     const lstat = settings.fs.lstatSync(path);
     if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
@@ -9404,16 +9406,16 @@ function read$2(path, settings) {
         throw error;
     }
 }
-sync$7.read = read$2;
+sync$a.read = read$2;
 
 var settings$3 = {};
 
-var fs$9 = {};
+var fs$c = {};
 
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default["default"];
+const fs = require$$0__default$2["default"];
 exports.FILE_SYSTEM_ADAPTER = {
     lstat: fs.lstat,
     stat: fs.stat,
@@ -9427,15 +9429,15 @@ function createFileSystemAdapter(fsMethods) {
     return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
 }
 exports.createFileSystemAdapter = createFileSystemAdapter;
-}(fs$9));
+}(fs$c));
 
 Object.defineProperty(settings$3, "__esModule", { value: true });
-const fs$8 = fs$9;
+const fs$b = fs$c;
 class Settings$2 {
     constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs$8.createFileSystemAdapter(this._options.fs);
+        this.fs = fs$b.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
     }
@@ -9448,7 +9450,7 @@ settings$3.default = Settings$2;
 Object.defineProperty(out$3, "__esModule", { value: true });
 out$3.statSync = out$3.stat = out$3.Settings = void 0;
 const async$4 = async$5;
-const sync$6 = sync$7;
+const sync$9 = sync$a;
 const settings_1$3 = settings$3;
 out$3.Settings = settings_1$3.default;
 function stat(path, optionsOrSettingsOrCallback, callback) {
@@ -9461,7 +9463,7 @@ function stat(path, optionsOrSettingsOrCallback, callback) {
 out$3.stat = stat;
 function statSync(path, optionsOrSettings) {
     const settings = getSettings$2(optionsOrSettings);
-    return sync$6.read(path, settings);
+    return sync$9.read(path, settings);
 }
 out$3.statSync = statSync;
 function getSettings$2(settingsOrOptions = {}) {
@@ -9566,10 +9568,10 @@ constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED
 
 var utils$h = {};
 
-var fs$7 = {};
+var fs$a = {};
 
-Object.defineProperty(fs$7, "__esModule", { value: true });
-fs$7.createDirentFromStats = void 0;
+Object.defineProperty(fs$a, "__esModule", { value: true });
+fs$a.createDirentFromStats = void 0;
 class DirentFromStats {
     constructor(name, stats) {
         this.name = name;
@@ -9585,12 +9587,12 @@ class DirentFromStats {
 function createDirentFromStats(name, stats) {
     return new DirentFromStats(name, stats);
 }
-fs$7.createDirentFromStats = createDirentFromStats;
+fs$a.createDirentFromStats = createDirentFromStats;
 
 Object.defineProperty(utils$h, "__esModule", { value: true });
 utils$h.fs = void 0;
-const fs$6 = fs$7;
-utils$h.fs = fs$6;
+const fs$9 = fs$a;
+utils$h.fs = fs$9;
 
 var common$e = {};
 
@@ -9711,10 +9713,10 @@ function callSuccessCallback$1(callback, result) {
     callback(null, result);
 }
 
-var sync$5 = {};
+var sync$8 = {};
 
-Object.defineProperty(sync$5, "__esModule", { value: true });
-sync$5.readdir = sync$5.readdirWithFileTypes = sync$5.read = void 0;
+Object.defineProperty(sync$8, "__esModule", { value: true });
+sync$8.readdir = sync$8.readdirWithFileTypes = sync$8.read = void 0;
 const fsStat$4 = out$3;
 const constants_1 = constants;
 const utils$f = utils$h;
@@ -9725,7 +9727,7 @@ function read(directory, settings) {
     }
     return readdir(directory, settings);
 }
-sync$5.read = read;
+sync$8.read = read;
 function readdirWithFileTypes(directory, settings) {
     const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
     return dirents.map((dirent) => {
@@ -9748,7 +9750,7 @@ function readdirWithFileTypes(directory, settings) {
         return entry;
     });
 }
-sync$5.readdirWithFileTypes = readdirWithFileTypes;
+sync$8.readdirWithFileTypes = readdirWithFileTypes;
 function readdir(directory, settings) {
     const names = settings.fs.readdirSync(directory);
     return names.map((name) => {
@@ -9765,16 +9767,16 @@ function readdir(directory, settings) {
         return entry;
     });
 }
-sync$5.readdir = readdir;
+sync$8.readdir = readdir;
 
 var settings$2 = {};
 
-var fs$5 = {};
+var fs$8 = {};
 
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default["default"];
+const fs = require$$0__default$2["default"];
 exports.FILE_SYSTEM_ADAPTER = {
     lstat: fs.lstat,
     stat: fs.stat,
@@ -9790,18 +9792,18 @@ function createFileSystemAdapter(fsMethods) {
     return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
 }
 exports.createFileSystemAdapter = createFileSystemAdapter;
-}(fs$5));
+}(fs$8));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$5 = path__default["default"];
+const path$8 = path__default["default"];
 const fsStat$3 = out$3;
-const fs$4 = fs$5;
+const fs$7 = fs$8;
 class Settings$1 {
     constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs$4.createFileSystemAdapter(this._options.fs);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$5.sep);
+        this.fs = fs$7.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$8.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
         this.fsStatSettings = new fsStat$3.Settings({
@@ -9819,7 +9821,7 @@ settings$2.default = Settings$1;
 Object.defineProperty(out$1, "__esModule", { value: true });
 out$1.Settings = out$1.scandirSync = out$1.scandir = void 0;
 const async = async$1;
-const sync$4 = sync$5;
+const sync$7 = sync$8;
 const settings_1$2 = settings$2;
 out$1.Settings = settings_1$2.default;
 function scandir(path, optionsOrSettingsOrCallback, callback) {
@@ -9832,7 +9834,7 @@ function scandir(path, optionsOrSettingsOrCallback, callback) {
 out$1.scandir = scandir;
 function scandirSync(path, optionsOrSettings) {
     const settings = getSettings$1(optionsOrSettings);
-    return sync$4.read(path, settings);
+    return sync$7.read(path, settings);
 }
 out$1.scandirSync = scandirSync;
 function getSettings$1(settingsOrOptions = {}) {
@@ -10205,7 +10207,7 @@ class Reader$1 {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$2, "__esModule", { value: true });
-const events_1 = require$$0__default$5["default"];
+const events_1 = require$$0__default$6["default"];
 const fsScandir$2 = out$1;
 const fastq = queue.exports;
 const common$9 = common$b;
@@ -10367,11 +10369,11 @@ class StreamProvider {
 }
 stream$1.default = StreamProvider;
 
-var sync$3 = {};
+var sync$6 = {};
 
-var sync$2 = {};
+var sync$5 = {};
 
-Object.defineProperty(sync$2, "__esModule", { value: true });
+Object.defineProperty(sync$5, "__esModule", { value: true });
 const fsScandir$1 = out$1;
 const common$8 = common$b;
 const reader_1$2 = reader$1;
@@ -10428,10 +10430,10 @@ class SyncReader extends reader_1$2.default {
         this._storage.push(entry);
     }
 }
-sync$2.default = SyncReader;
+sync$5.default = SyncReader;
 
-Object.defineProperty(sync$3, "__esModule", { value: true });
-const sync_1$3 = sync$2;
+Object.defineProperty(sync$6, "__esModule", { value: true });
+const sync_1$3 = sync$5;
 class SyncProvider {
     constructor(_root, _settings) {
         this._root = _root;
@@ -10442,12 +10444,12 @@ class SyncProvider {
         return this._reader.read();
     }
 }
-sync$3.default = SyncProvider;
+sync$6.default = SyncProvider;
 
 var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$4 = path__default["default"];
+const path$7 = path__default["default"];
 const fsScandir = out$1;
 class Settings {
     constructor(_options = {}) {
@@ -10457,7 +10459,7 @@ class Settings {
         this.deepFilter = this._getValue(this._options.deepFilter, null);
         this.entryFilter = this._getValue(this._options.entryFilter, null);
         this.errorFilter = this._getValue(this._options.errorFilter, null);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$4.sep);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$7.sep);
         this.fsScandirSettings = new fsScandir.Settings({
             followSymbolicLinks: this._options.followSymbolicLinks,
             fs: this._options.fs,
@@ -10476,7 +10478,7 @@ Object.defineProperty(out$2, "__esModule", { value: true });
 out$2.Settings = out$2.walkStream = out$2.walkSync = out$2.walk = void 0;
 const async_1$1 = async$3;
 const stream_1$4 = stream$1;
-const sync_1$2 = sync$3;
+const sync_1$2 = sync$6;
 const settings_1$1 = settings$1;
 out$2.Settings = settings_1$1.default;
 function walk(directory, optionsOrSettingsOrCallback, callback) {
@@ -10509,7 +10511,7 @@ function getSettings(settingsOrOptions = {}) {
 var reader = {};
 
 Object.defineProperty(reader, "__esModule", { value: true });
-const path$3 = path__default["default"];
+const path$6 = path__default["default"];
 const fsStat$2 = out$3;
 const utils$e = utils$s;
 class Reader {
@@ -10522,7 +10524,7 @@ class Reader {
         });
     }
     _getFullEntryPath(filepath) {
-        return path$3.resolve(this._settings.cwd, filepath);
+        return path$6.resolve(this._settings.cwd, filepath);
     }
     _makeEntry(stats, pattern) {
         const entry = {
@@ -10858,7 +10860,7 @@ class EntryTransformer {
 entry.default = EntryTransformer;
 
 Object.defineProperty(provider, "__esModule", { value: true });
-const path$2 = path__default["default"];
+const path$5 = path__default["default"];
 const deep_1 = deep;
 const entry_1 = entry$1;
 const error_1 = error;
@@ -10872,7 +10874,7 @@ class Provider {
         this.entryTransformer = new entry_2.default(this._settings);
     }
     _getRootDirectory(task) {
-        return path$2.resolve(this._settings.cwd, task.base);
+        return path$5.resolve(this._settings.cwd, task.base);
     }
     _getReaderOptions(task) {
         const basePath = task.base === '.' ? '' : task.base;
@@ -10966,11 +10968,11 @@ class ProviderStream extends provider_1$1.default {
 }
 stream.default = ProviderStream;
 
-var sync$1 = {};
+var sync$4 = {};
 
-var sync = {};
+var sync$3 = {};
 
-Object.defineProperty(sync, "__esModule", { value: true });
+Object.defineProperty(sync$3, "__esModule", { value: true });
 const fsStat = out$3;
 const fsWalk = out$2;
 const reader_1 = reader;
@@ -11011,10 +11013,10 @@ class ReaderSync extends reader_1.default {
         return this._statSync(filepath, this._fsStatSettings);
     }
 }
-sync.default = ReaderSync;
+sync$3.default = ReaderSync;
 
-Object.defineProperty(sync$1, "__esModule", { value: true });
-const sync_1$1 = sync;
+Object.defineProperty(sync$4, "__esModule", { value: true });
+const sync_1$1 = sync$3;
 const provider_1 = provider;
 class ProviderSync extends provider_1.default {
     constructor() {
@@ -11034,15 +11036,15 @@ class ProviderSync extends provider_1.default {
         return this._reader.static(task.patterns, options);
     }
 }
-sync$1.default = ProviderSync;
+sync$4.default = ProviderSync;
 
 var settings = {};
 
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default["default"];
-const os = require$$0__default$4["default"];
+const fs = require$$0__default$2["default"];
+const os = require$$0__default$5["default"];
 /**
  * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
  * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
@@ -11100,7 +11102,7 @@ exports.default = Settings;
 const taskManager = tasks;
 const async_1 = async$6;
 const stream_1 = stream;
-const sync_1 = sync$1;
+const sync_1 = sync$4;
 const settings_1 = settings;
 const utils$8 = utils$s;
 async function FastGlob(source, options) {
@@ -11168,8 +11170,8 @@ var dirGlob$1 = {exports: {}};
 
 var pathType$1 = {};
 
-const {promisify: promisify$1} = require$$0__default$2["default"];
-const fs$3 = fs__default["default"];
+const {promisify: promisify$1} = require$$0__default$3["default"];
+const fs$6 = require$$0__default$2["default"];
 
 async function isType(fsStatType, statsMethodName, filePath) {
 	if (typeof filePath !== 'string') {
@@ -11177,7 +11179,7 @@ async function isType(fsStatType, statsMethodName, filePath) {
 	}
 
 	try {
-		const stats = await promisify$1(fs$3[fsStatType])(filePath);
+		const stats = await promisify$1(fs$6[fsStatType])(filePath);
 		return stats[statsMethodName]();
 	} catch (error) {
 		if (error.code === 'ENOENT') {
@@ -11194,7 +11196,7 @@ function isTypeSync(fsStatType, statsMethodName, filePath) {
 	}
 
 	try {
-		return fs$3[fsStatType](filePath)[statsMethodName]();
+		return fs$6[fsStatType](filePath)[statsMethodName]();
 	} catch (error) {
 		if (error.code === 'ENOENT') {
 			return false;
@@ -11211,18 +11213,18 @@ pathType$1.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
 pathType$1.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
 pathType$1.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
 
-const path$1 = path__default["default"];
+const path$4 = path__default["default"];
 const pathType = pathType$1;
 
 const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
 
 const getPath = (filepath, cwd) => {
 	const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
-	return path$1.isAbsolute(pth) ? pth : path$1.join(cwd, pth);
+	return path$4.isAbsolute(pth) ? pth : path$4.join(cwd, pth);
 };
 
 const addExtensions = (file, extensions) => {
-	if (path$1.extname(file)) {
+	if (path$4.extname(file)) {
 		return `**/${file}`;
 	}
 
@@ -11239,18 +11241,18 @@ const getGlob = (directory, options) => {
 	}
 
 	if (options.files && options.extensions) {
-		return options.files.map(x => path$1.posix.join(directory, addExtensions(x, options.extensions)));
+		return options.files.map(x => path$4.posix.join(directory, addExtensions(x, options.extensions)));
 	}
 
 	if (options.files) {
-		return options.files.map(x => path$1.posix.join(directory, `**/${x}`));
+		return options.files.map(x => path$4.posix.join(directory, `**/${x}`));
 	}
 
 	if (options.extensions) {
-		return [path$1.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+		return [path$4.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
 	}
 
-	return [path$1.posix.join(directory, '**')];
+	return [path$4.posix.join(directory, '**')];
 };
 
 dirGlob$1.exports = async (input, options) => {
@@ -11897,9 +11899,9 @@ var slash$2 = path => {
 	return path.replace(/\\/g, '/');
 };
 
-const {promisify} = require$$0__default$2["default"];
-const fs$2 = fs__default["default"];
-const path = path__default["default"];
+const {promisify} = require$$0__default$3["default"];
+const fs$5 = require$$0__default$2["default"];
+const path$3 = path__default["default"];
 const fastGlob$1 = out;
 const gitIgnore = ignore;
 const slash$1 = slash$2;
@@ -11911,18 +11913,18 @@ const DEFAULT_IGNORE = [
 	'**/.git'
 ];
 
-const readFileP = promisify(fs$2.readFile);
+const readFileP = promisify(fs$5.readFile);
 
 const mapGitIgnorePatternTo = base => ignore => {
 	if (ignore.startsWith('!')) {
-		return '!' + path.posix.join(base, ignore.slice(1));
+		return '!' + path$3.posix.join(base, ignore.slice(1));
 	}
 
-	return path.posix.join(base, ignore);
+	return path$3.posix.join(base, ignore);
 };
 
 const parseGitIgnore = (content, options) => {
-	const base = slash$1(path.relative(options.cwd, path.dirname(options.fileName)));
+	const base = slash$1(path$3.relative(options.cwd, path$3.dirname(options.fileName)));
 
 	return content
 		.split(/\r?\n/)
@@ -11945,7 +11947,7 @@ const reduceIgnore = files => {
 
 const ensureAbsolutePathForCwd = (cwd, p) => {
 	cwd = slash$1(cwd);
-	if (path.isAbsolute(p)) {
+	if (path$3.isAbsolute(p)) {
 		if (slash$1(p).startsWith(cwd)) {
 			return p;
 		}
@@ -11953,15 +11955,15 @@ const ensureAbsolutePathForCwd = (cwd, p) => {
 		throw new Error(`Path ${p} is not in cwd ${cwd}`);
 	}
 
-	return path.join(cwd, p);
+	return path$3.join(cwd, p);
 };
 
 const getIsIgnoredPredecate = (ignores, cwd) => {
-	return p => ignores.ignores(slash$1(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
+	return p => ignores.ignores(slash$1(path$3.relative(cwd, ensureAbsolutePathForCwd(cwd, p.path || p))));
 };
 
 const getFile = async (file, cwd) => {
-	const filePath = path.join(cwd, file);
+	const filePath = path$3.join(cwd, file);
 	const content = await readFileP(filePath, 'utf8');
 
 	return {
@@ -11972,8 +11974,8 @@ const getFile = async (file, cwd) => {
 };
 
 const getFileSync = (file, cwd) => {
-	const filePath = path.join(cwd, file);
-	const content = fs$2.readFileSync(filePath, 'utf8');
+	const filePath = path$3.join(cwd, file);
+	const content = fs$5.readFileSync(filePath, 'utf8');
 
 	return {
 		cwd,
@@ -12063,7 +12065,7 @@ var streamUtils = {
 	UniqueStream: UniqueStream$1
 };
 
-const fs$1 = fs__default["default"];
+const fs$4 = require$$0__default$2["default"];
 const arrayUnion = arrayUnion$1;
 const merge2 = merge2_1;
 const fastGlob = out;
@@ -12088,7 +12090,7 @@ const checkCwdOption = (options = {}) => {
 
 	let stat;
 	try {
-		stat = fs$1.statSync(options.cwd);
+		stat = fs$4.statSync(options.cwd);
 	} catch {
 		return;
 	}
@@ -12098,7 +12100,7 @@ const checkCwdOption = (options = {}) => {
 	}
 };
 
-const getPathString = p => p.stats instanceof fs$1.Stats ? p.path : p;
+const getPathString = p => p.stats instanceof fs$4.Stats ? p.path : p;
 
 const generateGlobTasks = (patterns, taskOptions) => {
 	patterns = arrayUnion([].concat(patterns));
@@ -12374,7 +12376,7 @@ var ms$1 = function(val, options) {
   options = options || {};
   var type = typeof val;
   if (type === 'string' && val.length > 0) {
-    return parse$a(val);
+    return parse$c(val);
   } else if (type === 'number' && isFinite(val)) {
     return options.long ? fmtLong$1(val) : fmtShort$1(val);
   }
@@ -12392,7 +12394,7 @@ var ms$1 = function(val, options) {
  * @api private
  */
 
-function parse$a(str) {
+function parse$c(str) {
   str = String(str);
   if (str.length > 100) {
     return;
@@ -13061,8 +13063,8 @@ var node$1 = {exports: {}};
  */
 
 (function (module, exports) {
-const tty = require$$0__default$3["default"];
-const util = require$$0__default$2["default"];
+const tty = require$$0__default$4["default"];
+const util = require$$0__default$3["default"];
 
 /**
  * This is the Node.js implementation of `debug()`.
@@ -13380,6 +13382,7 @@ async function resolveConfig(root = process.cwd(), command = "serve", mode = "de
     outDir,
     tempDir: resolve(root, ".temp"),
     markdown: userConfig.markdown,
+    lastUpdated: userConfig.lastUpdated,
     alias: resolveAliases(root, themeDir),
     vue: userConfig.vue,
     vite: userConfig.vite,
@@ -14519,7 +14522,7 @@ var json = new Schema$3({
 var Schema$2 = schema;
 
 
-var core = new Schema$2({
+var core$1 = new Schema$2({
   include: [
     json
   ]
@@ -14888,7 +14891,7 @@ var Schema$1 = schema;
 
 var default_safe = new Schema$1({
   include: [
-    core
+    core$1
   ],
   implicit: [
     timestamp,
@@ -17603,7 +17606,7 @@ jsYaml$1.Type                = type;
 jsYaml$1.Schema              = schema;
 jsYaml$1.FAILSAFE_SCHEMA     = failsafe;
 jsYaml$1.JSON_SCHEMA         = json;
-jsYaml$1.CORE_SCHEMA         = core;
+jsYaml$1.CORE_SCHEMA         = core$1;
 jsYaml$1.DEFAULT_SAFE_SCHEMA = default_safe;
 jsYaml$1.DEFAULT_FULL_SCHEMA = default_full;
 jsYaml$1.load                = loader.load;
@@ -17947,7 +17950,7 @@ var toFile$1 = function(file) {
 const getEngine = engine;
 const defaults$4 = defaults$7;
 
-var parse$9 = function(language, str, options) {
+var parse$b = function(language, str, options) {
   const opts = defaults$4(options);
   const engine = getEngine(language, opts);
   if (typeof engine.parse !== 'function') {
@@ -17956,14 +17959,14 @@ var parse$9 = function(language, str, options) {
   return engine.parse(str, opts);
 };
 
-const fs = fs__default["default"];
+const fs$3 = require$$0__default$2["default"];
 const sections = sectionMatter;
 const defaults$3 = defaults$7;
 const stringify = stringify$2;
 const excerpt = excerpt$1;
 const engines = engines$2.exports;
 const toFile = toFile$1;
-const parse$8 = parse$9;
+const parse$a = parse$b;
 const utils$4 = utils$7;
 
 /**
@@ -18062,7 +18065,7 @@ function parseMatter(file, options) {
   } else {
 
     // create file.data by parsing the raw file.matter block
-    file.data = parse$8(file.language, file.matter, opts);
+    file.data = parse$a(file.language, file.matter, opts);
   }
 
   // update file.content
@@ -18132,7 +18135,7 @@ matter.stringify = function(file, data, options) {
  */
 
 matter.read = function(filepath, options) {
-  const str = fs.readFileSync(filepath, 'utf8');
+  const str = fs$3.readFileSync(filepath, 'utf8');
   const file = matter(str, options);
   file.path = filepath;
   return file;
@@ -23734,12 +23737,12 @@ Url.prototype.parseHost = function(host) {
   if (host) { this.hostname = host; }
 };
 
-var parse$7 = urlParse;
+var parse$9 = urlParse;
 
 mdurl$1.encode = encode_1;
 mdurl$1.decode = decode_1;
 mdurl$1.format = format$1;
-mdurl$1.parse  = parse$7;
+mdurl$1.parse  = parse$9;
 
 var uc_micro = {};
 
@@ -27694,7 +27697,7 @@ for (var i$2 = 0; i$2 < 256; i$2++) { ESCAPED.push(0); }
   .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });
 
 
-var _escape = function escape(state, silent) {
+var _escape$1 = function escape(state, silent) {
   var ch, pos = state.pos, max = state.posMax;
 
   if (state.src.charCodeAt(pos) !== 0x5C/* \ */) { return false; }
@@ -28825,7 +28828,7 @@ var Ruler           = ruler;
 var _rules = [
   [ 'text',            text ],
   [ 'newline',         newline ],
-  [ 'escape',          _escape ],
+  [ 'escape',          _escape$1 ],
   [ 'backticks',       backticks ],
   [ 'strikethrough',   strikethrough.tokenize ],
   [ 'emphasis',        emphasis.tokenize ],
@@ -35050,9 +35053,9 @@ const snippetPlugin = (md, srcDir) => {
       if (loader) {
         loader.addDependency(src);
       }
-      const isAFile = fs__default["default"].lstatSync(src).isFile();
-      if (fs__default["default"].existsSync(src) && isAFile) {
-        let content = fs__default["default"].readFileSync(src, "utf8");
+      const isAFile = require$$0__default$2["default"].lstatSync(src).isFile();
+      if (require$$0__default$2["default"].existsSync(src) && isAFile) {
+        let content = require$$0__default$2["default"].readFileSync(src, "utf8");
         if (regionName) {
           const lines = content.split(/\r?\n/);
           const region = findRegion(lines, regionName);
@@ -36478,14 +36481,639 @@ function slash(p) {
   return p.replace(/\\/g, "/");
 }
 
+var crossSpawn = {exports: {}};
+
+var windows = isexe$3;
+isexe$3.sync = sync$2;
+
+var fs$2 = require$$0__default$2["default"];
+
+function checkPathExt (path, options) {
+  var pathext = options.pathExt !== undefined ?
+    options.pathExt : process.env.PATHEXT;
+
+  if (!pathext) {
+    return true
+  }
+
+  pathext = pathext.split(';');
+  if (pathext.indexOf('') !== -1) {
+    return true
+  }
+  for (var i = 0; i < pathext.length; i++) {
+    var p = pathext[i].toLowerCase();
+    if (p && path.substr(-p.length).toLowerCase() === p) {
+      return true
+    }
+  }
+  return false
+}
+
+function checkStat$1 (stat, path, options) {
+  if (!stat.isSymbolicLink() && !stat.isFile()) {
+    return false
+  }
+  return checkPathExt(path, options)
+}
+
+function isexe$3 (path, options, cb) {
+  fs$2.stat(path, function (er, stat) {
+    cb(er, er ? false : checkStat$1(stat, path, options));
+  });
+}
+
+function sync$2 (path, options) {
+  return checkStat$1(fs$2.statSync(path), path, options)
+}
+
+var mode = isexe$2;
+isexe$2.sync = sync$1;
+
+var fs$1 = require$$0__default$2["default"];
+
+function isexe$2 (path, options, cb) {
+  fs$1.stat(path, function (er, stat) {
+    cb(er, er ? false : checkStat(stat, options));
+  });
+}
+
+function sync$1 (path, options) {
+  return checkStat(fs$1.statSync(path), options)
+}
+
+function checkStat (stat, options) {
+  return stat.isFile() && checkMode(stat, options)
+}
+
+function checkMode (stat, options) {
+  var mod = stat.mode;
+  var uid = stat.uid;
+  var gid = stat.gid;
+
+  var myUid = options.uid !== undefined ?
+    options.uid : process.getuid && process.getuid();
+  var myGid = options.gid !== undefined ?
+    options.gid : process.getgid && process.getgid();
+
+  var u = parseInt('100', 8);
+  var g = parseInt('010', 8);
+  var o = parseInt('001', 8);
+  var ug = u | g;
+
+  var ret = (mod & o) ||
+    (mod & g) && gid === myGid ||
+    (mod & u) && uid === myUid ||
+    (mod & ug) && myUid === 0;
+
+  return ret
+}
+
+var core;
+if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
+  core = windows;
+} else {
+  core = mode;
+}
+
+var isexe_1 = isexe$1;
+isexe$1.sync = sync;
+
+function isexe$1 (path, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+
+  if (!cb) {
+    if (typeof Promise !== 'function') {
+      throw new TypeError('callback not provided')
+    }
+
+    return new Promise(function (resolve, reject) {
+      isexe$1(path, options || {}, function (er, is) {
+        if (er) {
+          reject(er);
+        } else {
+          resolve(is);
+        }
+      });
+    })
+  }
+
+  core(path, options || {}, function (er, is) {
+    // ignore EACCES because that just means we aren't allowed to run it
+    if (er) {
+      if (er.code === 'EACCES' || options && options.ignoreErrors) {
+        er = null;
+        is = false;
+      }
+    }
+    cb(er, is);
+  });
+}
+
+function sync (path, options) {
+  // my kingdom for a filtered catch
+  try {
+    return core.sync(path, options || {})
+  } catch (er) {
+    if (options && options.ignoreErrors || er.code === 'EACCES') {
+      return false
+    } else {
+      throw er
+    }
+  }
+}
+
+const isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys';
+
+const path$2 = path__default["default"];
+const COLON$1 = isWindows ? ';' : ':';
+const isexe = isexe_1;
+
+const getNotFoundError = (cmd) =>
+  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
+
+const getPathInfo = (cmd, opt) => {
+  const colon = opt.colon || COLON$1;
+
+  // If it has a slash, then we don't bother searching the pathenv.
+  // just check the file itself, and that's it.
+  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
+    : (
+      [
+        // windows always checks the cwd first
+        ...(isWindows ? [process.cwd()] : []),
+        ...(opt.path || process.env.PATH ||
+          /* istanbul ignore next: very unusual */ '').split(colon),
+      ]
+    );
+  const pathExtExe = isWindows
+    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
+    : '';
+  const pathExt = isWindows ? pathExtExe.split(colon) : [''];
+
+  if (isWindows) {
+    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
+      pathExt.unshift('');
+  }
+
+  return {
+    pathEnv,
+    pathExt,
+    pathExtExe,
+  }
+};
+
+const which$1 = (cmd, opt, cb) => {
+  if (typeof opt === 'function') {
+    cb = opt;
+    opt = {};
+  }
+  if (!opt)
+    opt = {};
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  const step = i => new Promise((resolve, reject) => {
+    if (i === pathEnv.length)
+      return opt.all && found.length ? resolve(found)
+        : reject(getNotFoundError(cmd))
+
+    const ppRaw = pathEnv[i];
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+
+    const pCmd = path$2.join(pathPart, cmd);
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd;
+
+    resolve(subStep(p, i, 0));
+  });
+
+  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+    if (ii === pathExt.length)
+      return resolve(step(i + 1))
+    const ext = pathExt[ii];
+    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+      if (!er && is) {
+        if (opt.all)
+          found.push(p + ext);
+        else
+          return resolve(p + ext)
+      }
+      return resolve(subStep(p, i, ii + 1))
+    });
+  });
+
+  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
+};
+
+const whichSync = (cmd, opt) => {
+  opt = opt || {};
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  for (let i = 0; i < pathEnv.length; i ++) {
+    const ppRaw = pathEnv[i];
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+
+    const pCmd = path$2.join(pathPart, cmd);
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd;
+
+    for (let j = 0; j < pathExt.length; j ++) {
+      const cur = p + pathExt[j];
+      try {
+        const is = isexe.sync(cur, { pathExt: pathExtExe });
+        if (is) {
+          if (opt.all)
+            found.push(cur);
+          else
+            return cur
+        }
+      } catch (ex) {}
+    }
+  }
+
+  if (opt.all && found.length)
+    return found
+
+  if (opt.nothrow)
+    return null
+
+  throw getNotFoundError(cmd)
+};
+
+var which_1 = which$1;
+which$1.sync = whichSync;
+
+var pathKey$1 = {exports: {}};
+
+const pathKey = (options = {}) => {
+	const environment = options.env || process.env;
+	const platform = options.platform || process.platform;
+
+	if (platform !== 'win32') {
+		return 'PATH';
+	}
+
+	return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
+};
+
+pathKey$1.exports = pathKey;
+// TODO: Remove this for the next major release
+pathKey$1.exports.default = pathKey;
+
+const path$1 = path__default["default"];
+const which = which_1;
+const getPathKey = pathKey$1.exports;
+
+function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    // Worker threads do not have process.chdir()
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+
+    // If a custom `cwd` was specified, we need to change the process cwd
+    // because `which` will do stat calls but does not support a custom cwd
+    if (shouldSwitchCwd) {
+        try {
+            process.chdir(parsed.options.cwd);
+        } catch (err) {
+            /* Empty */
+        }
+    }
+
+    let resolved;
+
+    try {
+        resolved = which.sync(parsed.command, {
+            path: env[getPathKey({ env })],
+            pathExt: withoutPathExt ? path$1.delimiter : undefined,
+        });
+    } catch (e) {
+        /* Empty */
+    } finally {
+        if (shouldSwitchCwd) {
+            process.chdir(cwd);
+        }
+    }
+
+    // If we successfully resolved, ensure that an absolute path is returned
+    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
+    if (resolved) {
+        resolved = path$1.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+    }
+
+    return resolved;
+}
+
+function resolveCommand$1(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+}
+
+var resolveCommand_1 = resolveCommand$1;
+
+var _escape = {};
+
+// See http://www.robvanderwoude.com/escapechars.php
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+
+function escapeCommand(arg) {
+    // Escape meta chars
+    arg = arg.replace(metaCharsRegExp, '^$1');
+
+    return arg;
+}
+
+function escapeArgument(arg, doubleEscapeMetaChars) {
+    // Convert to string
+    arg = `${arg}`;
+
+    // Algorithm below is based on https://qntm.org/cmd
+
+    // Sequence of backslashes followed by a double quote:
+    // double up all the backslashes and escape the double quote
+    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+
+    // Sequence of backslashes followed by the end of the string
+    // (which will become a double quote later):
+    // double up all the backslashes
+    arg = arg.replace(/(\\*)$/, '$1$1');
+
+    // All other backslashes occur literally
+
+    // Quote the whole thing:
+    arg = `"${arg}"`;
+
+    // Escape meta chars
+    arg = arg.replace(metaCharsRegExp, '^$1');
+
+    // Double escape meta chars if necessary
+    if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, '^$1');
+    }
+
+    return arg;
+}
+
+_escape.command = escapeCommand;
+_escape.argument = escapeArgument;
+
+var shebangRegex$1 = /^#!(.*)/;
+
+const shebangRegex = shebangRegex$1;
+
+var shebangCommand$1 = (string = '') => {
+	const match = string.match(shebangRegex);
+
+	if (!match) {
+		return null;
+	}
+
+	const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+	const binary = path.split('/').pop();
+
+	if (binary === 'env') {
+		return argument;
+	}
+
+	return argument ? `${binary} ${argument}` : binary;
+};
+
+const fs = require$$0__default$2["default"];
+const shebangCommand = shebangCommand$1;
+
+function readShebang$1(command) {
+    // Read the first 150 bytes from the file
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+
+    let fd;
+
+    try {
+        fd = fs.openSync(command, 'r');
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
+    } catch (e) { /* Empty */ }
+
+    // Attempt to extract shebang (null is returned if not a shebang)
+    return shebangCommand(buffer.toString());
+}
+
+var readShebang_1 = readShebang$1;
+
+const path = path__default["default"];
+const resolveCommand = resolveCommand_1;
+const escape = _escape;
+const readShebang = readShebang_1;
+
+const isWin$2 = process.platform === 'win32';
+const isExecutableRegExp = /\.(?:com|exe)$/i;
+const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+
+function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+
+    const shebang = parsed.file && readShebang(parsed.file);
+
+    if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+
+        return resolveCommand(parsed);
+    }
+
+    return parsed.file;
+}
+
+function parseNonShell(parsed) {
+    if (!isWin$2) {
+        return parsed;
+    }
+
+    // Detect & add support for shebangs
+    const commandFile = detectShebang(parsed);
+
+    // We don't need a shell if the command filename is an executable
+    const needsShell = !isExecutableRegExp.test(commandFile);
+
+    // If a shell is required, use cmd.exe and take care of escaping everything correctly
+    // Note that `forceShell` is an hidden option used only in tests
+    if (parsed.options.forceShell || needsShell) {
+        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
+        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
+        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
+        // we need to double escape them
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+
+        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
+        // This is necessary otherwise it will always fail with ENOENT in those cases
+        parsed.command = path.normalize(parsed.command);
+
+        // Escape command & arguments
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+
+        const shellCommand = [parsed.command].concat(parsed.args).join(' ');
+
+        parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
+        parsed.command = process.env.comspec || 'cmd.exe';
+        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
+    }
+
+    return parsed;
+}
+
+function parse$8(command, args, options) {
+    // Normalize arguments, similar to nodejs
+    if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+    }
+
+    args = args ? args.slice(0) : []; // Clone array to avoid changing the original
+    options = Object.assign({}, options); // Clone object to avoid changing the original
+
+    // Build our parsed object
+    const parsed = {
+        command,
+        args,
+        options,
+        file: undefined,
+        original: {
+            command,
+            args,
+        },
+    };
+
+    // Delegate further parsing to shell or non-shell
+    return options.shell ? parsed : parseNonShell(parsed);
+}
+
+var parse_1 = parse$8;
+
+const isWin$1 = process.platform === 'win32';
+
+function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: 'ENOENT',
+        errno: 'ENOENT',
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args,
+    });
+}
+
+function hookChildProcess(cp, parsed) {
+    if (!isWin$1) {
+        return;
+    }
+
+    const originalEmit = cp.emit;
+
+    cp.emit = function (name, arg1) {
+        // If emitting "exit" event and exit code is 1, we need to check if
+        // the command exists and emit an "error" instead
+        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
+        if (name === 'exit') {
+            const err = verifyENOENT(arg1, parsed);
+
+            if (err) {
+                return originalEmit.call(cp, 'error', err);
+            }
+        }
+
+        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
+    };
+}
+
+function verifyENOENT(status, parsed) {
+    if (isWin$1 && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawn');
+    }
+
+    return null;
+}
+
+function verifyENOENTSync(status, parsed) {
+    if (isWin$1 && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawnSync');
+    }
+
+    return null;
+}
+
+var enoent$1 = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError,
+};
+
+const cp = require$$0__default$7["default"];
+const parse$7 = parse_1;
+const enoent = enoent$1;
+
+function spawn(command, args, options) {
+    // Parse the arguments
+    const parsed = parse$7(command, args, options);
+
+    // Spawn the child process
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+
+    // Hook into child process "exit" event to emit an error if the command
+    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+    enoent.hookChildProcess(spawned, parsed);
+
+    return spawned;
+}
+
+function spawnSync(command, args, options) {
+    // Parse the arguments
+    const parsed = parse$7(command, args, options);
+
+    // Spawn the child process
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+
+    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+
+    return result;
+}
+
+crossSpawn.exports = spawn;
+var spawn_1 = crossSpawn.exports.spawn = spawn;
+crossSpawn.exports.sync = spawnSync;
+
+crossSpawn.exports._parse = parse$7;
+crossSpawn.exports._enoent = enoent;
+
+function getGitTimestamp(file) {
+  return new Promise((resolve, reject) => {
+    const child = spawn_1("git", ["log", "-1", '--pretty="%ci"', file]);
+    let output = "";
+    child.stdout.on("data", (d) => output += String(d));
+    child.on("close", () => {
+      resolve(+new Date(output));
+    });
+    child.on("error", reject);
+  });
+}
+
 const debug$2 = _debug("vitepress:md");
 const cache = new lruCache({ max: 1024 });
 const includesRE = /<!--\s*@include:\s*(.*?)\s*-->/g;
-function createMarkdownToVueRenderFn(srcDir, options = {}, pages, userDefines, isBuild = false) {
+function createMarkdownToVueRenderFn(srcDir, options = {}, pages, userDefines, isBuild = false, includeLastUpdatedData = false) {
   const md = createMarkdownRenderer(srcDir, options);
   pages = pages.map((p) => slash(p.replace(/\.md$/, "")));
   const userDefineRegex = userDefines ? new RegExp(`\\b(${Object.keys(userDefines).map((key) => key.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&")).join("|")})`, "g") : null;
-  return (src, file, publicDir) => {
+  return async (src, file, publicDir) => {
     const relativePath = slash(path__default["default"].relative(srcDir, file));
     const dir = path__default["default"].dirname(file);
     const cached = cache.get(src);
@@ -36497,7 +37125,7 @@ function createMarkdownToVueRenderFn(srcDir, options = {}, pages, userDefines, i
     let includes = [];
     src = src.replace(includesRE, (_, m1) => {
       const includePath = path__default["default"].join(dir, m1);
-      const content2 = fs__default["default"].readFileSync(includePath, "utf-8");
+      const content2 = require$$0__default$2["default"].readFileSync(includePath, "utf-8");
       includes.push(slash(includePath));
       return content2;
     });
@@ -36529,7 +37157,7 @@ function createMarkdownToVueRenderFn(srcDir, options = {}, pages, userDefines, i
         if (url.endsWith("/"))
           url += `index`;
         const resolved = decodeURIComponent(slash(url.startsWith("/") ? url.slice(1) : path__default["default"].relative(srcDir, path__default["default"].resolve(dir2, url))));
-        if (!pages.includes(resolved) && !fs__default["default"].existsSync(path__default["default"].resolve(dir2, publicDir, `${resolved}.html`))) {
+        if (!pages.includes(resolved) && !require$$0__default$2["default"].existsSync(path__default["default"].resolve(dir2, publicDir, `${resolved}.html`))) {
           recordDeadLink(url);
         }
       }
@@ -36539,9 +37167,11 @@ function createMarkdownToVueRenderFn(srcDir, options = {}, pages, userDefines, i
       description: inferDescription(frontmatter),
       frontmatter,
       headers: data.headers || [],
-      relativePath,
-      lastUpdated: Math.round(fs__default["default"].statSync(file).mtimeMs)
+      relativePath
     };
+    if (includeLastUpdatedData) {
+      pageData.lastUpdated = await getGitTimestamp(file);
+    }
     const vueSrc = genPageDataCode(data.hoistedTags || [], pageData).join("\n") + `
 <template><div>${html}</div></template>`;
     debug$2(`[render] ${file} in ${Date.now() - start}ms.`);
@@ -36633,7 +37263,7 @@ const staticDataPlugin = {
           _resolve = r;
         });
       }
-      const base = path$p.dirname(id);
+      const base = path$s.dirname(id);
       let pattern;
       let loader;
       const existing = idToLoaderModulesMap[id];
@@ -36676,7 +37306,7 @@ const staticDataPlugin = {
       if (isLoaderFile) {
         delete idToLoaderModulesMap[id];
       }
-      if (isLoaderFile || pattern && micromatch_1.isMatch(path$p.relative(base, ctx.file), pattern)) {
+      if (isLoaderFile || pattern && micromatch_1.isMatch(path$s.relative(base, ctx.file), pattern)) {
         ctx.modules.push(server.moduleGraph.getModuleById(id));
       }
     }
@@ -36738,7 +37368,7 @@ function createVitePressPlugin(root, siteConfig, ssr = false, pageToHashMap, cli
     name: "vitepress",
     configResolved(resolvedConfig) {
       config = resolvedConfig;
-      markdownToVue = createMarkdownToVueRenderFn(srcDir, markdown, pages, config.define, config.command === "build");
+      markdownToVue = createMarkdownToVueRenderFn(srcDir, markdown, pages, config.define, config.command === "build", siteConfig.lastUpdated);
     },
     config() {
       var _a, _b;
@@ -36777,11 +37407,11 @@ function createVitePressPlugin(root, siteConfig, ssr = false, pageToHashMap, cli
         return `export default ${JSON.stringify(JSON.stringify(data))}`;
       }
     },
-    transform(code, id) {
+    async transform(code, id) {
       if (id.endsWith(".vue")) {
         return processClientJS(code, id);
       } else if (id.endsWith(".md")) {
-        const { vueSrc, deadLinks, includes } = markdownToVue(code, id, config.publicDir);
+        const { vueSrc, deadLinks, includes } = await markdownToVue(code, id, config.publicDir);
         if (deadLinks.length) {
           hasDeadLinks = true;
         }
@@ -36867,7 +37497,7 @@ function createVitePressPlugin(root, siteConfig, ssr = false, pageToHashMap, cli
       }
       if (file.endsWith(".md")) {
         const content = await read();
-        const { pageData, vueSrc } = markdownToVue(content, file, config.publicDir);
+        const { pageData, vueSrc } = await markdownToVue(content, file, config.publicDir);
         server.ws.send({
           type: "custom",
           event: "vitepress:pageData",
@@ -37035,7 +37665,7 @@ if (typeof process$1 !== 'object' || !process$1) {
   var signals = signals$1.exports;
   var isWin = /^win/i.test(process$1.platform);
 
-  var EE = require$$0__default$5["default"];
+  var EE = require$$0__default$6["default"];
   /* istanbul ignore if */
   if (typeof EE !== 'function') {
     EE = EE.EventEmitter;
@@ -39178,7 +39808,7 @@ if (typeof Object.create === 'function') {
 }
 
 try {
-  var util = require$$0__default$2["default"];
+  var util = require$$0__default$3["default"];
   /* istanbul ignore next */
   if (typeof util.inherits !== 'function') throw '';
   inherits$1.exports = util.inherits;
@@ -39187,7 +39817,7 @@ try {
   inherits$1.exports = inherits_browser.exports;
 }
 
-const { Buffer: Buffer$2 } = require$$0__default$6["default"];
+const { Buffer: Buffer$2 } = require$$0__default$8["default"];
 const symbol = Symbol.for('BufferList');
 
 function BufferList$1 (buf) {
@@ -39665,7 +40295,7 @@ bl.exports = BufferListStream$1;
 bl.exports.BufferListStream = BufferListStream$1;
 bl.exports.BufferList = BufferList;
 
-const readline = require$$0__default$7["default"];
+const readline = require$$0__default$9["default"];
 const chalk = source;
 const cliCursor = cliCursor$1;
 const cliSpinners = cliSpinners$1.exports;
@@ -40370,6 +41000,7 @@ async function build(root, buildOptions = {}) {
     spinner.stopAndPersist({
       symbol: okMark
     });
+    lib$1.writeJSONSync(path__default["default"].join(siteConfig.outDir, "hashmap.json"), pageToHashMap);
   } finally {
     await lib$1.remove(siteConfig.tempDir);
   }
@@ -40416,15 +41047,15 @@ function parse$6(req) {
 }
 
 function list(dir, callback, pre='') {
-	dir = path$p.resolve('.', dir);
-	let arr = fs$v.readdirSync(dir);
+	dir = path$s.resolve('.', dir);
+	let arr = require$$0$8.readdirSync(dir);
 	let i=0, abs, stats;
 	for (; i < arr.length; i++) {
-		abs = path$p.join(dir, arr[i]);
-		stats = fs$v.statSync(abs);
+		abs = path$s.join(dir, arr[i]);
+		stats = require$$0$8.statSync(abs);
 		stats.isDirectory()
-			? list(abs, callback, path$p.join(pre, arr[i]))
-			: callback(path$p.join(pre, arr[i]), abs, stats);
+			? list(abs, callback, path$s.join(pre, arr[i]))
+			: callback(path$s.join(pre, arr[i]), abs, stats);
 	}
 }
 
@@ -40564,9 +41195,9 @@ function viaLocal(dir, isEtag, uri, extns) {
 	let i=0, arr=toAssume(uri, extns);
 	let abs, stats, name, headers;
 	for (; i < arr.length; i++) {
-		abs = path$p.normalize(path$p.join(dir, name=arr[i]));
-		if (abs.startsWith(dir) && fs__namespace.existsSync(abs)) {
-			stats = fs__namespace.statSync(abs);
+		abs = path$s.normalize(path$s.join(dir, name=arr[i]));
+		if (abs.startsWith(dir) && require$$0__namespace.existsSync(abs)) {
+			stats = require$$0__namespace.statSync(abs);
 			if (stats.isDirectory()) continue;
 			headers = toHeaders(name, stats, isEtag);
 			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
@@ -40610,7 +41241,7 @@ function send(req, res, file, stats, headers) {
 	}
 
 	res.writeHead(code, headers);
-	fs__namespace.createReadStream(file, opts).pipe(res);
+	require$$0__namespace.createReadStream(file, opts).pipe(res);
 }
 
 function isEncoding(name, type, headers) {
@@ -40631,7 +41262,7 @@ function toHeaders(name, stats, isEtag) {
 }
 
 function sirv (dir, opts={}) {
-	dir = path$p.resolve(dir || '.');
+	dir = path$s.resolve(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
 	let setHeaders = opts.setHeaders || noop;
@@ -52682,7 +53313,7 @@ var safeBuffer = {exports: {}};
 /* eslint-disable node/no-deprecated-api */
 
 (function (module, exports) {
-var buffer = require$$0__default$6["default"];
+var buffer = require$$0__default$8["default"];
 var Buffer = buffer.Buffer;
 
 // alternative to using Object.keys for old browsers
@@ -64151,8 +64782,8 @@ var node = {exports: {}};
  */
 
 (function (module, exports) {
-var tty = require$$0__default$3["default"];
-var util = require$$0__default$2["default"];
+var tty = require$$0__default$4["default"];
+var util = require$$0__default$3["default"];
 
 /**
  * This is the Node.js implementation of `debug()`.
@@ -64332,7 +64963,7 @@ function createWritableStdioStream (fd) {
       break;
 
     case 'FILE':
-      var fs = fs__default["default"];
+      var fs = require$$0__default$2["default"];
       stream = new fs.SyncWriteStream(fd, { autoClose: false });
       stream._type = 'fs';
       break;
@@ -65180,7 +65811,7 @@ var url = function (req) {
 	return (req._parsedUrl = obj);
 };
 
-const http = require$$0__default$8["default"];
+const http = require$$0__default$a["default"];
 const Router = trouter;
 const { parse } = qs__default["default"];
 const parser = url;