@normed/bundle 4.4.0 → 4.5.0

package/bundles/bin/cli.js

@@ -78,54 +78,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs10) {
+    function patch(fs11) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs10);
-      }
-      if (!fs10.lutimes) {
-        patchLutimes(fs10);
-      }
-      fs10.chown = chownFix(fs10.chown);
-      fs10.fchown = chownFix(fs10.fchown);
-      fs10.lchown = chownFix(fs10.lchown);
-      fs10.chmod = chmodFix(fs10.chmod);
-      fs10.fchmod = chmodFix(fs10.fchmod);
-      fs10.lchmod = chmodFix(fs10.lchmod);
-      fs10.chownSync = chownFixSync(fs10.chownSync);
-      fs10.fchownSync = chownFixSync(fs10.fchownSync);
-      fs10.lchownSync = chownFixSync(fs10.lchownSync);
-      fs10.chmodSync = chmodFixSync(fs10.chmodSync);
-      fs10.fchmodSync = chmodFixSync(fs10.fchmodSync);
-      fs10.lchmodSync = chmodFixSync(fs10.lchmodSync);
-      fs10.stat = statFix(fs10.stat);
-      fs10.fstat = statFix(fs10.fstat);
-      fs10.lstat = statFix(fs10.lstat);
-      fs10.statSync = statFixSync(fs10.statSync);
-      fs10.fstatSync = statFixSync(fs10.fstatSync);
-      fs10.lstatSync = statFixSync(fs10.lstatSync);
-      if (fs10.chmod && !fs10.lchmod) {
-        fs10.lchmod = function(path12, mode, cb) {
+        patchLchmod(fs11);
+      }
+      if (!fs11.lutimes) {
+        patchLutimes(fs11);
+      }
+      fs11.chown = chownFix(fs11.chown);
+      fs11.fchown = chownFix(fs11.fchown);
+      fs11.lchown = chownFix(fs11.lchown);
+      fs11.chmod = chmodFix(fs11.chmod);
+      fs11.fchmod = chmodFix(fs11.fchmod);
+      fs11.lchmod = chmodFix(fs11.lchmod);
+      fs11.chownSync = chownFixSync(fs11.chownSync);
+      fs11.fchownSync = chownFixSync(fs11.fchownSync);
+      fs11.lchownSync = chownFixSync(fs11.lchownSync);
+      fs11.chmodSync = chmodFixSync(fs11.chmodSync);
+      fs11.fchmodSync = chmodFixSync(fs11.fchmodSync);
+      fs11.lchmodSync = chmodFixSync(fs11.lchmodSync);
+      fs11.stat = statFix(fs11.stat);
+      fs11.fstat = statFix(fs11.fstat);
+      fs11.lstat = statFix(fs11.lstat);
+      fs11.statSync = statFixSync(fs11.statSync);
+      fs11.fstatSync = statFixSync(fs11.fstatSync);
+      fs11.lstatSync = statFixSync(fs11.lstatSync);
+      if (fs11.chmod && !fs11.lchmod) {
+        fs11.lchmod = function(path12, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs10.lchmodSync = function() {
+        fs11.lchmodSync = function() {
         };
       }
-      if (fs10.chown && !fs10.lchown) {
-        fs10.lchown = function(path12, uid, gid, cb) {
+      if (fs11.chown && !fs11.lchown) {
+        fs11.lchown = function(path12, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs10.lchownSync = function() {
+        fs11.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs10.rename = typeof fs10.rename !== "function" ? fs10.rename : function(fs$rename) {
+        fs11.rename = typeof fs11.rename !== "function" ? fs11.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() {
-                  fs10.stat(to, function(stater, st) {
+                  fs11.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -141,9 +141,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs10.rename);
+        }(fs11.rename);
       }
-      fs10.read = typeof fs10.read !== "function" ? fs10.read : function(fs$read) {
+      fs11.read = typeof fs11.read !== "function" ? fs11.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -151,22 +151,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs11, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs10.read);
-      fs10.readSync = typeof fs10.readSync !== "function" ? fs10.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs11.read);
+      fs11.readSync = typeof fs11.readSync !== "function" ? fs11.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs10, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs11, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -176,10 +176,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs10.readSync);
-      function patchLchmod(fs11) {
-        fs11.lchmod = function(path12, mode, callback) {
-          fs11.open(
+      }(fs11.readSync);
+      function patchLchmod(fs12) {
+        fs12.lchmod = function(path12, mode, callback) {
+          fs12.open(
             path12,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -188,80 +188,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs11.fchmod(fd, mode, function(err2) {
-                fs11.close(fd, function(err22) {
+              fs12.fchmod(fd, mode, function(err2) {
+                fs12.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs11.lchmodSync = function(path12, mode) {
-          var fd = fs11.openSync(path12, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs12.lchmodSync = function(path12, mode) {
+          var fd = fs12.openSync(path12, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs11.fchmodSync(fd, mode);
+            ret = fs12.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs11.closeSync(fd);
+                fs12.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs11.closeSync(fd);
+              fs12.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs11) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
-          fs11.lutimes = function(path12, at, mt, cb) {
-            fs11.open(path12, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs12) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs12.futimes) {
+          fs12.lutimes = function(path12, at, mt, cb) {
+            fs12.open(path12, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs11.futimes(fd, at, mt, function(er2) {
-                fs11.close(fd, function(er22) {
+              fs12.futimes(fd, at, mt, function(er2) {
+                fs12.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs11.lutimesSync = function(path12, at, mt) {
-            var fd = fs11.openSync(path12, constants.O_SYMLINK);
+          fs12.lutimesSync = function(path12, at, mt) {
+            var fd = fs12.openSync(path12, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs11.futimesSync(fd, at, mt);
+              ret = fs12.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs11.closeSync(fd);
+                  fs12.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs11.closeSync(fd);
+                fs12.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs11.futimes) {
-          fs11.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs12.futimes) {
+          fs12.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs11.lutimesSync = function() {
+          fs12.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs10, target, mode, function(er) {
+          return orig.call(fs11, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -271,7 +271,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs10, target, mode);
+            return orig.call(fs11, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -280,7 +280,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs10, target, uid, gid, function(er) {
+          return orig.call(fs11, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -290,7 +290,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs10, target, uid, gid);
+            return orig.call(fs11, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -310,13 +310,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options2 ? orig.call(fs10, target, options2, callback) : orig.call(fs10, target, callback);
+          return options2 ? orig.call(fs11, target, options2, callback) : orig.call(fs11, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options2) {
-          var stats = options2 ? orig.call(fs10, target, options2) : orig.call(fs10, target);
+          var stats = options2 ? orig.call(fs11, target, options2) : orig.call(fs11, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -345,7 +345,7 @@ var require_legacy_streams = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-bf152d0ed1.zip/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs10) {
+    function legacy(fs11) {
       return {
         ReadStream,
         WriteStream
@@ -388,7 +388,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs10.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs11.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -427,7 +427,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs10.open;
+          this._open = fs11.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -462,7 +462,7 @@ var require_clone = __commonJS({
 // pnp:/builds/normed/bundle/.yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-bf152d0ed1.zip/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-bf152d0ed1.zip/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -494,12 +494,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs10[gracefulQueue]) {
+    if (!fs11[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs10, queue);
-      fs10.close = function(fs$close) {
+      publishQueue(fs11, queue);
+      fs11.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs10, fd, function(err) {
+          return fs$close.call(fs11, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -511,40 +511,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs10.close);
-      fs10.closeSync = function(fs$closeSync) {
+      }(fs11.close);
+      fs11.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs10, arguments);
+          fs$closeSync.apply(fs11, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs10.closeSync);
+      }(fs11.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs10[gracefulQueue]);
-          require("assert").equal(fs10[gracefulQueue].length, 0);
+          debug(fs11[gracefulQueue]);
+          require("assert").equal(fs11[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs10[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs10));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs10.__patched) {
-      module2.exports = patch(fs10);
-      fs10.__patched = true;
-    }
-    function patch(fs11) {
-      polyfills(fs11);
-      fs11.gracefulify = patch;
-      fs11.createReadStream = createReadStream;
-      fs11.createWriteStream = createWriteStream;
-      var fs$readFile = fs11.readFile;
-      fs11.readFile = readFile;
+      publishQueue(global, fs11[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs11));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs11.__patched) {
+      module2.exports = patch(fs11);
+      fs11.__patched = true;
+    }
+    function patch(fs12) {
+      polyfills(fs12);
+      fs12.gracefulify = patch;
+      fs12.createReadStream = createReadStream;
+      fs12.createWriteStream = createWriteStream;
+      var fs$readFile = fs12.readFile;
+      fs12.readFile = readFile;
       function readFile(path12, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
@@ -560,8 +560,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs11.writeFile;
-      fs11.writeFile = writeFile;
+      var fs$writeFile = fs12.writeFile;
+      fs12.writeFile = writeFile;
       function writeFile(path12, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
@@ -577,9 +577,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs11.appendFile;
+      var fs$appendFile = fs12.appendFile;
       if (fs$appendFile)
-        fs11.appendFile = appendFile;
+        fs12.appendFile = appendFile;
       function appendFile(path12, data, options2, cb) {
         if (typeof options2 === "function")
           cb = options2, options2 = null;
@@ -595,9 +595,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs11.copyFile;
+      var fs$copyFile = fs12.copyFile;
       if (fs$copyFile)
-        fs11.copyFile = copyFile;
+        fs12.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -615,8 +615,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs11.readdir;
-      fs11.readdir = readdir;
+      var fs$readdir = fs12.readdir;
+      fs12.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path12, options2, cb) {
         if (typeof options2 === "function")
@@ -657,21 +657,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs11);
+        var legStreams = legacy(fs12);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs11.ReadStream;
+      var fs$ReadStream = fs12.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs11.WriteStream;
+      var fs$WriteStream = fs12.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs11, "ReadStream", {
+      Object.defineProperty(fs12, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -681,7 +681,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs11, "WriteStream", {
+      Object.defineProperty(fs12, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -692,7 +692,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs11, "FileReadStream", {
+      Object.defineProperty(fs12, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -703,7 +703,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs11, "FileWriteStream", {
+      Object.defineProperty(fs12, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -752,13 +752,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path12, options2) {
-        return new fs11.ReadStream(path12, options2);
+        return new fs12.ReadStream(path12, options2);
       }
       function createWriteStream(path12, options2) {
-        return new fs11.WriteStream(path12, options2);
+        return new fs12.WriteStream(path12, options2);
       }
-      var fs$open = fs11.open;
-      fs11.open = open;
+      var fs$open = fs12.open;
+      fs12.open = open;
       function open(path12, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -774,20 +774,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs11;
+      return fs12;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs10[gracefulQueue].push(elem);
+      fs11[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs10[gracefulQueue].length; ++i) {
-        if (fs10[gracefulQueue][i].length > 2) {
-          fs10[gracefulQueue][i][3] = now;
-          fs10[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs11[gracefulQueue].length; ++i) {
+        if (fs11[gracefulQueue][i].length > 2) {
+          fs11[gracefulQueue][i][3] = now;
+          fs11[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -795,9 +795,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs10[gracefulQueue].length === 0)
+      if (fs11[gracefulQueue].length === 0)
         return;
-      var elem = fs10[gracefulQueue].shift();
+      var elem = fs11[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -819,7 +819,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime2]));
         } else {
-          fs10[gracefulQueue].push(elem);
+          fs11[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -834,7 +834,7 @@ var require_fs = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs10 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -875,26 +875,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs10[key] === "function";
+      return typeof fs11[key] === "function";
     });
-    Object.assign(exports2, fs10);
+    Object.assign(exports2, fs11);
     api.forEach((method) => {
-      exports2[method] = u(fs10[method]);
+      exports2[method] = u(fs11[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs10.exists(filename, callback);
+        return fs11.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs10.exists(filename, resolve);
+        return fs11.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs10.read(fd, buffer, offset, length, position, callback);
+        return fs11.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs10.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs11.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -902,10 +902,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs10.write(fd, buffer, ...args);
+        return fs11.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs10.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs11.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -913,10 +913,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs10.readv(fd, buffers, ...args);
+        return fs11.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs10.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs11.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -924,17 +924,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs10.writev(fd, buffers, ...args);
+        return fs11.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs10.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs11.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs10.realpath.native === "function") {
-      exports2.realpath.native = u(fs10.realpath.native);
+    if (typeof fs11.realpath.native === "function") {
+      exports2.realpath.native = u(fs11.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -967,7 +967,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options2) => {
       const defaults = { mode: 511 };
@@ -976,14 +976,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options2) => {
       checkPath(dir);
-      return fs10.mkdir(dir, {
+      return fs11.mkdir(dir, {
         mode: getMode(options2),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options2) => {
       checkPath(dir);
-      return fs10.mkdirSync(dir, {
+      return fs11.mkdirSync(dir, {
         mode: getMode(options2),
         recursive: true
       });
@@ -1015,13 +1015,13 @@ var require_path_exists = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     function pathExists(path12) {
-      return fs10.access(path12).then(() => true).catch(() => false);
+      return fs11.access(path12).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs10.existsSync
+      pathExistsSync: fs11.existsSync
     };
   }
 });
@@ -1030,16 +1030,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path12, atime, mtime) {
-      const fd = await fs10.open(path12, "r+");
+      const fd = await fs11.open(path12, "r+");
       let closeErr = null;
       try {
-        await fs10.futimes(fd, atime, mtime);
+        await fs11.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs10.close(fd);
+          await fs11.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -1049,9 +1049,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path12, atime, mtime) {
-      const fd = fs10.openSync(path12, "r+");
-      fs10.futimesSync(fd, atime, mtime);
-      return fs10.closeSync(fd);
+      const fd = fs11.openSync(path12, "r+");
+      fs11.futimesSync(fd, atime, mtime);
+      return fs11.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -1064,11 +1064,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var path12 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs10.stat(file, { bigint: true }) : (file) => fs10.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.stat(file, { bigint: true }) : (file) => fs11.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -1079,7 +1079,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs10.statSync(file, { bigint: true }) : (file) => fs10.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs11.statSync(file, { bigint: true }) : (file) => fs11.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -1141,7 +1141,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path12.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs10.stat(destParent, { bigint: true });
+        destStat = await fs11.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1157,7 +1157,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path12.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs10.statSync(destParent, { bigint: true });
+        destStat = fs11.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1196,7 +1196,7 @@ var require_stat = __commonJS({
 var require_copy = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var path12 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -1231,7 +1231,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs10.stat : fs10.lstat;
+      const statFn = opts.dereference ? fs11.stat : fs11.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1243,7 +1243,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs10.unlink(dest);
+        await fs11.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -1251,28 +1251,28 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs10.copyFile(src, dest);
+      await fs11.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs10.stat(src);
+        const updatedSrcStat = await fs11.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs10.chmod(dest, srcStat.mode);
+      return fs11.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs10.chmod(dest, srcMode | 128);
+      return fs11.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs10.mkdir(dest);
+        await fs11.mkdir(dest);
       }
       const promises = [];
-      for await (const item of await fs10.opendir(src)) {
+      for await (const item of await fs11.opendir(src)) {
         const srcItem = path12.join(src, item.name);
         const destItem = path12.join(dest, item.name);
         promises.push(
@@ -1287,22 +1287,22 @@ var require_copy = __commonJS({
       }
       await Promise.all(promises);
       if (!destStat) {
-        await fs10.chmod(dest, srcStat.mode);
+        await fs11.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs10.readlink(src);
+      let resolvedSrc = await fs11.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path12.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs10.symlink(resolvedSrc, dest);
+        return fs11.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs10.readlink(dest);
+        resolvedDest = await fs11.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs10.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs11.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -1314,8 +1314,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs10.unlink(dest);
-      return fs10.symlink(resolvedSrc, dest);
+      await fs11.unlink(dest);
+      return fs11.symlink(resolvedSrc, dest);
     }
     module2.exports = copy2;
   }
@@ -1325,7 +1325,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path12 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -1348,11 +1348,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path12.dirname(dest);
-      if (!fs10.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs11.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs10.statSync : fs10.lstatSync;
+      const statSync = opts.dereference ? fs11.statSync : fs11.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1367,14 +1367,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs10.unlinkSync(dest);
+        fs11.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs10.copyFileSync(src, dest);
+      fs11.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -1389,10 +1389,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs10.chmodSync(dest, srcMode);
+      return fs11.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs10.statSync(src);
+      const updatedSrcStat = fs11.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -1400,12 +1400,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs10.mkdirSync(dest);
+      fs11.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs10.opendirSync(src);
+      const dir = fs11.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -1423,18 +1423,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs10.readlinkSync(src);
+      let resolvedSrc = fs11.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path12.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs10.symlinkSync(resolvedSrc, dest);
+        return fs11.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs10.readlinkSync(dest);
+          resolvedDest = fs11.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs10.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs11.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -1450,8 +1450,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs10.unlinkSync(dest);
-      return fs10.symlinkSync(resolvedSrc, dest);
+      fs11.unlinkSync(dest);
+      return fs11.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -1473,13 +1473,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove(path12, callback) {
-      fs10.rm(path12, { recursive: true, force: true }, callback);
+      fs11.rm(path12, { recursive: true, force: true }, callback);
     }
     function removeSync(path12) {
-      fs10.rmSync(path12, { recursive: true, force: true });
+      fs11.rmSync(path12, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -1493,14 +1493,14 @@ var require_empty = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var path12 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs10.readdir(dir);
+        items = await fs11.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -1509,7 +1509,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs10.readdirSync(dir);
+        items = fs11.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -1533,51 +1533,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path12 = require("path");
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs10.stat(file);
+        stats = await fs11.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path12.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs10.stat(dir);
+        dirStats = await fs11.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs10.writeFile(file, "");
+          await fs11.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs10.writeFile(file, "");
+        await fs11.writeFile(file, "");
       } else {
-        await fs10.readdir(dir);
+        await fs11.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs10.statSync(file);
+        stats = fs11.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path12.dirname(file);
       try {
-        if (!fs10.statSync(dir).isDirectory()) {
-          fs10.readdirSync(dir);
+        if (!fs11.statSync(dir).isDirectory()) {
+          fs11.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs10.writeFileSync(file, "");
+      fs11.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -1592,19 +1592,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path12 = require("path");
-    var fs10 = require_fs();
+    var fs11 = 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 fs10.lstat(dstpath);
+        dstStat = await fs11.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs10.lstat(srcpath);
+        srcStat = await fs11.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -1615,26 +1615,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs10.link(srcpath, dstpath);
+      await fs11.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs10.lstatSync(dstpath);
+        dstStat = fs11.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs10.lstatSync(srcpath);
+        const srcStat = fs11.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path12.dirname(dstpath);
-      const dirExists = fs10.existsSync(dir);
-      if (dirExists) return fs10.linkSync(srcpath, dstpath);
+      const dirExists = fs11.existsSync(dir);
+      if (dirExists) return fs11.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs10.linkSync(srcpath, dstpath);
+      return fs11.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -1648,13 +1648,13 @@ var require_symlink_paths = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path12 = require("path");
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path12.isAbsolute(srcpath)) {
         try {
-          await fs10.lstat(srcpath);
+          await fs11.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -1674,7 +1674,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs10.lstat(srcpath);
+        await fs11.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -1686,7 +1686,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path12.isAbsolute(srcpath)) {
-        const exists2 = fs10.existsSync(srcpath);
+        const exists2 = fs11.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -1695,14 +1695,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path12.dirname(dstpath);
       const relativeToDst = path12.join(dstdir, srcpath);
-      const exists = fs10.existsSync(relativeToDst);
+      const exists = fs11.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs10.existsSync(srcpath);
+      const srcExists = fs11.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -1720,13 +1720,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs10.lstat(srcpath);
+        stats = await fs11.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -1736,7 +1736,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs10.lstatSync(srcpath);
+        stats = fs11.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -1755,7 +1755,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path12 = require("path");
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -1764,13 +1764,13 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs10.lstat(dstpath);
+        stats = await fs11.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs10.stat(srcpath),
-          fs10.stat(dstpath)
+          fs11.stat(srcpath),
+          fs11.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
@@ -1781,27 +1781,27 @@ var require_symlink = __commonJS({
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs10.symlink(srcpath, dstpath, toType);
+      return fs11.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs10.lstatSync(dstpath);
+        stats = fs11.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs10.statSync(srcpath);
-        const dstStat = fs10.statSync(dstpath);
+        const srcStat = fs11.statSync(srcpath);
+        const dstStat = fs11.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path12.dirname(dstpath);
-      const exists = fs10.existsSync(dir);
-      if (exists) return fs10.symlinkSync(srcpath, dstpath, type);
+      const exists = fs11.existsSync(dir);
+      if (exists) return fs11.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs10.symlinkSync(srcpath, dstpath, type);
+      return fs11.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -1868,9 +1868,9 @@ var require_jsonfile = __commonJS({
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
       }
-      const fs10 = options2.fs || _fs;
+      const fs11 = options2.fs || _fs;
       const shouldThrow = "throws" in options2 ? options2.throws : true;
-      let data = await universalify.fromCallback(fs10.readFile)(file, options2);
+      let data = await universalify.fromCallback(fs11.readFile)(file, options2);
       data = stripBom(data);
       let obj;
       try {
@@ -1890,10 +1890,10 @@ var require_jsonfile = __commonJS({
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
       }
-      const fs10 = options2.fs || _fs;
+      const fs11 = options2.fs || _fs;
       const shouldThrow = "throws" in options2 ? options2.throws : true;
       try {
-        let content = fs10.readFileSync(file, options2);
+        let content = fs11.readFileSync(file, options2);
         content = stripBom(content);
         return JSON.parse(content, options2.reviver);
       } catch (err) {
@@ -1906,15 +1906,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options2 = {}) {
-      const fs10 = options2.fs || _fs;
+      const fs11 = options2.fs || _fs;
       const str = stringify2(obj, options2);
-      await universalify.fromCallback(fs10.writeFile)(file, str, options2);
+      await universalify.fromCallback(fs11.writeFile)(file, str, options2);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options2 = {}) {
-      const fs10 = options2.fs || _fs;
+      const fs11 = options2.fs || _fs;
       const str = stringify2(obj, options2);
-      return fs10.writeFileSync(file, str, options2);
+      return fs11.writeFileSync(file, str, options2);
     }
     var jsonfile = {
       readFile,
@@ -1946,7 +1946,7 @@ var require_output_file = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var path12 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
@@ -1955,14 +1955,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs10.writeFile(file, data, encoding);
+      return fs11.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path12.dirname(file);
-      if (!fs10.existsSync(dir)) {
+      if (!fs11.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs10.writeFileSync(file, ...args);
+      fs11.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -2021,7 +2021,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_fs();
+    var fs11 = require_fs();
     var path12 = require("path");
     var { copy: copy2 } = require_copy2();
     var { remove } = require_remove();
@@ -2048,7 +2048,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs10.rename(src, dest);
+        await fs11.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -2073,7 +2073,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/fs-extra-npm-11.3.0-a6b1b4d5ad-c9fe7b23dd.zip/node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs10 = require_graceful_fs();
+    var fs11 = require_graceful_fs();
     var path12 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -2098,12 +2098,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs10.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs11.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs10.renameSync(src, dest);
+        fs11.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -6701,7 +6701,7 @@ var require_types = __commonJS({
 var require_mime = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/mime-npm-1.6.0-60ae95038a-b7d98bb1e0.zip/node_modules/mime/mime.js"(exports2, module2) {
     var path12 = require("path");
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     function Mime() {
       this.types = /* @__PURE__ */ Object.create(null);
       this.extensions = /* @__PURE__ */ Object.create(null);
@@ -6722,7 +6722,7 @@ var require_mime = __commonJS({
     };
     Mime.prototype.load = function(file) {
       this._loading = file;
-      var map = {}, content = fs10.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
+      var map = {}, content = fs11.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;
@@ -8526,13 +8526,13 @@ var require_fs2 = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/less-npm-4.3.0-29a3ad37f8-893d058939.zip/node_modules/less/lib/less-node/fs.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs10;
+    var fs11;
     try {
-      fs10 = require_graceful_fs();
+      fs11 = require_graceful_fs();
     } catch (e) {
-      fs10 = require("fs");
+      fs11 = require("fs");
     }
-    exports2.default = fs10;
+    exports2.default = fs11;
   }
 });
 
@@ -14332,7 +14332,7 @@ var require_decoder = __commonJS({
 // pnp:/builds/normed/bundle/.yarn/cache/needle-npm-3.3.1-069ce952ef-31925ec72b.zip/node_modules/needle/lib/utils.js
 var require_utils3 = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/needle-npm-3.3.1-069ce952ef-31925ec72b.zip/node_modules/needle/lib/utils.js"(exports2, module2) {
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var url = require("url");
     var stream = require("stream");
     function resolve_url(href, base) {
@@ -14383,7 +14383,7 @@ var require_utils3 = __commonJS({
         return cb(given_length);
       if (stream2.end !== void 0 && stream2.end !== Infinity && stream2.start !== void 0)
         return cb(stream2.end + 1 - (stream2.start || 0));
-      fs10.stat(stream2.path, function(err, stat) {
+      fs11.stat(stream2.path, function(err, stat) {
         cb(stat ? stat.size - (stream2.start || 0) : null);
       });
     }
@@ -14491,7 +14491,7 @@ var require_package = __commonJS({
 // pnp:/builds/normed/bundle/.yarn/cache/needle-npm-3.3.1-069ce952ef-31925ec72b.zip/node_modules/needle/lib/needle.js
 var require_needle = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/needle-npm-3.3.1-069ce952ef-31925ec72b.zip/node_modules/needle/lib/needle.js"(exports2, module2) {
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var http = require("http");
     var https = require("https");
     var url = require("url");
@@ -14891,7 +14891,7 @@ var require_needle = __commonJS({
           if (err && err.message == "write after end") request.destroy();
         });
         if (config.output && resp.statusCode == 200) {
-          var file = fs10.createWriteStream(config.output);
+          var file = fs11.createWriteStream(config.output);
           file.on("error", had_error);
           out.on("end", function() {
             if (file.writable) file.end();
@@ -22663,13 +22663,13 @@ var require_url = __commonJS({
         return "\\".concat(match);
       });
     }
-    var URL = function(val, index, currentFileInfo, isEvald) {
+    var URL2 = function(val, index, currentFileInfo, isEvald) {
       this.value = val;
       this._index = index;
       this._fileInfo = currentFileInfo;
       this.isEvald = isEvald;
     };
-    URL.prototype = Object.assign(new node_1.default(), {
+    URL2.prototype = Object.assign(new node_1.default(), {
       type: "Url",
       accept: function(visitor) {
         this.value = visitor.visit(this.value);
@@ -22704,10 +22704,10 @@ var require_url = __commonJS({
             }
           }
         }
-        return new URL(val, this.getIndex(), this.fileInfo(), true);
+        return new URL2(val, this.getIndex(), this.fileInfo(), true);
       }
     });
-    exports2.default = URL;
+    exports2.default = URL2;
   }
 });
 
@@ -26744,7 +26744,7 @@ var require_readUInt = __commonJS({
 var require_tiff = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/image-size-patch-bc5785d808-6fbf67bc78.zip/node_modules/image-size/lib/types/tiff.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var readUInt = require_readUInt();
     function isTIFF(buffer) {
       var hex4 = buffer.toString("hex", 0, 4);
@@ -26753,13 +26753,13 @@ var require_tiff = __commonJS({
     function readIFD(buffer, filepath, isBigEndian) {
       var ifdOffset = readUInt(buffer, 32, 4, isBigEndian);
       var bufferSize = 1024;
-      var fileSize = fs10.statSync(filepath).size;
+      var fileSize = fs11.statSync(filepath).size;
       if (ifdOffset + bufferSize > fileSize) {
         bufferSize = fileSize - ifdOffset - 10;
       }
       var endBuffer = new Buffer(bufferSize);
-      var descriptor = fs10.openSync(filepath, "r");
-      fs10.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
+      var descriptor = fs11.openSync(filepath, "r");
+      fs11.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
       var ifdBuffer = endBuffer.slice(2);
       return ifdBuffer;
     }
@@ -26930,7 +26930,7 @@ var require_detector = __commonJS({
 var require_lib4 = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/image-size-patch-bc5785d808-6fbf67bc78.zip/node_modules/image-size/lib/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var path12 = require("path");
     var detector = require_detector();
     var handlers = {};
@@ -26956,33 +26956,33 @@ var require_lib4 = __commonJS({
       throw new TypeError("unsupported file type: " + type + " (file: " + filepath + ")");
     }
     function asyncFileToBuffer(filepath, callback) {
-      fs10.open(filepath, "r", function(err, descriptor) {
+      fs11.open(filepath, "r", function(err, descriptor) {
         if (err) {
           return callback(err);
         }
-        var size = fs10.fstatSync(descriptor).size;
+        var size = fs11.fstatSync(descriptor).size;
         if (size <= 0) {
           return callback(new Error("File size is not greater than 0 \u2014\u2014 " + filepath));
         }
         var bufferSize = Math.min(size, MaxBufferSize);
         var buffer = new Buffer(bufferSize);
-        fs10.read(descriptor, buffer, 0, bufferSize, 0, function(err2) {
+        fs11.read(descriptor, buffer, 0, bufferSize, 0, function(err2) {
           if (err2) {
             return callback(err2);
           }
-          fs10.close(descriptor, function(err3) {
+          fs11.close(descriptor, function(err3) {
             callback(err3, buffer);
           });
         });
       });
     }
     function syncFileToBuffer(filepath) {
-      var descriptor = fs10.openSync(filepath, "r");
-      var size = fs10.fstatSync(descriptor).size;
+      var descriptor = fs11.openSync(filepath, "r");
+      var size = fs11.fstatSync(descriptor).size;
       var bufferSize = Math.min(size, MaxBufferSize);
       var buffer = new Buffer(bufferSize);
-      fs10.readSync(descriptor, buffer, 0, bufferSize, 0);
-      fs10.closeSync(descriptor);
+      fs11.readSync(descriptor, buffer, 0, bufferSize, 0);
+      fs11.closeSync(descriptor);
       return buffer;
     }
     module2.exports = function(input, callback) {
@@ -35138,7 +35138,7 @@ var require_pug_walk = __commonJS({
 var require_pug_load = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/pug-load-npm-3.0.0-dc9f2273d3-1800ec5199.zip/node_modules/pug-load/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var path12 = require("path");
     var walk = require_pug_walk();
     var assign = require_object_assign();
@@ -35209,7 +35209,7 @@ var require_pug_load = __commonJS({
       return filename;
     };
     load.read = function read(filename, options2) {
-      return fs10.readFileSync(filename);
+      return fs11.readFileSync(filename);
     };
     load.validateOptions = function validateOptions(options2) {
       if (typeof options2 !== "object") {
@@ -35855,7 +35855,7 @@ var require_is_promise = __commonJS({
 var require_jstransformer = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/jstransformer-npm-1.0.0-41a47d180a-7bca6e2e2f.zip/node_modules/jstransformer/index.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var assert = require("assert");
     var Promise2 = require_promise();
     var isPromise = require_is_promise();
@@ -35867,9 +35867,9 @@ var require_jstransformer = __commonJS({
     tr.normalizeFnAsync = normalizeFnAsync;
     tr.normalize = normalize;
     tr.normalizeAsync = normalizeAsync;
-    if (fs10.readFile) {
-      tr.readFile = Promise2.denodeify(fs10.readFile);
-      tr.readFileSync = fs10.readFileSync;
+    if (fs11.readFile) {
+      tr.readFile = Promise2.denodeify(fs11.readFile);
+      tr.readFileSync = fs11.readFileSync;
     } else {
       tr.readFile = function() {
         throw new Error("fs.readFile unsupported");
@@ -36663,14 +36663,14 @@ var require_is_core_module = __commonJS({
 // pnp:/builds/normed/bundle/.yarn/cache/resolve-patch-4254c24959-f345cd37f5.zip/node_modules/resolve/lib/async.js
 var require_async = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/resolve-patch-4254c24959-f345cd37f5.zip/node_modules/resolve/lib/async.js"(exports2, module2) {
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var getHomedir = require_homedir();
     var path12 = require("path");
     var caller = require_caller();
     var nodeModulesPaths = require_node_modules_paths();
     var normalizeOptions = require_normalize_options();
     var isCore = require_is_core_module();
-    var realpathFS = process.platform !== "win32" && fs10.realpath && typeof fs10.realpath.native === "function" ? fs10.realpath.native : fs10.realpath;
+    var realpathFS = process.platform !== "win32" && fs11.realpath && typeof fs11.realpath.native === "function" ? fs11.realpath.native : fs11.realpath;
     var homedir = getHomedir();
     var defaultPaths = function() {
       return [
@@ -36679,7 +36679,7 @@ var require_async = __commonJS({
       ];
     };
     var defaultIsFile = function isFile(file, cb) {
-      fs10.stat(file, function(err, stat) {
+      fs11.stat(file, function(err, stat) {
         if (!err) {
           return cb(null, stat.isFile() || stat.isFIFO());
         }
@@ -36688,7 +36688,7 @@ var require_async = __commonJS({
       });
     };
     var defaultIsDir = function isDirectory(dir, cb) {
-      fs10.stat(dir, function(err, stat) {
+      fs11.stat(dir, function(err, stat) {
         if (!err) {
           return cb(null, stat.isDirectory());
         }
@@ -36745,7 +36745,7 @@ var require_async = __commonJS({
       opts = normalizeOptions(x, opts);
       var isFile = opts.isFile || defaultIsFile;
       var isDirectory = opts.isDirectory || defaultIsDir;
-      var readFile = opts.readFile || fs10.readFile;
+      var readFile = opts.readFile || fs11.readFile;
       var realpath = opts.realpath || defaultRealpath;
       var readPackage = opts.readPackage || defaultReadPackage;
       if (opts.readFile && opts.readPackage) {
@@ -37150,13 +37150,13 @@ var require_is_core = __commonJS({
 var require_sync = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/resolve-patch-4254c24959-f345cd37f5.zip/node_modules/resolve/lib/sync.js"(exports2, module2) {
     var isCore = require_is_core_module();
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var path12 = require("path");
     var getHomedir = require_homedir();
     var caller = require_caller();
     var nodeModulesPaths = require_node_modules_paths();
     var normalizeOptions = require_normalize_options();
-    var realpathFS = process.platform !== "win32" && fs10.realpathSync && typeof fs10.realpathSync.native === "function" ? fs10.realpathSync.native : fs10.realpathSync;
+    var realpathFS = process.platform !== "win32" && fs11.realpathSync && typeof fs11.realpathSync.native === "function" ? fs11.realpathSync.native : fs11.realpathSync;
     var homedir = getHomedir();
     var defaultPaths = function() {
       return [
@@ -37166,7 +37166,7 @@ var require_sync = __commonJS({
     };
     var defaultIsFile = function isFile(file) {
       try {
-        var stat = fs10.statSync(file, { throwIfNoEntry: false });
+        var stat = fs11.statSync(file, { throwIfNoEntry: false });
       } catch (e) {
         if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
         throw e;
@@ -37175,7 +37175,7 @@ var require_sync = __commonJS({
     };
     var defaultIsDir = function isDirectory(dir) {
       try {
-        var stat = fs10.statSync(dir, { throwIfNoEntry: false });
+        var stat = fs11.statSync(dir, { throwIfNoEntry: false });
       } catch (e) {
         if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
         throw e;
@@ -37219,7 +37219,7 @@ var require_sync = __commonJS({
       }
       var opts = normalizeOptions(x, options2);
       var isFile = opts.isFile || defaultIsFile;
-      var readFileSync = opts.readFileSync || fs10.readFileSync;
+      var readFileSync = opts.readFileSync || fs11.readFileSync;
       var isDirectory = opts.isDirectory || defaultIsDir;
       var realpathSync = opts.realpathSync || defaultRealpathSync;
       var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
@@ -66317,7 +66317,7 @@ var require_sources = __commonJS({
 var require_build = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/pug-runtime-npm-3.0.1-13038c62ae-d34ee1b951.zip/node_modules/pug-runtime/build.js"(exports2, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var dependencies = require_dependencies();
     var internals = require_internals();
     var sources = require_sources();
@@ -68083,7 +68083,7 @@ var require_wrap = __commonJS({
 var require_lib14 = __commonJS({
   "pnp:/builds/normed/bundle/.yarn/cache/pug-npm-3.0.3-9b210cb01a-a883647575.zip/node_modules/pug/lib/index.js"(exports2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var path12 = require("path");
     var lex = require_pug_lexer();
     var stripComments = require_pug_strip_comments();
@@ -68245,7 +68245,7 @@ var require_lib14 = __commonJS({
       if (options2.cache && exports2.cache[key]) {
         return exports2.cache[key];
       } else {
-        if (str === void 0) str = fs10.readFileSync(options2.filename, "utf8");
+        if (str === void 0) str = fs11.readFileSync(options2.filename, "utf8");
         var templ = exports2.compile(str, options2);
         if (options2.cache) exports2.cache[key] = templ;
         return templ;
@@ -68355,7 +68355,7 @@ var require_lib14 = __commonJS({
       if (options2.cache && exports2.cache[key]) {
         return exports2.cache[key];
       }
-      var str = fs10.readFileSync(options2.filename, "utf8");
+      var str = fs11.readFileSync(options2.filename, "utf8");
       var out = exports2.compileClient(str, options2);
       if (options2.cache) exports2.cache[key] = out;
       return out;
@@ -68376,7 +68376,7 @@ var require_lib15 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.pnpPlugin = void 0;
     var tslib_1 = require_tslib();
-    var fs10 = tslib_1.__importStar(require("fs"));
+    var fs11 = tslib_1.__importStar(require("fs"));
     var path_1 = tslib_1.__importDefault(require("path"));
     var matchAll = /()/;
     var defaultExtensions = [`.tsx`, `.ts`, `.jsx`, `.mjs`, `.cjs`, `.js`, `.css`, `.json`];
@@ -68408,7 +68408,7 @@ var require_lib15 = __commonJS({
     }
     async function defaultOnLoad(args) {
       return {
-        contents: await fs10.promises.readFile(args.path),
+        contents: await fs11.promises.readFile(args.path),
         loader: `default`,
         // For regular imports in the `file` namespace, resolveDir is the directory the
         // file being resolved lives in. For all other virtual modules, this defaults to
@@ -69135,6 +69135,185 @@ var load_less_default = plugin;
 var import_pug = __toESM(require_lib14());
 var import_fs4 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
+function computeContentHash(content) {
+  const hash = import_crypto.default.createHash("sha256").update(content).digest();
+  const num = hash.readUInt32BE(0);
+  return num.toString(36).toUpperCase().padStart(8, "0").slice(0, 8);
+}
+var ASSET_ATTRIBUTES = {
+  img: ["src", "srcset"],
+  video: ["src", "poster"],
+  audio: ["src"],
+  source: ["src", "srcset"],
+  link: ["href"],
+  script: ["src"],
+  object: ["data"],
+  embed: ["src"],
+  track: ["src"],
+  input: ["src"]
+  // for type="image"
+};
+function isRelativeAssetPath(assetPath) {
+  if (!assetPath) return false;
+  if (assetPath.startsWith("#")) return false;
+  if (assetPath.startsWith("//")) return false;
+  try {
+    new URL(assetPath);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function isPugReference(assetPath) {
+  return assetPath.endsWith(".pug") && isRelativeAssetPath(assetPath);
+}
+var discoveredPugReferences = /* @__PURE__ */ new Map();
+function clearDiscoveredPugReferences() {
+  discoveredPugReferences.clear();
+}
+function applyAssetNamesTemplate(template, originalPath, hash, baseDir) {
+  const ext = import_path5.default.extname(originalPath).slice(1);
+  const name3 = import_path5.default.basename(originalPath, import_path5.default.extname(originalPath));
+  const dir = import_path5.default.dirname(originalPath);
+  const relativeDir = dir.startsWith(baseDir) ? dir.slice(baseDir.length).replace(/^\//, "") : dir;
+  return template.replace(/\[name\]/g, name3).replace(/\[hash\]/g, hash).replace(/\[ext\]/g, ext).replace(/\[dir\]/g, relativeDir) + "." + ext;
+}
+async function processHtmlAssets(html, pugFilePath, options2) {
+  const assets = [];
+  const pugReferences = [];
+  const assetNames = options2.assetNames || "[name]-[hash]";
+  const outdir = options2.outdir || ".";
+  const outbase = options2.outbase || import_path5.default.dirname(pugFilePath);
+  const pugDir = import_path5.default.dirname(pugFilePath);
+  const publicPath = options2.publicPath || "";
+  const processedAssets = /* @__PURE__ */ new Map();
+  const allAttrs = [...new Set(Object.values(ASSET_ATTRIBUTES).flat())].join(
+    "|"
+  );
+  const attrRegex = new RegExp(`(${allAttrs})\\s*=\\s*["']([^"']+)["']`, "gi");
+  let modifiedHtml = html;
+  const matches = [];
+  let match;
+  while ((match = attrRegex.exec(html)) !== null) {
+    const attr = match[1];
+    const value = match[2];
+    if (attr && value) {
+      matches.push({
+        fullMatch: match[0],
+        attr: attr.toLowerCase(),
+        value
+      });
+    }
+  }
+  const discoveredPugPaths = /* @__PURE__ */ new Set();
+  for (const { fullMatch, attr, value } of matches) {
+    let newValue = value;
+    if (attr === "srcset") {
+      const srcsetParts = value.split(",");
+      const newParts = [];
+      for (const part of srcsetParts) {
+        const trimmed = part.trim();
+        const [assetPath, ...descriptors] = trimmed.split(/\s+/);
+        if (assetPath && isPugReference(assetPath)) {
+          const absolutePath = import_path5.default.resolve(pugDir, assetPath);
+          if (!discoveredPugPaths.has(absolutePath)) {
+            discoveredPugPaths.add(absolutePath);
+            pugReferences.push({ originalHref: assetPath, absolutePath });
+          }
+          newParts.push(trimmed);
+        } else if (assetPath && isRelativeAssetPath(assetPath)) {
+          const hashedPath = await processAsset(
+            assetPath,
+            pugDir,
+            outdir,
+            outbase,
+            assetNames,
+            publicPath,
+            assets,
+            processedAssets
+          );
+          if (hashedPath) {
+            newParts.push(
+              [hashedPath, ...descriptors].filter(Boolean).join(" ")
+            );
+          } else {
+            newParts.push(trimmed);
+          }
+        } else {
+          newParts.push(trimmed);
+        }
+      }
+      newValue = newParts.join(", ");
+    } else if (isPugReference(value)) {
+      const absolutePath = import_path5.default.resolve(pugDir, value);
+      if (!discoveredPugPaths.has(absolutePath)) {
+        discoveredPugPaths.add(absolutePath);
+        pugReferences.push({ originalHref: value, absolutePath });
+      }
+    } else if (isRelativeAssetPath(value)) {
+      const hashedPath = await processAsset(
+        value,
+        pugDir,
+        outdir,
+        outbase,
+        assetNames,
+        publicPath,
+        assets,
+        processedAssets
+      );
+      if (hashedPath) {
+        newValue = hashedPath;
+      }
+    }
+    if (newValue !== value) {
+      const newFullMatch = fullMatch.replace(value, newValue);
+      modifiedHtml = modifiedHtml.replace(fullMatch, newFullMatch);
+    }
+  }
+  return { html: modifiedHtml, assets, pugReferences };
+}
+async function processAsset(assetPath, pugDir, outdir, outbase, assetNames, publicPath, assets, processedAssets) {
+  const absoluteSource = import_path5.default.resolve(pugDir, assetPath);
+  if (processedAssets.has(absoluteSource)) {
+    return processedAssets.get(absoluteSource);
+  }
+  if (!import_fs4.default.existsSync(absoluteSource)) {
+    return null;
+  }
+  try {
+    const content = await import_fs4.default.promises.readFile(absoluteSource);
+    const hash = computeContentHash(content);
+    const hashedFilename = applyAssetNamesTemplate(
+      assetNames,
+      assetPath,
+      hash,
+      outbase
+    );
+    const absoluteOutput = import_path5.default.join(outdir, hashedFilename);
+    const htmlPath = publicPath ? publicPath.replace(/\/$/, "") + "/" + hashedFilename : hashedFilename;
+    assets.push({
+      originalPath: assetPath,
+      hashedPath: htmlPath,
+      absoluteSource,
+      absoluteOutput
+    });
+    processedAssets.set(absoluteSource, htmlPath);
+    return htmlPath;
+  } catch {
+    return null;
+  }
+}
+async function copyAssets(assets) {
+  const copied = /* @__PURE__ */ new Set();
+  for (const asset of assets) {
+    if (copied.has(asset.absoluteOutput)) continue;
+    copied.add(asset.absoluteOutput);
+    const outputDir = import_path5.default.dirname(asset.absoluteOutput);
+    await import_fs4.default.promises.mkdir(outputDir, { recursive: true });
+    await import_fs4.default.promises.copyFile(asset.absoluteSource, asset.absoluteOutput);
+  }
+}
 var filters = {
   escape: (str) => {
     return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -69204,7 +69383,7 @@ async function loadAsHtml(filepath, options2) {
 }
 async function loadAsEntrypoint(filepath, options2) {
   const fileData = await import_fs4.default.promises.readFile(filepath, "utf8");
-  const contents = import_pug.default.render(fileData, {
+  let contents = import_pug.default.render(fileData, {
     filename: filepath,
     basedir: options2.outbase,
     name: "render",
@@ -69215,6 +69394,18 @@ async function loadAsEntrypoint(filepath, options2) {
     ],
     filters
   });
+  const {
+    html: processedHtml,
+    assets,
+    pugReferences
+  } = await processHtmlAssets(contents, filepath, options2);
+  contents = processedHtml;
+  if (pugReferences.length > 0) {
+    discoveredPugReferences.set(filepath, pugReferences);
+  }
+  if (assets.length > 0) {
+    await copyAssets(assets);
+  }
   return {
     contents,
     loader: "copy"
@@ -69398,7 +69589,18 @@ function createCssExternalUrlsPlugin(patterns) {
 var import_esbuild_plugin_pnp = __toESM(require_lib15());
 var ts = __toESM(require("typescript"));
 var import_path7 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
 import_chalk3.default.level = 3;
+function rewritePugReferencesInHtml(html, pugReferences, pugToOutputPath) {
+  let result = html;
+  for (const ref of pugReferences) {
+    const outputPath = pugToOutputPath.get(ref.absolutePath);
+    if (outputPath) {
+      result = result.split(ref.originalHref).join(outputPath);
+    }
+  }
+  return result;
+}
 function outExt(inExt) {
   if (inExt.match(/^((c|m)?sx?|tsx?)$/)) {
     return "js";
@@ -69501,7 +69703,12 @@ var esbuilder = {
           2
         )
       );
-      const codeBuild = esbuild.build(finalConfig).then(async (result) => {
+      clearDiscoveredPugReferences();
+      const pugHtmlOutputs = /* @__PURE__ */ new Map();
+      const pugToOutputPath = /* @__PURE__ */ new Map();
+      const processedPugFiles = /* @__PURE__ */ new Set();
+      const pendingPugFiles = [];
+      const processOutputFiles = async (result, currentOutputFilesMap, isDiscoveredBuild) => {
         if (result.errors.length || result.warnings.length) {
           log_default.info(`Build completed with errors or warnings:`, {
             errors: result.errors.length,
@@ -69525,24 +69732,24 @@ var esbuilder = {
           let relativeTarget = relativeFilePath;
           let content = file.contents;
           let transforms = [];
-          const oFM_result = outputFilesMap.get(relativeFilePath);
+          const oFM_result = currentOutputFilesMap.get(relativeFilePath);
           if (oFM_result) {
-            relativeTarget = oFM_result.entrypoint.outfile.relative;
+            relativeTarget = oFM_result.entrypoint?.outfile.relative ?? relativeFilePath;
             oFM_result.present = true;
             if (expectingSourcemap && oFM_result.mapFileExpected) {
             }
           } else if (expectingSourcemap && relativeFilePath.endsWith(".map")) {
             const nonMapPath = relativeFilePath.slice(0, -4);
-            const oFM_result2 = outputFilesMap.get(nonMapPath);
-            if (oFM_result2) {
-              relativeTarget = oFM_result2.entrypoint.outfile.relative + ".map";
-              oFM_result2.mapfilePresent = true;
+            const mapOFM = currentOutputFilesMap.get(nonMapPath);
+            if (mapOFM) {
+              relativeTarget = (mapOFM.entrypoint?.outfile.relative ?? nonMapPath) + ".map";
+              mapOFM.mapfilePresent = true;
             } else {
               log_default.warn(
                 `Build artefact "${relativeFilePath}" was created but not expected.`
               );
             }
-          } else {
+          } else if (!isDiscoveredBuild) {
             log_default.warn(
               `Build artefact "${relativeFilePath}" was created but not expected.`
             );
@@ -69552,48 +69759,149 @@ var esbuilder = {
               `Correcting output file name "${relativeFilePath}" to be "${relativeTarget}".`
             );
           }
-          const promise = fileWriter.writeFile(
-            import_path7.default.join(outdir, relativeTarget),
-            applyTransforms(content, transforms),
-            {
-              encoding: "utf-8"
+          const isHtmlOutput = relativeFilePath.endsWith(".html");
+          const sourcePath = oFM_result?.sourcePath;
+          if (isHtmlOutput && sourcePath) {
+            const pugRefs = discoveredPugReferences.get(sourcePath) || [];
+            pugToOutputPath.set(sourcePath, relativeTarget);
+            for (const ref of pugRefs) {
+              if (!processedPugFiles.has(ref.absolutePath) && !pendingPugFiles.includes(ref.absolutePath)) {
+                if (import_fs6.default.existsSync(ref.absolutePath)) {
+                  pendingPugFiles.push(ref.absolutePath);
+                  log_default.debug(
+                    `Discovered pug reference: ${ref.originalHref} -> ${ref.absolutePath}`
+                  );
+                } else {
+                  log_default.warn(
+                    `Referenced pug file not found: ${ref.originalHref} (resolved to ${ref.absolutePath})`
+                  );
+                }
+              }
             }
-          );
-          writers.push(promise);
+            pugHtmlOutputs.set(sourcePath, {
+              content: file.text,
+              sourcePath,
+              outputPath: import_path7.default.join(outdir, relativeTarget),
+              pugReferences: pugRefs
+            });
+          } else {
+            const promise = fileWriter.writeFile(
+              import_path7.default.join(outdir, relativeTarget),
+              applyTransforms(content, transforms),
+              { encoding: "utf-8" }
+            );
+            writers.push(promise);
+          }
         }
         for (const [
           fileName,
           { entrypoint, present, mapfilePresent, mapFileExpected }
-        ] of outputFilesMap.entries()) {
+        ] of currentOutputFilesMap.entries()) {
           if (!present) {
             log_default.warn(
-              `Output file "${fileName}" was expected but not created for entrypoint "${entrypoint.infile.relative}".`
+              `Output file "${fileName}" was expected but not created for entrypoint "${entrypoint?.infile.relative ?? fileName}".`
             );
           }
           if (expectingSourcemap && mapFileExpected && !mapfilePresent) {
             log_default.warn(
-              `Map file "${fileName}.map" was expected but not created for entrypoint "${entrypoint.infile.relative}".`
+              `Map file "${fileName}.map" was expected but not created for entrypoint "${entrypoint?.infile.relative ?? fileName}".`
             );
           }
         }
         await Promise.all(writers);
-      }).catch((err) => {
-        const errors = err.errors || [];
-        const warnings = err.warnings || [];
-        if (!errors.length && !warnings.length) {
-          log_default.error(
-            `Build failed with no errors or warnings, but an unknown error occurred.`
+      };
+      const codeBuild = (async () => {
+        try {
+          for (const entrypoint of build2) {
+            if (entrypoint.infile.extension === "pug") {
+              processedPugFiles.add(entrypoint.infile.absolute);
+            }
+          }
+          const extendedOutputFilesMap = /* @__PURE__ */ new Map();
+          for (const [key, value] of outputFilesMap.entries()) {
+            extendedOutputFilesMap.set(key, {
+              ...value,
+              sourcePath: value.entrypoint.infile.absolute
+            });
+          }
+          const initialResult = await esbuild.build(finalConfig);
+          await processOutputFiles(
+            initialResult,
+            extendedOutputFilesMap,
+            false
           );
-          throw err;
-        } else {
-          log_default.error(
-            `Build failed with ${errors.length} errors and ${warnings.length} warnings.`
+          while (pendingPugFiles.length > 0) {
+            const batch = pendingPugFiles.splice(0);
+            const newEntryPoints = batch.filter(
+              (f) => !processedPugFiles.has(f)
+            );
+            if (newEntryPoints.length === 0) break;
+            log_default.debug(
+              `Building ${newEntryPoints.length} discovered pug file(s):`,
+              newEntryPoints
+            );
+            const discoveredOutputFilesMap = /* @__PURE__ */ new Map();
+            for (const pugSourcePath of newEntryPoints) {
+              const relativeSource = import_path7.default.relative(indir, pugSourcePath);
+              const expectedOutput = relativeSource.replace(/\.pug$/, ".html");
+              discoveredOutputFilesMap.set(expectedOutput, {
+                entrypoint: void 0,
+                sourcePath: pugSourcePath,
+                present: false,
+                mapfilePresent: false,
+                mapFileExpected: false
+              });
+              processedPugFiles.add(pugSourcePath);
+            }
+            const discoveredConfig = {
+              ...finalConfig,
+              entryPoints: newEntryPoints
+            };
+            const discoveredResult = await esbuild.build(discoveredConfig);
+            await processOutputFiles(
+              discoveredResult,
+              discoveredOutputFilesMap,
+              true
+            );
+          }
+          log_default.debug(
+            `Rewriting pug references in ${pugHtmlOutputs.size} HTML file(s)`
           );
-          log_default.error(`Errors:`, errors);
-          log_default.warn(`Warnings:`, warnings);
-          throw [...errors, ...warnings];
+          const htmlWriters = [];
+          for (const [_sourcePath, output] of pugHtmlOutputs.entries()) {
+            let html = output.content;
+            if (output.pugReferences.length > 0) {
+              html = rewritePugReferencesInHtml(
+                html,
+                output.pugReferences,
+                pugToOutputPath
+              );
+            }
+            const promise = fileWriter.writeFile(output.outputPath, html, {
+              encoding: "utf-8"
+            });
+            htmlWriters.push(promise);
+          }
+          await Promise.all(htmlWriters);
+        } catch (err) {
+          const error = err;
+          const errors = error.errors || [];
+          const warnings = error.warnings || [];
+          if (!errors.length && !warnings.length) {
+            log_default.error(
+              `Build failed with no errors or warnings, but an unknown error occurred.`
+            );
+            throw err;
+          } else {
+            log_default.error(
+              `Build failed with ${errors.length} errors and ${warnings.length} warnings.`
+            );
+            log_default.error(`Errors:`, errors);
+            log_default.warn(`Warnings:`, warnings);
+            throw [...errors, ...warnings];
+          }
         }
-      });
+      })();
       promises.push(codeBuild);
       if (exampleFile.entryconfig.declarations) {
         log_default.debug(`Generating Declarations`);
@@ -69703,7 +70011,7 @@ var import_path11 = __toESM(require("path"));
 
 // pnp:/builds/normed/bundle/.yarn/cache/filesystem-traverse-npm-3.0.0-2273ac54af-8725791ac7.zip/node_modules/filesystem-traverse/dist/esm/index.mjs
 var import_path8 = __toESM(require("path"), 1);
-var import_fs6 = __toESM(require("fs"), 1);
+var import_fs7 = __toESM(require("fs"), 1);
 function makeAsync(func) {
   return async (arg) => func(arg);
 }
@@ -69734,11 +70042,11 @@ function makeInclude(include, exclude) {
   };
 }
 async function search(match, context, directory, state = { complete: false }) {
-  const { fs: fs10, basedir, includeFile, includeDirectory } = context;
+  const { fs: fs11, basedir, includeFile, includeDirectory } = context;
   if (state.complete) {
     return;
   }
-  const entries = await fs10.promises.readdir(import_path8.default.join(basedir, directory), {
+  const entries = await fs11.promises.readdir(import_path8.default.join(basedir, directory), {
     encoding: "utf8",
     withFileTypes: true
   });
@@ -69764,9 +70072,9 @@ function optionsToContext(options2) {
     options2.include_dir,
     options2.exclude_dir
   );
-  const fs10 = options2.fs || import_fs6.default;
+  const fs11 = options2.fs || import_fs7.default;
   return {
-    fs: fs10,
+    fs: fs11,
     basedir,
     includeFile,
     includeDirectory
@@ -70112,7 +70420,7 @@ var SetMap = class _SetMap {
 };
 
 // pnp:/builds/normed/bundle/packages/bundle/src/EntryConfigInstance.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs8 = __toESM(require("fs"));
 var import_path10 = __toESM(require("path"));
 var namedEntryConfigs = /* @__PURE__ */ new Map();
 var entryConfigEquality = new SetMap();
@@ -70299,7 +70607,7 @@ async function readEsbuild(filepath, relativeDirectory) {
     relativeDirectory ?? process.cwd(),
     filepath
   );
-  const data = await import_fs7.default.promises.readFile(aboslutePath, "utf-8");
+  const data = await import_fs8.default.promises.readFile(aboslutePath, "utf-8");
   return JSON.parse(data);
 }
 async function readTsconfig(filepath, relativeDirectory) {
@@ -70307,12 +70615,12 @@ async function readTsconfig(filepath, relativeDirectory) {
     relativeDirectory ?? process.cwd(),
     filepath
   );
-  const data = await import_fs7.default.promises.readFile(aboslutePath, "utf-8");
+  const data = await import_fs8.default.promises.readFile(aboslutePath, "utf-8");
   return JSON.parse(data);
 }
 
 // pnp:/builds/normed/bundle/packages/bundle/src/entrypoints.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 async function pathToEntrypoint(buildConfig, file, source) {
   const infile = new File({
     supportedModifiers: buildConfig.modifiers,
@@ -70320,7 +70628,7 @@ async function pathToEntrypoint(buildConfig, file, source) {
     basedir: buildConfig.dir.in,
     parseModifiers: true
   });
-  const stats = await import_fs8.default.promises.stat(infile.absolute);
+  const stats = await import_fs9.default.promises.stat(infile.absolute);
   if (stats.isDirectory()) {
     (await Promise.all(
       await index_default({