@forsakringskassan/docs-generator 1.25.3 → 1.26.0

package/dist/generator.js

@@ -87,56 +87,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs13) {
+    function patch(fs14) {
       if (constants3.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs13);
-      }
-      if (!fs13.lutimes) {
-        patchLutimes(fs13);
-      }
-      fs13.chown = chownFix(fs13.chown);
-      fs13.fchown = chownFix(fs13.fchown);
-      fs13.lchown = chownFix(fs13.lchown);
-      fs13.chmod = chmodFix(fs13.chmod);
-      fs13.fchmod = chmodFix(fs13.fchmod);
-      fs13.lchmod = chmodFix(fs13.lchmod);
-      fs13.chownSync = chownFixSync(fs13.chownSync);
-      fs13.fchownSync = chownFixSync(fs13.fchownSync);
-      fs13.lchownSync = chownFixSync(fs13.lchownSync);
-      fs13.chmodSync = chmodFixSync(fs13.chmodSync);
-      fs13.fchmodSync = chmodFixSync(fs13.fchmodSync);
-      fs13.lchmodSync = chmodFixSync(fs13.lchmodSync);
-      fs13.stat = statFix(fs13.stat);
-      fs13.fstat = statFix(fs13.fstat);
-      fs13.lstat = statFix(fs13.lstat);
-      fs13.statSync = statFixSync(fs13.statSync);
-      fs13.fstatSync = statFixSync(fs13.fstatSync);
-      fs13.lstatSync = statFixSync(fs13.lstatSync);
-      if (fs13.chmod && !fs13.lchmod) {
-        fs13.lchmod = function(path24, mode, cb) {
+        patchLchmod(fs14);
+      }
+      if (!fs14.lutimes) {
+        patchLutimes(fs14);
+      }
+      fs14.chown = chownFix(fs14.chown);
+      fs14.fchown = chownFix(fs14.fchown);
+      fs14.lchown = chownFix(fs14.lchown);
+      fs14.chmod = chmodFix(fs14.chmod);
+      fs14.fchmod = chmodFix(fs14.fchmod);
+      fs14.lchmod = chmodFix(fs14.lchmod);
+      fs14.chownSync = chownFixSync(fs14.chownSync);
+      fs14.fchownSync = chownFixSync(fs14.fchownSync);
+      fs14.lchownSync = chownFixSync(fs14.lchownSync);
+      fs14.chmodSync = chmodFixSync(fs14.chmodSync);
+      fs14.fchmodSync = chmodFixSync(fs14.fchmodSync);
+      fs14.lchmodSync = chmodFixSync(fs14.lchmodSync);
+      fs14.stat = statFix(fs14.stat);
+      fs14.fstat = statFix(fs14.fstat);
+      fs14.lstat = statFix(fs14.lstat);
+      fs14.statSync = statFixSync(fs14.statSync);
+      fs14.fstatSync = statFixSync(fs14.fstatSync);
+      fs14.lstatSync = statFixSync(fs14.lstatSync);
+      if (fs14.chmod && !fs14.lchmod) {
+        fs14.lchmod = function(path24, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs13.lchmodSync = function() {
+        fs14.lchmodSync = function() {
         };
       }
-      if (fs13.chown && !fs13.lchown) {
-        fs13.lchown = function(path24, uid, gid, cb) {
+      if (fs14.chown && !fs14.lchown) {
+        fs14.lchown = function(path24, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs13.lchownSync = function() {
+        fs14.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs13.rename = typeof fs13.rename !== "function" ? fs13.rename : function(fs$rename) {
+        fs14.rename = typeof fs14.rename !== "function" ? fs14.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs13.stat(to, function(stater, st) {
+                  fs14.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -154,9 +154,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs13.rename);
+        }(fs14.rename);
       }
-      fs13.read = typeof fs13.read !== "function" ? fs13.read : function(fs$read) {
+      fs14.read = typeof fs14.read !== "function" ? fs14.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -164,23 +164,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs14, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs14, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs13.read);
-      fs13.readSync = typeof fs13.readSync !== "function" ? fs13.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs14.read);
+      fs14.readSync = typeof fs14.readSync !== "function" ? fs14.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs13, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs14, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -190,10 +190,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs13.readSync);
-      function patchLchmod(fs14) {
-        fs14.lchmod = function(path24, mode, callback) {
-          fs14.open(
+      }(fs14.readSync);
+      function patchLchmod(fs15) {
+        fs15.lchmod = function(path24, mode, callback) {
+          fs15.open(
             path24,
             constants3.O_WRONLY | constants3.O_SYMLINK,
             mode,
@@ -203,8 +203,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs14.fchmod(fd, mode, function(err2) {
-                fs14.close(fd, function(err22) {
+              fs15.fchmod(fd, mode, function(err2) {
+                fs15.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -212,68 +212,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs14.lchmodSync = function(path24, mode) {
-          var fd = fs14.openSync(path24, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
+        fs15.lchmodSync = function(path24, mode) {
+          var fd = fs15.openSync(path24, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs14.fchmodSync(fd, mode);
+            ret = fs15.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs14.closeSync(fd);
+              fs15.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs14) {
-        if (constants3.hasOwnProperty("O_SYMLINK") && fs14.futimes) {
-          fs14.lutimes = function(path24, at, mt, cb) {
-            fs14.open(path24, constants3.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs15) {
+        if (constants3.hasOwnProperty("O_SYMLINK") && fs15.futimes) {
+          fs15.lutimes = function(path24, at, mt, cb) {
+            fs15.open(path24, constants3.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs14.futimes(fd, at, mt, function(er2) {
-                fs14.close(fd, function(er22) {
+              fs15.futimes(fd, at, mt, function(er2) {
+                fs15.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs14.lutimesSync = function(path24, at, mt) {
-            var fd = fs14.openSync(path24, constants3.O_SYMLINK);
+          fs15.lutimesSync = function(path24, at, mt) {
+            var fd = fs15.openSync(path24, constants3.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs14.futimesSync(fd, at, mt);
+              ret = fs15.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs14.closeSync(fd);
+                  fs15.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs14.futimes) {
-          fs14.lutimes = function(_a3, _b, _c, cb) {
+        } else if (fs15.futimes) {
+          fs15.lutimes = function(_a3, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs14.lutimesSync = function() {
+          fs15.lutimesSync = function() {
           };
         }
       }
@@ -281,7 +281,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs13, target, mode, function(er) {
+          return orig.call(fs14, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -294,7 +294,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs13, target, mode);
+            return orig.call(fs14, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -305,7 +305,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs13, target, uid, gid, function(er) {
+          return orig.call(fs14, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -318,7 +318,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs13, target, uid, gid);
+            return orig.call(fs14, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -343,14 +343,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs13, target, options, callback) : orig.call(fs13, target, callback);
+          return options ? orig.call(fs14, target, options, callback) : orig.call(fs14, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs13, target, options) : orig.call(fs13, target);
+          var stats = options ? orig.call(fs14, target, options) : orig.call(fs14, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -381,7 +381,7 @@ var require_legacy_streams = __commonJS({
   "node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream2 = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs13) {
+    function legacy(fs14) {
       return {
         ReadStream,
         WriteStream
@@ -426,7 +426,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs13.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs14.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -466,7 +466,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs13.open;
+          this._open = fs14.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -501,7 +501,7 @@ var require_clone = __commonJS({
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -533,12 +533,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs13[gracefulQueue]) {
+    if (!fs14[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs13, queue);
-      fs13.close = function(fs$close) {
+      publishQueue(fs14, queue);
+      fs14.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs13, fd, function(err) {
+          return fs$close.call(fs14, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -550,40 +550,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs13.close);
-      fs13.closeSync = function(fs$closeSync) {
+      }(fs14.close);
+      fs14.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs13, arguments);
+          fs$closeSync.apply(fs14, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs13.closeSync);
+      }(fs14.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs13[gracefulQueue]);
-          require("assert").equal(fs13[gracefulQueue].length, 0);
+          debug(fs14[gracefulQueue]);
+          require("assert").equal(fs14[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs13[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs13));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs13.__patched) {
-      module2.exports = patch(fs13);
-      fs13.__patched = true;
-    }
-    function patch(fs14) {
-      polyfills(fs14);
-      fs14.gracefulify = patch;
-      fs14.createReadStream = createReadStream2;
-      fs14.createWriteStream = createWriteStream2;
-      var fs$readFile = fs14.readFile;
-      fs14.readFile = readFile;
+      publishQueue(global, fs14[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs14));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs14.__patched) {
+      module2.exports = patch(fs14);
+      fs14.__patched = true;
+    }
+    function patch(fs15) {
+      polyfills(fs15);
+      fs15.gracefulify = patch;
+      fs15.createReadStream = createReadStream2;
+      fs15.createWriteStream = createWriteStream2;
+      var fs$readFile = fs15.readFile;
+      fs15.readFile = readFile;
       function readFile(path24, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -599,8 +599,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs14.writeFile;
-      fs14.writeFile = writeFile;
+      var fs$writeFile = fs15.writeFile;
+      fs15.writeFile = writeFile;
       function writeFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -616,9 +616,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs14.appendFile;
+      var fs$appendFile = fs15.appendFile;
       if (fs$appendFile)
-        fs14.appendFile = appendFile;
+        fs15.appendFile = appendFile;
       function appendFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -634,9 +634,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs14.copyFile;
+      var fs$copyFile = fs15.copyFile;
       if (fs$copyFile)
-        fs14.copyFile = copyFile;
+        fs15.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -654,8 +654,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs14.readdir;
-      fs14.readdir = readdir2;
+      var fs$readdir = fs15.readdir;
+      fs15.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path24, options, cb) {
         if (typeof options === "function")
@@ -696,21 +696,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs14);
+        var legStreams = legacy(fs15);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs14.ReadStream;
+      var fs$ReadStream = fs15.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs14.WriteStream;
+      var fs$WriteStream = fs15.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs14, "ReadStream", {
+      Object.defineProperty(fs15, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -720,7 +720,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs14, "WriteStream", {
+      Object.defineProperty(fs15, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -731,7 +731,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs14, "FileReadStream", {
+      Object.defineProperty(fs15, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -742,7 +742,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs14, "FileWriteStream", {
+      Object.defineProperty(fs15, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -791,13 +791,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream2(path24, options) {
-        return new fs14.ReadStream(path24, options);
+        return new fs15.ReadStream(path24, options);
       }
       function createWriteStream2(path24, options) {
-        return new fs14.WriteStream(path24, options);
+        return new fs15.WriteStream(path24, options);
       }
-      var fs$open = fs14.open;
-      fs14.open = open;
+      var fs$open = fs15.open;
+      fs15.open = open;
       function open(path24, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -813,20 +813,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs14;
+      return fs15;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs13[gracefulQueue].push(elem);
+      fs14[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs13[gracefulQueue].length; ++i) {
-        if (fs13[gracefulQueue][i].length > 2) {
-          fs13[gracefulQueue][i][3] = now;
-          fs13[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs14[gracefulQueue].length; ++i) {
+        if (fs14[gracefulQueue][i].length > 2) {
+          fs14[gracefulQueue][i][3] = now;
+          fs14[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -834,9 +834,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs13[gracefulQueue].length === 0)
+      if (fs14[gracefulQueue].length === 0)
         return;
-      var elem = fs13[gracefulQueue].shift();
+      var elem = fs14[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -858,7 +858,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs13[gracefulQueue].push(elem);
+          fs14[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -873,7 +873,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -910,26 +910,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs13[key] === "function";
+      return typeof fs14[key] === "function";
     });
-    Object.assign(exports2, fs13);
+    Object.assign(exports2, fs14);
     api.forEach((method) => {
-      exports2[method] = u(fs13[method]);
+      exports2[method] = u(fs14[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs13.exists(filename, callback);
+        return fs14.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs13.exists(filename, resolve);
+        return fs14.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs13.read(fd, buffer, offset, length, position, callback);
+        return fs14.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs13.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs14.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
@@ -938,10 +938,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.write(fd, buffer, ...args);
+        return fs14.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs14.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
@@ -950,10 +950,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.readv(fd, buffers, ...args);
+        return fs14.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs14.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err)
             return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
@@ -962,18 +962,18 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs13.writev(fd, buffers, ...args);
+        return fs14.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs13.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs14.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err)
             return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs13.realpath.native === "function") {
-      exports2.realpath.native = u(fs13.realpath.native);
+    if (typeof fs14.realpath.native === "function") {
+      exports2.realpath.native = u(fs14.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -1006,7 +1006,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -1016,14 +1016,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs13.mkdir(dir, {
+      return fs14.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs13.mkdirSync(dir, {
+      return fs14.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -1055,13 +1055,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     function pathExists(path24) {
-      return fs13.access(path24).then(() => true).catch(() => false);
+      return fs14.access(path24).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs13.existsSync
+      pathExistsSync: fs14.existsSync
     };
   }
 });
@@ -1070,16 +1070,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path24, atime, mtime) {
-      const fd = await fs13.open(path24, "r+");
+      const fd = await fs14.open(path24, "r+");
       let closeErr = null;
       try {
-        await fs13.futimes(fd, atime, mtime);
+        await fs14.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs13.close(fd);
+          await fs14.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -1089,9 +1089,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path24, atime, mtime) {
-      const fd = fs13.openSync(path24, "r+");
-      fs13.futimesSync(fd, atime, mtime);
-      return fs13.closeSync(fd);
+      const fd = fs14.openSync(path24, "r+");
+      fs14.futimesSync(fd, atime, mtime);
+      return fs14.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -1104,11 +1104,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path24 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs13.stat(file, { bigint: true }) : (file) => fs13.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs14.stat(file, { bigint: true }) : (file) => fs14.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -1120,7 +1120,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs13.statSync(file, { bigint: true }) : (file) => fs13.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs14.statSync(file, { bigint: true }) : (file) => fs14.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -1184,7 +1184,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = await fs13.stat(destParent, { bigint: true });
+        destStat = await fs14.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -1202,7 +1202,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = fs13.statSync(destParent, { bigint: true });
+        destStat = fs14.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -1242,7 +1242,7 @@ var require_stat = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path24 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -1279,7 +1279,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs13.stat : fs13.lstat;
+      const statFn = opts.dereference ? fs14.stat : fs14.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -1297,7 +1297,7 @@ var require_copy = __commonJS({
       if (!destStat)
         return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs13.unlink(dest);
+        await fs14.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -1305,27 +1305,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs13.copyFile(src, dest);
+      await fs14.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs13.stat(src);
+        const updatedSrcStat = await fs14.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs13.chmod(dest, srcStat.mode);
+      return fs14.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs13.chmod(dest, srcMode | 128);
+      return fs14.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs13.mkdir(dest);
+        await fs14.mkdir(dest);
       }
-      const items = await fs13.readdir(src);
+      const items = await fs14.readdir(src);
       await Promise.all(items.map(async (item) => {
         const srcItem = path24.join(src, item);
         const destItem = path24.join(dest, item);
@@ -1336,23 +1336,23 @@ var require_copy = __commonJS({
         return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
       }));
       if (!destStat) {
-        await fs13.chmod(dest, srcStat.mode);
+        await fs14.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs13.readlink(src);
+      let resolvedSrc = await fs14.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlink(resolvedSrc, dest);
+        return fs14.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs13.readlink(dest);
+        resolvedDest = await fs14.readlink(dest);
       } catch (e) {
         if (e.code === "EINVAL" || e.code === "UNKNOWN")
-          return fs13.symlink(resolvedSrc, dest);
+          return fs14.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -1364,8 +1364,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs13.unlink(dest);
-      return fs13.symlink(resolvedSrc, dest);
+      await fs14.unlink(dest);
+      return fs14.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -1375,7 +1375,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path24 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -1399,12 +1399,12 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path24.dirname(dest);
-      if (!fs13.existsSync(destParent))
+      if (!fs14.existsSync(destParent))
         mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs13.statSync : fs13.lstatSync;
+      const statSync = opts.dereference ? fs14.statSync : fs14.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -1425,14 +1425,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs13.unlinkSync(dest);
+        fs14.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs13.copyFileSync(src, dest);
+      fs14.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
         handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
@@ -1449,10 +1449,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs13.chmodSync(dest, srcMode);
+      return fs14.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs13.statSync(src);
+      const updatedSrcStat = fs14.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -1461,12 +1461,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs13.mkdirSync(dest);
+      fs14.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs13.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs14.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path24.join(src, item);
@@ -1477,19 +1477,19 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs13.readlinkSync(src);
+      let resolvedSrc = fs14.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs13.symlinkSync(resolvedSrc, dest);
+        return fs14.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs13.readlinkSync(dest);
+          resolvedDest = fs14.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs13.symlinkSync(resolvedSrc, dest);
+            return fs14.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -1505,8 +1505,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs13.unlinkSync(dest);
-      return fs13.symlinkSync(resolvedSrc, dest);
+      fs14.unlinkSync(dest);
+      return fs14.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -1528,13 +1528,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path24, callback) {
-      fs13.rm(path24, { recursive: true, force: true }, callback);
+      fs14.rm(path24, { recursive: true, force: true }, callback);
     }
     function removeSync(path24) {
-      fs13.rmSync(path24, { recursive: true, force: true });
+      fs14.rmSync(path24, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -1548,14 +1548,14 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path24 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs13.readdir(dir);
+        items = await fs14.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -1564,7 +1564,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs13.readdirSync(dir);
+        items = fs14.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -1588,12 +1588,12 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path24 = require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs13.stat(file);
+        stats = await fs14.stat(file);
       } catch {
       }
       if (stats && stats.isFile())
@@ -1601,34 +1601,34 @@ var require_file = __commonJS({
       const dir = path24.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs13.stat(dir);
+        dirStats = await fs14.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs13.writeFile(file, "");
+          await fs14.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs13.writeFile(file, "");
+        await fs14.writeFile(file, "");
       } else {
-        await fs13.readdir(dir);
+        await fs14.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs13.statSync(file);
+        stats = fs14.statSync(file);
       } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path24.dirname(file);
       try {
-        if (!fs13.statSync(dir).isDirectory()) {
-          fs13.readdirSync(dir);
+        if (!fs14.statSync(dir).isDirectory()) {
+          fs14.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT")
@@ -1636,7 +1636,7 @@ var require_file = __commonJS({
         else
           throw err;
       }
-      fs13.writeFileSync(file, "");
+      fs14.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -1651,19 +1651,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path24 = require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs13.lstat(dstpath);
+        dstStat = await fs14.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs13.lstat(srcpath);
+        srcStat = await fs14.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -1675,16 +1675,16 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs13.link(srcpath, dstpath);
+      await fs14.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs13.lstatSync(dstpath);
+        dstStat = fs14.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs13.lstatSync(srcpath);
+        const srcStat = fs14.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat))
           return;
       } catch (err) {
@@ -1692,11 +1692,11 @@ var require_link = __commonJS({
         throw err;
       }
       const dir = path24.dirname(dstpath);
-      const dirExists = fs13.existsSync(dir);
+      const dirExists = fs14.existsSync(dir);
       if (dirExists)
-        return fs13.linkSync(srcpath, dstpath);
+        return fs14.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs13.linkSync(srcpath, dstpath);
+      return fs14.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -1710,13 +1710,13 @@ var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path24 = require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path24.isAbsolute(srcpath)) {
         try {
-          await fs13.lstat(srcpath);
+          await fs14.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -1736,7 +1736,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs13.lstat(srcpath);
+        await fs14.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -1748,7 +1748,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path24.isAbsolute(srcpath)) {
-        const exists2 = fs13.existsSync(srcpath);
+        const exists2 = fs14.existsSync(srcpath);
         if (!exists2)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -1758,14 +1758,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path24.dirname(dstpath);
       const relativeToDst = path24.join(dstdir, srcpath);
-      const exists = fs13.existsSync(relativeToDst);
+      const exists = fs14.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs13.existsSync(srcpath);
+      const srcExists = fs14.existsSync(srcpath);
       if (!srcExists)
         throw new Error("relative srcpath does not exist");
       return {
@@ -1784,14 +1784,14 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type)
         return type;
       let stats;
       try {
-        stats = await fs13.lstat(srcpath);
+        stats = await fs14.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -1802,7 +1802,7 @@ var require_symlink_type = __commonJS({
         return type;
       let stats;
       try {
-        stats = fs13.lstatSync(srcpath);
+        stats = fs14.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -1821,7 +1821,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path24 = require("path");
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -1830,13 +1830,13 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs13.lstat(dstpath);
+        stats = await fs14.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs13.stat(srcpath),
-          fs13.stat(dstpath)
+          fs14.stat(srcpath),
+          fs14.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat))
           return;
@@ -1848,17 +1848,17 @@ var require_symlink = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs13.symlink(srcpath, dstpath, toType);
+      return fs14.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs13.lstatSync(dstpath);
+        stats = fs14.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs13.statSync(srcpath);
-        const dstStat = fs13.statSync(dstpath);
+        const srcStat = fs14.statSync(srcpath);
+        const dstStat = fs14.statSync(dstpath);
         if (areIdentical(srcStat, dstStat))
           return;
       }
@@ -1866,11 +1866,11 @@ var require_symlink = __commonJS({
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path24.dirname(dstpath);
-      const exists = fs13.existsSync(dir);
+      const exists = fs14.existsSync(dir);
       if (exists)
-        return fs13.symlinkSync(srcpath, dstpath, type);
+        return fs14.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs13.symlinkSync(srcpath, dstpath, type);
+      return fs14.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -1938,9 +1938,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs13.readFile)(file, options);
+      let data = await universalify.fromCallback(fs14.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -1960,10 +1960,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs13.readFileSync(file, options);
+        let content = fs14.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -1976,15 +1976,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs13.writeFile)(file, str, options);
+      await universalify.fromCallback(fs14.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs13 = options.fs || _fs;
+      const fs14 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs13.writeFileSync(file, str, options);
+      return fs14.writeFileSync(file, str, options);
     }
     var jsonfile = {
       readFile,
@@ -2016,7 +2016,7 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path24 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -2025,14 +2025,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs13.writeFile(file, data, encoding);
+      return fs14.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path24.dirname(file);
-      if (!fs13.existsSync(dir)) {
+      if (!fs14.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs13.writeFileSync(file, ...args);
+      fs14.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -2091,7 +2091,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_fs();
+    var fs14 = require_fs();
     var path24 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
@@ -2118,7 +2118,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs13.rename(src, dest);
+        await fs14.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -2143,7 +2143,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs13 = require_graceful_fs();
+    var fs14 = require_graceful_fs();
     var path24 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -2170,13 +2170,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs13.existsSync(dest))
+      if (fs14.existsSync(dest))
         throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs13.renameSync(src, dest);
+        fs14.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV")
           throw err;
@@ -6503,7 +6503,7 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync2;
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     function checkPathExt(path24, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -6528,12 +6528,12 @@ var require_windows = __commonJS({
       return checkPathExt(path24, options);
     }
     function isexe(path24, options, cb) {
-      fs13.stat(path24, function(er, stat) {
+      fs14.stat(path24, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path24, options));
       });
     }
     function sync2(path24, options) {
-      return checkStat(fs13.statSync(path24), path24, options);
+      return checkStat(fs14.statSync(path24), path24, options);
     }
   }
 });
@@ -6543,14 +6543,14 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync2;
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     function isexe(path24, options, cb) {
-      fs13.stat(path24, function(er, stat) {
+      fs14.stat(path24, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync2(path24, options) {
-      return checkStat(fs13.statSync(path24), options);
+      return checkStat(fs14.statSync(path24), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -6574,7 +6574,7 @@ var require_mode = __commonJS({
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -6838,16 +6838,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs13.openSync(command, "r");
-        fs13.readSync(fd, buffer, 0, size, 0);
-        fs13.closeSync(fd);
+        fd = fs14.openSync(command, "r");
+        fs14.readSync(fd, buffer, 0, size, 0);
+        fs14.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -21820,15 +21820,15 @@ var require_picomatch2 = __commonJS({
 var require_readdirp = __commonJS({
   "node_modules/readdirp/index.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var { Readable } = require("stream");
     var sysPath = require("path");
     var { promisify: promisify2 } = require("util");
     var picomatch = require_picomatch2();
-    var readdir2 = promisify2(fs13.readdir);
-    var stat = promisify2(fs13.stat);
-    var lstat2 = promisify2(fs13.lstat);
-    var realpath2 = promisify2(fs13.realpath);
+    var readdir2 = promisify2(fs14.readdir);
+    var stat = promisify2(fs14.stat);
+    var lstat2 = promisify2(fs14.lstat);
+    var realpath2 = promisify2(fs14.realpath);
     var BANG = "!";
     var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
     var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
@@ -21904,7 +21904,7 @@ var require_readdirp = __commonJS({
         this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
         this._wantsEverything = type === EVERYTHING_TYPE;
         this._root = sysPath.resolve(root);
-        this._isDirent = "Dirent" in fs13 && !opts.alwaysStat;
+        this._isDirent = "Dirent" in fs14 && !opts.alwaysStat;
         this._statsProp = this._isDirent ? "dirent" : "stats";
         this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
         this.parents = [this._exploreDir(root, 1)];
@@ -23784,7 +23784,7 @@ var require_constants4 = __commonJS({
 var require_nodefs_handler = __commonJS({
   "node_modules/chokidar/lib/nodefs-handler.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var sysPath = require("path");
     var { promisify: promisify2 } = require("util");
     var isBinaryPath = require_is_binary_path();
@@ -23807,11 +23807,11 @@ var require_nodefs_handler = __commonJS({
       STAR
     } = require_constants4();
     var THROTTLE_MODE_WATCH = "watch";
-    var open = promisify2(fs13.open);
-    var stat = promisify2(fs13.stat);
-    var lstat2 = promisify2(fs13.lstat);
-    var close = promisify2(fs13.close);
-    var fsrealpath = promisify2(fs13.realpath);
+    var open = promisify2(fs14.open);
+    var stat = promisify2(fs14.stat);
+    var lstat2 = promisify2(fs14.lstat);
+    var close = promisify2(fs14.close);
+    var fsrealpath = promisify2(fs14.realpath);
     var statMethods = { lstat: lstat2, stat };
     var foreach = (val, fn) => {
       if (val instanceof Set) {
@@ -23858,7 +23858,7 @@ var require_nodefs_handler = __commonJS({
         }
       };
       try {
-        return fs13.watch(path24, options, handleEvent);
+        return fs14.watch(path24, options, handleEvent);
       } catch (error) {
         errHandler(error);
       }
@@ -23945,7 +23945,7 @@ var require_nodefs_handler = __commonJS({
       if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
         listeners = cont.listeners;
         rawEmitters = cont.rawEmitters;
-        fs13.unwatchFile(fullPath);
+        fs14.unwatchFile(fullPath);
         cont = void 0;
       }
       if (cont) {
@@ -23956,7 +23956,7 @@ var require_nodefs_handler = __commonJS({
           listeners: listener,
           rawEmitters: rawEmitter,
           options,
-          watcher: fs13.watchFile(fullPath, options, (curr, prev) => {
+          watcher: fs14.watchFile(fullPath, options, (curr, prev) => {
             foreach(cont.rawEmitters, (rawEmitter2) => {
               rawEmitter2(EV_CHANGE, fullPath, { curr, prev });
             });
@@ -23973,7 +23973,7 @@ var require_nodefs_handler = __commonJS({
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
           FsWatchFileInstances.delete(fullPath);
-          fs13.unwatchFile(fullPath);
+          fs14.unwatchFile(fullPath);
           cont.options = cont.watcher = void 0;
           Object.freeze(cont);
         }
@@ -24293,7 +24293,7 @@ var require_nodefs_handler = __commonJS({
 var require_fsevents_handler = __commonJS({
   "node_modules/chokidar/lib/fsevents-handler.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var sysPath = require("path");
     var { promisify: promisify2 } = require("util");
     var fsevents;
@@ -24339,9 +24339,9 @@ var require_fsevents_handler = __commonJS({
       IDENTITY_FN
     } = require_constants4();
     var Depth = (value) => isNaN(value) ? {} : { depth: value };
-    var stat = promisify2(fs13.stat);
-    var lstat2 = promisify2(fs13.lstat);
-    var realpath2 = promisify2(fs13.realpath);
+    var stat = promisify2(fs14.stat);
+    var lstat2 = promisify2(fs14.lstat);
+    var realpath2 = promisify2(fs14.realpath);
     var statMethods = { stat, lstat: lstat2 };
     var FSEventsWatchers = /* @__PURE__ */ new Map();
     var consolidateThreshhold = 10;
@@ -24716,7 +24716,7 @@ var require_chokidar = __commonJS({
   "node_modules/chokidar/index.js"(exports2) {
     "use strict";
     var { EventEmitter: EventEmitter2 } = require("events");
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var sysPath = require("path");
     var { promisify: promisify2 } = require("util");
     var readdirp = require_readdirp();
@@ -24761,8 +24761,8 @@ var require_chokidar = __commonJS({
       isMacos,
       isIBMi
     } = require_constants4();
-    var stat = promisify2(fs13.stat);
-    var readdir2 = promisify2(fs13.readdir);
+    var stat = promisify2(fs14.stat);
+    var readdir2 = promisify2(fs14.readdir);
     var arrify = (value = []) => Array.isArray(value) ? value : [value];
     var flatten = (list2, result = []) => {
       list2.forEach((item) => {
@@ -25304,7 +25304,7 @@ var require_chokidar = __commonJS({
         }
         const now = /* @__PURE__ */ new Date();
         const awaitWriteFinish = (prevStat) => {
-          fs13.stat(fullPath, (err, curStat) => {
+          fs14.stat(fullPath, (err, curStat) => {
             if (err || !this._pendingWrites.has(path24)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
@@ -26787,8 +26787,8 @@ var require_node = __commonJS({
           }
           break;
         case "FILE":
-          var fs13 = require("fs");
-          stream3 = new fs13.SyncWriteStream(fd2, { autoClose: false });
+          var fs14 = require("fs");
+          stream3 = new fs14.SyncWriteStream(fd2, { autoClose: false });
           stream3._type = "fs";
           break;
         case "PIPE":
@@ -45814,8 +45814,8 @@ var require_node2 = __commonJS({
           }
           break;
         case "FILE":
-          var fs13 = require("fs");
-          stream3 = new fs13.SyncWriteStream(fd2, { autoClose: false });
+          var fs14 = require("fs");
+          stream3 = new fs14.SyncWriteStream(fd2, { autoClose: false });
           stream3._type = "fs";
           break;
         case "PIPE":
@@ -46431,8 +46431,8 @@ var require_node3 = __commonJS({
           }
           break;
         case "FILE":
-          var fs13 = require("fs");
-          stream3 = new fs13.SyncWriteStream(fd2, { autoClose: false });
+          var fs14 = require("fs");
+          stream3 = new fs14.SyncWriteStream(fd2, { autoClose: false });
           stream3._type = "fs";
           break;
         case "PIPE":
@@ -47298,7 +47298,7 @@ var require_view = __commonJS({
     "use strict";
     var debug = require_src5()("express:view");
     var path24 = require("path");
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var dirname = path24.dirname;
     var basename = path24.basename;
     var extname = path24.extname;
@@ -47364,7 +47364,7 @@ var require_view = __commonJS({
     function tryStat(path25) {
       debug('stat "%s"', path25);
       try {
-        return fs13.statSync(path25);
+        return fs14.statSync(path25);
       } catch (e) {
         return void 0;
       }
@@ -47979,8 +47979,8 @@ var require_node4 = __commonJS({
           }
           break;
         case "FILE":
-          var fs13 = require("fs");
-          stream3 = new fs13.SyncWriteStream(fd2, { autoClose: false });
+          var fs14 = require("fs");
+          stream3 = new fs14.SyncWriteStream(fd2, { autoClose: false });
           stream3._type = "fs";
           break;
         case "PIPE":
@@ -48153,7 +48153,7 @@ var require_types = __commonJS({
 var require_mime = __commonJS({
   "node_modules/mime/mime.js"(exports2, module2) {
     var path24 = require("path");
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     function Mime() {
       this.types = /* @__PURE__ */ Object.create(null);
       this.extensions = /* @__PURE__ */ Object.create(null);
@@ -48174,7 +48174,7 @@ var require_mime = __commonJS({
     };
     Mime.prototype.load = function(file) {
       this._loading = file;
-      var map = {}, content = fs13.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
+      var map = {}, content = fs14.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
       lines.forEach(function(line) {
         var fields = line.replace(/\s*#.*|^\s*|\s*$/g, "").split(/\s+/);
         map[fields.shift()] = fields;
@@ -48412,7 +48412,7 @@ var require_send = __commonJS({
     var escapeHtml3 = require_escape_html();
     var etag = require_etag();
     var fresh = require_fresh();
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var mime = require_mime();
     var ms = require_ms3();
     var onFinished = require_on_finished();
@@ -48746,7 +48746,7 @@ var require_send = __commonJS({
       var i = 0;
       var self2 = this;
       debug('stat "%s"', path25);
-      fs13.stat(path25, function onstat(err, stat) {
+      fs14.stat(path25, function onstat(err, stat) {
         if (err && err.code === "ENOENT" && !extname(path25) && path25[path25.length - 1] !== sep2) {
           return next(err);
         }
@@ -48763,7 +48763,7 @@ var require_send = __commonJS({
         }
         var p = path25 + "." + self2._extensions[i++];
         debug('stat "%s"', p);
-        fs13.stat(p, function(err2, stat) {
+        fs14.stat(p, function(err2, stat) {
           if (err2)
             return next(err2);
           if (stat.isDirectory())
@@ -48784,7 +48784,7 @@ var require_send = __commonJS({
         }
         var p = join(path25, self2._index[i]);
         debug('stat "%s"', p);
-        fs13.stat(p, function(err2, stat) {
+        fs14.stat(p, function(err2, stat) {
           if (err2)
             return next(err2);
           if (stat.isDirectory())
@@ -48798,7 +48798,7 @@ var require_send = __commonJS({
     SendStream.prototype.stream = function stream2(path25, options) {
       var self2 = this;
       var res = this.res;
-      var stream3 = fs13.createReadStream(path25, options);
+      var stream3 = fs14.createReadStream(path25, options);
       this.emit("stream", stream3);
       stream3.pipe(res);
       function cleanup() {
@@ -56685,6 +56685,7 @@ __export(generator_exports, {
   Generator: () => Generator,
   frontMatterFileReader: () => frontMatterFileReader,
   livereloadProcessor: () => livereloadProcessor,
+  manifestProcessor: () => manifestProcessor,
   matomoProcessor: () => matomoProcessor,
   navigationFileReader: () => navigationFileReader,
   searchProcessor: () => searchProcessor,
@@ -56696,7 +56697,7 @@ __export(generator_exports, {
 });
 module.exports = __toCommonJS(generator_exports);
 var import_node_fs6 = require("node:fs");
-var import_promises12 = __toESM(require("node:fs/promises"));
+var import_promises13 = __toESM(require("node:fs/promises"));
 var import_node_path15 = __toESM(require("node:path"));
 var import_fs_extra = __toESM(require_lib());
 
@@ -56824,6 +56825,12 @@ function getOutputFilePath(outputFolder, fileInfo) {
   return normalizePath(outputFolder, path24, outputName);
 }
 
+// src/utils/have-output.ts
+function haveOutput(doc) {
+  const { fileInfo } = doc;
+  return Boolean(fileInfo.outputName);
+}
+
 // src/utils/parse-import.ts
 var import_node_path = __toESM(require("node:path"));
 function parseImport(raw) {
@@ -67183,8 +67190,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs13 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs13);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs14 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs14);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_url.fileURLToPath)(cwd);
     }
@@ -67742,8 +67749,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs13) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs13 });
+  newRoot(fs14) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs14 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -67771,8 +67778,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs13) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs13 });
+  newRoot(fs14) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs14 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -70745,8 +70752,8 @@ var require_worker = __commonJS2({
         }
       });
     });
-    editModule("fs", (fs13) => {
-      fs13.readFileSync = new Proxy(fs13.readFileSync, {
+    editModule("fs", (fs14) => {
+      fs14.readFileSync = new Proxy(fs14.readFileSync, {
         apply(target, thisArg, args) {
           if (usedFiles && requireDepth === 0)
             usedFiles.add(args[0]);
@@ -70864,7 +70871,7 @@ var require_worker = __commonJS2({
 var require_src = __commonJS2({
   "../../node_modules/esbuild-vue/src/index.js"(exports2, module2) {
     var { resolve, relative, dirname } = __require("path");
-    var fs13 = __require("fs");
+    var fs14 = __require("fs");
     var escapeRegExp = require_lodash();
     var EXTRACT_CSS_NAMESPACE = "esbuild-vue-css";
     var EXTRACT_CSS_SUFFIX = "?" + EXTRACT_CSS_NAMESPACE;
@@ -70894,7 +70901,7 @@ var require_src = __commonJS2({
           const cssCode = /* @__PURE__ */ new Map();
           build.onLoad({ filter: /[^/]\.vue$/ }, async ({ path: path24 }) => {
             const filename = relative(process.cwd(), path24);
-            const source = await fs13.promises.readFile(path24, "utf8");
+            const source = await fs14.promises.readFile(path24, "utf8");
             let { code: code2, styles, errors, usedFiles, loader: loader2 } = await runTask({
               filename,
               source,
@@ -71187,7 +71194,7 @@ var require_utils3 = __commonJS3({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AsyncCache = exports2.tryAsync = exports2.getFullPath = exports2.fileExists = exports2.getUrlParams = void 0;
-    var fs13 = __importStar(__require2("fs"));
+    var fs14 = __importStar(__require2("fs"));
     var path24 = __importStar(__require2("path"));
     function getUrlParams(search) {
       var hashes = search.slice(search.indexOf("?") + 1).split("&");
@@ -71205,7 +71212,7 @@ var require_utils3 = __commonJS3({
           switch (_a3.label) {
             case 0:
               _a3.trys.push([0, 2, , 3]);
-              return [4, fs13.promises.stat(path25)];
+              return [4, fs14.promises.stat(path25)];
             case 1:
               stat = _a3.sent();
               return [2, stat.isFile()];
@@ -71419,7 +71426,7 @@ var require_paths = __commonJS3({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.replaceRules = exports2.loadRules = void 0;
     var utils_1 = require_utils3();
-    var fs13 = __importStar(__require2("fs"));
+    var fs14 = __importStar(__require2("fs"));
     var typescript_1 = __require2("typescript");
     var rules = [];
     function loadRules(opts, tsconfigPath) {
@@ -71471,7 +71478,7 @@ var require_paths = __commonJS3({
               }
               _c = typescript_1.parseConfigFileTextToJson;
               _d = [path24];
-              return [4, fs13.promises.readFile(path24)];
+              return [4, fs14.promises.readFile(path24)];
             case 2:
               _b = _c.apply(void 0, _d.concat([_e.sent().toString()])), tsconfig = _b.config, error = _b.error;
               if (error) {
@@ -79228,7 +79235,7 @@ var require_is_data_uri_resource = __commonJS3({
 });
 var require_apply_source_maps = __commonJS3({
   "../../node_modules/clean-css/lib/reader/apply-source-maps.js"(exports2, module2) {
-    var fs13 = __require2("fs");
+    var fs14 = __require2("fs");
     var path24 = __require2("path");
     var isAllowedResource = require_is_allowed_resource();
     var matchDataUri = require_match_data_uri();
@@ -79361,14 +79368,14 @@ var require_apply_source_maps = __commonJS3({
     function loadInputSourceMapFromLocalUri(uri, applyContext) {
       var isAllowed = isAllowedResource(uri, false, applyContext.inline);
       var sourceMap;
-      if (!fs13.existsSync(uri) || !fs13.statSync(uri).isFile()) {
+      if (!fs14.existsSync(uri) || !fs14.statSync(uri).isFile()) {
         applyContext.warnings.push('Ignoring local source map at "' + uri + '" as resource is missing.');
         return null;
       } else if (!isAllowed) {
         applyContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
         return null;
       }
-      sourceMap = fs13.readFileSync(uri, "utf-8");
+      sourceMap = fs14.readFileSync(uri, "utf-8");
       return JSON.parse(sourceMap);
     }
     function applySourceMapRecursively(tokens, inputSourceMapTracker) {
@@ -79458,7 +79465,7 @@ var require_extract_import_url_and_media = __commonJS3({
 });
 var require_load_original_sources = __commonJS3({
   "../../node_modules/clean-css/lib/reader/load-original-sources.js"(exports2, module2) {
-    var fs13 = __require2("fs");
+    var fs14 = __require2("fs");
     var path24 = __require2("path");
     var isAllowedResource = require_is_allowed_resource();
     var hasProtocol = require_has_protocol();
@@ -79549,14 +79556,14 @@ var require_load_original_sources = __commonJS3({
     function loadOriginalSourceFromLocalUri(relativeUri, loadContext) {
       var isAllowed = isAllowedResource(relativeUri, false, loadContext.inline);
       var absoluteUri = path24.resolve(loadContext.rebaseTo, relativeUri);
-      if (!fs13.existsSync(absoluteUri) || !fs13.statSync(absoluteUri).isFile()) {
+      if (!fs14.existsSync(absoluteUri) || !fs14.statSync(absoluteUri).isFile()) {
         loadContext.warnings.push('Ignoring local source map at "' + absoluteUri + '" as resource is missing.');
         return null;
       } else if (!isAllowed) {
         loadContext.warnings.push('Cannot fetch "' + absoluteUri + '" as resource is not allowed.');
         return null;
       }
-      return fs13.readFileSync(absoluteUri, "utf8");
+      return fs14.readFileSync(absoluteUri, "utf8");
     }
     module2.exports = loadOriginalSources;
   }
@@ -80203,7 +80210,7 @@ var require_tokenize = __commonJS3({
 });
 var require_read_sources = __commonJS3({
   "../../node_modules/clean-css/lib/reader/read-sources.js"(exports2, module2) {
-    var fs13 = __require2("fs");
+    var fs14 = __require2("fs");
     var path24 = __require2("path");
     var applySourceMaps = require_apply_source_maps();
     var extractImportUrlAndMedia = require_extract_import_url_and_media();
@@ -80436,7 +80443,7 @@ var require_read_sources = __commonJS3({
       var isLoaded = normalizedPath in inlinerContext.externalContext.sourcesContent;
       if (inlinerContext.inlinedStylesheets.indexOf(absoluteUri) > -1) {
         inlinerContext.warnings.push('Ignoring local @import of "' + uri + '" as it has already been imported.');
-      } else if (!isLoaded && (!fs13.existsSync(absoluteUri) || !fs13.statSync(absoluteUri).isFile())) {
+      } else if (!isLoaded && (!fs14.existsSync(absoluteUri) || !fs14.statSync(absoluteUri).isFile())) {
         inlinerContext.errors.push('Ignoring local @import of "' + uri + '" as resource is missing.');
       } else if (!isAllowed && inlinerContext.afterContent) {
         inlinerContext.warnings.push('Ignoring local @import of "' + uri + '" as resource is not allowed and after other content.');
@@ -80446,7 +80453,7 @@ var require_read_sources = __commonJS3({
         inlinerContext.warnings.push('Skipping local @import of "' + uri + '" as resource is not allowed.');
         inlinerContext.outputTokens = inlinerContext.outputTokens.concat(inlinerContext.sourceTokens.slice(0, 1));
       } else {
-        importedStyles = isLoaded ? inlinerContext.externalContext.sourcesContent[normalizedPath] : fs13.readFileSync(absoluteUri, "utf-8");
+        importedStyles = isLoaded ? inlinerContext.externalContext.sourcesContent[normalizedPath] : fs14.readFileSync(absoluteUri, "utf-8");
         inlinerContext.inlinedStylesheets.push(absoluteUri);
         inlinerContext.inline = inlinerContext.externalContext.options.inline;
         inlinerContext.externalContext.source = normalizedPath;
@@ -83164,7 +83171,7 @@ var require_html = __commonJS3({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.generateIndexHTML = void 0;
-    var fs13 = __importStar(__require2("fs"));
+    var fs14 = __importStar(__require2("fs"));
     var path24 = __importStar(__require2("path"));
     var utils_1 = require_utils3();
     function generateIndexHTML(result, opts, min, inlineStyles) {
@@ -83187,7 +83194,7 @@ var require_html = __commonJS3({
             case 1:
               cheerio = _e.sent();
               _b = (_a3 = cheerio).load;
-              return [4, fs13.promises.readFile(opts.sourceFile)];
+              return [4, fs14.promises.readFile(opts.sourceFile)];
             case 2:
               $2 = _b.apply(_a3, [_e.sent()]);
               if (opts.preload) {
@@ -83240,7 +83247,7 @@ var require_html = __commonJS3({
               html = minify(html, __assign({ collapseWhitespace: true, minifyCSS: true, removeComments: true }, opts.minifyOptions));
               _e.label = 4;
             case 4:
-              return [4, fs13.promises.writeFile(opts.outFile, html)];
+              return [4, fs14.promises.writeFile(opts.outFile, html)];
             case 5:
               _e.sent();
               return [
@@ -83450,7 +83457,7 @@ var require_dist = __commonJS3({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     var path24 = __importStar(__require2("path"));
-    var fs13 = __importStar(__require2("fs"));
+    var fs14 = __importStar(__require2("fs"));
     var crypto4 = __importStar(__require2("crypto"));
     var typescript_1 = __importDefault(__require2("typescript"));
     var sfc = __importStar(__require2("@vue/compiler-sfc"));
@@ -83603,7 +83610,7 @@ var require_dist = __commonJS3({
                           switch (_a22.label) {
                             case 0:
                               encPath = args.path.replace(/\\/g, "\\\\");
-                              return [4, fs13.promises.readFile(args.path, "utf8")];
+                              return [4, fs14.promises.readFile(args.path, "utf8")];
                             case 1:
                               source = _a22.sent();
                               filename = path24.relative(process.cwd(), args.path);
@@ -83764,7 +83771,7 @@ var require_dist = __commonJS3({
                                     function(url) {
                                       var projectRoot = process.env.npm_config_local_prefix || process.cwd();
                                       var modulePath = path24.join(projectRoot, "node_modules", url);
-                                      if (fs13.existsSync(modulePath)) {
+                                      if (fs14.existsSync(modulePath)) {
                                         return { file: modulePath };
                                       }
                                       return null;
@@ -84484,8 +84491,7 @@ function codePreview(options) {
   };
   function fence2(_md, tokens, idx, _options, env) {
     const { fileInfo } = env;
-    const { content: source } = tokens[idx];
-    const { info } = tokens[idx];
+    const { content: source, info, map } = tokens[idx];
     const [language, ...rawTags] = info.split(/\s+/);
     if (language === "mermaid") {
       return (
@@ -84502,6 +84508,8 @@ function codePreview(options) {
       tags: rawTags
     });
     const { tags } = example;
+    const hashContent = `${map == null ? void 0 : map[0]}:${map == null ? void 0 : map[1]}:${info}:${source}`;
+    const fingerprint = getFingerprint(hashContent);
     const highlightedCode = replaceAtLink(highlight(example));
     const testId = findTestId(tags);
     const liveExample = tags.includes("live-example");
@@ -84516,6 +84524,7 @@ function codePreview(options) {
         /* HTML */
         `
                 <div
+                    id="example-${fingerprint}"
                     class="code-preview code-preview--borderless"
                     ${testIdAttr}
                 >
@@ -84528,7 +84537,11 @@ function codePreview(options) {
       return (
         /* HTML */
         `
-                <div class="code-preview ${modifier}" ${testIdAttr}>
+                <div
+                    id="example-${fingerprint}"
+                    class="code-preview ${modifier}"
+                    ${testIdAttr}
+                >
                     ${example.comments.join("\n")}
                     <pre class="code-preview__markup">${highlightedCode}</pre>
                 </div>
@@ -84539,7 +84552,11 @@ function codePreview(options) {
       return (
         /* HTML */
         `
-                <div class="code-preview ${modifier}" ${testIdAttr}>
+                <div
+                    id="example-${fingerprint}"
+                    class="code-preview ${modifier}"
+                    ${testIdAttr}
+                >
                     ${example.comments.join("\n")}
                     <div class="code-preview__preview">${example.markup}</div>
                 </div>
@@ -84572,7 +84589,11 @@ function codePreview(options) {
     return (
       /* HTML */
       `
-            <div class="code-preview ${modifier}" ${testIdAttr}>
+            <div
+                id="example-${fingerprint}"
+                class="code-preview ${modifier}"
+                ${testIdAttr}
+            >
                 ${example.comments.join("\n")}
                 <div class="code-preview__preview">${example.markup}</div>
                 <div>${toggleMarkup} ${toggleFullscreen}</div>
@@ -85117,7 +85138,14 @@ async function render(doc, docs, nav, vendors, options) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`${prefix}: ${message}`, { cause: err });
   }
-  const writeFile = import_promises10.default.writeFile(dst, content ?? "null", "utf-8");
+  const expandedDst = dst.replace(/\[([^]+)\]/g, (match3, key) => {
+    if (key === "hash") {
+      return getFingerprint(doc.body);
+    } else {
+      return match3;
+    }
+  });
+  const writeFile = import_promises10.default.writeFile(expandedDst, content ?? "null", "utf-8");
   try {
     await compileExamples({
       fileInfo,
@@ -85203,6 +85231,46 @@ function nunjucksProcessor(options) {
   };
 }
 
+// src/manifest/manifest-page-from-document.ts
+function flattenOutline(outline) {
+  return outline.flatMap((entry) => {
+    return [
+      { heading: entry.title, anchor: entry.anchor },
+      ...flattenOutline(entry.subheadings)
+    ];
+  });
+}
+function findExamples(doc) {
+  if (doc.format !== "markdown") {
+    return [];
+  }
+  const collected = [];
+  const md2 = lib_default();
+  md2.renderer.rules.fence = (tokens, idx) => {
+    const { content, info, map } = tokens[idx];
+    const [language, ...tags] = info.split(/\s+/);
+    const hashContent = `${map == null ? void 0 : map[0]}:${map == null ? void 0 : map[1]}:${info}:${content}`;
+    const fingerprint = getFingerprint(hashContent);
+    collected.push({
+      selector: `#example-${fingerprint}`,
+      language,
+      tags
+    });
+    return "";
+  };
+  md2.render(doc.body);
+  return collected;
+}
+function manifestPageFromDocument(doc) {
+  const { fileInfo } = doc;
+  return {
+    path: getOutputFilePath("", fileInfo),
+    title: doc.attributes.title ?? doc.name ?? "",
+    outline: flattenOutline(doc.outline),
+    examples: findExamples(doc)
+  };
+}
+
 // src/vendor/vendor-processor.ts
 var import_posix7 = __toESM(require("node:path/posix"));
 
@@ -85470,6 +85538,47 @@ function matomoProcessor(options) {
   };
 }
 
+// src/processors/manifest-processor.ts
+var import_promises12 = __toESM(require("node:fs/promises"));
+function renderMarkdown(manifest) {
+  return [
+    "## Documentation manifest",
+    "",
+    "> Do not edit this file. It is a automatically generated by `@forsakringskassan/docs-generator`.",
+    "",
+    "```",
+    ...manifest.pages.map((it) => it.path),
+    "```",
+    ""
+  ].join("\n");
+}
+function renderJSON(manifest) {
+  return JSON.stringify(manifest, null, 2);
+}
+function manifestProcessor(options) {
+  const { markdown, json } = options;
+  return {
+    name: "manifestProcessor",
+    before: "render",
+    async handler(context) {
+      const docs = context.docs.filter(haveOutput);
+      const pages = docs.map(manifestPageFromDocument);
+      pages.sort((a, b) => {
+        return a.path.localeCompare(b.path);
+      });
+      const manifest = { pages };
+      if (markdown) {
+        const content = renderMarkdown(manifest);
+        await import_promises12.default.writeFile(markdown, content, "utf-8");
+      }
+      if (json) {
+        const content = renderJSON(manifest);
+        await import_promises12.default.writeFile(json, content, "utf-8");
+      }
+    }
+  };
+}
+
 // src/processors/theme-select-processor.ts
 function themeSelectProcessor() {
   return {
@@ -85583,8 +85692,9 @@ function searchProcessor() {
       const body = JSON.stringify(index);
       const fingerprint = getFingerprint(body);
       const integrity = getIntegrity(body);
-      const outputName = `search-data-${fingerprint}.json`;
-      context.setTemplateData("searchDataUrl", outputName);
+      const outputName = `search-data-[hash].json`;
+      const expandedName = `search-data-${fingerprint}.json`;
+      context.setTemplateData("searchDataUrl", expandedName);
       context.setTemplateData("searchDataIntegrity", integrity);
       context.addDocument({
         id: "search:data",
@@ -85648,19 +85758,25 @@ function filterProcessors(stage2, processors) {
   }
   return [...before, ...during, ...after];
 }
-async function stage(stage2, context, processors) {
-  console.log(`stage:${stage2}`);
+async function stage(stage2, context, processors, { verbose } = { verbose: true }) {
+  if (verbose) {
+    console.log(`stage:${stage2}`);
+  }
   let generatedFiles = [];
   const filteredProcessors = filterProcessors(stage2, processors);
   for (let i = 0; i < filteredProcessors.length; i++) {
     const processor = filteredProcessors[i];
     const isLast = i === filteredProcessors.length - 1;
-    console.log(isLast ? "  \u2514\u2500" : "  \u251C\u2500", processor.name);
+    if (verbose) {
+      console.log(isLast ? "  \u2514\u2500" : "  \u251C\u2500", processor.name);
+    }
     try {
       const result = await processor.handler({
         ...context,
         log(...args) {
-          console.log(isLast ? "      " : "  \u2502   ", ...args);
+          if (verbose) {
+            console.log(isLast ? "      " : "  \u2502   ", ...args);
+          }
         }
       });
       if (result) {
@@ -85815,6 +85931,26 @@ var Generator = class {
       to: dst
     });
   }
+  /**
+   * Generate a manifest listing all generated documents that will be present
+   * in `outputFolder`.
+   *
+   * Note: this only collects documents from the `generate-docs` stage,
+   * potential documents generated at later stages will not be present.
+   *
+   * @public
+   */
+  async manifest(sourceFiles) {
+    const processors = [
+      fileReaderProcessor(sourceFiles),
+      ...this.processors
+    ];
+    const context = createContext();
+    await stage("generate-docs", context, processors, { verbose: false });
+    const docs = context.docs.filter(haveOutput);
+    const pages = docs.map(manifestPageFromDocument);
+    return { pages };
+  }
   async build(sourceFiles) {
     this.sourceFiles = sourceFiles;
     const {
@@ -85872,15 +86008,15 @@ var Generator = class {
   }
   async _prepareFolders() {
     const { outputFolder, cacheFolder, assetFolder } = this;
-    await import_promises12.default.rm(cacheFolder, { force: true, recursive: true });
+    await import_promises13.default.rm(cacheFolder, { force: true, recursive: true });
     if ((0, import_node_fs6.existsSync)(outputFolder)) {
-      await import_promises12.default.mkdir(import_node_path15.default.dirname(cacheFolder), { recursive: true });
+      await import_promises13.default.mkdir(import_node_path15.default.dirname(cacheFolder), { recursive: true });
       await import_fs_extra.default.copy(outputFolder, cacheFolder);
-      await import_promises12.default.rm(outputFolder, { recursive: true });
+      await import_promises13.default.rm(outputFolder, { recursive: true });
     }
-    await import_promises12.default.mkdir(outputFolder, { recursive: true });
-    await import_promises12.default.mkdir(assetFolder, { recursive: true });
-    await import_promises12.default.mkdir("temp", { recursive: true });
+    await import_promises13.default.mkdir(outputFolder, { recursive: true });
+    await import_promises13.default.mkdir(assetFolder, { recursive: true });
+    await import_promises13.default.mkdir("temp", { recursive: true });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -85888,6 +86024,7 @@ var Generator = class {
   Generator,
   frontMatterFileReader,
   livereloadProcessor,
+  manifestProcessor,
   matomoProcessor,
   navigationFileReader,
   searchProcessor,