@aws-cdk/integ-runner 2.200.2 → 2.201.0

package/lib/index.js

@@ -850,17 +850,17 @@ var require_conversions = __commonJS({
       return [0, 0, args[0]];
     };
     convert.gray.hsv = convert.gray.hsl;
-    convert.gray.hwb = function(gray3) {
-      return [0, 100, gray3[0]];
+    convert.gray.hwb = function(gray) {
+      return [0, 100, gray[0]];
     };
-    convert.gray.cmyk = function(gray3) {
-      return [0, 0, 0, gray3[0]];
+    convert.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
     };
-    convert.gray.lab = function(gray3) {
-      return [gray3[0], 0, 0];
+    convert.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
     };
-    convert.gray.hex = function(gray3) {
-      const val = Math.round(gray3[0] / 100 * 255) & 255;
+    convert.gray.hex = function(gray) {
+      const val = Math.round(gray[0] / 100 * 255) & 255;
       const integer = (val << 16) + (val << 8) + val;
       const string = integer.toString(16).toUpperCase();
       return "000000".substring(string.length) + string;
@@ -917,15 +917,15 @@ var require_route = __commonJS({
     }
     __name(link, "link");
     function wrapConversion(toModel, graph) {
-      const path3 = [graph[toModel].parent, toModel];
+      const path4 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path3.unshift(graph[cur].parent);
+        path4.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path3;
+      fn.conversion = path4;
       return fn;
     }
     __name(wrapConversion, "wrapConversion");
@@ -2681,12 +2681,12 @@ var require_src = __commonJS({
 });
 
 // lib/logger.ts
-var util, chalk, stderr, logger, print, error, warning, success, highlight, trace;
+var util, import_chalk, stderr, logger, print, error, warning, success, highlight, trace;
 var init_logger = __esm({
   "lib/logger.ts"() {
     "use strict";
     util = __toESM(require("util"));
-    chalk = __toESM(require_source());
+    import_chalk = __toESM(require_source());
     ({ stderr } = process);
     logger = /* @__PURE__ */ __name((stream, styles) => (fmt, ...args) => {
       let str = util.format(fmt, ...args);
@@ -2696,11 +2696,11 @@ var init_logger = __esm({
       stream.write(str + "\n");
     }, "logger");
     print = logger(stderr);
-    error = logger(stderr, [chalk.red]);
-    warning = logger(stderr, [chalk.yellow]);
-    success = logger(stderr, [chalk.green]);
-    highlight = logger(stderr, [chalk.bold]);
-    trace = logger(stderr, [chalk.gray]);
+    error = logger(stderr, [import_chalk.default.red]);
+    warning = logger(stderr, [import_chalk.default.yellow]);
+    success = logger(stderr, [import_chalk.default.green]);
+    highlight = logger(stderr, [import_chalk.default.bold]);
+    trace = logger(stderr, [import_chalk.default.gray]);
   }
 });
 
@@ -2758,54 +2758,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs3) {
+    function patch(fs4) {
       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(path3, mode, cb) {
+        patchLchmod(fs4);
+      }
+      if (!fs4.lutimes) {
+        patchLutimes(fs4);
+      }
+      fs4.chown = chownFix(fs4.chown);
+      fs4.fchown = chownFix(fs4.fchown);
+      fs4.lchown = chownFix(fs4.lchown);
+      fs4.chmod = chmodFix(fs4.chmod);
+      fs4.fchmod = chmodFix(fs4.fchmod);
+      fs4.lchmod = chmodFix(fs4.lchmod);
+      fs4.chownSync = chownFixSync(fs4.chownSync);
+      fs4.fchownSync = chownFixSync(fs4.fchownSync);
+      fs4.lchownSync = chownFixSync(fs4.lchownSync);
+      fs4.chmodSync = chmodFixSync(fs4.chmodSync);
+      fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
+      fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
+      fs4.stat = statFix(fs4.stat);
+      fs4.fstat = statFix(fs4.fstat);
+      fs4.lstat = statFix(fs4.lstat);
+      fs4.statSync = statFixSync(fs4.statSync);
+      fs4.fstatSync = statFixSync(fs4.fstatSync);
+      fs4.lstatSync = statFixSync(fs4.lstatSync);
+      if (fs4.chmod && !fs4.lchmod) {
+        fs4.lchmod = function(path4, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs3.lchmodSync = function() {
+        fs4.lchmodSync = function() {
         };
       }
-      if (fs3.chown && !fs3.lchown) {
-        fs3.lchown = function(path3, uid, gid, cb) {
+      if (fs4.chown && !fs4.lchown) {
+        fs4.lchown = function(path4, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs3.lchownSync = function() {
+        fs4.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : (function(fs$rename) {
+        fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, /* @__PURE__ */ __name(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) {
+                  fs4.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -2822,9 +2822,9 @@ var require_polyfills = __commonJS({
           __name(rename, "rename");
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs3.rename);
+        })(fs4.rename);
       }
-      fs3.read = typeof fs3.read !== "function" ? fs3.read : (function(fs$read) {
+      fs4.read = typeof fs4.read !== "function" ? fs4.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -2832,23 +2832,23 @@ var require_polyfills = __commonJS({
             callback = /* @__PURE__ */ __name(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(fs4, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             }, "callback");
           }
-          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
         }
         __name(read, "read");
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs3.read);
-      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs4.read);
+      fs4.readSync = typeof fs4.readSync !== "function" ? fs4.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(fs4, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -2858,11 +2858,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs3.readSync);
-      function patchLchmod(fs4) {
-        fs4.lchmod = function(path3, mode, callback) {
-          fs4.open(
-            path3,
+      })(fs4.readSync);
+      function patchLchmod(fs5) {
+        fs5.lchmod = function(path4, mode, callback) {
+          fs5.open(
+            path4,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -2870,74 +2870,74 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs4.fchmod(fd, mode, function(err2) {
-                fs4.close(fd, function(err22) {
+              fs5.fchmod(fd, mode, function(err2) {
+                fs5.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs4.lchmodSync = function(path3, mode) {
-          var fd = fs4.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs5.lchmodSync = function(path4, mode) {
+          var fd = fs5.openSync(path4, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs4.fchmodSync(fd, mode);
+            ret = fs5.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs4.closeSync(fd);
+                fs5.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs4.closeSync(fd);
+              fs5.closeSync(fd);
             }
           }
           return ret;
         };
       }
       __name(patchLchmod, "patchLchmod");
-      function patchLutimes(fs4) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
-          fs4.lutimes = function(path3, at, mt, cb) {
-            fs4.open(path3, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs5) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
+          fs5.lutimes = function(path4, at, mt, cb) {
+            fs5.open(path4, 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) {
+              fs5.futimes(fd, at, mt, function(er2) {
+                fs5.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs4.lutimesSync = function(path3, at, mt) {
-            var fd = fs4.openSync(path3, constants.O_SYMLINK);
+          fs5.lutimesSync = function(path4, at, mt) {
+            var fd = fs5.openSync(path4, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs4.futimesSync(fd, at, mt);
+              ret = fs5.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs4.closeSync(fd);
+                  fs5.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs4.closeSync(fd);
+                fs5.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs4.futimes) {
-          fs4.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs5.futimes) {
+          fs5.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs4.lutimesSync = function() {
+          fs5.lutimesSync = function() {
           };
         }
       }
@@ -2945,7 +2945,7 @@ var require_polyfills = __commonJS({
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs3, target, mode, function(er) {
+          return orig.call(fs4, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -2956,7 +2956,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs3, target, mode);
+            return orig.call(fs4, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -2966,7 +2966,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs3, target, uid, gid, function(er) {
+          return orig.call(fs4, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -2977,7 +2977,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs3, target, uid, gid);
+            return orig.call(fs4, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -2999,14 +2999,14 @@ var require_polyfills = __commonJS({
             if (cb) cb.apply(this, arguments);
           }
           __name(callback, "callback");
-          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
+          return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
         };
       }
       __name(statFix, "statFix");
       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(fs4, target, options) : orig.call(fs4, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -3038,16 +3038,16 @@ var require_legacy_streams = __commonJS({
   "../../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs3) {
+    function legacy(fs4) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path3, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path3, options);
+      function ReadStream(path4, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path4, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path3;
+        this.path = path4;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -3081,7 +3081,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs4.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -3093,10 +3093,10 @@ var require_legacy_streams = __commonJS({
         });
       }
       __name(ReadStream, "ReadStream");
-      function WriteStream(path3, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path3, options);
+      function WriteStream(path4, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path4, options);
         Stream.call(this);
-        this.path = path3;
+        this.path = path4;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -3121,7 +3121,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs3.open;
+          this._open = fs4.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -3159,7 +3159,7 @@ var require_clone = __commonJS({
 // ../../../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs3 = require("fs");
+    var fs4 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -3193,12 +3193,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       }, "debug");
-    if (!fs3[gracefulQueue]) {
+    if (!fs4[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs3, queue);
-      fs3.close = (function(fs$close) {
+      publishQueue(fs4, queue);
+      fs4.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs3, fd, function(err) {
+          return fs$close.call(fs4, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -3211,10 +3211,10 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs3.close);
-      fs3.closeSync = (function(fs$closeSync) {
+      })(fs4.close);
+      fs4.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs3, arguments);
+          fs$closeSync.apply(fs4, arguments);
           resetQueue();
         }
         __name(closeSync, "closeSync");
@@ -3222,38 +3222,38 @@ var require_graceful_fs = __commonJS({
           value: fs$closeSync
         });
         return closeSync;
-      })(fs3.closeSync);
+      })(fs4.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(fs4[gracefulQueue]);
+          require("assert").equal(fs4[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs3[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs3));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
-      module2.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;
-      function readFile(path3, options, cb) {
+      publishQueue(global, fs4[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs4));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
+      module2.exports = patch(fs4);
+      fs4.__patched = true;
+    }
+    function patch(fs5) {
+      polyfills(fs5);
+      fs5.gracefulify = patch;
+      fs5.createReadStream = createReadStream;
+      fs5.createWriteStream = createWriteStream;
+      var fs$readFile = fs5.readFile;
+      fs5.readFile = readFile2;
+      function readFile2(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path3, options, cb);
-        function go$readFile(path4, options2, cb2, startTime) {
-          return fs$readFile(path4, options2, function(err) {
+        return go$readFile(path4, options, cb);
+        function go$readFile(path5, options2, cb2, startTime) {
+          return fs$readFile(path5, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path4, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path5, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3262,17 +3262,17 @@ var require_graceful_fs = __commonJS({
         }
         __name(go$readFile, "go$readFile");
       }
-      __name(readFile, "readFile");
-      var fs$writeFile = fs4.writeFile;
-      fs4.writeFile = writeFile;
-      function writeFile(path3, data, options, cb) {
+      __name(readFile2, "readFile");
+      var fs$writeFile = fs5.writeFile;
+      fs5.writeFile = writeFile;
+      function writeFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path3, data, options, cb);
-        function go$writeFile(path4, data2, options2, cb2, startTime) {
-          return fs$writeFile(path4, data2, options2, function(err) {
+        return go$writeFile(path4, data, options, cb);
+        function go$writeFile(path5, data2, options2, cb2, startTime) {
+          return fs$writeFile(path5, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3282,17 +3282,17 @@ var require_graceful_fs = __commonJS({
         __name(go$writeFile, "go$writeFile");
       }
       __name(writeFile, "writeFile");
-      var fs$appendFile = fs4.appendFile;
+      var fs$appendFile = fs5.appendFile;
       if (fs$appendFile)
-        fs4.appendFile = appendFile;
-      function appendFile(path3, data, options, cb) {
+        fs5.appendFile = appendFile;
+      function appendFile(path4, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path3, data, options, cb);
-        function go$appendFile(path4, data2, options2, cb2, startTime) {
-          return fs$appendFile(path4, data2, options2, function(err) {
+        return go$appendFile(path4, data, options, cb);
+        function go$appendFile(path5, data2, options2, cb2, startTime) {
+          return fs$appendFile(path5, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path5, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3302,9 +3302,9 @@ var require_graceful_fs = __commonJS({
         __name(go$appendFile, "go$appendFile");
       }
       __name(appendFile, "appendFile");
-      var fs$copyFile = fs4.copyFile;
+      var fs$copyFile = fs5.copyFile;
       if (fs$copyFile)
-        fs4.copyFile = copyFile;
+        fs5.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -3324,34 +3324,34 @@ var require_graceful_fs = __commonJS({
         __name(go$copyFile, "go$copyFile");
       }
       __name(copyFile, "copyFile");
-      var fs$readdir = fs4.readdir;
-      fs4.readdir = readdir2;
+      var fs$readdir = fs5.readdir;
+      fs5.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path3, options, cb) {
+      function readdir2(path4, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path4, options2, cb2, startTime) {
-          return fs$readdir(path4, fs$readdirCallback(
-            path4,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, fs$readdirCallback(
+            path5,
             options2,
             cb2,
             startTime
           ));
-        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path4, options2, cb2, startTime) {
-          return fs$readdir(path4, options2, fs$readdirCallback(
-            path4,
+        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path5, options2, cb2, startTime) {
+          return fs$readdir(path5, options2, fs$readdirCallback(
+            path5,
             options2,
             cb2,
             startTime
           ));
         }, "go$readdir");
-        return go$readdir(path3, options, cb);
-        function fs$readdirCallback(path4, options2, cb2, startTime) {
+        return go$readdir(path4, options, cb);
+        function fs$readdirCallback(path5, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path4, options2, cb2],
+                [path5, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -3368,21 +3368,21 @@ var require_graceful_fs = __commonJS({
       }
       __name(readdir2, "readdir");
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs4);
+        var legStreams = legacy(fs5);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs4.ReadStream;
+      var fs$ReadStream = fs5.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs4.WriteStream;
+      var fs$WriteStream = fs5.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs4, "ReadStream", {
+      Object.defineProperty(fs5, "ReadStream", {
         get: /* @__PURE__ */ __name(function() {
           return ReadStream;
         }, "get"),
@@ -3392,7 +3392,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs4, "WriteStream", {
+      Object.defineProperty(fs5, "WriteStream", {
         get: /* @__PURE__ */ __name(function() {
           return WriteStream;
         }, "get"),
@@ -3403,7 +3403,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs4, "FileReadStream", {
+      Object.defineProperty(fs5, "FileReadStream", {
         get: /* @__PURE__ */ __name(function() {
           return FileReadStream;
         }, "get"),
@@ -3414,7 +3414,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs4, "FileWriteStream", {
+      Object.defineProperty(fs5, "FileWriteStream", {
         get: /* @__PURE__ */ __name(function() {
           return FileWriteStream;
         }, "get"),
@@ -3424,7 +3424,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path3, options) {
+      function ReadStream(path4, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -3446,7 +3446,7 @@ var require_graceful_fs = __commonJS({
         });
       }
       __name(ReadStream$open, "ReadStream$open");
-      function WriteStream(path3, options) {
+      function WriteStream(path4, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -3466,24 +3466,24 @@ var require_graceful_fs = __commonJS({
         });
       }
       __name(WriteStream$open, "WriteStream$open");
-      function createReadStream(path3, options) {
-        return new fs4.ReadStream(path3, options);
+      function createReadStream(path4, options) {
+        return new fs5.ReadStream(path4, options);
       }
       __name(createReadStream, "createReadStream");
-      function createWriteStream(path3, options) {
-        return new fs4.WriteStream(path3, options);
+      function createWriteStream(path4, options) {
+        return new fs5.WriteStream(path4, options);
       }
       __name(createWriteStream, "createWriteStream");
-      var fs$open = fs4.open;
-      fs4.open = open;
-      function open(path3, flags, mode, cb) {
+      var fs$open = fs5.open;
+      fs5.open = open;
+      function open(path4, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path3, flags, mode, cb);
-        function go$open(path4, flags2, mode2, cb2, startTime) {
-          return fs$open(path4, flags2, mode2, function(err, fd) {
+        return go$open(path4, flags, mode, cb);
+        function go$open(path5, flags2, mode2, cb2, startTime) {
+          return fs$open(path5, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path4, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path5, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -3493,22 +3493,22 @@ var require_graceful_fs = __commonJS({
         __name(go$open, "go$open");
       }
       __name(open, "open");
-      return fs4;
+      return fs5;
     }
     __name(patch, "patch");
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs3[gracefulQueue].push(elem);
+      fs4[gracefulQueue].push(elem);
       retry();
     }
     __name(enqueue, "enqueue");
     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 < fs4[gracefulQueue].length; ++i) {
+        if (fs4[gracefulQueue][i].length > 2) {
+          fs4[gracefulQueue][i][3] = now;
+          fs4[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -3517,9 +3517,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs3[gracefulQueue].length === 0)
+      if (fs4[gracefulQueue].length === 0)
         return;
-      var elem = fs3[gracefulQueue].shift();
+      var elem = fs4[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -3541,7 +3541,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs3[gracefulQueue].push(elem);
+          fs4[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -3557,7 +3557,7 @@ var require_fs = __commonJS({
   "../../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs3 = require_graceful_fs();
+    var fs4 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -3598,26 +3598,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs3[key] === "function";
+      return typeof fs4[key] === "function";
     });
-    Object.assign(exports2, fs3);
+    Object.assign(exports2, fs4);
     api.forEach((method) => {
-      exports2[method] = u(fs3[method]);
+      exports2[method] = u(fs4[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs3.exists(filename, callback);
+        return fs4.exists(filename, callback);
       }
       return new Promise((resolve3) => {
-        return fs3.exists(filename, resolve3);
+        return fs4.exists(filename, resolve3);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs3.read(fd, buffer, offset, length, position, callback);
+        return fs4.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve3, reject) => {
-        fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve3({ bytesRead, buffer: buffer2 });
         });
@@ -3625,10 +3625,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.write(fd, buffer, ...args);
+        return fs4.write(fd, buffer, ...args);
       }
       return new Promise((resolve3, reject) => {
-        fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve3({ bytesWritten, buffer: buffer2 });
         });
@@ -3636,10 +3636,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.readv(fd, buffers, ...args);
+        return fs4.readv(fd, buffers, ...args);
       }
       return new Promise((resolve3, reject) => {
-        fs3.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs4.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve3({ bytesRead, buffers: buffers2 });
         });
@@ -3647,17 +3647,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs3.writev(fd, buffers, ...args);
+        return fs4.writev(fd, buffers, ...args);
       }
       return new Promise((resolve3, reject) => {
-        fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs4.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve3({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs3.realpath.native === "function") {
-      exports2.realpath.native = u(fs3.realpath.native);
+    if (typeof fs4.realpath.native === "function") {
+      exports2.realpath.native = u(fs4.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -3672,10 +3672,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "../../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path3 = require("path");
+    var path4 = require("path");
     module2.exports.checkPath = /* @__PURE__ */ __name(function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path3.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path4.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error2 = new Error(`Path contains invalid characters: ${pth}`);
           error2.code = "EINVAL";
@@ -3690,7 +3690,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
+    var fs4 = require_fs();
     var { checkPath } = require_utils();
     var getMode = /* @__PURE__ */ __name((options) => {
       const defaults = { mode: 511 };
@@ -3699,14 +3699,14 @@ var require_make_dir = __commonJS({
     }, "getMode");
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs3.mkdir(dir, {
+      return fs4.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs3.mkdirSync(dir, {
+      return fs4.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -3738,14 +3738,14 @@ var require_path_exists = __commonJS({
   "../../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    function pathExists(path3) {
-      return fs3.access(path3).then(() => true).catch(() => false);
+    var fs4 = require_fs();
+    function pathExists(path4) {
+      return fs4.access(path4).then(() => true).catch(() => false);
     }
     __name(pathExists, "pathExists");
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs3.existsSync
+      pathExistsSync: fs4.existsSync
     };
   }
 });
@@ -3754,16 +3754,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
+    var fs4 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path3, atime, mtime) {
-      const fd = await fs3.open(path3, "r+");
+    async function utimesMillis(path4, atime, mtime) {
+      const fd = await fs4.open(path4, "r+");
       let closeErr = null;
       try {
-        await fs3.futimes(fd, atime, mtime);
+        await fs4.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs3.close(fd);
+          await fs4.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -3773,10 +3773,10 @@ var require_utimes = __commonJS({
       }
     }
     __name(utimesMillis, "utimesMillis");
-    function utimesMillisSync(path3, atime, mtime) {
-      const fd = fs3.openSync(path3, "r+");
-      fs3.futimesSync(fd, atime, mtime);
-      return fs3.closeSync(fd);
+    function utimesMillisSync(path4, atime, mtime) {
+      const fd = fs4.openSync(path4, "r+");
+      fs4.futimesSync(fd, atime, mtime);
+      return fs4.closeSync(fd);
     }
     __name(utimesMillisSync, "utimesMillisSync");
     module2.exports = {
@@ -3790,11 +3790,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
-    var path3 = require("path");
+    var fs4 = require_fs();
+    var path4 = 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) => fs4.stat(file, { bigint: true }) : (file) => fs4.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -3806,7 +3806,7 @@ var require_stat = __commonJS({
     __name(getStats, "getStats");
     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) => fs4.statSync(file, { bigint: true }) : (file) => fs4.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -3821,8 +3821,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path3.basename(src);
-          const destBaseName = path3.basename(dest);
+          const srcBaseName = path4.basename(src);
+          const destBaseName = path4.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -3845,8 +3845,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path3.basename(src);
-          const destBaseName = path3.basename(dest);
+          const srcBaseName = path4.basename(src);
+          const destBaseName = path4.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -3866,12 +3866,12 @@ var require_stat = __commonJS({
     }
     __name(checkPathsSync, "checkPathsSync");
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path3.resolve(path3.dirname(src));
-      const destParent = path3.resolve(path3.dirname(dest));
-      if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
+      const srcParent = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs3.stat(destParent, { bigint: true });
+        destStat = await fs4.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -3883,12 +3883,12 @@ var require_stat = __commonJS({
     }
     __name(checkParentPaths, "checkParentPaths");
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path3.resolve(path3.dirname(src));
-      const destParent = path3.resolve(path3.dirname(dest));
-      if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
+      const srcParent = path4.resolve(path4.dirname(src));
+      const destParent = path4.resolve(path4.dirname(dest));
+      if (destParent === srcParent || destParent === path4.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs3.statSync(destParent, { bigint: true });
+        destStat = fs4.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -3904,8 +3904,8 @@ var require_stat = __commonJS({
     }
     __name(areIdentical, "areIdentical");
     function isSrcSubdir(src, dest) {
-      const srcArr = path3.resolve(src).split(path3.sep).filter((i) => i);
-      const destArr = path3.resolve(dest).split(path3.sep).filter((i) => i);
+      const srcArr = path4.resolve(src).split(path4.sep).filter((i) => i);
+      const destArr = path4.resolve(dest).split(path4.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     __name(isSrcSubdir, "isSrcSubdir");
@@ -3960,8 +3960,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
-    var path3 = require("path");
+    var fs4 = require_fs();
+    var path4 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -3984,7 +3984,7 @@ var require_copy = __commonJS({
       await stat2.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path3.dirname(dest);
+      const destParent = path4.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -3998,7 +3998,7 @@ var require_copy = __commonJS({
     }
     __name(runFilter, "runFilter");
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs3.stat : fs3.lstat;
+      const statFn = opts.dereference ? fs4.stat : fs4.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);
@@ -4011,7 +4011,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 fs3.unlink(dest);
+        await fs4.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -4020,15 +4020,15 @@ var require_copy = __commonJS({
     }
     __name(onFile, "onFile");
     async function copyFile(srcStat, src, dest, opts) {
-      await fs3.copyFile(src, dest);
+      await fs4.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs3.stat(src);
+        const updatedSrcStat = await fs4.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs3.chmod(dest, srcStat.mode);
+      return fs4.chmod(dest, srcStat.mode);
     }
     __name(copyFile, "copyFile");
     function fileIsNotWritable(srcMode) {
@@ -4036,16 +4036,16 @@ var require_copy = __commonJS({
     }
     __name(fileIsNotWritable, "fileIsNotWritable");
     function makeFileWritable(dest, srcMode) {
-      return fs3.chmod(dest, srcMode | 128);
+      return fs4.chmod(dest, srcMode | 128);
     }
     __name(makeFileWritable, "makeFileWritable");
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs3.mkdir(dest);
+        await fs4.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs3.opendir(src), async (item) => {
-        const srcItem = path3.join(src, item.name);
-        const destItem = path3.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs4.opendir(src), async (item) => {
+        const srcItem = path4.join(src, item.name);
+        const destItem = path4.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat2.checkPaths(srcItem, destItem, "copy", opts);
@@ -4053,27 +4053,27 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs3.chmod(dest, srcStat.mode);
+        await fs4.chmod(dest, srcStat.mode);
       }
     }
     __name(onDir, "onDir");
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs3.readlink(src);
+      let resolvedSrc = await fs4.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs3.symlink(resolvedSrc, dest);
+        return fs4.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs3.readlink(dest);
+        resolvedDest = await fs4.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs4.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path3.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path4.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -4083,8 +4083,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs3.unlink(dest);
-      return fs3.symlink(resolvedSrc, dest);
+      await fs4.unlink(dest);
+      return fs4.symlink(resolvedSrc, dest);
     }
     __name(onLink, "onLink");
     module2.exports = copy;
@@ -4095,8 +4095,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_graceful_fs();
-    var path3 = require("path");
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat2 = require_stat();
@@ -4117,13 +4117,13 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat2.checkPathsSync(src, dest, "copy", opts);
       stat2.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path3.dirname(dest);
-      if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path4.dirname(dest);
+      if (!fs4.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     __name(copySync, "copySync");
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
+      const statSync = opts.dereference ? fs4.statSync : fs4.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);
@@ -4140,7 +4140,7 @@ var require_copy_sync = __commonJS({
     __name(onFile, "onFile");
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs3.unlinkSync(dest);
+        fs4.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
@@ -4148,7 +4148,7 @@ var require_copy_sync = __commonJS({
     }
     __name(mayCopyFile, "mayCopyFile");
     function copyFile(srcStat, src, dest, opts) {
-      fs3.copyFileSync(src, dest);
+      fs4.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -4167,11 +4167,11 @@ var require_copy_sync = __commonJS({
     }
     __name(makeFileWritable, "makeFileWritable");
     function setDestMode(dest, srcMode) {
-      return fs3.chmodSync(dest, srcMode);
+      return fs4.chmodSync(dest, srcMode);
     }
     __name(setDestMode, "setDestMode");
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs3.statSync(src);
+      const updatedSrcStat = fs4.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     __name(setDestTimestamps, "setDestTimestamps");
@@ -4181,13 +4181,13 @@ var require_copy_sync = __commonJS({
     }
     __name(onDir, "onDir");
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs3.mkdirSync(dest);
+      fs4.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     __name(mkDirAndCopy, "mkDirAndCopy");
     function copyDir(src, dest, opts) {
-      const dir = fs3.opendirSync(src);
+      const dir = fs4.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -4199,30 +4199,30 @@ var require_copy_sync = __commonJS({
     }
     __name(copyDir, "copyDir");
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path3.join(src, item);
-      const destItem = path3.join(dest, item);
+      const srcItem = path4.join(src, item);
+      const destItem = path4.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     __name(copyDirItem, "copyDirItem");
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs3.readlinkSync(src);
+      let resolvedSrc = fs4.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path4.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs3.symlinkSync(resolvedSrc, dest);
+        return fs4.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs3.readlinkSync(dest);
+          resolvedDest = fs4.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs3.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs4.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path3.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path4.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -4237,8 +4237,8 @@ var require_copy_sync = __commonJS({
     }
     __name(onLink, "onLink");
     function copyLink(resolvedSrc, dest) {
-      fs3.unlinkSync(dest);
-      return fs3.symlinkSync(resolvedSrc, dest);
+      fs4.unlinkSync(dest);
+      return fs4.symlinkSync(resolvedSrc, dest);
     }
     __name(copyLink, "copyLink");
     module2.exports = copySync;
@@ -4261,14 +4261,14 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_graceful_fs();
+    var fs4 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path3, callback) {
-      fs3.rm(path3, { recursive: true, force: true }, callback);
+    function remove(path4, callback) {
+      fs4.rm(path4, { recursive: true, force: true }, callback);
     }
     __name(remove, "remove");
-    function removeSync(path3) {
-      fs3.rmSync(path3, { recursive: true, force: true });
+    function removeSync(path4) {
+      fs4.rmSync(path4, { recursive: true, force: true });
     }
     __name(removeSync, "removeSync");
     module2.exports = {
@@ -4283,28 +4283,28 @@ var require_empty = __commonJS({
   "../../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    var path3 = require("path");
+    var fs4 = require_fs();
+    var path4 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(/* @__PURE__ */ __name(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs3.readdir(dir);
+        items = await fs4.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path3.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path4.join(dir, item))));
     }, "emptyDir"));
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs3.readdirSync(dir);
+        items = fs4.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path3.join(dir, item);
+        item = path4.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -4323,53 +4323,53 @@ var require_file = __commonJS({
   "../../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path3 = require("path");
-    var fs3 = require_fs();
+    var path4 = require("path");
+    var fs4 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs3.stat(file);
+        stats = await fs4.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path3.dirname(file);
+      const dir = path4.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs3.stat(dir);
+        dirStats = await fs4.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs3.writeFile(file, "");
+          await fs4.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs3.writeFile(file, "");
+        await fs4.writeFile(file, "");
       } else {
-        await fs3.readdir(dir);
+        await fs4.readdir(dir);
       }
     }
     __name(createFile, "createFile");
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs3.statSync(file);
+        stats = fs4.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path3.dirname(file);
+      const dir = path4.dirname(file);
       try {
-        if (!fs3.statSync(dir).isDirectory()) {
-          fs3.readdirSync(dir);
+        if (!fs4.statSync(dir).isDirectory()) {
+          fs4.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs3.writeFileSync(file, "");
+      fs4.writeFileSync(file, "");
     }
     __name(createFileSync, "createFileSync");
     module2.exports = {
@@ -4384,51 +4384,51 @@ var require_link = __commonJS({
   "../../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path3 = require("path");
-    var fs3 = require_fs();
+    var path4 = require("path");
+    var fs4 = 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 fs4.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs3.lstat(srcpath);
+        srcStat = await fs4.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path3.dirname(dstpath);
+      const dir = path4.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs3.link(srcpath, dstpath);
+      await fs4.link(srcpath, dstpath);
     }
     __name(createLink, "createLink");
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs3.lstatSync(dstpath);
+        dstStat = fs4.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs3.lstatSync(srcpath);
+        const srcStat = fs4.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path3.dirname(dstpath);
-      const dirExists = fs3.existsSync(dir);
-      if (dirExists) return fs3.linkSync(srcpath, dstpath);
+      const dir = path4.dirname(dstpath);
+      const dirExists = fs4.existsSync(dir);
+      if (dirExists) return fs4.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs3.linkSync(srcpath, dstpath);
+      return fs4.linkSync(srcpath, dstpath);
     }
     __name(createLinkSync, "createLinkSync");
     module2.exports = {
@@ -4442,14 +4442,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path3 = require("path");
-    var fs3 = require_fs();
+    var path4 = require("path");
+    var fs4 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path3.isAbsolute(srcpath)) {
+      if (path4.isAbsolute(srcpath)) {
         try {
-          await fs3.lstat(srcpath);
+          await fs4.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -4459,8 +4459,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path3.dirname(dstpath);
-      const relativeToDst = path3.join(dstdir, srcpath);
+      const dstdir = path4.dirname(dstpath);
+      const relativeToDst = path4.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -4469,40 +4469,40 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs3.lstat(srcpath);
+        await fs4.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path3.relative(dstdir, srcpath)
+        toDst: path4.relative(dstdir, srcpath)
       };
     }
     __name(symlinkPaths, "symlinkPaths");
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path3.isAbsolute(srcpath)) {
-        const exists2 = fs3.existsSync(srcpath);
+      if (path4.isAbsolute(srcpath)) {
+        const exists2 = fs4.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path3.dirname(dstpath);
-      const relativeToDst = path3.join(dstdir, srcpath);
-      const exists = fs3.existsSync(relativeToDst);
+      const dstdir = path4.dirname(dstpath);
+      const relativeToDst = path4.join(dstdir, srcpath);
+      const exists = fs4.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs3.existsSync(srcpath);
+      const srcExists = fs4.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path3.relative(dstdir, srcpath)
+        toDst: path4.relative(dstdir, srcpath)
       };
     }
     __name(symlinkPathsSync, "symlinkPathsSync");
@@ -4517,13 +4517,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
+    var fs4 = 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 fs4.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -4534,7 +4534,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs3.lstatSync(srcpath);
+        stats = fs4.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -4553,8 +4553,8 @@ var require_symlink = __commonJS({
   "../../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path3 = require("path");
-    var fs3 = require_fs();
+    var path4 = require("path");
+    var fs4 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -4563,65 +4563,65 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs3.lstat(dstpath);
+        stats = await fs4.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path3.isAbsolute(srcpath)) {
-          srcStat = await fs3.stat(srcpath);
+        if (path4.isAbsolute(srcpath)) {
+          srcStat = await fs4.stat(srcpath);
         } else {
-          const dstdir = path3.dirname(dstpath);
-          const relativeToDst = path3.join(dstdir, srcpath);
+          const dstdir = path4.dirname(dstpath);
+          const relativeToDst = path4.join(dstdir, srcpath);
           try {
-            srcStat = await fs3.stat(relativeToDst);
+            srcStat = await fs4.stat(relativeToDst);
           } catch {
-            srcStat = await fs3.stat(srcpath);
+            srcStat = await fs4.stat(srcpath);
           }
         }
-        const dstStat = await fs3.stat(dstpath);
+        const dstStat = await fs4.stat(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = await symlinkPaths(srcpath, dstpath);
       srcpath = relative2.toDst;
       const toType = await symlinkType(relative2.toCwd, type);
-      const dir = path3.dirname(dstpath);
+      const dir = path4.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs3.symlink(srcpath, dstpath, toType);
+      return fs4.symlink(srcpath, dstpath, toType);
     }
     __name(createSymlink, "createSymlink");
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs3.lstatSync(dstpath);
+        stats = fs4.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
-        if (path3.isAbsolute(srcpath)) {
-          srcStat = fs3.statSync(srcpath);
+        if (path4.isAbsolute(srcpath)) {
+          srcStat = fs4.statSync(srcpath);
         } else {
-          const dstdir = path3.dirname(dstpath);
-          const relativeToDst = path3.join(dstdir, srcpath);
+          const dstdir = path4.dirname(dstpath);
+          const relativeToDst = path4.join(dstdir, srcpath);
           try {
-            srcStat = fs3.statSync(relativeToDst);
+            srcStat = fs4.statSync(relativeToDst);
           } catch {
-            srcStat = fs3.statSync(srcpath);
+            srcStat = fs4.statSync(srcpath);
           }
         }
-        const dstStat = fs3.statSync(dstpath);
+        const dstStat = fs4.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative2 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative2.toDst;
       type = symlinkTypeSync(relative2.toCwd, type);
-      const dir = path3.dirname(dstpath);
-      const exists = fs3.existsSync(dir);
-      if (exists) return fs3.symlinkSync(srcpath, dstpath, type);
+      const dir = path4.dirname(dstpath);
+      const exists = fs4.existsSync(dir);
+      if (exists) return fs4.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs3.symlinkSync(srcpath, dstpath, type);
+      return fs4.symlinkSync(srcpath, dstpath, type);
     }
     __name(createSymlinkSync, "createSymlinkSync");
     module2.exports = {
@@ -4691,9 +4691,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs3 = options.fs || _fs;
+      const fs4 = 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(fs4.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -4709,15 +4709,15 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     __name(_readFile, "_readFile");
-    var readFile = universalify.fromPromise(_readFile);
+    var readFile2 = universalify.fromPromise(_readFile);
     function readFileSync2(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs3 = options.fs || _fs;
+      const fs4 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs3.readFileSync(file, options);
+        let content = fs4.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -4731,20 +4731,20 @@ var require_jsonfile = __commonJS({
     }
     __name(readFileSync2, "readFileSync");
     async function _writeFile(file, obj, options = {}) {
-      const fs3 = options.fs || _fs;
+      const fs4 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs3.writeFile)(file, str, options);
+      await universalify.fromCallback(fs4.writeFile)(file, str, options);
     }
     __name(_writeFile, "_writeFile");
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs3 = options.fs || _fs;
+      const fs4 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs3.writeFileSync(file, str, options);
+      return fs4.writeFileSync(file, str, options);
     }
     __name(writeFileSync, "writeFileSync");
     module2.exports = {
-      readFile,
+      readFile: readFile2,
       readFileSync: readFileSync2,
       writeFile,
       writeFileSync
@@ -4772,24 +4772,24 @@ var require_output_file = __commonJS({
   "../../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs3 = require_fs();
-    var path3 = require("path");
+    var fs4 = require_fs();
+    var path4 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file, data, encoding = "utf-8") {
-      const dir = path3.dirname(file);
+      const dir = path4.dirname(file);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs3.writeFile(file, data, encoding);
+      return fs4.writeFile(file, data, encoding);
     }
     __name(outputFile, "outputFile");
     function outputFileSync(file, ...args) {
-      const dir = path3.dirname(file);
-      if (!fs3.existsSync(dir)) {
+      const dir = path4.dirname(file);
+      if (!fs4.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs3.writeFileSync(file, ...args);
+      fs4.writeFileSync(file, ...args);
     }
     __name(outputFileSync, "outputFileSync");
     module2.exports = {
@@ -4851,8 +4851,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_fs();
-    var path3 = require("path");
+    var fs4 = require_fs();
+    var path4 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -4862,8 +4862,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat2.checkPaths(src, dest, "move", opts);
       await stat2.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path3.dirname(dest);
-      const parsedParentPath = path3.parse(destParent);
+      const destParent = path4.dirname(dest);
+      const parsedParentPath = path4.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -4879,7 +4879,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs3.rename(src, dest);
+        await fs4.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -4906,8 +4906,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs3 = require_graceful_fs();
-    var path3 = require("path");
+    var fs4 = require_graceful_fs();
+    var path4 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -4917,13 +4917,13 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
       stat2.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path3.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path4.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     __name(moveSync, "moveSync");
     function isParentRoot(dest) {
-      const parent = path3.dirname(dest);
-      const parsedPath = path3.parse(parent);
+      const parent = path4.dirname(dest);
+      const parsedPath = path4.parse(parent);
       return parsedPath.root === parent;
     }
     __name(isParentRoot, "isParentRoot");
@@ -4933,13 +4933,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs3.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs4.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     __name(doRename, "doRename");
     function rename(src, dest, overwrite) {
       try {
-        fs3.renameSync(src, dest);
+        fs4.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -4993,6 +4993,56 @@ var require_lib = __commonJS({
   }
 });
 
+// lib/runner/private/test-specific-context.ts
+async function findTestSpecificContext(directory) {
+  const existing = CONTEXT_CACHE.get(directory);
+  if (existing) {
+    return existing;
+  }
+  let maybeContext;
+  if (maybeContext === void 0) {
+    const contextFile = path.join(directory, INTEG_CONTEXT_JSON_FILE);
+    maybeContext = await tryReadJsonFile(contextFile);
+  }
+  if (maybeContext === void 0) {
+    const cdkJsonFile = path.join(directory, CDK_JSON_FILE);
+    let maybeCdkJson = await tryReadJsonFile(cdkJsonFile);
+    maybeContext = maybeCdkJson?.context;
+  }
+  if (maybeContext === void 0) {
+    const parentDir = path.dirname(directory);
+    if (parentDir !== directory) {
+      maybeContext = await findTestSpecificContext(parentDir);
+    }
+  }
+  CONTEXT_CACHE.set(directory, maybeContext);
+  return maybeContext;
+}
+async function tryReadJsonFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    return JSON.parse(content);
+  } catch (e) {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") {
+      return void 0;
+    }
+    throw e;
+  }
+}
+var fs, path, INTEG_CONTEXT_JSON_FILE, CDK_JSON_FILE, CONTEXT_CACHE;
+var init_test_specific_context = __esm({
+  "lib/runner/private/test-specific-context.ts"() {
+    "use strict";
+    fs = __toESM(require("fs/promises"));
+    path = __toESM(require("path"));
+    INTEG_CONTEXT_JSON_FILE = "integ.context.json";
+    CDK_JSON_FILE = "cdk.json";
+    CONTEXT_CACHE = /* @__PURE__ */ new Map();
+    __name(findTestSpecificContext, "findTestSpecificContext");
+    __name(tryReadJsonFile, "tryReadJsonFile");
+  }
+});
+
 // lib/runner/integration-tests.ts
 function pythonExecutable() {
   let python = "python3";
@@ -5001,26 +5051,27 @@ function pythonExecutable() {
   }
   return python;
 }
-var path, fs, CDK_OUTDIR_PREFIX, IntegTest, IntegrationTests;
+var path2, fs2, CDK_OUTDIR_PREFIX, IntegTest, IntegrationTests;
 var init_integration_tests = __esm({
   "lib/runner/integration-tests.ts"() {
     "use strict";
-    path = __toESM(require("path"));
-    fs = __toESM(require_lib());
+    path2 = __toESM(require("path"));
+    fs2 = __toESM(require_lib());
+    init_test_specific_context();
     CDK_OUTDIR_PREFIX = "cdk-integ.out";
     IntegTest = class {
       constructor(info) {
         this.info = info;
         this.appCommand = info.appCommand ?? "node {filePath}";
         this.directory = process.cwd();
-        this.absoluteFileName = path.resolve(info.fileName);
-        this.fileName = path.relative(this.directory, info.fileName);
-        this.discoveryRelativeFileName = path.relative(info.discoveryRoot, info.fileName);
-        const parsed = path.parse(this.fileName);
-        this.testName = path.join(path.relative(this.info.discoveryRoot, parsed.dir), parsed.name);
+        this.absoluteFileName = path2.resolve(info.fileName);
+        this.fileName = path2.relative(this.directory, info.fileName);
+        this.discoveryRelativeFileName = path2.relative(info.discoveryRoot, info.fileName);
+        const parsed = path2.parse(this.fileName);
+        this.testName = path2.join(path2.relative(this.info.discoveryRoot, parsed.dir), parsed.name);
         this.normalizedTestName = parsed.name;
-        this.snapshotDir = path.join(parsed.dir, `${parsed.base}.snapshot`);
-        this.temporaryOutputDir = path.join(parsed.dir, `${CDK_OUTDIR_PREFIX}.${parsed.base}.snapshot`);
+        this.snapshotDir = path2.join(parsed.dir, `${parsed.base}.snapshot`);
+        this.temporaryOutputDir = path2.join(parsed.dir, `${CDK_OUTDIR_PREFIX}.${parsed.base}.snapshot`);
       }
       info;
       static {
@@ -5093,6 +5144,16 @@ var init_integration_tests = __esm({
           this.absoluteFileName
         ].includes(name);
       }
+      /**
+       * Search for a test-specific context file and return its contents if it exists.
+       *
+       * If `undefined`, no test-specific context could be found. Test-specific context
+       * will be taken from either `integ.context.json` if found, or otherwise
+       * `cdk.json#context` if not found, upstream from the test.
+       */
+      async testSpecificContext() {
+        return findTestSpecificContext(this.fileName);
+      }
     };
     __name(pythonExecutable, "pythonExecutable");
     IntegrationTests = class {
@@ -5203,7 +5264,7 @@ var init_integration_tests = __esm({
         const testCases = Object.entries(options.testCases).flatMap(
           ([appCommand, patterns]) => files.filter((fileName) => patterns.some((pattern) => {
             const regex = new RegExp(pattern);
-            return regex.test(fileName) || regex.test(path.basename(fileName));
+            return regex.test(fileName) || regex.test(path2.basename(fileName));
           })).map((fileName) => new IntegTest({
             discoveryRoot: this.directory,
             fileName,
@@ -5225,10 +5286,10 @@ var init_integration_tests = __esm({
       async readTree() {
         const ret = new Array();
         async function recurse(dir) {
-          const files = await fs.readdir(dir);
+          const files = await fs2.readdir(dir);
           for (const file of files) {
-            const fullPath = path.join(dir, file);
-            const statf = await fs.stat(fullPath);
+            const fullPath = path2.join(dir, file);
+            const statf = await fs2.stat(fullPath);
             if (statf.isFile()) {
               ret.push(fullPath);
             }
@@ -5304,37 +5365,37 @@ var init_unstable_features = __esm({
 // lib/workers/common.ts
 function printSummary(total, failed) {
   if (failed > 0) {
-    print("%s:    %s %s, %s total", chalk2.bold("Tests"), chalk2.red(failed), chalk2.red("failed"), total);
+    print("%s:    %s %s, %s total", import_chalk2.default.bold("Tests"), import_chalk2.default.red(failed), import_chalk2.default.red("failed"), total);
   } else {
-    print("%s:    %s %s, %s total", chalk2.bold("Tests"), chalk2.green(total), chalk2.green("passed"), total);
+    print("%s:    %s %s, %s total", import_chalk2.default.bold("Tests"), import_chalk2.default.green(total), import_chalk2.default.green("passed"), total);
   }
 }
 function printResults(diagnostic) {
   switch (diagnostic.reason) {
     case "SNAPSHOT_SUCCESS" /* SNAPSHOT_SUCCESS */:
-      success("  UNCHANGED  %s %s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`));
+      success("  UNCHANGED  %s %s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`));
       break;
     case "TEST_SUCCESS" /* TEST_SUCCESS */:
-      success("  SUCCESS    %s %s\n      ", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`));
+      success("  SUCCESS    %s %s\n      ", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`));
       break;
     case "NO_SNAPSHOT" /* NO_SNAPSHOT */:
-      error("  NEW        %s %s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`));
+      error("  NEW        %s %s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`));
       break;
     case "SNAPSHOT_FAILED" /* SNAPSHOT_FAILED */:
-      error("  CHANGED    %s %s\n%s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
+      error("  CHANGED    %s %s\n%s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
       break;
     case "TEST_WARNING" /* TEST_WARNING */:
-      warning("  WARN       %s %s\n%s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
+      warning("  WARN       %s %s\n%s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
       break;
     case "SNAPSHOT_ERROR" /* SNAPSHOT_ERROR */:
     case "TEST_ERROR" /* TEST_ERROR */:
-      error("  ERROR      %s %s\n%s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
+      error("  ERROR      %s %s\n%s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
       break;
     case "TEST_FAILED" /* TEST_FAILED */:
-      error("  FAILED     %s %s\n%s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
+      error("  FAILED     %s %s\n%s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
       break;
     case "ASSERTION_FAILED" /* ASSERTION_FAILED */:
-      error("  ASSERT     %s %s\n%s", diagnostic.testName, chalk2.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
+      error("  ASSERT     %s %s\n%s", diagnostic.testName, import_chalk2.default.gray(`${diagnostic.duration}s`), indentLines(diagnostic.message, 6));
       break;
   }
   for (const addl of diagnostic.additionalMessages ?? []) {
@@ -5350,13 +5411,13 @@ function printLaggards(testNames) {
     `Waiting for ${testNames.size} more`,
     testNames.size < 10 ? ["(", Array.from(testNames).join(", "), ")"].join("") : ""
   ];
-  print(chalk2.grey(parts.filter((x) => x).join(" ")));
+  print(import_chalk2.default.grey(parts.filter((x) => x).join(" ")));
 }
-var chalk2;
+var import_chalk2;
 var init_common = __esm({
   "lib/workers/common.ts"() {
     "use strict";
-    chalk2 = __toESM(require_source());
+    import_chalk2 = __toESM(require_source());
     init_logger();
     __name(printSummary, "printSummary");
     __name(printResults, "printResults");
@@ -5574,9 +5635,9 @@ var init_integ_watch_worker = __esm({
 var require_build = __commonJS({
   "../../../node_modules/y18n/build/index.cjs"(exports2, module2) {
     "use strict";
-    var fs3 = require("fs");
+    var fs4 = require("fs");
     var util2 = require("util");
-    var path3 = require("path");
+    var path4 = require("path");
     var shim;
     var Y18N = class {
       static {
@@ -5742,14 +5803,14 @@ var require_build = __commonJS({
     __name(y18n$1, "y18n$1");
     var nodePlatformShim = {
       fs: {
-        readFileSync: fs3.readFileSync,
-        writeFile: fs3.writeFile
+        readFileSync: fs4.readFileSync,
+        writeFile: fs4.writeFile
       },
       format: util2.format,
-      resolve: path3.resolve,
+      resolve: path4.resolve,
       exists: /* @__PURE__ */ __name((file) => {
         try {
-          return fs3.statSync(file).isFile();
+          return fs4.statSync(file).isFile();
         } catch (err) {
           return false;
         }
@@ -5767,8 +5828,8 @@ var require_build2 = __commonJS({
   "node_modules/yargs-parser/build/index.cjs"(exports2, module2) {
     "use strict";
     var util2 = require("util");
-    var fs3 = require("fs");
-    var path3 = require("path");
+    var fs4 = require("fs");
+    var path4 = require("path");
     function camelCase(str) {
       const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
       if (!isCamelCase) {
@@ -6741,13 +6802,13 @@ var require_build2 = __commonJS({
         return env;
       }, "env"),
       format: util2.format,
-      normalize: path3.normalize,
-      resolve: path3.resolve,
-      require: /* @__PURE__ */ __name((path4) => {
+      normalize: path4.normalize,
+      resolve: path4.resolve,
+      require: /* @__PURE__ */ __name((path5) => {
         if (typeof require !== "undefined") {
-          return require(path4);
-        } else if (path4.match(/\.json$/)) {
-          return fs3.readFileSync(path4, "utf8");
+          return require(path5);
+        } else if (path5.match(/\.json$/)) {
+          return fs4.readFileSync(path5, "utf8");
         } else {
           throw Error("only .json config files are supported in ESM");
         }
@@ -7314,18 +7375,18 @@ var require_build3 = __commonJS({
 // ../../../node_modules/escalade/sync/index.js
 var require_sync = __commonJS({
   "../../../node_modules/escalade/sync/index.js"(exports2, module2) {
-    var { dirname, resolve: resolve3 } = require("path");
+    var { dirname: dirname2, resolve: resolve3 } = require("path");
     var { readdirSync, statSync } = require("fs");
     module2.exports = function(start, callback) {
       let dir = resolve3(".", start);
       let tmp, stats = statSync(dir);
       if (!stats.isDirectory()) {
-        dir = dirname(dir);
+        dir = dirname2(dir);
       }
       while (true) {
         tmp = callback(dir, readdirSync(dir));
         if (tmp) return resolve3(dir, tmp);
-        dir = dirname(tmp = dir);
+        dir = dirname2(tmp = dir);
         if (tmp === dir) break;
       }
     };
@@ -7360,10 +7421,10 @@ var require_get_caller_file = __commonJS({
 var require_require_directory = __commonJS({
   "../../../node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
-    var fs3 = require("fs");
-    var join3 = require("path").join;
+    var fs4 = require("fs");
+    var join4 = require("path").join;
     var resolve3 = require("path").resolve;
-    var dirname = require("path").dirname;
+    var dirname2 = require("path").dirname;
     var defaultOptions = {
       extensions: ["js", "json", "coffee"],
       recurse: true,
@@ -7374,22 +7435,22 @@ var require_require_directory = __commonJS({
         return obj;
       }, "visit")
     };
-    function checkFileInclusion(path3, filename, options) {
+    function checkFileInclusion(path4, filename, options) {
       return (
         // verify file has valid extension
         new RegExp("\\.(" + options.extensions.join("|") + ")$", "i").test(filename) && // if options.include is a RegExp, evaluate it and make sure the path passes
-        !(options.include && options.include instanceof RegExp && !options.include.test(path3)) && // if options.include is a function, evaluate it and make sure the path passes
-        !(options.include && typeof options.include === "function" && !options.include(path3, filename)) && // if options.exclude is a RegExp, evaluate it and make sure the path doesn't pass
-        !(options.exclude && options.exclude instanceof RegExp && options.exclude.test(path3)) && // if options.exclude is a function, evaluate it and make sure the path doesn't pass
-        !(options.exclude && typeof options.exclude === "function" && options.exclude(path3, filename))
+        !(options.include && options.include instanceof RegExp && !options.include.test(path4)) && // if options.include is a function, evaluate it and make sure the path passes
+        !(options.include && typeof options.include === "function" && !options.include(path4, filename)) && // if options.exclude is a RegExp, evaluate it and make sure the path doesn't pass
+        !(options.exclude && options.exclude instanceof RegExp && options.exclude.test(path4)) && // if options.exclude is a function, evaluate it and make sure the path doesn't pass
+        !(options.exclude && typeof options.exclude === "function" && options.exclude(path4, filename))
       );
     }
     __name(checkFileInclusion, "checkFileInclusion");
-    function requireDirectory(m, path3, options) {
+    function requireDirectory(m, path4, options) {
       var retval = {};
-      if (path3 && !options && typeof path3 !== "string") {
-        options = path3;
-        path3 = null;
+      if (path4 && !options && typeof path4 !== "string") {
+        options = path4;
+        path4 = null;
       }
       options = options || {};
       for (var prop in defaultOptions) {
@@ -7397,10 +7458,10 @@ var require_require_directory = __commonJS({
           options[prop] = defaultOptions[prop];
         }
       }
-      path3 = !path3 ? dirname(m.filename) : resolve3(dirname(m.filename), path3);
-      fs3.readdirSync(path3).forEach(function(filename) {
-        var joined = join3(path3, filename), files, key, obj;
-        if (fs3.statSync(joined).isDirectory() && options.recurse) {
+      path4 = !path4 ? dirname2(m.filename) : resolve3(dirname2(m.filename), path4);
+      fs4.readdirSync(path4).forEach(function(filename) {
+        var joined = join4(path4, filename), files, key, obj;
+        if (fs4.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
             retval[options.rename(filename, joined, filename)] = files;
@@ -10280,7 +10341,7 @@ function parseCliArgs(args = []) {
   if (argv.strict && argv.exclude) {
     throw new Error("Cannot use --strict with --exclude");
   }
-  const requestedTests = fromFile ? fs2.readFileSync(fromFile, { encoding: "utf8" }).split("\n").filter((x) => x).filter((x) => !x.startsWith("#")) : tests.length > 0 ? tests : void 0;
+  const requestedTests = fromFile ? fs3.readFileSync(fromFile, { encoding: "utf8" }).split("\n").filter((x) => x).filter((x) => !x.startsWith("#")) : tests.length > 0 ? tests : void 0;
   if (argv["disable-update-workflow"] !== void 0 && argv["update-workflow"] !== void 0) {
     throw new Error("--disable-update-workflow and --[no-]update-workflow cannot be used together");
   }
@@ -10334,12 +10395,12 @@ async function run(options) {
   if (options.updateFromTags) {
     options.force = true;
   }
-  const testsFromArgs = await new IntegrationTests(path2.resolve(options.directory)).fromCliOptions(options);
+  const testsFromArgs = await new IntegrationTests(path3.resolve(options.directory)).fromCliOptions(options);
   if (options.list) {
     process.stdout.write(testsFromArgs.map((t) => t.discoveryRelativeFileName).join("\n") + "\n");
     return;
   }
-  const pool2 = workerpool.pool(path2.join(__dirname, "..", "lib", "workers", "extract", "index.js"), {
+  const pool2 = workerpool.pool(path3.join(__dirname, "..", "lib", "workers", "extract", "index.js"), {
     maxWorkers: options.watch ? 1 : options.maxWorkers
   });
   const testsToRun = [];
@@ -10440,7 +10501,7 @@ function validateWatchArgs(args) {
 }
 function printDestructiveChanges(changes) {
   if (changes.length > 0) {
-    warning("!!! This test contains %s !!!", chalk3.bold("destructive changes"));
+    warning("!!! This test contains %s !!!", import_chalk3.default.bold("destructive changes"));
     changes.forEach((change) => {
       warning("    Stack: %s - Resource: %s - Impact: %s", change.stackName, change.logicalId, change.impact);
     });
@@ -10478,7 +10539,7 @@ function configFromFile(fileName) {
     return {};
   }
   try {
-    return JSON.parse(fs2.readFileSync(fileName, { encoding: "utf-8" }));
+    return JSON.parse(fs3.readFileSync(fileName, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -10486,13 +10547,13 @@ function configFromFile(fileName) {
 function splitByComma(xs) {
   return xs.flatMap((x) => x.split(",")).map((x) => x.trim());
 }
-var fs2, path2, chalk3, workerpool, yargs;
+var fs3, path3, import_chalk3, workerpool, yargs;
 var init_cli = __esm({
   "lib/cli.ts"() {
     "use strict";
-    fs2 = __toESM(require("fs"));
-    path2 = __toESM(require("path"));
-    chalk3 = __toESM(require_source());
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    import_chalk3 = __toESM(require_source());
     workerpool = __toESM(require_src());
     init_logger();
     init_integration_tests();