@kubb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/{chunk-FOQFLMOC.js → chunk-ICRPOCV4.cjs}

@@ -1,14 +1,13 @@
-import { createRequire } from 'module';
-import { __commonJS, init_esm_shims, __require, __toESM } from './chunk-6N4JBFFS.js';
-import { resolve, relative, basename, extname, dirname } from 'path';
-import { switcher } from 'js-runtime';
+'use strict';
 
-createRequire(import.meta.url);
+var chunkMM42A6GN_cjs = require('./chunk-MM42A6GN.cjs');
+var path = require('path');
+var jsRuntime = require('js-runtime');
 
 // ../../node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
-var require_universalify = __commonJS({
+var require_universalify = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js"(exports) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     exports.fromCallback = function(fn) {
       return Object.defineProperty(function(...args) {
         if (typeof args[args.length - 1] === "function")
@@ -36,10 +35,10 @@ var require_universalify = __commonJS({
 });
 
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
-var require_polyfills = __commonJS({
+var require_polyfills = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    init_esm_shims();
-    var constants = __require("constants");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var constants = chunkMM42A6GN_cjs.__require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -63,56 +62,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs3) {
+    function patch(fs2) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs3);
-      }
-      if (!fs3.lutimes) {
-        patchLutimes(fs3);
-      }
-      fs3.chown = chownFix(fs3.chown);
-      fs3.fchown = chownFix(fs3.fchown);
-      fs3.lchown = chownFix(fs3.lchown);
-      fs3.chmod = chmodFix(fs3.chmod);
-      fs3.fchmod = chmodFix(fs3.fchmod);
-      fs3.lchmod = chmodFix(fs3.lchmod);
-      fs3.chownSync = chownFixSync(fs3.chownSync);
-      fs3.fchownSync = chownFixSync(fs3.fchownSync);
-      fs3.lchownSync = chownFixSync(fs3.lchownSync);
-      fs3.chmodSync = chmodFixSync(fs3.chmodSync);
-      fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
-      fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
-      fs3.stat = statFix(fs3.stat);
-      fs3.fstat = statFix(fs3.fstat);
-      fs3.lstat = statFix(fs3.lstat);
-      fs3.statSync = statFixSync(fs3.statSync);
-      fs3.fstatSync = statFixSync(fs3.fstatSync);
-      fs3.lstatSync = statFixSync(fs3.lstatSync);
-      if (fs3.chmod && !fs3.lchmod) {
-        fs3.lchmod = function(path, mode, cb) {
+        patchLchmod(fs2);
+      }
+      if (!fs2.lutimes) {
+        patchLutimes(fs2);
+      }
+      fs2.chown = chownFix(fs2.chown);
+      fs2.fchown = chownFix(fs2.fchown);
+      fs2.lchown = chownFix(fs2.lchown);
+      fs2.chmod = chmodFix(fs2.chmod);
+      fs2.fchmod = chmodFix(fs2.fchmod);
+      fs2.lchmod = chmodFix(fs2.lchmod);
+      fs2.chownSync = chownFixSync(fs2.chownSync);
+      fs2.fchownSync = chownFixSync(fs2.fchownSync);
+      fs2.lchownSync = chownFixSync(fs2.lchownSync);
+      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+      fs2.stat = statFix(fs2.stat);
+      fs2.fstat = statFix(fs2.fstat);
+      fs2.lstat = statFix(fs2.lstat);
+      fs2.statSync = statFixSync(fs2.statSync);
+      fs2.fstatSync = statFixSync(fs2.fstatSync);
+      fs2.lstatSync = statFixSync(fs2.lstatSync);
+      if (fs2.chmod && !fs2.lchmod) {
+        fs2.lchmod = function(path, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs3.lchmodSync = function() {
+        fs2.lchmodSync = function() {
         };
       }
-      if (fs3.chown && !fs3.lchown) {
-        fs3.lchown = function(path, uid, gid, cb) {
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs3.lchownSync = function() {
+        fs2.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.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() {
-                  fs3.stat(to, function(stater, st) {
+                  fs2.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -130,33 +129,33 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs3.rename);
+        }(fs2.rename);
       }
-      fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
-        function read2(fd, buffer, offset, length, position, callback_) {
+      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
             var eagCounter = 0;
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(read2, fs$read);
-        return read2;
-      }(fs3.read);
-      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ function(fs$readSync) {
+          Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs3, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -166,10 +165,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs3.readSync);
-      function patchLchmod(fs4) {
-        fs4.lchmod = function(path, mode, callback) {
-          fs4.open(
+      }(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path, mode, callback) {
+          fs3.open(
             path,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -179,8 +178,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs4.fchmod(fd, mode, function(err2) {
-                fs4.close(fd, function(err22) {
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -188,68 +187,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs4.lchmodSync = function(path, mode) {
-          var fd = fs4.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs3.lchmodSync = function(path, mode) {
+          var fd = fs3.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs4.fchmodSync(fd, mode);
+            ret = fs3.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs4.closeSync(fd);
+                fs3.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs4.closeSync(fd);
+              fs3.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs4) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
-          fs4.lutimes = function(path, at, mt, cb) {
-            fs4.open(path, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs3) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+          fs3.lutimes = function(path, at, mt, cb) {
+            fs3.open(path, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs4.futimes(fd, at, mt, function(er2) {
-                fs4.close(fd, function(er22) {
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs4.lutimesSync = function(path, at, mt) {
-            var fd = fs4.openSync(path, constants.O_SYMLINK);
+          fs3.lutimesSync = function(path, at, mt) {
+            var fd = fs3.openSync(path, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs4.futimesSync(fd, at, mt);
+              ret = fs3.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs4.closeSync(fd);
+                  fs3.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs4.closeSync(fd);
+                fs3.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs4.futimes) {
-          fs4.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs4.lutimesSync = function() {
+          fs3.lutimesSync = function() {
           };
         }
       }
@@ -257,7 +256,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs3, target, mode, function(er) {
+          return orig.call(fs2, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -270,7 +269,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs3, target, mode);
+            return orig.call(fs2, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -281,7 +280,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs3, target, uid, gid, function(er) {
+          return orig.call(fs2, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -294,7 +293,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs3, target, uid, gid);
+            return orig.call(fs2, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -319,14 +318,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -353,12 +352,12 @@ var require_polyfills = __commonJS({
 });
 
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams = __commonJS({
+var require_legacy_streams = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
-    init_esm_shims();
-    var Stream = __require("stream").Stream;
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var Stream = chunkMM42A6GN_cjs.__require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs3) {
+    function legacy(fs2) {
       return {
         ReadStream,
         WriteStream
@@ -403,7 +402,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -443,7 +442,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs3.open;
+          this._open = fs2.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -453,9 +452,9 @@ var require_legacy_streams = __commonJS({
 });
 
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
-var require_clone = __commonJS({
+var require_clone = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     module.exports = clone;
     var getPrototypeOf = Object.getPrototypeOf || function(obj) {
       return obj.__proto__;
@@ -476,14 +475,14 @@ var require_clone = __commonJS({
 });
 
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
-var require_graceful_fs = __commonJS({
+var require_graceful_fs = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = __require("fs");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = chunkMM42A6GN_cjs.__require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
-    var util = __require("util");
+    var util = chunkMM42A6GN_cjs.__require("util");
     var gracefulQueue;
     var previousSymbol;
     if (typeof Symbol === "function" && typeof Symbol.for === "function") {
@@ -511,12 +510,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs3[gracefulQueue]) {
+    if (!fs2[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs3, queue);
-      fs3.close = function(fs$close) {
+      publishQueue(fs2, queue);
+      fs2.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs3, fd, function(err) {
+          return fs$close.call(fs2, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -528,40 +527,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs3.close);
-      fs3.closeSync = function(fs$closeSync) {
+      }(fs2.close);
+      fs2.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs3, arguments);
+          fs$closeSync.apply(fs2, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs3.closeSync);
+      }(fs2.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs3[gracefulQueue]);
-          __require("assert").equal(fs3[gracefulQueue].length, 0);
+          debug(fs2[gracefulQueue]);
+          chunkMM42A6GN_cjs.__require("assert").equal(fs2[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs3[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs3));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
-      module.exports = patch(fs3);
-      fs3.__patched = true;
-    }
-    function patch(fs4) {
-      polyfills(fs4);
-      fs4.gracefulify = patch;
-      fs4.createReadStream = createReadStream;
-      fs4.createWriteStream = createWriteStream;
-      var fs$readFile = fs4.readFile;
-      fs4.readFile = readFile;
+      publishQueue(global, fs2[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs2));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+      module.exports = patch(fs2);
+      fs2.__patched = true;
+    }
+    function patch(fs3) {
+      polyfills(fs3);
+      fs3.gracefulify = patch;
+      fs3.createReadStream = createReadStream;
+      fs3.createWriteStream = createWriteStream;
+      var fs$readFile = fs3.readFile;
+      fs3.readFile = readFile;
       function readFile(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -577,8 +576,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs4.writeFile;
-      fs4.writeFile = writeFile;
+      var fs$writeFile = fs3.writeFile;
+      fs3.writeFile = writeFile;
       function writeFile(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -594,9 +593,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs4.appendFile;
+      var fs$appendFile = fs3.appendFile;
       if (fs$appendFile)
-        fs4.appendFile = appendFile;
+        fs3.appendFile = appendFile;
       function appendFile(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -612,9 +611,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs4.copyFile;
+      var fs$copyFile = fs3.copyFile;
       if (fs$copyFile)
-        fs4.copyFile = copyFile;
+        fs3.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -632,8 +631,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs4.readdir;
-      fs4.readdir = readdir;
+      var fs$readdir = fs3.readdir;
+      fs3.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path, options, cb) {
         if (typeof options === "function")
@@ -674,21 +673,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs4);
+        var legStreams = legacy(fs3);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs4.ReadStream;
+      var fs$ReadStream = fs3.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs4.WriteStream;
+      var fs$WriteStream = fs3.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs4, "ReadStream", {
+      Object.defineProperty(fs3, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -698,7 +697,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs4, "WriteStream", {
+      Object.defineProperty(fs3, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -709,7 +708,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs4, "FileReadStream", {
+      Object.defineProperty(fs3, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -720,7 +719,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs4, "FileWriteStream", {
+      Object.defineProperty(fs3, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -769,13 +768,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path, options) {
-        return new fs4.ReadStream(path, options);
+        return new fs3.ReadStream(path, options);
       }
       function createWriteStream(path, options) {
-        return new fs4.WriteStream(path, options);
+        return new fs3.WriteStream(path, options);
       }
-      var fs$open = fs4.open;
-      fs4.open = open;
+      var fs$open = fs3.open;
+      fs3.open = open;
       function open(path, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -791,20 +790,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs4;
+      return fs3;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs3[gracefulQueue].push(elem);
+      fs2[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
-        if (fs3[gracefulQueue][i].length > 2) {
-          fs3[gracefulQueue][i][3] = now;
-          fs3[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
+        if (fs2[gracefulQueue][i].length > 2) {
+          fs2[gracefulQueue][i][3] = now;
+          fs2[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -812,9 +811,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs3[gracefulQueue].length === 0)
+      if (fs2[gracefulQueue].length === 0)
         return;
-      var elem = fs3[gracefulQueue].shift();
+      var elem = fs2[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -836,7 +835,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs3[gracefulQueue].push(elem);
+          fs2[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -847,11 +846,11 @@ var require_graceful_fs = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js
-var require_fs = __commonJS({
+var require_fs = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromCallback;
-    var fs3 = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -888,26 +887,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs3[key] === "function";
+      return typeof fs2[key] === "function";
     });
-    Object.assign(exports, fs3);
+    Object.assign(exports, fs2);
     api.forEach((method) => {
-      exports[method] = u(fs3[method]);
+      exports[method] = u(fs2[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs3.exists(filename, callback);
+        return fs2.exists(filename, callback);
       }
       return new Promise((resolve2) => {
-        return fs3.exists(filename, resolve2);
+        return fs2.exists(filename, resolve2);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs3.read(fd, buffer, offset, length, position, callback);
+        return fs2.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve2, reject) => {
-        fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
           resolve2({ bytesRead, buffer: buffer2 });
@@ -916,10 +915,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.write(fd, buffer, ...args);
+        return fs2.write(fd, buffer, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
           resolve2({ bytesWritten, buffer: buffer2 });
@@ -928,10 +927,10 @@ var require_fs = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.readv(fd, buffers, ...args);
+        return fs2.readv(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs3.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs2.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err)
             return reject(err);
           resolve2({ bytesRead, buffers: buffers2 });
@@ -940,18 +939,18 @@ var require_fs = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.writev(fd, buffers, ...args);
+        return fs2.writev(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err)
             return reject(err);
           resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs3.realpath.native === "function") {
-      exports.realpath.native = u(fs3.realpath.native);
+    if (typeof fs2.realpath.native === "function") {
+      exports.realpath.native = u(fs2.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -963,10 +962,10 @@ var require_fs = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js
-var require_utils = __commonJS({
+var require_utils = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
-    init_esm_shims();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var path = chunkMM42A6GN_cjs.__require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
         const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
@@ -981,10 +980,10 @@ var require_utils = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js
-var require_make_dir = __commonJS({
+var require_make_dir = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -994,14 +993,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs3.mkdir(dir, {
+      return fs2.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs3.mkdirSync(dir, {
+      return fs2.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -1010,9 +1009,9 @@ var require_make_dir = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js
-var require_mkdirs = __commonJS({
+var require_mkdirs = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
     var { makeDir: _makeDir, makeDirSync } = require_make_dir();
     var makeDir = u(_makeDir);
@@ -1029,35 +1028,35 @@ var require_mkdirs = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js
-var require_path_exists = __commonJS({
+var require_path_exists = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
+    var fs2 = require_fs();
     function pathExists(path) {
-      return fs3.access(path).then(() => true).catch(() => false);
+      return fs2.access(path).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs3.existsSync
+      pathExistsSync: fs2.existsSync
     };
   }
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js
-var require_utimes = __commonJS({
+var require_utimes = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path, atime, mtime) {
-      const fd = await fs3.open(path, "r+");
+      const fd = await fs2.open(path, "r+");
       let closeErr = null;
       try {
-        await fs3.futimes(fd, atime, mtime);
+        await fs2.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs3.close(fd);
+          await fs2.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -1067,9 +1066,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path, atime, mtime) {
-      const fd = fs3.openSync(path, "r+");
-      fs3.futimesSync(fd, atime, mtime);
-      return fs3.closeSync(fd);
+      const fd = fs2.openSync(path, "r+");
+      fs2.futimesSync(fd, atime, mtime);
+      return fs2.closeSync(fd);
     }
     module.exports = {
       utimesMillis: u(utimesMillis),
@@ -1079,14 +1078,14 @@ var require_utimes = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js
-var require_stat = __commonJS({
+var require_stat = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs3.stat(file, { bigint: true }) : (file) => fs3.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs2.stat(file, { bigint: true }) : (file) => fs2.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -1098,7 +1097,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs3.statSync(file, { bigint: true }) : (file) => fs3.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs2.statSync(file, { bigint: true }) : (file) => fs2.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -1162,7 +1161,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = await fs3.stat(destParent, { bigint: true });
+        destStat = await fs2.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -1180,7 +1179,7 @@ var require_stat = __commonJS({
         return;
       let destStat;
       try {
-        destStat = fs3.statSync(destParent, { bigint: true });
+        destStat = fs2.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT")
           return;
@@ -1217,11 +1216,11 @@ var require_stat = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js
-var require_copy = __commonJS({
+var require_copy = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -1257,7 +1256,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs3.stat : fs3.lstat;
+      const statFn = opts.dereference ? fs2.stat : fs2.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -1275,7 +1274,7 @@ var require_copy = __commonJS({
       if (!destStat)
         return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs3.unlink(dest);
+        await fs2.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -1283,27 +1282,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs3.copyFile(src, dest);
+      await fs2.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs3.stat(src);
+        const updatedSrcStat = await fs2.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs3.chmod(dest, srcStat.mode);
+      return fs2.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs3.chmod(dest, srcMode | 128);
+      return fs2.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs3.mkdir(dest);
+        await fs2.mkdir(dest);
       }
-      const items = await fs3.readdir(src);
+      const items = await fs2.readdir(src);
       await Promise.all(items.map(async (item) => {
         const srcItem = path.join(src, item);
         const destItem = path.join(dest, item);
@@ -1314,23 +1313,23 @@ var require_copy = __commonJS({
         return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
       }));
       if (!destStat) {
-        await fs3.chmod(dest, srcStat.mode);
+        await fs2.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs3.readlink(src);
+      let resolvedSrc = await fs2.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs3.symlink(resolvedSrc, dest);
+        return fs2.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs3.readlink(dest);
+        resolvedDest = await fs2.readlink(dest);
       } catch (e) {
         if (e.code === "EINVAL" || e.code === "UNKNOWN")
-          return fs3.symlink(resolvedSrc, dest);
+          return fs2.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -1342,19 +1341,19 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs3.unlink(dest);
-      return fs3.symlink(resolvedSrc, dest);
+      await fs2.unlink(dest);
+      return fs2.symlink(resolvedSrc, dest);
     }
     module.exports = copy;
   }
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js
-var require_copy_sync = __commonJS({
+var require_copy_sync = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_graceful_fs();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_graceful_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -1377,12 +1376,12 @@ var require_copy_sync = __commonJS({
       if (opts.filter && !opts.filter(src, dest))
         return;
       const destParent = path.dirname(dest);
-      if (!fs3.existsSync(destParent))
+      if (!fs2.existsSync(destParent))
         mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
+      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory())
         return onDir(srcStat, destStat, src, dest, opts);
@@ -1403,14 +1402,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs3.unlinkSync(dest);
+        fs2.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs3.copyFileSync(src, dest);
+      fs2.copyFileSync(src, dest);
       if (opts.preserveTimestamps)
         handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
@@ -1427,10 +1426,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs3.chmodSync(dest, srcMode);
+      return fs2.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs3.statSync(src);
+      const updatedSrcStat = fs2.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -1439,12 +1438,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs3.mkdirSync(dest);
+      fs2.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs3.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
       const srcItem = path.join(src, item);
@@ -1455,19 +1454,19 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs3.readlinkSync(src);
+      let resolvedSrc = fs2.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs3.symlinkSync(resolvedSrc, dest);
+        return fs2.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs3.readlinkSync(dest);
+          resolvedDest = fs2.readlinkSync(dest);
         } catch (err) {
           if (err.code === "EINVAL" || err.code === "UNKNOWN")
-            return fs3.symlinkSync(resolvedSrc, dest);
+            return fs2.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -1483,17 +1482,17 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs3.unlinkSync(dest);
-      return fs3.symlinkSync(resolvedSrc, dest);
+      fs2.unlinkSync(dest);
+      return fs2.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js
-var require_copy2 = __commonJS({
+var require_copy2 = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
     module.exports = {
       copy: u(require_copy()),
@@ -1503,52 +1502,52 @@ var require_copy2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js
-var require_remove = __commonJS({
+var require_remove = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_graceful_fs();
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove2(path, callback) {
-      fs3.rm(path, { recursive: true, force: true }, callback);
+    function remove(path, callback) {
+      fs2.rm(path, { recursive: true, force: true }, callback);
     }
     function removeSync(path) {
-      fs3.rmSync(path, { recursive: true, force: true });
+      fs2.rmSync(path, { recursive: true, force: true });
     }
     module.exports = {
-      remove: u(remove2),
+      remove: u(remove),
       removeSync
     };
   }
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js
-var require_empty = __commonJS({
+var require_empty = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    var path = __require("path");
+    var fs2 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var mkdir = require_mkdirs();
-    var remove2 = require_remove();
+    var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs3.readdir(dir);
+        items = await fs2.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove2.remove(path.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs3.readdirSync(dir);
+        items = fs2.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
         item = path.join(dir, item);
-        remove2.removeSync(item);
+        remove.removeSync(item);
       });
     }
     module.exports = {
@@ -1561,17 +1560,17 @@ var require_empty = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js
-var require_file = __commonJS({
+var require_file = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var path = __require("path");
-    var fs3 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
+    var fs2 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs3.stat(file);
+        stats = await fs2.stat(file);
       } catch {
       }
       if (stats && stats.isFile())
@@ -1579,34 +1578,34 @@ var require_file = __commonJS({
       const dir = path.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs3.stat(dir);
+        dirStats = await fs2.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs3.writeFile(file, "");
+          await fs2.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs3.writeFile(file, "");
+        await fs2.writeFile(file, "");
       } else {
-        await fs3.readdir(dir);
+        await fs2.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs3.statSync(file);
+        stats = fs2.statSync(file);
       } catch {
       }
       if (stats && stats.isFile())
         return;
       const dir = path.dirname(file);
       try {
-        if (!fs3.statSync(dir).isDirectory()) {
-          fs3.readdirSync(dir);
+        if (!fs2.statSync(dir).isDirectory()) {
+          fs2.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT")
@@ -1614,7 +1613,7 @@ var require_file = __commonJS({
         else
           throw err;
       }
-      fs3.writeFileSync(file, "");
+      fs2.writeFileSync(file, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -1624,24 +1623,24 @@ var require_file = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js
-var require_link = __commonJS({
+var require_link = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var path = __require("path");
-    var fs3 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
+    var fs2 = 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 fs3.lstat(dstpath);
+        dstStat = await fs2.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs3.lstat(srcpath);
+        srcStat = await fs2.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -1653,16 +1652,16 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs3.link(srcpath, dstpath);
+      await fs2.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs3.lstatSync(dstpath);
+        dstStat = fs2.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs3.lstatSync(srcpath);
+        const srcStat = fs2.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat))
           return;
       } catch (err) {
@@ -1670,11 +1669,11 @@ var require_link = __commonJS({
         throw err;
       }
       const dir = path.dirname(dstpath);
-      const dirExists = fs3.existsSync(dir);
+      const dirExists = fs2.existsSync(dir);
       if (dirExists)
-        return fs3.linkSync(srcpath, dstpath);
+        return fs2.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs3.linkSync(srcpath, dstpath);
+      return fs2.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -1684,17 +1683,17 @@ var require_link = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
-var require_symlink_paths = __commonJS({
+var require_symlink_paths = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
-    init_esm_shims();
-    var path = __require("path");
-    var fs3 = require_fs();
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var path = chunkMM42A6GN_cjs.__require("path");
+    var fs2 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path.isAbsolute(srcpath)) {
         try {
-          await fs3.lstat(srcpath);
+          await fs2.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -1714,7 +1713,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs3.lstat(srcpath);
+        await fs2.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -1726,7 +1725,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path.isAbsolute(srcpath)) {
-        const exists2 = fs3.existsSync(srcpath);
+        const exists2 = fs2.existsSync(srcpath);
         if (!exists2)
           throw new Error("absolute srcpath does not exist");
         return {
@@ -1736,14 +1735,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path.dirname(dstpath);
       const relativeToDst = path.join(dstdir, srcpath);
-      const exists = fs3.existsSync(relativeToDst);
+      const exists = fs2.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs3.existsSync(srcpath);
+      const srcExists = fs2.existsSync(srcpath);
       if (!srcExists)
         throw new Error("relative srcpath does not exist");
       return {
@@ -1759,17 +1758,17 @@ var require_symlink_paths = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js
-var require_symlink_type = __commonJS({
+var require_symlink_type = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type)
         return type;
       let stats;
       try {
-        stats = await fs3.lstat(srcpath);
+        stats = await fs2.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -1780,7 +1779,7 @@ var require_symlink_type = __commonJS({
         return type;
       let stats;
       try {
-        stats = fs3.lstatSync(srcpath);
+        stats = fs2.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -1794,12 +1793,12 @@ var require_symlink_type = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js
-var require_symlink = __commonJS({
+var require_symlink = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var path = __require("path");
-    var fs3 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
+    var fs2 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -1808,47 +1807,47 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs3.lstat(dstpath);
+        stats = await fs2.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs3.stat(srcpath),
-          fs3.stat(dstpath)
+          fs2.stat(srcpath),
+          fs2.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat))
           return;
       }
-      const relative2 = await symlinkPaths(srcpath, dstpath);
-      srcpath = relative2.toDst;
-      const toType = await symlinkType(relative2.toCwd, type);
+      const relative = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative.toDst;
+      const toType = await symlinkType(relative.toCwd, type);
       const dir = path.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs3.symlink(srcpath, dstpath, toType);
+      return fs2.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs3.lstatSync(dstpath);
+        stats = fs2.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs3.statSync(srcpath);
-        const dstStat = fs3.statSync(dstpath);
+        const srcStat = fs2.statSync(srcpath);
+        const dstStat = fs2.statSync(dstpath);
         if (areIdentical(srcStat, dstStat))
           return;
       }
-      const relative2 = symlinkPathsSync(srcpath, dstpath);
-      srcpath = relative2.toDst;
-      type = symlinkTypeSync(relative2.toCwd, type);
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
       const dir = path.dirname(dstpath);
-      const exists = fs3.existsSync(dir);
+      const exists = fs2.existsSync(dir);
       if (exists)
-        return fs3.symlinkSync(srcpath, dstpath, type);
+        return fs2.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs3.symlinkSync(srcpath, dstpath, type);
+      return fs2.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -1858,9 +1857,9 @@ var require_symlink = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js
-var require_ensure = __commonJS({
+var require_ensure = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var { createFile, createFileSync } = require_file();
     var { createLink, createLinkSync } = require_link();
     var { createSymlink, createSymlinkSync } = require_symlink();
@@ -1885,9 +1884,9 @@ var require_ensure = __commonJS({
 });
 
 // ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
-var require_utils2 = __commonJS({
+var require_utils2 = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
       const EOF = finalEOL ? EOL : "";
       const str = JSON.stringify(obj, replacer, spaces);
@@ -1903,14 +1902,14 @@ var require_utils2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
-var require_jsonfile = __commonJS({
+var require_jsonfile = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var _fs;
     try {
       _fs = require_graceful_fs();
     } catch (_) {
-      _fs = __require("fs");
+      _fs = chunkMM42A6GN_cjs.__require("fs");
     }
     var universalify = require_universalify();
     var { stringify, stripBom } = require_utils2();
@@ -1918,9 +1917,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs3 = options.fs || _fs;
+      const fs2 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs3.readFile)(file, options);
+      let data = await universalify.fromCallback(fs2.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -1940,10 +1939,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs3 = options.fs || _fs;
+      const fs2 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs3.readFileSync(file, options);
+        let content = fs2.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -1956,15 +1955,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs3 = options.fs || _fs;
+      const fs2 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs3.writeFile)(file, str, options);
+      await universalify.fromCallback(fs2.writeFile)(file, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs3 = options.fs || _fs;
+      const fs2 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs3.writeFileSync(file, str, options);
+      return fs2.writeFileSync(file, str, options);
     }
     var jsonfile = {
       readFile,
@@ -1977,9 +1976,9 @@ var require_jsonfile = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js
-var require_jsonfile2 = __commonJS({
+var require_jsonfile2 = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var jsonFile = require_jsonfile();
     module.exports = {
       // jsonfile exports
@@ -1992,12 +1991,12 @@ var require_jsonfile2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js
-var require_output_file = __commonJS({
+var require_output_file = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    var path = __require("path");
+    var fs2 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
@@ -2005,14 +2004,14 @@ var require_output_file = __commonJS({
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs3.writeFile(file, data, encoding);
+      return fs2.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path.dirname(file);
-      if (!fs3.existsSync(dir)) {
+      if (!fs2.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs3.writeFileSync(file, ...args);
+      fs2.writeFileSync(file, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -2022,9 +2021,9 @@ var require_output_file = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js
-var require_output_json = __commonJS({
+var require_output_json = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var { stringify } = require_utils2();
     var { outputFile } = require_output_file();
     async function outputJson(file, data, options = {}) {
@@ -2036,9 +2035,9 @@ var require_output_json = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js
-var require_output_json_sync = __commonJS({
+var require_output_json_sync = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var { stringify } = require_utils2();
     var { outputFileSync } = require_output_file();
     function outputJsonSync(file, data, options) {
@@ -2050,9 +2049,9 @@ var require_output_json_sync = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js
-var require_json = __commonJS({
+var require_json = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
     var jsonFile = require_jsonfile2();
     jsonFile.outputJson = u(require_output_json());
@@ -2068,13 +2067,13 @@ var require_json = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js
-var require_move = __commonJS({
+var require_move = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_fs();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var { copy } = require_copy2();
-    var { remove: remove2 } = require_remove();
+    var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var stat = require_stat();
@@ -2092,13 +2091,13 @@ var require_move = __commonJS({
     async function doRename(src, dest, overwrite, isChangingCase) {
       if (!isChangingCase) {
         if (overwrite) {
-          await remove2(dest);
+          await remove(dest);
         } else if (await pathExists(dest)) {
           throw new Error("dest already exists.");
         }
       }
       try {
-        await fs3.rename(src, dest);
+        await fs2.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -2113,18 +2112,18 @@ var require_move = __commonJS({
         preserveTimestamps: true
       };
       await copy(src, dest, opts);
-      return remove2(src);
+      return remove(src);
     }
     module.exports = move;
   }
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js
-var require_move_sync = __commonJS({
+var require_move_sync = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
-    init_esm_shims();
-    var fs3 = require_graceful_fs();
-    var path = __require("path");
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    var fs2 = require_graceful_fs();
+    var path = chunkMM42A6GN_cjs.__require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -2150,13 +2149,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs3.existsSync(dest))
+      if (fs2.existsSync(dest))
         throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs3.renameSync(src, dest);
+        fs2.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV")
           throw err;
@@ -2177,9 +2176,9 @@ var require_move_sync = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js
-var require_move2 = __commonJS({
+var require_move2 = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var u = require_universalify().fromPromise;
     module.exports = {
       move: u(require_move()),
@@ -2189,9 +2188,9 @@ var require_move2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js
-var require_lib = __commonJS({
+var require_lib = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js"(exports, module) {
-    init_esm_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     module.exports = {
       // Export promiseified graceful-fs:
       ...require_fs(),
@@ -2209,87 +2208,24 @@ var require_lib = __commonJS({
   }
 });
 
-// src/fs/clean.ts
-init_esm_shims();
-var import_fs_extra = __toESM(require_lib(), 1);
-async function clean(path) {
-  return (0, import_fs_extra.remove)(path);
-}
-
-// src/fs/read.ts
-init_esm_shims();
-var import_fs_extra2 = __toESM(require_lib(), 1);
-function slash(path, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path);
-  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-  }
-  return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-}
-function getRelativePath(rootDir, filePath, platform = "linux") {
-  if (!rootDir || !filePath) {
-    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
-  }
-  const relativePath = relative(rootDir, filePath);
-  const slashedPath = slash(relativePath, platform);
-  if (slashedPath.startsWith("../")) {
-    return slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)));
-  }
-  return `./${slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))}`;
-}
-var reader = switcher(
-  {
-    node: async (path) => {
-      return import_fs_extra2.default.readFile(path, { encoding: "utf8" });
-    },
-    bun: async (path) => {
-      const file = Bun.file(path);
-      return file.text();
-    }
-  },
-  "node"
-);
-var syncReader = switcher(
-  {
-    node: (path) => {
-      return import_fs_extra2.default.readFileSync(path, { encoding: "utf8" });
-    },
-    bun: () => {
-      throw new Error("Bun cannot read sync");
-    }
-  },
-  "node"
-);
-async function read(path) {
-  return reader(path);
-}
-function readSync(path) {
-  return syncReader(path);
-}
-
 // src/fs/write.ts
-init_esm_shims();
-var import_fs_extra3 = __toESM(require_lib(), 1);
-async function saveCreateDirectory(path) {
-  const passedPath = dirname(resolve(path));
-  await import_fs_extra3.default.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
+chunkMM42A6GN_cjs.init_cjs_shims();
+var import_fs_extra = chunkMM42A6GN_cjs.__toESM(require_lib(), 1);
+var writer = jsRuntime.switcher(
   {
-    node: async (path, data) => {
+    node: async (path$1, data, { sanity }) => {
       try {
-        await import_fs_extra3.default.stat(resolve(path));
-        const oldContent = await import_fs_extra3.default.readFile(resolve(path), { encoding: "utf-8" });
+        const oldContent = await import_fs_extra.default.readFile(path.resolve(path$1), { encoding: "utf-8" });
         if (oldContent?.toString() === data?.toString()) {
           return;
         }
       } catch (_err) {
       }
-      await saveCreateDirectory(path);
-      await import_fs_extra3.default.writeFile(resolve(path), data, { encoding: "utf-8" });
-      const savedData = await import_fs_extra3.default.readFile(resolve(path), { encoding: "utf-8" });
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path}
+      await import_fs_extra.default.outputFile(path.resolve(path$1), data, { encoding: "utf-8" });
+      if (sanity) {
+        const savedData = await import_fs_extra.default.readFile(path.resolve(path$1), { encoding: "utf-8" });
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path$1}
 
 Data[${data.length}]:
 ${data}
@@ -2297,17 +2233,19 @@ ${data}
 Saved[${savedData.length}]:
 ${savedData}
 `);
+        }
+        return savedData;
       }
-      return savedData;
+      return data;
     },
-    bun: async (path, data) => {
+    bun: async (path$1, data, { sanity }) => {
       try {
-        await saveCreateDirectory(path);
-        await Bun.write(resolve(path), data);
-        const file = Bun.file(resolve(path));
-        const savedData = await file.text();
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path}
+        await Bun.write(path.resolve(path$1), data);
+        if (sanity) {
+          const file = Bun.file(path.resolve(path$1));
+          const savedData = await file.text();
+          if (savedData?.toString() !== data?.toString()) {
+            throw new Error(`Sanity check failed for ${path$1}
 
 Data[${data.length}]:
 ${data}
@@ -2315,22 +2253,38 @@ ${data}
 Saved[${savedData.length}]:
 ${savedData}
 `);
+          }
+          return savedData;
         }
-        return savedData;
+        return data;
       } catch (e) {
-        console.log(e, resolve(path));
+        console.log(e, path.resolve(path$1));
       }
     }
   },
   "node"
 );
-async function write(data, path) {
+async function write(data, path, options = {}) {
   if (data.trim() === "") {
     return void 0;
   }
-  return writer(path, data.trim());
+  return writer(path, data.trim(), options);
+}
+async function writeLog(data) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  const path$1 = path.resolve(process.cwd(), "kubb-log.log");
+  let previousLogs = "";
+  try {
+    previousLogs = await import_fs_extra.default.readFile(path.resolve(path$1), { encoding: "utf-8" });
+  } catch (_err) {
+  }
+  return writer(path$1, [previousLogs, data.trim()].filter(Boolean).join("\n\n\n"), { sanity: false });
 }
 
-export { clean, getRelativePath, read, readSync, write };
+exports.require_lib = require_lib;
+exports.write = write;
+exports.writeLog = writeLog;
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-FOQFLMOC.js.map
+//# sourceMappingURL=chunk-ICRPOCV4.cjs.map