@settlemint/sdk-cli 1.0.9-main73ff5050 → 1.0.9-main74c34848

package/dist/cli.js

@@ -202564,24 +202564,24 @@ ${options.prefix}` : `
       }
       filesToStringWorker(writeProjectFileNames, writeFileExplaination, writeFileVersionAndText) {
         if (this.initialLoadPending)
-          return `	Files (0) InitialLoadPending
+          return `\tFiles (0) InitialLoadPending
 `;
         if (!this.program)
-          return `	Files (0) NoProgram
+          return `\tFiles (0) NoProgram
 `;
         const sourceFiles = this.program.getSourceFiles();
-        let strBuilder = `	Files (${sourceFiles.length})
+        let strBuilder = `\tFiles (${sourceFiles.length})
 `;
         if (writeProjectFileNames) {
           for (const file of sourceFiles) {
-            strBuilder += `	${file.fileName}${writeFileVersionAndText ? ` ${file.version} ${JSON.stringify(file.text)}` : ""}
+            strBuilder += `\t${file.fileName}${writeFileVersionAndText ? ` ${file.version} ${JSON.stringify(file.text)}` : ""}
 `;
           }
           if (writeFileExplaination) {
             strBuilder += `
 
 `;
-            explainFiles(this.program, (s2) => strBuilder += `	${s2}
+            explainFiles(this.program, (s2) => strBuilder += `\t${s2}
 `);
           }
         }
@@ -204716,8 +204716,8 @@ ${options.prefix}` : `
         this.logger.info("Open files: ");
         this.openFiles.forEach((projectRootPath, path5) => {
           const info = this.getScriptInfoForPath(path5);
-          this.logger.info(`	FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
-          this.logger.info(`		Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
+          this.logger.info(`\tFileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
+          this.logger.info(`\t\tProjects: ${info.containingProjects.map((p) => p.getProjectName())}`);
         });
         this.logger.endGroup();
       }
@@ -228191,6 +228191,222 @@ var require_lib12 = __commonJS((exports, module) => {
   module.exports = MuteStream;
 });
 
+// ../../node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm(() => {
+  signals = [];
+  signals.push("SIGHUP", "SIGINT", "SIGTERM");
+  if (process.platform !== "win32") {
+    signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+  }
+});
+
+// ../../node_modules/signal-exit/dist/mjs/index.js
+class Emitter2 {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global2[kExitEmitter]) {
+      return global2[kExitEmitter];
+    }
+    ObjectDefineProperty(global2, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list3 = this.listeners[ev];
+    const i6 = list3.indexOf(fn);
+    if (i6 === -1) {
+      return;
+    }
+    if (i6 === 0 && list3.length === 1) {
+      list3.length = 0;
+    } else {
+      list3.splice(i6, 1);
+    }
+  }
+  emit(ev, code2, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code2, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code2, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase2 {
+}
+var processOk2 = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function", kExitEmitter, global2, ObjectDefineProperty, signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+}, SignalExitFallback2, SignalExit2, process7, onExit, load2, unload;
+var init_mjs = __esm(() => {
+  init_signals();
+  kExitEmitter = Symbol.for("signal-exit emitter");
+  global2 = globalThis;
+  ObjectDefineProperty = Object.defineProperty.bind(Object);
+  SignalExitFallback2 = class SignalExitFallback2 extends SignalExitBase2 {
+    onExit() {
+      return () => {
+      };
+    }
+    load() {
+    }
+    unload() {
+    }
+  };
+  SignalExit2 = class SignalExit2 extends SignalExitBase2 {
+    #hupSig = process7.platform === "win32" ? "SIGINT" : "SIGHUP";
+    #emitter = new Emitter2;
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process7) {
+      super();
+      this.#process = process7;
+      this.#sigListeners = {};
+      for (const sig of signals) {
+        this.#sigListeners[sig] = () => {
+          const listeners = this.#process.listeners(sig);
+          let { count } = this.#emitter;
+          const p6 = process7;
+          if (typeof p6.__signal_exit_emitter__ === "object" && typeof p6.__signal_exit_emitter__.count === "number") {
+            count += p6.__signal_exit_emitter__.count;
+          }
+          if (listeners.length === count) {
+            this.unload();
+            const ret = this.#emitter.emit("exit", null, sig);
+            const s8 = sig === "SIGHUP" ? this.#hupSig : sig;
+            if (!ret)
+              process7.kill(process7.pid, s8);
+          }
+        };
+      }
+      this.#originalProcessReallyExit = process7.reallyExit;
+      this.#originalProcessEmit = process7.emit;
+    }
+    onExit(cb, opts) {
+      if (!processOk2(this.#process)) {
+        return () => {
+        };
+      }
+      if (this.#loaded === false) {
+        this.load();
+      }
+      const ev = opts?.alwaysLast ? "afterExit" : "exit";
+      this.#emitter.on(ev, cb);
+      return () => {
+        this.#emitter.removeListener(ev, cb);
+        if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+          this.unload();
+        }
+      };
+    }
+    load() {
+      if (this.#loaded) {
+        return;
+      }
+      this.#loaded = true;
+      this.#emitter.count += 1;
+      for (const sig of signals) {
+        try {
+          const fn = this.#sigListeners[sig];
+          if (fn)
+            this.#process.on(sig, fn);
+        } catch (_5) {
+        }
+      }
+      this.#process.emit = (ev, ...a7) => {
+        return this.#processEmit(ev, ...a7);
+      };
+      this.#process.reallyExit = (code2) => {
+        return this.#processReallyExit(code2);
+      };
+    }
+    unload() {
+      if (!this.#loaded) {
+        return;
+      }
+      this.#loaded = false;
+      signals.forEach((sig) => {
+        const listener = this.#sigListeners[sig];
+        if (!listener) {
+          throw new Error("Listener not defined for signal: " + sig);
+        }
+        try {
+          this.#process.removeListener(sig, listener);
+        } catch (_5) {
+        }
+      });
+      this.#process.emit = this.#originalProcessEmit;
+      this.#process.reallyExit = this.#originalProcessReallyExit;
+      this.#emitter.count -= 1;
+    }
+    #processReallyExit(code2) {
+      if (!processOk2(this.#process)) {
+        return 0;
+      }
+      this.#process.exitCode = code2 || 0;
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+      const og = this.#originalProcessEmit;
+      if (ev === "exit" && processOk2(this.#process)) {
+        if (typeof args[0] === "number") {
+          this.#process.exitCode = args[0];
+        }
+        const ret = og.call(this.#process, ev, ...args);
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return ret;
+      } else {
+        return og.call(this.#process, ev, ...args);
+      }
+    }
+  };
+  process7 = globalThis.process;
+  ({
+    onExit,
+    load: load2,
+    unload
+  } = signalExitWrap(processOk2(process7) ? new SignalExit2(process7) : new SignalExitFallback2));
+});
+
 // ../../node_modules/ansi-escapes/index.js
 var require_ansi_escapes = __commonJS((exports, module) => {
   var ansiEscapes = exports;
@@ -234802,6 +235018,1879 @@ var require_tar = __commonJS((exports) => {
   exports.types = require_types2();
 });
 
+// ../../node_modules/cross-spawn/node_modules/which/node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync3;
+  var fs3 = __require("fs");
+  function checkPathExt(path6, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i6 = 0;i6 < pathext.length; i6++) {
+      var p6 = pathext[i6].toLowerCase();
+      if (p6 && path6.substr(-p6.length).toLowerCase() === p6) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat8, path6, options) {
+    if (!stat8.isSymbolicLink() && !stat8.isFile()) {
+      return false;
+    }
+    return checkPathExt(path6, options);
+  }
+  function isexe(path6, options, cb) {
+    fs3.stat(path6, function(er2, stat8) {
+      cb(er2, er2 ? false : checkStat(stat8, path6, options));
+    });
+  }
+  function sync3(path6, options) {
+    return checkStat(fs3.statSync(path6), path6, options);
+  }
+});
+
+// ../../node_modules/cross-spawn/node_modules/which/node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync3;
+  var fs3 = __require("fs");
+  function isexe(path6, options, cb) {
+    fs3.stat(path6, function(er2, stat8) {
+      cb(er2, er2 ? false : checkStat(stat8, options));
+    });
+  }
+  function sync3(path6, options) {
+    return checkStat(fs3.statSync(path6), options);
+  }
+  function checkStat(stat8, options) {
+    return stat8.isFile() && checkMode(stat8, options);
+  }
+  function checkMode(stat8, options) {
+    var mod = stat8.mode;
+    var uid = stat8.uid;
+    var gid = stat8.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u6 = parseInt("100", 8);
+    var g6 = parseInt("010", 8);
+    var o8 = parseInt("001", 8);
+    var ug = u6 | g6;
+    var ret = mod & o8 || mod & g6 && gid === myGid || mod & u6 && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// ../../node_modules/cross-spawn/node_modules/which/node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs3 = __require("fs");
+  var core;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core = require_windows();
+  } else {
+    core = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync3;
+  function isexe(path6, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve7, reject) {
+        isexe(path6, options || {}, function(er2, is) {
+          if (er2) {
+            reject(er2);
+          } else {
+            resolve7(is);
+          }
+        });
+      });
+    }
+    core(path6, options || {}, function(er2, is) {
+      if (er2) {
+        if (er2.code === "EACCES" || options && options.ignoreErrors) {
+          er2 = null;
+          is = false;
+        }
+      }
+      cb(er2, is);
+    });
+  }
+  function sync3(path6, options) {
+    try {
+      return core.sync(path6, options || {});
+    } catch (er2) {
+      if (options && options.ignoreErrors || er2.code === "EACCES") {
+        return false;
+      } else {
+        throw er2;
+      }
+    }
+  }
+});
+
+// ../../node_modules/cross-spawn/node_modules/which/which.js
+var require_which2 = __commonJS((exports, module) => {
+  var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path6 = __require("path");
+  var COLON = isWindows2 ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError2 = (cmd2) => Object.assign(new Error(`not found: ${cmd2}`), { code: "ENOENT" });
+  var getPathInfo2 = (cmd2, opt2) => {
+    const colon = opt2.colon || COLON;
+    const pathEnv = cmd2.match(/\//) || isWindows2 && cmd2.match(/\\/) ? [""] : [
+      ...isWindows2 ? [process.cwd()] : [],
+      ...(opt2.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows2 ? opt2.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
+    if (isWindows2) {
+      if (cmd2.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd2, opt2, cb) => {
+    if (typeof opt2 === "function") {
+      cb = opt2;
+      opt2 = {};
+    }
+    if (!opt2)
+      opt2 = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo2(cmd2, opt2);
+    const found = [];
+    const step = (i6) => new Promise((resolve7, reject) => {
+      if (i6 === pathEnv.length)
+        return opt2.all && found.length ? resolve7(found) : reject(getNotFoundError2(cmd2));
+      const ppRaw = pathEnv[i6];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path6.join(pathPart, cmd2);
+      const p6 = !pathPart && /^\.[\\\/]/.test(cmd2) ? cmd2.slice(0, 2) + pCmd : pCmd;
+      resolve7(subStep(p6, i6, 0));
+    });
+    const subStep = (p6, i6, ii2) => new Promise((resolve7, reject) => {
+      if (ii2 === pathExt.length)
+        return resolve7(step(i6 + 1));
+      const ext2 = pathExt[ii2];
+      isexe(p6 + ext2, { pathExt: pathExtExe }, (er2, is) => {
+        if (!er2 && is) {
+          if (opt2.all)
+            found.push(p6 + ext2);
+          else
+            return resolve7(p6 + ext2);
+        }
+        return resolve7(subStep(p6, i6, ii2 + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd2, opt2) => {
+    opt2 = opt2 || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo2(cmd2, opt2);
+    const found = [];
+    for (let i6 = 0;i6 < pathEnv.length; i6++) {
+      const ppRaw = pathEnv[i6];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path6.join(pathPart, cmd2);
+      const p6 = !pathPart && /^\.[\\\/]/.test(cmd2) ? cmd2.slice(0, 2) + pCmd : pCmd;
+      for (let j3 = 0;j3 < pathExt.length; j3++) {
+        const cur = p6 + pathExt[j3];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt2.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {
+        }
+      }
+    }
+    if (opt2.all && found.length)
+      return found;
+    if (opt2.nothrow)
+      return null;
+    throw getNotFoundError2(cmd2);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// ../../node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey2 = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform2 = options.platform || process.platform;
+    if (platform2 !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key2) => key2.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey2;
+  module.exports.default = pathKey2;
+});
+
+// ../../node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path6 = __require("path");
+  var which = require_which2();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt2(parsed, withoutPathExt) {
+    const env2 = parsed.options.env || process.env;
+    const cwd2 = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {
+      }
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env2[getPathKey({ env: env2 })],
+        pathExt: withoutPathExt ? path6.delimiter : undefined
+      });
+    } catch (e10) {
+    } finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd2);
+      }
+    }
+    if (resolved) {
+      resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt2(parsed) || resolveCommandAttempt2(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// ../../node_modules/cross-spawn/lib/util/escape.js
+var require_escape3 = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand2(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument2(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand2;
+  exports.argument = escapeArgument2;
+});
+
+// ../../node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// ../../node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string = "") => {
+    const match2 = string.match(shebangRegex);
+    if (!match2) {
+      return null;
+    }
+    const [path6, argument] = match2[0].replace(/#! ?/, "").split(" ");
+    const binary = path6.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// ../../node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs3 = __require("fs");
+  var shebangCommand2 = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs3.openSync(command, "r");
+      fs3.readSync(fd, buffer, 0, size, 0);
+      fs3.closeSync(fd);
+    } catch (e10) {
+    }
+    return shebangCommand2(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// ../../node_modules/cross-spawn/lib/parse.js
+var require_parse6 = __commonJS((exports, module) => {
+  var path6 = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape2 = require_escape3();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell2(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path6.normalize(parsed.command);
+      parsed.command = escape2.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse6(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell2(parsed);
+  }
+  module.exports = parse6;
+});
+
+// ../../node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError2(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess2(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name2, arg1) {
+      if (name2 === "exit") {
+        const err = verifyENOENT2(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT2(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError2(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync2(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError2(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess: hookChildProcess2,
+    verifyENOENT: verifyENOENT2,
+    verifyENOENTSync: verifyENOENTSync2,
+    notFoundError: notFoundError2
+  };
+});
+
+// ../../node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse6 = require_parse6();
+  var enoent = require_enoent();
+  function spawn3(command, args, options) {
+    const parsed = parse6(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync2(command, args, options) {
+    const parsed = parse6(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn3;
+  module.exports.spawn = spawn3;
+  module.exports.sync = spawnSync2;
+  module.exports._parse = parse6;
+  module.exports._enoent = enoent;
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/strip-final-newline/index.js
+function stripFinalNewline(input) {
+  const LF = typeof input === "string" ? `
+` : `
+`.charCodeAt();
+  const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+  if (input[input.length - 1] === LF) {
+    input = input.slice(0, -1);
+  }
+  if (input[input.length - 1] === CR) {
+    input = input.slice(0, -1);
+  }
+  return input;
+}
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/npm-run-path/node_modules/path-key/index.js
+function pathKey2(options = {}) {
+  const {
+    env: env2 = process.env,
+    platform: platform2 = process.platform
+  } = options;
+  if (platform2 !== "win32") {
+    return "PATH";
+  }
+  return Object.keys(env2).reverse().find((key2) => key2.toUpperCase() === "PATH") || "Path";
+}
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/npm-run-path/index.js
+import process8 from "node:process";
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+var npmRunPath = ({
+  cwd: cwd2 = process8.cwd(),
+  path: pathOption = process8.env[pathKey2()],
+  preferLocal = true,
+  execPath = process8.execPath,
+  addExecPath = true
+} = {}) => {
+  const cwdString = cwd2 instanceof URL ? fileURLToPath5(cwd2) : cwd2;
+  const cwdPath = path6.resolve(cwdString);
+  const result = [];
+  if (preferLocal) {
+    applyPreferLocal2(result, cwdPath);
+  }
+  if (addExecPath) {
+    applyExecPath2(result, execPath, cwdPath);
+  }
+  return [...result, pathOption].join(path6.delimiter);
+}, applyPreferLocal2 = (result, cwdPath) => {
+  let previous;
+  while (previous !== cwdPath) {
+    result.push(path6.join(cwdPath, "node_modules/.bin"));
+    previous = cwdPath;
+    cwdPath = path6.resolve(cwdPath, "..");
+  }
+}, applyExecPath2 = (result, execPath, cwdPath) => {
+  const execPathString = execPath instanceof URL ? fileURLToPath5(execPath) : execPath;
+  result.push(path6.resolve(cwdPath, execPathString, ".."));
+}, npmRunPathEnv2 = ({ env: env2 = process8.env, ...options } = {}) => {
+  env2 = { ...env2 };
+  const pathName = pathKey2({ env: env2 });
+  options.path = env2[pathName];
+  env2[pathName] = npmRunPath(options);
+  return env2;
+};
+var init_npm_run_path = () => {
+};
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/onetime/node_modules/mimic-fn/index.js
+function mimicFunction2(to, from, { ignoreNonConfigurable = false } = {}) {
+  const { name: name2 } = to;
+  for (const property of Reflect.ownKeys(from)) {
+    copyProperty2(to, from, property, ignoreNonConfigurable);
+  }
+  changePrototype(to, from);
+  changeToString(to, from, name2);
+  return to;
+}
+var copyProperty2 = (to, from, property, ignoreNonConfigurable) => {
+  if (property === "length" || property === "prototype") {
+    return;
+  }
+  if (property === "arguments" || property === "caller") {
+    return;
+  }
+  const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+  if (!canCopyProperty2(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+    return;
+  }
+  Object.defineProperty(to, property, fromDescriptor);
+}, canCopyProperty2 = function(toDescriptor, fromDescriptor) {
+  return toDescriptor === undefined || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+}, changePrototype = (to, from) => {
+  const fromPrototype = Object.getPrototypeOf(from);
+  if (fromPrototype === Object.getPrototypeOf(to)) {
+    return;
+  }
+  Object.setPrototypeOf(to, fromPrototype);
+}, wrappedToString2 = (withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`, toStringDescriptor, toStringName, changeToString = (to, from, name2) => {
+  const withName = name2 === "" ? "" : `with ${name2.trim()}() `;
+  const newToString = wrappedToString2.bind(null, withName, from.toString());
+  Object.defineProperty(newToString, "name", toStringName);
+  Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
+};
+var init_mimic_fn = __esm(() => {
+  toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
+  toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/onetime/index.js
+var calledFunctions, onetime2 = (function_, options = {}) => {
+  if (typeof function_ !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  let returnValue;
+  let callCount = 0;
+  const functionName = function_.displayName || function_.name || "<anonymous>";
+  const onetime3 = function(...arguments_4) {
+    calledFunctions.set(onetime3, ++callCount);
+    if (callCount === 1) {
+      returnValue = function_.apply(this, arguments_4);
+      function_ = null;
+    } else if (options.throw === true) {
+      throw new Error(`Function \`${functionName}\` can only be called once`);
+    }
+    return returnValue;
+  };
+  mimicFunction2(onetime3, function_);
+  calledFunctions.set(onetime3, callCount);
+  return onetime3;
+}, onetime_default;
+var init_onetime = __esm(() => {
+  init_mimic_fn();
+  calledFunctions = new WeakMap;
+  onetime2.callCount = (function_) => {
+    if (!calledFunctions.has(function_)) {
+      throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+    }
+    return calledFunctions.get(function_);
+  };
+  onetime_default = onetime2;
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/human-signals/build/src/realtime.js
+var getRealtimeSignals = () => {
+  const length = SIGRTMAX - SIGRTMIN + 1;
+  return Array.from({ length }, getRealtimeSignal2);
+}, getRealtimeSignal2 = (value4, index) => ({
+  name: `SIGRT${index + 1}`,
+  number: SIGRTMIN + index,
+  action: "terminate",
+  description: "Application-specific signal (realtime)",
+  standard: "posix"
+}), SIGRTMIN = 34, SIGRTMAX = 64;
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/human-signals/build/src/core.js
+var SIGNALS;
+var init_core = __esm(() => {
+  SIGNALS = [
+    {
+      name: "SIGHUP",
+      number: 1,
+      action: "terminate",
+      description: "Terminal closed",
+      standard: "posix"
+    },
+    {
+      name: "SIGINT",
+      number: 2,
+      action: "terminate",
+      description: "User interruption with CTRL-C",
+      standard: "ansi"
+    },
+    {
+      name: "SIGQUIT",
+      number: 3,
+      action: "core",
+      description: "User interruption with CTRL-\\",
+      standard: "posix"
+    },
+    {
+      name: "SIGILL",
+      number: 4,
+      action: "core",
+      description: "Invalid machine instruction",
+      standard: "ansi"
+    },
+    {
+      name: "SIGTRAP",
+      number: 5,
+      action: "core",
+      description: "Debugger breakpoint",
+      standard: "posix"
+    },
+    {
+      name: "SIGABRT",
+      number: 6,
+      action: "core",
+      description: "Aborted",
+      standard: "ansi"
+    },
+    {
+      name: "SIGIOT",
+      number: 6,
+      action: "core",
+      description: "Aborted",
+      standard: "bsd"
+    },
+    {
+      name: "SIGBUS",
+      number: 7,
+      action: "core",
+      description: "Bus error due to misaligned, non-existing address or paging error",
+      standard: "bsd"
+    },
+    {
+      name: "SIGEMT",
+      number: 7,
+      action: "terminate",
+      description: "Command should be emulated but is not implemented",
+      standard: "other"
+    },
+    {
+      name: "SIGFPE",
+      number: 8,
+      action: "core",
+      description: "Floating point arithmetic error",
+      standard: "ansi"
+    },
+    {
+      name: "SIGKILL",
+      number: 9,
+      action: "terminate",
+      description: "Forced termination",
+      standard: "posix",
+      forced: true
+    },
+    {
+      name: "SIGUSR1",
+      number: 10,
+      action: "terminate",
+      description: "Application-specific signal",
+      standard: "posix"
+    },
+    {
+      name: "SIGSEGV",
+      number: 11,
+      action: "core",
+      description: "Segmentation fault",
+      standard: "ansi"
+    },
+    {
+      name: "SIGUSR2",
+      number: 12,
+      action: "terminate",
+      description: "Application-specific signal",
+      standard: "posix"
+    },
+    {
+      name: "SIGPIPE",
+      number: 13,
+      action: "terminate",
+      description: "Broken pipe or socket",
+      standard: "posix"
+    },
+    {
+      name: "SIGALRM",
+      number: 14,
+      action: "terminate",
+      description: "Timeout or timer",
+      standard: "posix"
+    },
+    {
+      name: "SIGTERM",
+      number: 15,
+      action: "terminate",
+      description: "Termination",
+      standard: "ansi"
+    },
+    {
+      name: "SIGSTKFLT",
+      number: 16,
+      action: "terminate",
+      description: "Stack is empty or overflowed",
+      standard: "other"
+    },
+    {
+      name: "SIGCHLD",
+      number: 17,
+      action: "ignore",
+      description: "Child process terminated, paused or unpaused",
+      standard: "posix"
+    },
+    {
+      name: "SIGCLD",
+      number: 17,
+      action: "ignore",
+      description: "Child process terminated, paused or unpaused",
+      standard: "other"
+    },
+    {
+      name: "SIGCONT",
+      number: 18,
+      action: "unpause",
+      description: "Unpaused",
+      standard: "posix",
+      forced: true
+    },
+    {
+      name: "SIGSTOP",
+      number: 19,
+      action: "pause",
+      description: "Paused",
+      standard: "posix",
+      forced: true
+    },
+    {
+      name: "SIGTSTP",
+      number: 20,
+      action: "pause",
+      description: 'Paused using CTRL-Z or "suspend"',
+      standard: "posix"
+    },
+    {
+      name: "SIGTTIN",
+      number: 21,
+      action: "pause",
+      description: "Background process cannot read terminal input",
+      standard: "posix"
+    },
+    {
+      name: "SIGBREAK",
+      number: 21,
+      action: "terminate",
+      description: "User interruption with CTRL-BREAK",
+      standard: "other"
+    },
+    {
+      name: "SIGTTOU",
+      number: 22,
+      action: "pause",
+      description: "Background process cannot write to terminal output",
+      standard: "posix"
+    },
+    {
+      name: "SIGURG",
+      number: 23,
+      action: "ignore",
+      description: "Socket received out-of-band data",
+      standard: "bsd"
+    },
+    {
+      name: "SIGXCPU",
+      number: 24,
+      action: "core",
+      description: "Process timed out",
+      standard: "bsd"
+    },
+    {
+      name: "SIGXFSZ",
+      number: 25,
+      action: "core",
+      description: "File too big",
+      standard: "bsd"
+    },
+    {
+      name: "SIGVTALRM",
+      number: 26,
+      action: "terminate",
+      description: "Timeout or timer",
+      standard: "bsd"
+    },
+    {
+      name: "SIGPROF",
+      number: 27,
+      action: "terminate",
+      description: "Timeout or timer",
+      standard: "bsd"
+    },
+    {
+      name: "SIGWINCH",
+      number: 28,
+      action: "ignore",
+      description: "Terminal window size changed",
+      standard: "bsd"
+    },
+    {
+      name: "SIGIO",
+      number: 29,
+      action: "terminate",
+      description: "I/O is available",
+      standard: "other"
+    },
+    {
+      name: "SIGPOLL",
+      number: 29,
+      action: "terminate",
+      description: "Watched event",
+      standard: "other"
+    },
+    {
+      name: "SIGINFO",
+      number: 29,
+      action: "ignore",
+      description: "Request for process information",
+      standard: "other"
+    },
+    {
+      name: "SIGPWR",
+      number: 30,
+      action: "terminate",
+      description: "Device running out of power",
+      standard: "systemv"
+    },
+    {
+      name: "SIGSYS",
+      number: 31,
+      action: "core",
+      description: "Invalid system call",
+      standard: "other"
+    },
+    {
+      name: "SIGUNUSED",
+      number: 31,
+      action: "terminate",
+      description: "Invalid system call",
+      standard: "other"
+    }
+  ];
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/human-signals/build/src/signals.js
+import { constants } from "node:os";
+var getSignals2 = () => {
+  const realtimeSignals = getRealtimeSignals();
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal2);
+  return signals2;
+}, normalizeSignal2 = ({
+  name: name2,
+  number: defaultNumber,
+  description,
+  action,
+  forced = false,
+  standard
+}) => {
+  const {
+    signals: { [name2]: constantSignal }
+  } = constants;
+  const supported = constantSignal !== undefined;
+  const number = supported ? constantSignal : defaultNumber;
+  return { name: name2, number, description, supported, action, forced, standard };
+};
+var init_signals2 = __esm(() => {
+  init_core();
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/human-signals/build/src/main.js
+import { constants as constants2 } from "node:os";
+var getSignalsByName = () => {
+  const signals2 = getSignals2();
+  return Object.fromEntries(signals2.map(getSignalByName2));
+}, getSignalByName2 = ({
+  name: name2,
+  number,
+  description,
+  supported,
+  action,
+  forced,
+  standard
+}) => [name2, { name: name2, number, description, supported, action, forced, standard }], signalsByName, getSignalsByNumber = () => {
+  const signals2 = getSignals2();
+  const length = SIGRTMAX + 1;
+  const signalsA = Array.from({ length }, (value4, number) => getSignalByNumber2(number, signals2));
+  return Object.assign({}, ...signalsA);
+}, getSignalByNumber2 = (number, signals2) => {
+  const signal = findSignalByNumber2(number, signals2);
+  if (signal === undefined) {
+    return {};
+  }
+  const { name: name2, description, supported, action, forced, standard } = signal;
+  return {
+    [number]: {
+      name: name2,
+      number,
+      description,
+      supported,
+      action,
+      forced,
+      standard
+    }
+  };
+}, findSignalByNumber2 = (number, signals2) => {
+  const signal = signals2.find(({ name: name2 }) => constants2.signals[name2] === number);
+  if (signal !== undefined) {
+    return signal;
+  }
+  return signals2.find((signalA) => signalA.number === number);
+}, signalsByNumber;
+var init_main = __esm(() => {
+  init_signals2();
+  signalsByName = getSignalsByName();
+  signalsByNumber = getSignalsByNumber();
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/error.js
+import process9 from "node:process";
+var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode: exitCode2, isCanceled }) => {
+  if (timedOut) {
+    return `timed out after ${timeout} milliseconds`;
+  }
+  if (isCanceled) {
+    return "was canceled";
+  }
+  if (errorCode !== undefined) {
+    return `failed with ${errorCode}`;
+  }
+  if (signal !== undefined) {
+    return `was killed with ${signal} (${signalDescription})`;
+  }
+  if (exitCode2 !== undefined) {
+    return `failed with exit code ${exitCode2}`;
+  }
+  return "failed";
+}, makeError2 = ({
+  stdout,
+  stderr,
+  all,
+  error: error5,
+  signal,
+  exitCode: exitCode2,
+  command,
+  escapedCommand,
+  timedOut,
+  isCanceled,
+  killed,
+  parsed: { options: { timeout, cwd: cwd2 = process9.cwd() } }
+}) => {
+  exitCode2 = exitCode2 === null ? undefined : exitCode2;
+  signal = signal === null ? undefined : signal;
+  const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
+  const errorCode = error5 && error5.code;
+  const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode: exitCode2, isCanceled });
+  const execaMessage = `Command ${prefix}: ${command}`;
+  const isError = Object.prototype.toString.call(error5) === "[object Error]";
+  const shortMessage = isError ? `${execaMessage}
+${error5.message}` : execaMessage;
+  const message = [shortMessage, stderr, stdout].filter(Boolean).join(`
+`);
+  if (isError) {
+    error5.originalMessage = error5.message;
+    error5.message = message;
+  } else {
+    error5 = new Error(message);
+  }
+  error5.shortMessage = shortMessage;
+  error5.command = command;
+  error5.escapedCommand = escapedCommand;
+  error5.exitCode = exitCode2;
+  error5.signal = signal;
+  error5.signalDescription = signalDescription;
+  error5.stdout = stdout;
+  error5.stderr = stderr;
+  error5.cwd = cwd2;
+  if (all !== undefined) {
+    error5.all = all;
+  }
+  if ("bufferedData" in error5) {
+    delete error5.bufferedData;
+  }
+  error5.failed = true;
+  error5.timedOut = Boolean(timedOut);
+  error5.isCanceled = isCanceled;
+  error5.killed = killed && !timedOut;
+  return error5;
+};
+var init_error = __esm(() => {
+  init_main();
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/stdio.js
+var aliases, hasAlias = (options) => aliases.some((alias) => options[alias] !== undefined), normalizeStdio2 = (options) => {
+  if (!options) {
+    return;
+  }
+  const { stdio } = options;
+  if (stdio === undefined) {
+    return aliases.map((alias) => options[alias]);
+  }
+  if (hasAlias(options)) {
+    throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+  }
+  if (typeof stdio === "string") {
+    return stdio;
+  }
+  if (!Array.isArray(stdio)) {
+    throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+  }
+  const length = Math.max(stdio.length, aliases.length);
+  return Array.from({ length }, (value4, index) => stdio[index]);
+}, normalizeStdioNode = (options) => {
+  const stdio = normalizeStdio2(options);
+  if (stdio === "ipc") {
+    return "ipc";
+  }
+  if (stdio === undefined || typeof stdio === "string") {
+    return [stdio, stdio, stdio, "ipc"];
+  }
+  if (stdio.includes("ipc")) {
+    return stdio;
+  }
+  return [...stdio, "ipc"];
+};
+var init_stdio = __esm(() => {
+  aliases = ["stdin", "stdout", "stderr"];
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/kill.js
+import os from "node:os";
+var DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill2 = (kill, signal = "SIGTERM", options = {}) => {
+  const killResult = kill(signal);
+  setKillTimeout2(kill, signal, options, killResult);
+  return killResult;
+}, setKillTimeout2 = (kill, signal, options, killResult) => {
+  if (!shouldForceKill2(signal, options, killResult)) {
+    return;
+  }
+  const timeout = getForceKillAfterTimeout2(options);
+  const t8 = setTimeout(() => {
+    kill("SIGKILL");
+  }, timeout);
+  if (t8.unref) {
+    t8.unref();
+  }
+}, shouldForceKill2 = (signal, { forceKillAfterTimeout }, killResult) => isSigterm2(signal) && forceKillAfterTimeout !== false && killResult, isSigterm2 = (signal) => signal === os.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM", getForceKillAfterTimeout2 = ({ forceKillAfterTimeout = true }) => {
+  if (forceKillAfterTimeout === true) {
+    return DEFAULT_FORCE_KILL_TIMEOUT;
+  }
+  if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+    throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+  }
+  return forceKillAfterTimeout;
+}, spawnedCancel2 = (spawned, context) => {
+  const killResult = spawned.kill();
+  if (killResult) {
+    context.isCanceled = true;
+  }
+}, timeoutKill = (spawned, signal, reject) => {
+  spawned.kill(signal);
+  reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+}, setupTimeout2 = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+  if (timeout === 0 || timeout === undefined) {
+    return spawnedPromise;
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve7, reject) => {
+    timeoutId = setTimeout(() => {
+      timeoutKill(spawned, killSignal, reject);
+    }, timeout);
+  });
+  const safeSpawnedPromise = spawnedPromise.finally(() => {
+    clearTimeout(timeoutId);
+  });
+  return Promise.race([timeoutPromise, safeSpawnedPromise]);
+}, validateTimeout2 = ({ timeout }) => {
+  if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+  }
+}, setExitHandler2 = async (spawned, { cleanup, detached }, timedPromise) => {
+  if (!cleanup || detached) {
+    return timedPromise;
+  }
+  const removeExitHandler = onExit(() => {
+    spawned.kill();
+  });
+  return timedPromise.finally(() => {
+    removeExitHandler();
+  });
+};
+var init_kill = __esm(() => {
+  init_mjs();
+  DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/is-stream/index.js
+function isStream4(stream2) {
+  return stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+}
+function isWritableStream2(stream2) {
+  return isStream4(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
+}
+
+// ../../node_modules/nypm/node_modules/execa/lib/pipe.js
+import { createWriteStream } from "node:fs";
+import { ChildProcess } from "node:child_process";
+var isExecaChildProcess = (target) => target instanceof ChildProcess && typeof target.then === "function", pipeToTarget2 = (spawned, streamName, target) => {
+  if (typeof target === "string") {
+    spawned[streamName].pipe(createWriteStream(target));
+    return spawned;
+  }
+  if (isWritableStream2(target)) {
+    spawned[streamName].pipe(target);
+    return spawned;
+  }
+  if (!isExecaChildProcess(target)) {
+    throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
+  }
+  if (!isWritableStream2(target.stdin)) {
+    throw new TypeError("The target child process's stdin must be available.");
+  }
+  spawned[streamName].pipe(target.stdin);
+  return target;
+}, addPipeMethods2 = (spawned) => {
+  if (spawned.stdout !== null) {
+    spawned.pipeStdout = pipeToTarget2.bind(undefined, spawned, "stdout");
+  }
+  if (spawned.stderr !== null) {
+    spawned.pipeStderr = pipeToTarget2.bind(undefined, spawned, "stderr");
+  }
+  if (spawned.all !== undefined) {
+    spawned.pipeAll = pipeToTarget2.bind(undefined, spawned, "all");
+  }
+};
+var init_pipe = () => {
+};
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/contents.js
+var getStreamContents2 = async (stream2, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+  if (!isAsyncIterable2(stream2)) {
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+  }
+  const state = init2();
+  state.length = 0;
+  try {
+    for await (const chunk of stream2) {
+      const chunkType = getChunkType2(chunk);
+      const convertedChunk = convertChunk[chunkType](chunk, state);
+      appendChunk2({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+    }
+    appendFinalChunk2({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
+    return finalize(state);
+  } catch (error5) {
+    error5.bufferedData = finalize(state);
+    throw error5;
+  }
+}, appendFinalChunk2 = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+  const convertedChunk = getFinalChunk(state);
+  if (convertedChunk !== undefined) {
+    appendChunk2({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+  }
+}, appendChunk2 = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+  const chunkSize = getSize(convertedChunk);
+  const newLength = state.length + chunkSize;
+  if (newLength <= maxBuffer) {
+    addNewChunk2(convertedChunk, state, addChunk, newLength);
+    return;
+  }
+  const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+  if (truncatedChunk !== undefined) {
+    addNewChunk2(truncatedChunk, state, addChunk, maxBuffer);
+  }
+  throw new MaxBufferError2;
+}, addNewChunk2 = (convertedChunk, state, addChunk, newLength) => {
+  state.contents = addChunk(convertedChunk, state, newLength);
+  state.length = newLength;
+}, isAsyncIterable2 = (stream2) => typeof stream2 === "object" && stream2 !== null && typeof stream2[Symbol.asyncIterator] === "function", getChunkType2 = (chunk) => {
+  const typeOfChunk = typeof chunk;
+  if (typeOfChunk === "string") {
+    return "string";
+  }
+  if (typeOfChunk !== "object" || chunk === null) {
+    return "others";
+  }
+  if (globalThis.Buffer?.isBuffer(chunk)) {
+    return "buffer";
+  }
+  const prototypeName = objectToString.call(chunk);
+  if (prototypeName === "[object ArrayBuffer]") {
+    return "arrayBuffer";
+  }
+  if (prototypeName === "[object DataView]") {
+    return "dataView";
+  }
+  if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]") {
+    return "typedArray";
+  }
+  return "others";
+}, objectToString, MaxBufferError2;
+var init_contents = __esm(() => {
+  ({ toString: objectToString } = Object.prototype);
+  MaxBufferError2 = class MaxBufferError2 extends Error {
+    name = "MaxBufferError";
+    constructor() {
+      super("maxBuffer exceeded");
+    }
+  };
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/utils.js
+var identity2 = (value4) => value4, noop2 = () => {
+  return;
+}, getContentsProp = ({ contents }) => contents, throwObjectStream2 = (chunk) => {
+  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+}, getLengthProp2 = (convertedChunk) => convertedChunk.length;
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/array.js
+var init_array = __esm(() => {
+  init_contents();
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream2, options) {
+  return getStreamContents2(stream2, arrayBufferMethods, options);
+}
+var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) }), useTextEncoder = (chunk) => textEncoder.encode(chunk), textEncoder, useUint8Array2 = (chunk) => new Uint8Array(chunk), useUint8ArrayWithOffset2 = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength), truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+  const newContents = hasArrayBufferResize2() ? resizeArrayBuffer2(contents, length) : resizeArrayBufferSlow2(contents, length);
+  new Uint8Array(newContents).set(convertedChunk, previousLength);
+  return newContents;
+}, resizeArrayBufferSlow2 = (contents, length) => {
+  if (length <= contents.byteLength) {
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(getNewContentsLength2(length));
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+}, resizeArrayBuffer2 = (contents, length) => {
+  if (length <= contents.maxByteLength) {
+    contents.resize(length);
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength2(length) });
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+}, getNewContentsLength2 = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR)), SCALE_FACTOR = 2, finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize2() ? contents : contents.slice(0, length), hasArrayBufferResize2 = () => ("resize" in ArrayBuffer.prototype), arrayBufferMethods;
+var init_array_buffer = __esm(() => {
+  init_contents();
+  textEncoder = new TextEncoder;
+  arrayBufferMethods = {
+    init: initArrayBuffer,
+    convertChunk: {
+      string: useTextEncoder,
+      buffer: useUint8Array2,
+      arrayBuffer: useUint8Array2,
+      dataView: useUint8ArrayWithOffset2,
+      typedArray: useUint8ArrayWithOffset2,
+      others: throwObjectStream2
+    },
+    getSize: getLengthProp2,
+    truncateChunk: truncateArrayBufferChunk,
+    addChunk: addArrayBufferChunk,
+    getFinalChunk: noop2,
+    finalize: finalizeArrayBuffer
+  };
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/buffer.js
+async function getStreamAsBuffer2(stream2, options) {
+  if (!("Buffer" in globalThis)) {
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  }
+  try {
+    return arrayBufferToNodeBuffer2(await getStreamAsArrayBuffer(stream2, options));
+  } catch (error5) {
+    if (error5.bufferedData !== undefined) {
+      error5.bufferedData = arrayBufferToNodeBuffer2(error5.bufferedData);
+    }
+    throw error5;
+  }
+}
+var arrayBufferToNodeBuffer2 = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+var init_buffer = __esm(() => {
+  init_array_buffer();
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/string.js
+async function getStreamAsString(stream2, options) {
+  return getStreamContents2(stream2, stringMethods, options);
+}
+var initString = () => ({ contents: "", textDecoder: new TextDecoder }), useTextDecoder2 = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true }), addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk, truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), getFinalStringChunk = ({ textDecoder }) => {
+  const finalChunk = textDecoder.decode();
+  return finalChunk === "" ? undefined : finalChunk;
+}, stringMethods;
+var init_string = __esm(() => {
+  init_contents();
+  stringMethods = {
+    init: initString,
+    convertChunk: {
+      string: identity2,
+      buffer: useTextDecoder2,
+      arrayBuffer: useTextDecoder2,
+      dataView: useTextDecoder2,
+      typedArray: useTextDecoder2,
+      others: throwObjectStream2
+    },
+    getSize: getLengthProp2,
+    truncateChunk: truncateStringChunk,
+    addChunk: addStringChunk,
+    getFinalChunk: getFinalStringChunk,
+    finalize: getContentsProp
+  };
+});
+
+// ../../node_modules/nypm/node_modules/execa/node_modules/get-stream/source/index.js
+var init_source = __esm(() => {
+  init_array();
+  init_array_buffer();
+  init_buffer();
+  init_string();
+  init_contents();
+});
+
+// ../../node_modules/merge-stream/index.js
+var require_merge_stream = __commonJS((exports, module) => {
+  var { PassThrough } = __require("stream");
+  module.exports = function() {
+    var sources = [];
+    var output = new PassThrough({ objectMode: true });
+    output.setMaxListeners(0);
+    output.add = add;
+    output.isEmpty = isEmpty2;
+    output.on("unpipe", remove);
+    Array.prototype.slice.call(arguments).forEach(add);
+    return output;
+    function add(source) {
+      if (Array.isArray(source)) {
+        source.forEach(add);
+        return this;
+      }
+      sources.push(source);
+      source.once("end", remove.bind(null, source));
+      source.once("error", output.emit.bind(output, "error"));
+      source.pipe(output, { end: false });
+      return this;
+    }
+    function isEmpty2() {
+      return sources.length == 0;
+    }
+    function remove(source) {
+      sources = sources.filter(function(it2) {
+        return it2 !== source;
+      });
+      if (!sources.length && output.readable) {
+        output.end();
+      }
+    }
+  };
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/stream.js
+import { createReadStream, readFileSync } from "node:fs";
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+var import_merge_stream, validateInputOptions = (input) => {
+  if (input !== undefined) {
+    throw new TypeError("The `input` and `inputFile` options cannot be both set.");
+  }
+}, getInputSync = ({ input, inputFile }) => {
+  if (typeof inputFile !== "string") {
+    return input;
+  }
+  validateInputOptions(input);
+  return readFileSync(inputFile);
+}, handleInputSync = (options) => {
+  const input = getInputSync(options);
+  if (isStream4(input)) {
+    throw new TypeError("The `input` option cannot be a stream in sync mode");
+  }
+  return input;
+}, getInput2 = ({ input, inputFile }) => {
+  if (typeof inputFile !== "string") {
+    return input;
+  }
+  validateInputOptions(input);
+  return createReadStream(inputFile);
+}, handleInput2 = (spawned, options) => {
+  const input = getInput2(options);
+  if (input === undefined) {
+    return;
+  }
+  if (isStream4(input)) {
+    input.pipe(spawned.stdin);
+  } else {
+    spawned.stdin.end(input);
+  }
+}, makeAllStream2 = (spawned, { all }) => {
+  if (!all || !spawned.stdout && !spawned.stderr) {
+    return;
+  }
+  const mixed = import_merge_stream.default();
+  if (spawned.stdout) {
+    mixed.add(spawned.stdout);
+  }
+  if (spawned.stderr) {
+    mixed.add(spawned.stderr);
+  }
+  return mixed;
+}, getBufferedData2 = async (stream2, streamPromise) => {
+  if (!stream2 || streamPromise === undefined) {
+    return;
+  }
+  await setTimeout2(0);
+  stream2.destroy();
+  try {
+    return await streamPromise;
+  } catch (error5) {
+    return error5.bufferedData;
+  }
+}, getStreamPromise2 = (stream2, { encoding, buffer, maxBuffer }) => {
+  if (!stream2 || !buffer) {
+    return;
+  }
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return getStreamAsString(stream2, { maxBuffer });
+  }
+  if (encoding === null || encoding === "buffer") {
+    return getStreamAsBuffer2(stream2, { maxBuffer });
+  }
+  return applyEncoding2(stream2, maxBuffer, encoding);
+}, applyEncoding2 = async (stream2, maxBuffer, encoding) => {
+  const buffer = await getStreamAsBuffer2(stream2, { maxBuffer });
+  return buffer.toString(encoding);
+}, getSpawnedResult2 = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
+  const stdoutPromise = getStreamPromise2(stdout, { encoding, buffer, maxBuffer });
+  const stderrPromise = getStreamPromise2(stderr, { encoding, buffer, maxBuffer });
+  const allPromise = getStreamPromise2(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+  try {
+    return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+  } catch (error5) {
+    return Promise.all([
+      { error: error5, signal: error5.signal, timedOut: error5.timedOut },
+      getBufferedData2(stdout, stdoutPromise),
+      getBufferedData2(stderr, stderrPromise),
+      getBufferedData2(all, allPromise)
+    ]);
+  }
+};
+var init_stream = __esm(() => {
+  init_source();
+  import_merge_stream = __toESM(require_merge_stream(), 1);
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/promise.js
+var nativePromisePrototype, descriptors, mergePromise2 = (spawned, promise) => {
+  for (const [property, descriptor] of descriptors) {
+    const value4 = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
+    Reflect.defineProperty(spawned, property, { ...descriptor, value: value4 });
+  }
+}, getSpawnedPromise2 = (spawned) => new Promise((resolve7, reject) => {
+  spawned.on("exit", (exitCode2, signal) => {
+    resolve7({ exitCode: exitCode2, signal });
+  });
+  spawned.on("error", (error5) => {
+    reject(error5);
+  });
+  if (spawned.stdin) {
+    spawned.stdin.on("error", (error5) => {
+      reject(error5);
+    });
+  }
+});
+var init_promise = __esm(() => {
+  nativePromisePrototype = (async () => {
+  })().constructor.prototype;
+  descriptors = ["then", "catch", "finally"].map((property) => [
+    property,
+    Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
+  ]);
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/command.js
+import { Buffer as Buffer2 } from "node:buffer";
+import { ChildProcess as ChildProcess2 } from "node:child_process";
+var normalizeArgs2 = (file, args = []) => {
+  if (!Array.isArray(args)) {
+    return [file];
+  }
+  return [file, ...args];
+}, NO_ESCAPE_REGEXP, escapeArg = (arg) => {
+  if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
+    return arg;
+  }
+  return `"${arg.replaceAll('"', "\\\"")}"`;
+}, joinCommand2 = (file, args) => normalizeArgs2(file, args).join(" "), getEscapedCommand2 = (file, args) => normalizeArgs2(file, args).map((arg) => escapeArg(arg)).join(" "), SPACES_REGEXP, parseCommand = (command) => {
+  const tokens = [];
+  for (const token of command.trim().split(SPACES_REGEXP)) {
+    const previousToken = tokens.at(-1);
+    if (previousToken && previousToken.endsWith("\\")) {
+      tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+    } else {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}, parseExpression = (expression) => {
+  const typeOfExpression = typeof expression;
+  if (typeOfExpression === "string") {
+    return expression;
+  }
+  if (typeOfExpression === "number") {
+    return String(expression);
+  }
+  if (typeOfExpression === "object" && expression !== null && !(expression instanceof ChildProcess2) && "stdout" in expression) {
+    const typeOfStdout = typeof expression.stdout;
+    if (typeOfStdout === "string") {
+      return expression.stdout;
+    }
+    if (Buffer2.isBuffer(expression.stdout)) {
+      return expression.stdout.toString();
+    }
+    throw new TypeError(`Unexpected "${typeOfStdout}" stdout in template expression`);
+  }
+  throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
+}, concatTokens = (tokens, nextTokens, isNew) => isNew || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
+  ...tokens.slice(0, -1),
+  `${tokens.at(-1)}${nextTokens[0]}`,
+  ...nextTokens.slice(1)
+], parseTemplate = ({ templates, expressions, tokens, index, template }) => {
+  const templateString = template ?? templates.raw[index];
+  const templateTokens = templateString.split(SPACES_REGEXP).filter(Boolean);
+  const newTokens = concatTokens(tokens, templateTokens, templateString.startsWith(" "));
+  if (index === expressions.length) {
+    return newTokens;
+  }
+  const expression = expressions[index];
+  const expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
+  return concatTokens(newTokens, expressionTokens, templateString.endsWith(" "));
+}, parseTemplates = (templates, expressions) => {
+  let tokens = [];
+  for (const [index, template] of templates.entries()) {
+    tokens = parseTemplate({ templates, expressions, tokens, index, template });
+  }
+  return tokens;
+};
+var init_command = __esm(() => {
+  NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+  SPACES_REGEXP = / +/g;
+});
+
+// ../../node_modules/nypm/node_modules/execa/lib/verbose.js
+import { debuglog } from "node:util";
+import process10 from "node:process";
+var verboseDefault, padField2 = (field2, padding) => String(field2).padStart(padding, "0"), getTimestamp = () => {
+  const date = new Date;
+  return `${padField2(date.getHours(), 2)}:${padField2(date.getMinutes(), 2)}:${padField2(date.getSeconds(), 2)}.${padField2(date.getMilliseconds(), 3)}`;
+}, logCommand2 = (escapedCommand, { verbose }) => {
+  if (!verbose) {
+    return;
+  }
+  process10.stderr.write(`[${getTimestamp()}] ${escapedCommand}
+`);
+};
+var init_verbose = __esm(() => {
+  verboseDefault = debuglog("execa").enabled;
+});
+
+// ../../node_modules/nypm/node_modules/execa/index.js
+var exports_execa = {};
+__export(exports_execa, {
+  execaSync: () => execaSync,
+  execaNode: () => execaNode,
+  execaCommandSync: () => execaCommandSync,
+  execaCommand: () => execaCommand,
+  execa: () => execa2,
+  $: () => $4
+});
+import { Buffer as Buffer3 } from "node:buffer";
+import path7 from "node:path";
+import childProcess from "node:child_process";
+import process11 from "node:process";
+function execa2(file, args, options) {
+  const parsed = handleArguments2(file, args, options);
+  const command = joinCommand2(file, args);
+  const escapedCommand = getEscapedCommand2(file, args);
+  logCommand2(escapedCommand, parsed.options);
+  validateTimeout2(parsed.options);
+  let spawned;
+  try {
+    spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
+  } catch (error5) {
+    const dummySpawned = new childProcess.ChildProcess;
+    const errorPromise = Promise.reject(makeError2({
+      error: error5,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    }));
+    mergePromise2(dummySpawned, errorPromise);
+    return dummySpawned;
+  }
+  const spawnedPromise = getSpawnedPromise2(spawned);
+  const timedPromise = setupTimeout2(spawned, parsed.options, spawnedPromise);
+  const processDone = setExitHandler2(spawned, parsed.options, timedPromise);
+  const context = { isCanceled: false };
+  spawned.kill = spawnedKill2.bind(null, spawned.kill.bind(spawned));
+  spawned.cancel = spawnedCancel2.bind(null, spawned, context);
+  const handlePromise = async () => {
+    const [{ error: error5, exitCode: exitCode2, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult2(spawned, parsed.options, processDone);
+    const stdout = handleOutput2(parsed.options, stdoutResult);
+    const stderr = handleOutput2(parsed.options, stderrResult);
+    const all = handleOutput2(parsed.options, allResult);
+    if (error5 || exitCode2 !== 0 || signal !== null) {
+      const returnedError = makeError2({
+        error: error5,
+        exitCode: exitCode2,
+        signal,
+        stdout,
+        stderr,
+        all,
+        command,
+        escapedCommand,
+        parsed,
+        timedOut,
+        isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
+        killed: spawned.killed
+      });
+      if (!parsed.options.reject) {
+        return returnedError;
+      }
+      throw returnedError;
+    }
+    return {
+      command,
+      escapedCommand,
+      exitCode: 0,
+      stdout,
+      stderr,
+      all,
+      failed: false,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    };
+  };
+  const handlePromiseOnce = onetime_default(handlePromise);
+  handleInput2(spawned, parsed.options);
+  spawned.all = makeAllStream2(spawned, parsed.options);
+  addPipeMethods2(spawned);
+  mergePromise2(spawned, handlePromiseOnce);
+  return spawned;
+}
+function execaSync(file, args, options) {
+  const parsed = handleArguments2(file, args, options);
+  const command = joinCommand2(file, args);
+  const escapedCommand = getEscapedCommand2(file, args);
+  logCommand2(escapedCommand, parsed.options);
+  const input = handleInputSync(parsed.options);
+  let result;
+  try {
+    result = childProcess.spawnSync(parsed.file, parsed.args, { ...parsed.options, input });
+  } catch (error5) {
+    throw makeError2({
+      error: error5,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    });
+  }
+  const stdout = handleOutput2(parsed.options, result.stdout, result.error);
+  const stderr = handleOutput2(parsed.options, result.stderr, result.error);
+  if (result.error || result.status !== 0 || result.signal !== null) {
+    const error5 = makeError2({
+      stdout,
+      stderr,
+      error: result.error,
+      signal: result.signal,
+      exitCode: result.status,
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: result.error && result.error.code === "ETIMEDOUT",
+      isCanceled: false,
+      killed: result.signal !== null
+    });
+    if (!parsed.options.reject) {
+      return error5;
+    }
+    throw error5;
+  }
+  return {
+    command,
+    escapedCommand,
+    exitCode: 0,
+    stdout,
+    stderr,
+    failed: false,
+    timedOut: false,
+    isCanceled: false,
+    killed: false
+  };
+}
+function create$(options) {
+  function $4(templatesOrOptions, ...expressions) {
+    if (!Array.isArray(templatesOrOptions)) {
+      return create$({ ...options, ...templatesOrOptions });
+    }
+    const [file, ...args] = parseTemplates(templatesOrOptions, expressions);
+    return execa2(file, args, normalizeScriptOptions(options));
+  }
+  $4.sync = (templates, ...expressions) => {
+    if (!Array.isArray(templates)) {
+      throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
+    }
+    const [file, ...args] = parseTemplates(templates, expressions);
+    return execaSync(file, args, normalizeScriptOptions(options));
+  };
+  return $4;
+}
+function execaCommand(command, options) {
+  const [file, ...args] = parseCommand(command);
+  return execa2(file, args, options);
+}
+function execaCommandSync(command, options) {
+  const [file, ...args] = parseCommand(command);
+  return execaSync(file, args, options);
+}
+function execaNode(scriptPath, args, options = {}) {
+  if (args && !Array.isArray(args) && typeof args === "object") {
+    options = args;
+    args = [];
+  }
+  const stdio = normalizeStdioNode(options);
+  const defaultExecArgv = process11.execArgv.filter((arg) => !arg.startsWith("--inspect"));
+  const {
+    nodePath = process11.execPath,
+    nodeOptions = defaultExecArgv
+  } = options;
+  return execa2(nodePath, [
+    ...nodeOptions,
+    scriptPath,
+    ...Array.isArray(args) ? args : []
+  ], {
+    ...options,
+    stdin: undefined,
+    stdout: undefined,
+    stderr: undefined,
+    stdio,
+    shell: false
+  });
+}
+var import_cross_spawn, DEFAULT_MAX_BUFFER, getEnv2 = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+  const env2 = extendEnv ? { ...process11.env, ...envOption } : envOption;
+  if (preferLocal) {
+    return npmRunPathEnv2({ env: env2, cwd: localDir, execPath });
+  }
+  return env2;
+}, handleArguments2 = (file, args, options = {}) => {
+  const parsed = import_cross_spawn.default._parse(file, args, options);
+  file = parsed.command;
+  args = parsed.args;
+  options = parsed.options;
+  options = {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    buffer: true,
+    stripFinalNewline: true,
+    extendEnv: true,
+    preferLocal: false,
+    localDir: options.cwd || process11.cwd(),
+    execPath: process11.execPath,
+    encoding: "utf8",
+    reject: true,
+    cleanup: true,
+    all: false,
+    windowsHide: true,
+    verbose: verboseDefault,
+    ...options
+  };
+  options.env = getEnv2(options);
+  options.stdio = normalizeStdio2(options);
+  if (process11.platform === "win32" && path7.basename(file, ".exe") === "cmd") {
+    args.unshift("/q");
+  }
+  return { file, args, options, parsed };
+}, handleOutput2 = (options, value4, error5) => {
+  if (typeof value4 !== "string" && !Buffer3.isBuffer(value4)) {
+    return error5 === undefined ? undefined : "";
+  }
+  if (options.stripFinalNewline) {
+    return stripFinalNewline(value4);
+  }
+  return value4;
+}, normalizeScriptStdin = ({ input, inputFile, stdio }) => input === undefined && inputFile === undefined && stdio === undefined ? { stdin: "inherit" } : {}, normalizeScriptOptions = (options = {}) => ({
+  preferLocal: true,
+  ...normalizeScriptStdin(options),
+  ...options
+}), $4;
+var init_execa = __esm(() => {
+  import_cross_spawn = __toESM(require_cross_spawn(), 1);
+  init_npm_run_path();
+  init_onetime();
+  init_error();
+  init_stdio();
+  init_kill();
+  init_pipe();
+  init_stream();
+  init_promise();
+  init_command();
+  init_verbose();
+  DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
+  $4 = create$();
+});
+
 // ../../node_modules/node-fetch-native/dist/shared/node-fetch-native.DhEqb06g.cjs
 var require_node_fetch_native_DhEqb06g = __commonJS((exports) => {
   var l3 = Object.defineProperty;
@@ -234832,7 +236921,7 @@ var require_multipart_parser = __commonJS((exports) => {
   var A5 = 97;
   var Z4 = 122;
   var lower = c3((_5) => _5 | 32, "lower");
-  var noop2 = c3(() => {
+  var noop3 = c3(() => {
   }, "noop");
 
   class MultipartParser {
@@ -234840,7 +236929,7 @@ var require_multipart_parser = __commonJS((exports) => {
       c3(this, "MultipartParser");
     }
     constructor(a7) {
-      this.index = 0, this.flags = 0, this.onHeaderEnd = noop2, this.onHeaderField = noop2, this.onHeadersEnd = noop2, this.onHeaderValue = noop2, this.onPartBegin = noop2, this.onPartData = noop2, this.onPartEnd = noop2, this.boundaryChars = {}, a7 = `\r
+      this.index = 0, this.flags = 0, this.onHeaderEnd = noop3, this.onHeaderField = noop3, this.onHeadersEnd = noop3, this.onHeaderValue = noop3, this.onPartBegin = noop3, this.onPartData = noop3, this.onPartEnd = noop3, this.boundaryChars = {}, a7 = `\r
 --` + a7;
       const t8 = new Uint8Array(a7.length);
       for (let n6 = 0;n6 < a7.length; n6++)
@@ -235120,15 +237209,15 @@ var require_node3 = __commonJS((exports) => {
           }
           return se4(n6);
         }, "_queueMicrotask");
-        function $4(n6, o8, a7) {
+        function $5(n6, o8, a7) {
           if (typeof n6 != "function")
             throw new TypeError("Argument is not a function");
           return Function.prototype.apply.call(n6, o8, a7);
         }
-        u6($4, "reflectCall");
+        u6($5, "reflectCall");
         function N6(n6, o8, a7) {
           try {
-            return W4($4(n6, o8, a7));
+            return W4($5(n6, o8, a7));
           } catch (p6) {
             return T4(p6);
           }
@@ -235480,7 +237569,7 @@ var require_node3 = __commonJS((exports) => {
               a7 = at2(n6, Symbol.iterator);
           if (a7 === undefined)
             throw new TypeError("The object is not iterable");
-          const p6 = $4(a7, n6, []);
+          const p6 = $5(a7, n6, []);
           if (!b4(p6))
             throw new TypeError("The iterator method must return an object");
           const g6 = p6.next;
@@ -235488,7 +237577,7 @@ var require_node3 = __commonJS((exports) => {
         }
         u6(Lr2, "GetIterator");
         function Gn(n6) {
-          const o8 = $4(n6.nextMethod, n6.iterator, []);
+          const o8 = $5(n6.nextMethod, n6.iterator, []);
           if (!b4(o8))
             throw new TypeError("The iterator.next() method must return an object");
           return o8;
@@ -236129,7 +238218,7 @@ var require_node3 = __commonJS((exports) => {
         }
         u6(go, "convertUnderlyingSinkCloseCallback");
         function _o(n6, o8, a7) {
-          return X4(n6, a7), (p6) => $4(n6, o8, [p6]);
+          return X4(n6, a7), (p6) => $5(n6, o8, [p6]);
         }
         u6(_o, "convertUnderlyingSinkStartCallback");
         function So(n6, o8, a7) {
@@ -237069,7 +239158,7 @@ var require_node3 = __commonJS((exports) => {
               return W4(undefined);
             let P4;
             try {
-              P4 = $4(q5, C4, [S4]);
+              P4 = $5(q5, C4, [S4]);
             } catch (O6) {
               return T4(O6);
             }
@@ -237129,7 +239218,7 @@ var require_node3 = __commonJS((exports) => {
         }
         u6(li, "convertUnderlyingSourcePullCallback");
         function fi(n6, o8, a7) {
-          return X4(n6, a7), (p6) => $4(n6, o8, [p6]);
+          return X4(n6, a7), (p6) => $5(n6, o8, [p6]);
         }
         u6(fi, "convertUnderlyingSourceStartCallback");
         function ci(n6, o8) {
@@ -237380,7 +239469,7 @@ var require_node3 = __commonJS((exports) => {
         }
         u6(mi, "convertTransformerFlushCallback");
         function yi(n6, o8, a7) {
-          return X4(n6, a7), (p6) => $4(n6, o8, [p6]);
+          return X4(n6, a7), (p6) => $5(n6, o8, [p6]);
         }
         u6(yi, "convertTransformerStartCallback");
         function gi(n6, o8, a7) {
@@ -237804,7 +239893,7 @@ var require_node3 = __commonJS((exports) => {
   var f6 = u6((c3, l3, d6) => (c3 += "", /^(Blob|File)$/.test(l3 && l3[t$12]) ? [(d6 = d6 !== undefined ? d6 + "" : l3[t$12] == "File" ? l3.name : "blob", c3), l3.name !== d6 || l3[t$12] == "blob" ? new File2([l3], d6, l3) : l3] : [c3, l3 + ""]), "f");
   var e$12 = u6((c3, l3) => (l3 ? c3 : c3.replace(/\r?\n|\r/g, `\r
 `)).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "e$1");
-  var x7 = u6((c3, l3, d6) => {
+  var x6 = u6((c3, l3, d6) => {
     if (l3.length < d6)
       throw new TypeError(`Failed to execute '${c3}' on 'FormData': ${d6} arguments required, but only ${l3.length} present.`);
   }, "x");
@@ -237827,31 +239916,31 @@ var require_node3 = __commonJS((exports) => {
       return l3 && typeof l3 == "object" && l3[t$12] === "FormData" && !m6.some((d6) => typeof l3[d6] != "function");
     }
     append(...l3) {
-      x7("append", arguments, 2), this.#e.push(f6(...l3));
+      x6("append", arguments, 2), this.#e.push(f6(...l3));
     }
     delete(l3) {
-      x7("delete", arguments, 1), l3 += "", this.#e = this.#e.filter(([d6]) => d6 !== l3);
+      x6("delete", arguments, 1), l3 += "", this.#e = this.#e.filter(([d6]) => d6 !== l3);
     }
     get(l3) {
-      x7("get", arguments, 1), l3 += "";
+      x6("get", arguments, 1), l3 += "";
       for (var d6 = this.#e, y4 = d6.length, b4 = 0;b4 < y4; b4++)
         if (d6[b4][0] === l3)
           return d6[b4][1];
       return null;
     }
     getAll(l3, d6) {
-      return x7("getAll", arguments, 1), d6 = [], l3 += "", this.#e.forEach((y4) => y4[0] === l3 && d6.push(y4[1])), d6;
+      return x6("getAll", arguments, 1), d6 = [], l3 += "", this.#e.forEach((y4) => y4[0] === l3 && d6.push(y4[1])), d6;
     }
     has(l3) {
-      return x7("has", arguments, 1), l3 += "", this.#e.some((d6) => d6[0] === l3);
+      return x6("has", arguments, 1), l3 += "", this.#e.some((d6) => d6[0] === l3);
     }
     forEach(l3, d6) {
-      x7("forEach", arguments, 1);
+      x6("forEach", arguments, 1);
       for (var [y4, b4] of this)
         l3.call(d6, b4, y4, this);
     }
     set(...l3) {
-      x7("set", arguments, 2);
+      x6("set", arguments, 2);
       var d6 = [], y4 = true;
       l3 = f6(...l3), this.#e.forEach((b4) => {
         b4[0] === l3[0] ? y4 && (y4 = !d6.push(l3)) : d6.push(b4);
@@ -238452,13 +240541,13 @@ Content-Type: ${R5.type || "application/octet-stream"}\r
         T4.setTimeout(0);
         const Z4 = fromRawHeaders(E6.rawHeaders);
         if (isRedirect(E6.statusCode)) {
-          const $4 = Z4.get("Location");
+          const $5 = Z4.get("Location");
           let N6 = null;
           try {
-            N6 = $4 === null ? null : new URL($4, b4.url);
+            N6 = $5 === null ? null : new URL($5, b4.url);
           } catch {
             if (b4.redirect !== "manual") {
-              y4(new FetchError(`uri requested responds with an invalid redirect URL: ${$4}`, "invalid-redirect")), D3();
+              y4(new FetchError(`uri requested responds with an invalid redirect URL: ${$5}`, "invalid-redirect")), D3();
               return;
             }
           }
@@ -238495,8 +240584,8 @@ Content-Type: ${R5.type || "application/octet-stream"}\r
         F3 && E6.once("end", () => {
           F3.removeEventListener("abort", W4);
         });
-        let M5 = Stream3.pipeline(E6, new Stream3.PassThrough, ($4) => {
-          $4 && y4($4);
+        let M5 = Stream3.pipeline(E6, new Stream3.PassThrough, ($5) => {
+          $5 && y4($5);
         });
         process.version < "v12.10" && E6.on("aborted", W4);
         const U4 = { url: b4.url, status: E6.statusCode, statusText: E6.statusMessage, headers: Z4, size: b4.size, counter: b4.counter, highWaterMark: b4.highWaterMark }, K4 = Z4.get("Content-Encoding");
@@ -238506,29 +240595,29 @@ Content-Type: ${R5.type || "application/octet-stream"}\r
         }
         const se4 = { flush: zlib__default.Z_SYNC_FLUSH, finishFlush: zlib__default.Z_SYNC_FLUSH };
         if (K4 === "gzip" || K4 === "x-gzip") {
-          M5 = Stream3.pipeline(M5, zlib__default.createGunzip(se4), ($4) => {
-            $4 && y4($4);
+          M5 = Stream3.pipeline(M5, zlib__default.createGunzip(se4), ($5) => {
+            $5 && y4($5);
           }), B4 = new Response(M5, U4), d6(B4);
           return;
         }
         if (K4 === "deflate" || K4 === "x-deflate") {
-          const $4 = Stream3.pipeline(E6, new Stream3.PassThrough, (N6) => {
+          const $5 = Stream3.pipeline(E6, new Stream3.PassThrough, (N6) => {
             N6 && y4(N6);
           });
-          $4.once("data", (N6) => {
+          $5.once("data", (N6) => {
             (N6[0] & 15) === 8 ? M5 = Stream3.pipeline(M5, zlib__default.createInflate(), (V5) => {
               V5 && y4(V5);
             }) : M5 = Stream3.pipeline(M5, zlib__default.createInflateRaw(), (V5) => {
               V5 && y4(V5);
             }), B4 = new Response(M5, U4), d6(B4);
-          }), $4.once("end", () => {
+          }), $5.once("end", () => {
             B4 || (B4 = new Response(M5, U4), d6(B4));
           });
           return;
         }
         if (K4 === "br") {
-          M5 = Stream3.pipeline(M5, zlib__default.createBrotliDecompress(), ($4) => {
-            $4 && y4($4);
+          M5 = Stream3.pipeline(M5, zlib__default.createBrotliDecompress(), ($5) => {
+            $5 && y4($5);
           }), B4 = new Response(M5, U4), d6(B4);
           return;
         }
@@ -239575,10 +241664,10 @@ var require_proxy = __commonJS((exports) => {
       return L4 && typeof L4 == "object" && typeof L4.append == "function" && typeof L4.delete == "function" && typeof L4.get == "function" && typeof L4.getAll == "function" && typeof L4.has == "function" && typeof L4.set == "function" && L4[Symbol.toStringTag] === "FormData";
     }
     e10(nA, "isFormDataLike");
-    function $4(L4, AA) {
+    function $5(L4, AA) {
       return "addEventListener" in L4 ? (L4.addEventListener("abort", AA, { once: true }), () => L4.removeEventListener("abort", AA)) : (L4.addListener("abort", AA), () => L4.removeListener("abort", AA));
     }
-    e10($4, "addAbortListener");
+    e10($5, "addAbortListener");
     const sA = typeof String.prototype.toWellFormed == "function", BA = typeof String.prototype.isWellFormed == "function";
     function dA(L4) {
       return sA ? `${L4}`.toWellFormed() : u6.toUSVString(L4);
@@ -239655,7 +241744,7 @@ var require_proxy = __commonJS((exports) => {
     const ZA = Object.create(null);
     ZA.enumerable = true;
     const PA = { delete: "DELETE", DELETE: "DELETE", get: "GET", GET: "GET", head: "HEAD", HEAD: "HEAD", options: "OPTIONS", OPTIONS: "OPTIONS", post: "POST", POST: "POST", put: "PUT", PUT: "PUT" }, oA = { ...PA, patch: "patch", PATCH: "PATCH" };
-    return Object.setPrototypeOf(PA, null), Object.setPrototypeOf(oA, null), util$7 = { kEnumerableProperty: ZA, nop: J4, isDisturbed: UA, isErrored: QA, isReadable: eA, toUSVString: dA, isUSVString: CA, isBlobLike: H4, parseOrigin: F3, parseURL: i6, getServerName: D3, isStream: V5, isIterable: q5, isAsyncIterable: W4, isDestroyed: P4, headerNameToString: fA, bufferToLowerCasedHeaderName: uA, addListener: GA, removeAllListeners: NA, errorRequest: KA, parseRawHeaders: RA, parseHeaders: pA, parseKeepAliveTimeout: EA, destroy: Z4, bodyLength: O6, deepClone: S4, ReadableStreamFrom: YA, isBuffer: DA, validateHandler: TA, getSocketInfo: lA, isFormDataLike: nA, buildURL: h7, addAbortListener: $4, isValidHTTPToken: xA, isValidHeaderValue: WA, isTokenCharCode: mA, parseRangeHeader: LA, normalizedMethodRecordsBase: PA, normalizedMethodRecords: oA, isValidPort: I5, isHttpOrHttpsPrefixed: k5, nodeMajor: d6, nodeMinor: N6, safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"], wrapRequestBody: Y4 }, util$7;
+    return Object.setPrototypeOf(PA, null), Object.setPrototypeOf(oA, null), util$7 = { kEnumerableProperty: ZA, nop: J4, isDisturbed: UA, isErrored: QA, isReadable: eA, toUSVString: dA, isUSVString: CA, isBlobLike: H4, parseOrigin: F3, parseURL: i6, getServerName: D3, isStream: V5, isIterable: q5, isAsyncIterable: W4, isDestroyed: P4, headerNameToString: fA, bufferToLowerCasedHeaderName: uA, addListener: GA, removeAllListeners: NA, errorRequest: KA, parseRawHeaders: RA, parseHeaders: pA, parseKeepAliveTimeout: EA, destroy: Z4, bodyLength: O6, deepClone: S4, ReadableStreamFrom: YA, isBuffer: DA, validateHandler: TA, getSocketInfo: lA, isFormDataLike: nA, buildURL: h7, addAbortListener: $5, isValidHTTPToken: xA, isValidHeaderValue: WA, isTokenCharCode: mA, parseRangeHeader: LA, normalizedMethodRecordsBase: PA, normalizedMethodRecords: oA, isValidPort: I5, isHttpOrHttpsPrefixed: k5, nodeMajor: d6, nodeMinor: N6, safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"], wrapRequestBody: Y4 }, util$7;
   }
   e10(requireUtil$7, "requireUtil$7");
   var diagnostics;
@@ -240989,7 +243078,7 @@ var require_proxy = __commonJS((exports) => {
       const T4 = YA(j3);
       if (T4 === "no metadata" || T4.length === 0)
         return true;
-      const X4 = nA(T4), K4 = $4(T4, X4);
+      const X4 = nA(T4), K4 = $5(T4, X4);
       for (const _5 of K4) {
         const { algo: gA, hash: tA } = _5;
         let hA = J4.createHash(gA).update(G4).digest("base64");
@@ -241032,7 +243121,7 @@ var require_proxy = __commonJS((exports) => {
       return j3;
     }
     e10(nA, "getStrongestMetadata");
-    function $4(G4, j3) {
+    function $5(G4, j3) {
       if (G4.length === 1)
         return G4;
       let T4 = 0;
@@ -241040,7 +243129,7 @@ var require_proxy = __commonJS((exports) => {
         G4[X4].algo === j3 && (G4[T4++] = G4[X4]);
       return G4.length = T4, G4;
     }
-    e10($4, "filterMetadataListByAlgorithm");
+    e10($5, "filterMetadataListByAlgorithm");
     function sA(G4, j3) {
       if (G4.length !== j3.length)
         return false;
@@ -241658,8 +243747,8 @@ Content-Type: ${BA.type || "application/octet-stream"}\r
 `);
             lA.push(dA, BA, YA), typeof BA.size == "number" ? pA += dA.byteLength + BA.size + YA.byteLength : nA = true;
           }
-        const $4 = V5.encode(`--${TA}--`);
-        lA.push($4), pA += $4.byteLength, nA && (pA = null), uA = Z4, fA = e10(async function* () {
+        const $5 = V5.encode(`--${TA}--`);
+        lA.push($5), pA += $5.byteLength, nA && (pA = null), uA = Z4, fA = e10(async function* () {
           for (const sA of lA)
             sA.stream ? yield* sA.stream() : yield sA;
         }, "action"), RA = `multipart/form-data; boundary=${TA}`;
@@ -241786,7 +243875,7 @@ Content-Type: ${BA.type || "application/octet-stream"}\r
     if (hasRequiredClientH1)
       return clientH1;
     hasRequiredClientH1 = 1;
-    const A5 = require$$0__default, p6 = requireUtil$7(), { channels: c3 } = requireDiagnostics(), E6 = requireTimers(), { RequestContentLengthMismatchError: t8, ResponseContentLengthMismatchError: B4, RequestAbortedError: f6, HeadersTimeoutError: l3, HeadersOverflowError: Q4, SocketError: u6, InformationalError: n6, BodyTimeoutError: r6, HTTPParserError: o8, ResponseExceededMaxSizeError: a7 } = requireErrors(), { kUrl: g6, kReset: d6, kClient: N6, kParser: M5, kBlocking: Y4, kRunning: J4, kPending: V5, kSize: H4, kWriting: h7, kQueue: I5, kNoRef: k5, kKeepAliveDefaultTimeout: i6, kHostHeader: F3, kPendingIdx: m6, kRunningIdx: D3, kError: S4, kPipelining: W4, kSocket: q5, kKeepAliveTimeoutValue: O6, kMaxHeadersSize: P4, kKeepAliveMaxTimeout: Z4, kKeepAliveTimeoutThreshold: cA, kHeadersTimeout: EA, kBodyTimeout: fA, kStrictContentLength: uA, kMaxRequests: pA, kCounter: RA, kMaxResponseSize: DA, kOnError: TA, kResume: UA, kHTTPContext: QA } = requireSymbols$4(), eA = requireConstants$3(), lA = Buffer.alloc(0), YA = Buffer[Symbol.species], nA = p6.addListener, $4 = p6.removeAllListeners;
+    const A5 = require$$0__default, p6 = requireUtil$7(), { channels: c3 } = requireDiagnostics(), E6 = requireTimers(), { RequestContentLengthMismatchError: t8, ResponseContentLengthMismatchError: B4, RequestAbortedError: f6, HeadersTimeoutError: l3, HeadersOverflowError: Q4, SocketError: u6, InformationalError: n6, BodyTimeoutError: r6, HTTPParserError: o8, ResponseExceededMaxSizeError: a7 } = requireErrors(), { kUrl: g6, kReset: d6, kClient: N6, kParser: M5, kBlocking: Y4, kRunning: J4, kPending: V5, kSize: H4, kWriting: h7, kQueue: I5, kNoRef: k5, kKeepAliveDefaultTimeout: i6, kHostHeader: F3, kPendingIdx: m6, kRunningIdx: D3, kError: S4, kPipelining: W4, kSocket: q5, kKeepAliveTimeoutValue: O6, kMaxHeadersSize: P4, kKeepAliveMaxTimeout: Z4, kKeepAliveTimeoutThreshold: cA, kHeadersTimeout: EA, kBodyTimeout: fA, kStrictContentLength: uA, kMaxRequests: pA, kCounter: RA, kMaxResponseSize: DA, kOnError: TA, kResume: UA, kHTTPContext: QA } = requireSymbols$4(), eA = requireConstants$3(), lA = Buffer.alloc(0), YA = Buffer[Symbol.species], nA = p6.addListener, $5 = p6.removeAllListeners;
     let sA;
     async function BA() {
       const kA = process.env.JEST_WORKER_ID ? requireLlhttpWasm() : undefined;
@@ -241909,7 +243998,7 @@ Content-Type: ${BA.type || "application/octet-stream"}\r
         const { upgrade: iA, client: rA, socket: aA, headers: yA, statusCode: SA } = this;
         A5(iA), A5(rA[q5] === aA), A5(!aA.destroyed), A5(!this.paused), A5((yA.length & 1) === 0);
         const vA = rA[I5][rA[D3]];
-        A5(vA), A5(vA.upgrade || vA.method === "CONNECT"), this.statusCode = null, this.statusText = "", this.shouldKeepAlive = null, this.headers = [], this.headersSize = 0, aA.unshift(z5), aA[M5].destroy(), aA[M5] = null, aA[N6] = null, aA[S4] = null, $4(aA), rA[q5] = null, rA[QA] = null, rA[I5][rA[D3]++] = null, rA.emit("disconnect", rA[g6], [rA], new n6("upgrade"));
+        A5(vA), A5(vA.upgrade || vA.method === "CONNECT"), this.statusCode = null, this.statusText = "", this.shouldKeepAlive = null, this.headers = [], this.headersSize = 0, aA.unshift(z5), aA[M5].destroy(), aA[M5] = null, aA[N6] = null, aA[S4] = null, $5(aA), rA[q5] = null, rA[QA] = null, rA[I5][rA[D3]++] = null, rA.emit("disconnect", rA[g6], [rA], new n6("upgrade"));
         try {
           vA.onUpgrade(SA, yA, aA);
         } catch (G4) {
@@ -242265,20 +244354,20 @@ ${j3.toString(16)}\r
     }
     const { constants: { HTTP2_HEADER_AUTHORITY: D3, HTTP2_HEADER_METHOD: S4, HTTP2_HEADER_PATH: W4, HTTP2_HEADER_SCHEME: q5, HTTP2_HEADER_CONTENT_LENGTH: O6, HTTP2_HEADER_EXPECT: P4, HTTP2_HEADER_STATUS: Z4 } } = m6;
     function cA(nA) {
-      const $4 = [];
+      const $5 = [];
       for (const [sA, BA] of Object.entries(nA))
         if (Array.isArray(BA))
           for (const dA of BA)
-            $4.push(Buffer.from(sA), Buffer.from(dA));
+            $5.push(Buffer.from(sA), Buffer.from(dA));
         else
-          $4.push(Buffer.from(sA), Buffer.from(BA));
-      return $4;
+          $5.push(Buffer.from(sA), Buffer.from(BA));
+      return $5;
     }
     e10(cA, "parseH2Headers");
-    async function EA(nA, $4) {
-      nA[N6] = $4, F3 || (F3 = true, process.emitWarning("H2 support is experimental, expect them to change at any time.", { code: "UNDICI-H2" }));
-      const sA = m6.connect(nA[l3], { createConnection: e10(() => $4, "createConnection"), peerMaxConcurrentStreams: nA[J4] });
-      sA[k5] = 0, sA[u6] = nA, sA[N6] = $4, c3.addListener(sA, "error", uA), c3.addListener(sA, "frameError", pA), c3.addListener(sA, "end", RA), c3.addListener(sA, "goaway", DA), c3.addListener(sA, "close", function() {
+    async function EA(nA, $5) {
+      nA[N6] = $5, F3 || (F3 = true, process.emitWarning("H2 support is experimental, expect them to change at any time.", { code: "UNDICI-H2" }));
+      const sA = m6.connect(nA[l3], { createConnection: e10(() => $5, "createConnection"), peerMaxConcurrentStreams: nA[J4] });
+      sA[k5] = 0, sA[u6] = nA, sA[N6] = $5, c3.addListener(sA, "error", uA), c3.addListener(sA, "frameError", pA), c3.addListener(sA, "end", RA), c3.addListener(sA, "goaway", DA), c3.addListener(sA, "close", function() {
         const { [u6]: dA } = this, { [N6]: CA } = dA, mA = this[N6][d6] || this[d6] || new B4("closed", c3.getSocketInfo(CA));
         if (dA[V5] = null, dA.destroyed) {
           A5(dA[r6] === 0);
@@ -242288,42 +244377,42 @@ ${j3.toString(16)}\r
             c3.errorRequest(dA, WA, mA);
           }
         }
-      }), sA.unref(), nA[V5] = sA, $4[V5] = sA, c3.addListener($4, "error", function(dA) {
+      }), sA.unref(), nA[V5] = sA, $5[V5] = sA, c3.addListener($5, "error", function(dA) {
         A5(dA.code !== "ERR_TLS_CERT_ALTNAME_INVALID"), this[d6] = dA, this[u6][Y4](dA);
-      }), c3.addListener($4, "end", function() {
+      }), c3.addListener($5, "end", function() {
         c3.destroy(this, new B4("other side closed", c3.getSocketInfo(this)));
-      }), c3.addListener($4, "close", function() {
+      }), c3.addListener($5, "close", function() {
         const dA = this[d6] || new B4("closed", c3.getSocketInfo(this));
         nA[N6] = null, this[V5] != null && this[V5].destroy(dA), nA[a7] = nA[g6], A5(nA[n6] === 0), nA.emit("disconnect", nA[l3], [nA], dA), nA[H4]();
       });
       let BA = false;
-      return $4.on("close", () => {
+      return $5.on("close", () => {
         BA = true;
       }), { version: "h2", defaultPipelining: 1 / 0, write(...dA) {
         return UA(nA, ...dA);
       }, resume() {
         fA(nA);
       }, destroy(dA, CA) {
-        BA ? queueMicrotask(CA) : $4.destroy(dA).on("close", CA);
+        BA ? queueMicrotask(CA) : $5.destroy(dA).on("close", CA);
       }, get destroyed() {
-        return $4.destroyed;
+        return $5.destroyed;
       }, busy() {
         return false;
       } };
     }
     e10(EA, "connectH2");
     function fA(nA) {
-      const $4 = nA[N6];
-      $4?.destroyed === false && (nA[h7] === 0 && nA[J4] === 0 ? ($4.unref(), nA[V5].unref()) : ($4.ref(), nA[V5].ref()));
+      const $5 = nA[N6];
+      $5?.destroyed === false && (nA[h7] === 0 && nA[J4] === 0 ? ($5.unref(), nA[V5].unref()) : ($5.ref(), nA[V5].ref()));
     }
     e10(fA, "resumeH2");
     function uA(nA) {
       A5(nA.code !== "ERR_TLS_CERT_ALTNAME_INVALID"), this[N6][d6] = nA, this[u6][Y4](nA);
     }
     e10(uA, "onHttp2SessionError");
-    function pA(nA, $4, sA) {
+    function pA(nA, $5, sA) {
       if (sA === 0) {
-        const BA = new f6(`HTTP/2: "frameError" received - type ${nA}, code ${$4}`);
+        const BA = new f6(`HTTP/2: "frameError" received - type ${nA}, code ${$5}`);
         this[N6][d6] = BA, this[u6][Y4](BA);
       }
     }
@@ -242334,23 +244423,23 @@ ${j3.toString(16)}\r
     }
     e10(RA, "onHttp2SessionEnd");
     function DA(nA) {
-      const $4 = this[d6] || new B4(`HTTP/2: "GOAWAY" frame received with code ${nA}`, c3.getSocketInfo(this)), sA = this[u6];
-      if (sA[N6] = null, sA[I5] = null, this[V5] != null && (this[V5].destroy($4), this[V5] = null), c3.destroy(this[N6], $4), sA[g6] < sA[o8].length) {
+      const $5 = this[d6] || new B4(`HTTP/2: "GOAWAY" frame received with code ${nA}`, c3.getSocketInfo(this)), sA = this[u6];
+      if (sA[N6] = null, sA[I5] = null, this[V5] != null && (this[V5].destroy($5), this[V5] = null), c3.destroy(this[N6], $5), sA[g6] < sA[o8].length) {
         const BA = sA[o8][sA[g6]];
-        sA[o8][sA[g6]++] = null, c3.errorRequest(sA, BA, $4), sA[a7] = sA[g6];
+        sA[o8][sA[g6]++] = null, c3.errorRequest(sA, BA, $5), sA[a7] = sA[g6];
       }
-      A5(sA[n6] === 0), sA.emit("disconnect", sA[l3], [sA], $4), sA[H4]();
+      A5(sA[n6] === 0), sA.emit("disconnect", sA[l3], [sA], $5), sA[H4]();
     }
     e10(DA, "onHTTP2GoAway");
     function TA(nA) {
       return nA !== "GET" && nA !== "HEAD" && nA !== "OPTIONS" && nA !== "TRACE" && nA !== "CONNECT";
     }
     e10(TA, "shouldSendContentLength");
-    function UA(nA, $4) {
-      const sA = nA[V5], { method: BA, path: dA, host: CA, upgrade: mA, expectContinue: xA, signal: bA, headers: WA } = $4;
-      let { body: LA } = $4;
+    function UA(nA, $5) {
+      const sA = nA[V5], { method: BA, path: dA, host: CA, upgrade: mA, expectContinue: xA, signal: bA, headers: WA } = $5;
+      let { body: LA } = $5;
       if (mA)
-        return c3.errorRequest(nA, $4, new Error("Upgrade not supported for H2")), false;
+        return c3.errorRequest(nA, $5, new Error("Upgrade not supported for H2")), false;
       const GA = {};
       for (let wA = 0;wA < WA.length; wA += 2) {
         const FA = WA[wA + 0], MA = WA[wA + 1];
@@ -242364,18 +244453,18 @@ ${j3.toString(16)}\r
       const { hostname: KA, port: ZA } = nA[l3];
       GA[D3] = CA || `${KA}${ZA ? `:${ZA}` : ""}`, GA[S4] = BA;
       const PA = e10((wA) => {
-        $4.aborted || $4.completed || (wA = wA || new t8, c3.errorRequest(nA, $4, wA), NA != null && c3.destroy(NA, wA), c3.destroy(LA, wA), nA[o8][nA[g6]++] = null, nA[H4]());
+        $5.aborted || $5.completed || (wA = wA || new t8, c3.errorRequest(nA, $5, wA), NA != null && c3.destroy(NA, wA), c3.destroy(LA, wA), nA[o8][nA[g6]++] = null, nA[H4]());
       }, "abort");
       try {
-        $4.onConnect(PA);
+        $5.onConnect(PA);
       } catch (wA) {
-        c3.errorRequest(nA, $4, wA);
+        c3.errorRequest(nA, $5, wA);
       }
-      if ($4.aborted)
+      if ($5.aborted)
         return false;
       if (BA === "CONNECT")
-        return sA.ref(), NA = sA.request(GA, { endStream: false, signal: bA }), NA.id && !NA.pending ? ($4.onUpgrade(null, null, NA), ++sA[k5], nA[o8][nA[g6]++] = null) : NA.once("ready", () => {
-          $4.onUpgrade(null, null, NA), ++sA[k5], nA[o8][nA[g6]++] = null;
+        return sA.ref(), NA = sA.request(GA, { endStream: false, signal: bA }), NA.id && !NA.pending ? ($5.onUpgrade(null, null, NA), ++sA[k5], nA[o8][nA[g6]++] = null) : NA.once("ready", () => {
+          $5.onUpgrade(null, null, NA), ++sA[k5], nA[o8][nA[g6]++] = null;
         }), NA.once("close", () => {
           sA[k5] -= 1, sA[k5] === 0 && sA.unref();
         }), true;
@@ -242388,25 +244477,25 @@ ${j3.toString(16)}\r
         const [wA, FA] = i6(LA);
         GA["content-type"] = FA, LA = wA.stream, L4 = wA.length;
       }
-      if (L4 == null && (L4 = $4.contentLength), (L4 === 0 || !oA) && (L4 = null), TA(BA) && L4 > 0 && $4.contentLength != null && $4.contentLength !== L4) {
+      if (L4 == null && (L4 = $5.contentLength), (L4 === 0 || !oA) && (L4 = null), TA(BA) && L4 > 0 && $5.contentLength != null && $5.contentLength !== L4) {
         if (nA[M5])
-          return c3.errorRequest(nA, $4, new E6), false;
+          return c3.errorRequest(nA, $5, new E6), false;
         process.emitWarning(new E6);
       }
       L4 != null && (A5(LA, "no body must not have content length"), GA[O6] = `${L4}`), sA.ref();
       const AA = BA === "GET" || BA === "HEAD" || LA === null;
       return xA ? (GA[P4] = "100-continue", NA = sA.request(GA, { endStream: AA, signal: bA }), NA.once("continue", IA)) : (NA = sA.request(GA, { endStream: AA, signal: bA }), IA()), ++sA[k5], NA.once("response", (wA) => {
         const { [Z4]: FA, ...MA } = wA;
-        if ($4.onResponseStarted(), $4.aborted) {
+        if ($5.onResponseStarted(), $5.aborted) {
           const OA = new t8;
-          c3.errorRequest(nA, $4, OA), c3.destroy(NA, OA);
+          c3.errorRequest(nA, $5, OA), c3.destroy(NA, OA);
           return;
         }
-        $4.onHeaders(Number(FA), cA(MA), NA.resume.bind(NA), "") === false && NA.pause(), NA.on("data", (OA) => {
-          $4.onData(OA) === false && NA.pause();
+        $5.onHeaders(Number(FA), cA(MA), NA.resume.bind(NA), "") === false && NA.pause(), NA.on("data", (OA) => {
+          $5.onData(OA) === false && NA.pause();
         });
       }), NA.once("end", () => {
-        (NA.state?.state == null || NA.state.state < 6) && $4.onComplete([]), sA[k5] === 0 && sA.unref(), PA(new f6("HTTP/2: stream half-closed (remote)")), nA[o8][nA[g6]++] = null, nA[a7] = nA[g6], nA[H4]();
+        (NA.state?.state == null || NA.state.state < 6) && $5.onComplete([]), sA[k5] === 0 && sA.unref(), PA(new f6("HTTP/2: stream half-closed (remote)")), nA[o8][nA[g6]++] = null, nA[a7] = nA[g6], nA[H4]();
       }), NA.once("close", () => {
         sA[k5] -= 1, sA[k5] === 0 && sA.unref();
       }), NA.once("error", function(wA) {
@@ -242415,23 +244504,23 @@ ${j3.toString(16)}\r
         PA(new f6(`HTTP/2: "frameError" received - type ${wA}, code ${FA}`));
       }), true;
       function IA() {
-        !LA || L4 === 0 ? QA(PA, NA, null, nA, $4, nA[N6], L4, oA) : c3.isBuffer(LA) ? QA(PA, NA, LA, nA, $4, nA[N6], L4, oA) : c3.isBlobLike(LA) ? typeof LA.stream == "function" ? YA(PA, NA, LA.stream(), nA, $4, nA[N6], L4, oA) : lA(PA, NA, LA, nA, $4, nA[N6], L4, oA) : c3.isStream(LA) ? eA(PA, nA[N6], oA, NA, LA, nA, $4, L4) : c3.isIterable(LA) ? YA(PA, NA, LA, nA, $4, nA[N6], L4, oA) : A5(false);
+        !LA || L4 === 0 ? QA(PA, NA, null, nA, $5, nA[N6], L4, oA) : c3.isBuffer(LA) ? QA(PA, NA, LA, nA, $5, nA[N6], L4, oA) : c3.isBlobLike(LA) ? typeof LA.stream == "function" ? YA(PA, NA, LA.stream(), nA, $5, nA[N6], L4, oA) : lA(PA, NA, LA, nA, $5, nA[N6], L4, oA) : c3.isStream(LA) ? eA(PA, nA[N6], oA, NA, LA, nA, $5, L4) : c3.isIterable(LA) ? YA(PA, NA, LA, nA, $5, nA[N6], L4, oA) : A5(false);
       }
       e10(IA, "writeBodyH2");
     }
     e10(UA, "writeH2");
-    function QA(nA, $4, sA, BA, dA, CA, mA, xA) {
+    function QA(nA, $5, sA, BA, dA, CA, mA, xA) {
       try {
-        sA != null && c3.isBuffer(sA) && (A5(mA === sA.byteLength, "buffer body must have content length"), $4.cork(), $4.write(sA), $4.uncork(), $4.end(), dA.onBodySent(sA)), xA || (CA[Q4] = true), dA.onRequestSent(), BA[H4]();
+        sA != null && c3.isBuffer(sA) && (A5(mA === sA.byteLength, "buffer body must have content length"), $5.cork(), $5.write(sA), $5.uncork(), $5.end(), dA.onBodySent(sA)), xA || (CA[Q4] = true), dA.onRequestSent(), BA[H4]();
       } catch (bA) {
         nA(bA);
       }
     }
     e10(QA, "writeBuffer");
-    function eA(nA, $4, sA, BA, dA, CA, mA, xA) {
+    function eA(nA, $5, sA, BA, dA, CA, mA, xA) {
       A5(xA !== 0 || CA[n6] === 0, "stream body cannot be pipelined");
       const bA = p6(dA, BA, (LA) => {
-        LA ? (c3.destroy(bA, LA), nA(LA)) : (c3.removeAllListeners(bA), mA.onRequestSent(), sA || ($4[Q4] = true), CA[H4]());
+        LA ? (c3.destroy(bA, LA), nA(LA)) : (c3.removeAllListeners(bA), mA.onRequestSent(), sA || ($5[Q4] = true), CA[H4]());
       });
       c3.addListener(bA, "data", WA);
       function WA(LA) {
@@ -242440,19 +244529,19 @@ ${j3.toString(16)}\r
       e10(WA, "onPipeData");
     }
     e10(eA, "writeStream");
-    async function lA(nA, $4, sA, BA, dA, CA, mA, xA) {
+    async function lA(nA, $5, sA, BA, dA, CA, mA, xA) {
       A5(mA === sA.size, "blob body must have content length");
       try {
         if (mA != null && mA !== sA.size)
           throw new E6;
         const bA = Buffer.from(await sA.arrayBuffer());
-        $4.cork(), $4.write(bA), $4.uncork(), $4.end(), dA.onBodySent(bA), dA.onRequestSent(), xA || (CA[Q4] = true), BA[H4]();
+        $5.cork(), $5.write(bA), $5.uncork(), $5.end(), dA.onBodySent(bA), dA.onRequestSent(), xA || (CA[Q4] = true), BA[H4]();
       } catch (bA) {
         nA(bA);
       }
     }
     e10(lA, "writeBlob");
-    async function YA(nA, $4, sA, BA, dA, CA, mA, xA) {
+    async function YA(nA, $5, sA, BA, dA, CA, mA, xA) {
       A5(mA !== 0 || BA[n6] === 0, "iterator body cannot be pipelined");
       let bA = null;
       function WA() {
@@ -242465,19 +244554,19 @@ ${j3.toString(16)}\r
       const LA = e10(() => new Promise((GA, NA) => {
         A5(bA === null), CA[d6] ? NA(CA[d6]) : bA = GA;
       }), "waitForDrain");
-      $4.on("close", WA).on("drain", WA);
+      $5.on("close", WA).on("drain", WA);
       try {
         for await (const GA of sA) {
           if (CA[d6])
             throw CA[d6];
-          const NA = $4.write(GA);
+          const NA = $5.write(GA);
           dA.onBodySent(GA), NA || await LA();
         }
-        $4.end(), dA.onRequestSent(), xA || (CA[Q4] = true), BA[H4]();
+        $5.end(), dA.onRequestSent(), xA || (CA[Q4] = true), BA[H4]();
       } catch (GA) {
         nA(GA);
       } finally {
-        $4.off("close", WA).off("drain", WA);
+        $5.off("close", WA).off("drain", WA);
       }
     }
     return e10(YA, "writeIterable"), clientH2 = EA, clientH2;
@@ -242606,7 +244695,7 @@ ${j3.toString(16)}\r
     if (hasRequiredClient)
       return client;
     hasRequiredClient = 1;
-    const A5 = require$$0__default, p6 = require$$0__default$1, c3 = http__default, E6 = requireUtil$7(), { channels: t8 } = requireDiagnostics(), B4 = requireRequest$1(), f6 = requireDispatcherBase(), { InvalidArgumentError: l3, InformationalError: Q4, ClientDestroyedError: u6 } = requireErrors(), n6 = requireConnect(), { kUrl: r6, kServerName: o8, kClient: a7, kBusy: g6, kConnect: d6, kResuming: N6, kRunning: M5, kPending: Y4, kSize: J4, kQueue: V5, kConnected: H4, kConnecting: h7, kNeedDrain: I5, kKeepAliveDefaultTimeout: k5, kHostHeader: i6, kPendingIdx: F3, kRunningIdx: m6, kError: D3, kPipelining: S4, kKeepAliveTimeoutValue: W4, kMaxHeadersSize: q5, kKeepAliveMaxTimeout: O6, kKeepAliveTimeoutThreshold: P4, kHeadersTimeout: Z4, kBodyTimeout: cA, kStrictContentLength: EA, kConnector: fA, kMaxRedirections: uA, kMaxRequests: pA, kCounter: RA, kClose: DA, kDestroy: TA, kDispatch: UA, kInterceptors: QA, kLocalAddress: eA, kMaxResponseSize: lA, kOnError: YA, kHTTPContext: nA, kMaxConcurrentStreams: $4, kResume: sA } = requireSymbols$4(), BA = requireClientH1(), dA = requireClientH2();
+    const A5 = require$$0__default, p6 = require$$0__default$1, c3 = http__default, E6 = requireUtil$7(), { channels: t8 } = requireDiagnostics(), B4 = requireRequest$1(), f6 = requireDispatcherBase(), { InvalidArgumentError: l3, InformationalError: Q4, ClientDestroyedError: u6 } = requireErrors(), n6 = requireConnect(), { kUrl: r6, kServerName: o8, kClient: a7, kBusy: g6, kConnect: d6, kResuming: N6, kRunning: M5, kPending: Y4, kSize: J4, kQueue: V5, kConnected: H4, kConnecting: h7, kNeedDrain: I5, kKeepAliveDefaultTimeout: k5, kHostHeader: i6, kPendingIdx: F3, kRunningIdx: m6, kError: D3, kPipelining: S4, kKeepAliveTimeoutValue: W4, kMaxHeadersSize: q5, kKeepAliveMaxTimeout: O6, kKeepAliveTimeoutThreshold: P4, kHeadersTimeout: Z4, kBodyTimeout: cA, kStrictContentLength: EA, kConnector: fA, kMaxRedirections: uA, kMaxRequests: pA, kCounter: RA, kClose: DA, kDestroy: TA, kDispatch: UA, kInterceptors: QA, kLocalAddress: eA, kMaxResponseSize: lA, kOnError: YA, kHTTPContext: nA, kMaxConcurrentStreams: $5, kResume: sA } = requireSymbols$4(), BA = requireClientH1(), dA = requireClientH2();
     let CA = false;
     const mA = Symbol("kClosedResolve"), xA = e10(() => {
     }, "noop");
@@ -242663,7 +244752,7 @@ ${j3.toString(16)}\r
         if (JA != null && (typeof JA != "number" || JA < 1))
           throw new l3("maxConcurrentStreams must be a positive integer, greater than 0");
         typeof X4 != "function" && (X4 = n6({ ...vA, maxCachedSessions: j3, allowH2: qA, socketPath: yA, timeout: OA, ...tA ? { autoSelectFamily: tA, autoSelectFamilyAttemptTimeout: hA } : undefined, ...X4 })), AA?.Client && Array.isArray(AA.Client) ? (this[QA] = AA.Client, CA || (CA = true, process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.", { code: "UNDICI-CLIENT-INTERCEPTOR-DEPRECATED" }))) : this[QA] = [LA({ maxRedirections: T4 })], this[r6] = E6.parseOrigin(L4), this[fA] = X4, this[S4] = SA ?? 1, this[q5] = IA || c3.maxHeaderSize, this[k5] = z5 ?? 4000, this[O6] = rA ?? 600000, this[P4] = aA ?? 2000, this[W4] = this[k5], this[o8] = null, this[eA] = _5 ?? null, this[N6] = 0, this[I5] = 0, this[i6] = `host: ${this[r6].hostname}${this[r6].port ? `:${this[r6].port}` : ""}\r
-`, this[cA] = _A ?? 300000, this[Z4] = wA ?? 300000, this[EA] = G4 ?? true, this[uA] = T4, this[pA] = K4, this[mA] = null, this[lA] = gA > -1 ? gA : -1, this[$4] = JA ?? 100, this[nA] = null, this[V5] = [], this[m6] = 0, this[F3] = 0, this[sA] = (VA) => ZA(this, VA), this[YA] = (VA) => GA(this, VA);
+`, this[cA] = _A ?? 300000, this[Z4] = wA ?? 300000, this[EA] = G4 ?? true, this[uA] = T4, this[pA] = K4, this[mA] = null, this[lA] = gA > -1 ? gA : -1, this[$5] = JA ?? 100, this[nA] = null, this[V5] = [], this[m6] = 0, this[F3] = 0, this[sA] = (VA) => ZA(this, VA), this[YA] = (VA) => GA(this, VA);
       }
       get pipelining() {
         return this[S4];
@@ -244340,8 +246429,8 @@ ${j3.toString(16)}\r
           lA.then((sA) => DA(UA, sA));
           return;
         }
-        const YA = N6(lA), nA = H4(Z4), $4 = H4(cA);
-        S4.onConnect?.((sA) => S4.onError(sA), null), S4.onHeaders?.(O6, nA, TA, h7(O6)), S4.onData?.(Buffer.from(YA)), S4.onComplete?.($4), J4(UA, W4);
+        const YA = N6(lA), nA = H4(Z4), $5 = H4(cA);
+        S4.onConnect?.((sA) => S4.onError(sA), null), S4.onHeaders?.(O6, nA, TA, h7(O6)), S4.onData?.(Buffer.from(YA)), S4.onComplete?.($5), J4(UA, W4);
       }
       e10(DA, "handleReply");
       function TA() {
@@ -245238,8 +247327,8 @@ ${h7.format(I5)}
       }
       static json(eA, lA = {}) {
         m6.argumentLengthCheck(arguments, 1, "Response.json"), lA !== null && (lA = m6.converters.ResponseInit(lA));
-        const YA = P4.encode(J4(eA)), nA = f6(YA), $4 = UA(EA({}), "response");
-        return TA($4, lA, { body: nA[0], type: "application/json" }), $4;
+        const YA = P4.encode(J4(eA)), nA = f6(YA), $5 = UA(EA({}), "response");
+        return TA($5, lA, { body: nA[0], type: "application/json" }), $5;
       }
       static redirect(eA, lA = 302) {
         m6.argumentLengthCheck(arguments, 1, "Response.redirect"), eA = m6.converters.USVString(eA), lA = m6.converters["unsigned short"](lA);
@@ -245253,8 +247342,8 @@ ${h7.format(I5)}
           throw new RangeError(`Invalid status code ${lA}`);
         const nA = UA(EA({}), "immutable");
         nA[i6].status = lA;
-        const $4 = H4(S4(YA));
-        return nA[i6].headersList.append("location", $4, true), nA;
+        const $5 = H4(S4(YA));
+        return nA[i6].headersList.append("location", $5, true), nA;
       }
       constructor(eA = null, lA = {}) {
         if (m6.util.markAsUncloneable(this), eA === W4)
@@ -245262,8 +247351,8 @@ ${h7.format(I5)}
         eA !== null && (eA = m6.converters.BodyInit(eA)), lA = m6.converters.ResponseInit(lA), this[i6] = EA({}), this[F3] = new A5(W4), t8(this[F3], "response"), B4(this[F3], this[i6].headersList);
         let YA = null;
         if (eA != null) {
-          const [nA, $4] = f6(eA);
-          YA = { body: nA, type: $4 };
+          const [nA, $5] = f6(eA);
+          YA = { body: nA, type: $5 };
         }
         TA(this, lA, YA);
       }
@@ -245422,13 +247511,13 @@ ${h7.format(I5)}
     if (hasRequiredRequest)
       return request2;
     hasRequiredRequest = 1;
-    const { extractBody: A5, mixinBody: p6, cloneBody: c3, bodyUnusable: E6 } = requireBody(), { Headers: t8, fill: B4, HeadersList: f6, setHeadersGuard: l3, getHeadersGuard: Q4, setHeadersList: u6, getHeadersList: n6 } = requireHeaders(), { FinalizationRegistry: r6 } = requireDispatcherWeakref()(), o8 = requireUtil$7(), a7 = require$$0__default$3, { isValidHTTPToken: g6, sameOrigin: d6, environmentSettingsObject: N6 } = requireUtil$6(), { forbiddenMethodsSet: M5, corsSafeListedMethodsSet: Y4, referrerPolicy: J4, requestRedirect: V5, requestMode: H4, requestCredentials: h7, requestCache: I5, requestDuplex: k5 } = requireConstants$2(), { kEnumerableProperty: i6, normalizedMethodRecordsBase: F3, normalizedMethodRecords: m6 } = o8, { kHeaders: D3, kSignal: S4, kState: W4, kDispatcher: q5 } = requireSymbols$3(), { webidl: O6 } = requireWebidl(), { URLSerializer: P4 } = requireDataUrl(), { kConstruct: Z4 } = requireSymbols$4(), cA = require$$0__default, { getMaxListeners: EA, setMaxListeners: fA, getEventListeners: uA, defaultMaxListeners: pA } = require$$8__default, RA = Symbol("abortController"), DA = new r6(({ signal: $4, abort: sA }) => {
-      $4.removeEventListener("abort", sA);
+    const { extractBody: A5, mixinBody: p6, cloneBody: c3, bodyUnusable: E6 } = requireBody(), { Headers: t8, fill: B4, HeadersList: f6, setHeadersGuard: l3, getHeadersGuard: Q4, setHeadersList: u6, getHeadersList: n6 } = requireHeaders(), { FinalizationRegistry: r6 } = requireDispatcherWeakref()(), o8 = requireUtil$7(), a7 = require$$0__default$3, { isValidHTTPToken: g6, sameOrigin: d6, environmentSettingsObject: N6 } = requireUtil$6(), { forbiddenMethodsSet: M5, corsSafeListedMethodsSet: Y4, referrerPolicy: J4, requestRedirect: V5, requestMode: H4, requestCredentials: h7, requestCache: I5, requestDuplex: k5 } = requireConstants$2(), { kEnumerableProperty: i6, normalizedMethodRecordsBase: F3, normalizedMethodRecords: m6 } = o8, { kHeaders: D3, kSignal: S4, kState: W4, kDispatcher: q5 } = requireSymbols$3(), { webidl: O6 } = requireWebidl(), { URLSerializer: P4 } = requireDataUrl(), { kConstruct: Z4 } = requireSymbols$4(), cA = require$$0__default, { getMaxListeners: EA, setMaxListeners: fA, getEventListeners: uA, defaultMaxListeners: pA } = require$$8__default, RA = Symbol("abortController"), DA = new r6(({ signal: $5, abort: sA }) => {
+      $5.removeEventListener("abort", sA);
     }), TA = new WeakMap;
-    function UA($4) {
+    function UA($5) {
       return sA;
       function sA() {
-        const BA = $4.deref();
+        const BA = $5.deref();
         if (BA !== undefined) {
           DA.unregister(sA), this.removeEventListener("abort", sA), BA.abort(this.reason);
           const dA = TA.get(BA.signal);
@@ -245645,22 +247734,22 @@ ${h7.format(I5)}
       }
     }
     p6(eA);
-    function lA($4) {
-      return { method: $4.method ?? "GET", localURLsOnly: $4.localURLsOnly ?? false, unsafeRequest: $4.unsafeRequest ?? false, body: $4.body ?? null, client: $4.client ?? null, reservedClient: $4.reservedClient ?? null, replacesClientId: $4.replacesClientId ?? "", window: $4.window ?? "client", keepalive: $4.keepalive ?? false, serviceWorkers: $4.serviceWorkers ?? "all", initiator: $4.initiator ?? "", destination: $4.destination ?? "", priority: $4.priority ?? null, origin: $4.origin ?? "client", policyContainer: $4.policyContainer ?? "client", referrer: $4.referrer ?? "client", referrerPolicy: $4.referrerPolicy ?? "", mode: $4.mode ?? "no-cors", useCORSPreflightFlag: $4.useCORSPreflightFlag ?? false, credentials: $4.credentials ?? "same-origin", useCredentials: $4.useCredentials ?? false, cache: $4.cache ?? "default", redirect: $4.redirect ?? "follow", integrity: $4.integrity ?? "", cryptoGraphicsNonceMetadata: $4.cryptoGraphicsNonceMetadata ?? "", parserMetadata: $4.parserMetadata ?? "", reloadNavigation: $4.reloadNavigation ?? false, historyNavigation: $4.historyNavigation ?? false, userActivation: $4.userActivation ?? false, taintedOrigin: $4.taintedOrigin ?? false, redirectCount: $4.redirectCount ?? 0, responseTainting: $4.responseTainting ?? "basic", preventNoCacheCacheControlHeaderModification: $4.preventNoCacheCacheControlHeaderModification ?? false, done: $4.done ?? false, timingAllowFailed: $4.timingAllowFailed ?? false, urlList: $4.urlList, url: $4.urlList[0], headersList: $4.headersList ? new f6($4.headersList) : new f6 };
+    function lA($5) {
+      return { method: $5.method ?? "GET", localURLsOnly: $5.localURLsOnly ?? false, unsafeRequest: $5.unsafeRequest ?? false, body: $5.body ?? null, client: $5.client ?? null, reservedClient: $5.reservedClient ?? null, replacesClientId: $5.replacesClientId ?? "", window: $5.window ?? "client", keepalive: $5.keepalive ?? false, serviceWorkers: $5.serviceWorkers ?? "all", initiator: $5.initiator ?? "", destination: $5.destination ?? "", priority: $5.priority ?? null, origin: $5.origin ?? "client", policyContainer: $5.policyContainer ?? "client", referrer: $5.referrer ?? "client", referrerPolicy: $5.referrerPolicy ?? "", mode: $5.mode ?? "no-cors", useCORSPreflightFlag: $5.useCORSPreflightFlag ?? false, credentials: $5.credentials ?? "same-origin", useCredentials: $5.useCredentials ?? false, cache: $5.cache ?? "default", redirect: $5.redirect ?? "follow", integrity: $5.integrity ?? "", cryptoGraphicsNonceMetadata: $5.cryptoGraphicsNonceMetadata ?? "", parserMetadata: $5.parserMetadata ?? "", reloadNavigation: $5.reloadNavigation ?? false, historyNavigation: $5.historyNavigation ?? false, userActivation: $5.userActivation ?? false, taintedOrigin: $5.taintedOrigin ?? false, redirectCount: $5.redirectCount ?? 0, responseTainting: $5.responseTainting ?? "basic", preventNoCacheCacheControlHeaderModification: $5.preventNoCacheCacheControlHeaderModification ?? false, done: $5.done ?? false, timingAllowFailed: $5.timingAllowFailed ?? false, urlList: $5.urlList, url: $5.urlList[0], headersList: $5.headersList ? new f6($5.headersList) : new f6 };
     }
     e10(lA, "makeRequest");
-    function YA($4) {
-      const sA = lA({ ...$4, body: null });
-      return $4.body != null && (sA.body = c3(sA, $4.body)), sA;
+    function YA($5) {
+      const sA = lA({ ...$5, body: null });
+      return $5.body != null && (sA.body = c3(sA, $5.body)), sA;
     }
     e10(YA, "cloneRequest");
-    function nA($4, sA, BA) {
+    function nA($5, sA, BA) {
       const dA = new eA(Z4);
-      return dA[W4] = $4, dA[S4] = sA, dA[D3] = new t8(Z4), u6(dA[D3], $4.headersList), l3(dA[D3], BA), dA;
+      return dA[W4] = $5, dA[S4] = sA, dA[D3] = new t8(Z4), u6(dA[D3], $5.headersList), l3(dA[D3], BA), dA;
     }
-    return e10(nA, "fromInnerRequest"), Object.defineProperties(eA.prototype, { method: i6, url: i6, headers: i6, redirect: i6, clone: i6, signal: i6, duplex: i6, destination: i6, body: i6, bodyUsed: i6, isHistoryNavigation: i6, isReloadNavigation: i6, keepalive: i6, integrity: i6, cache: i6, credentials: i6, attribute: i6, referrerPolicy: i6, referrer: i6, mode: i6, [Symbol.toStringTag]: { value: "Request", configurable: true } }), O6.converters.Request = O6.interfaceConverter(eA), O6.converters.RequestInfo = function($4, sA, BA) {
-      return typeof $4 == "string" ? O6.converters.USVString($4, sA, BA) : $4 instanceof eA ? O6.converters.Request($4, sA, BA) : O6.converters.USVString($4, sA, BA);
-    }, O6.converters.AbortSignal = O6.interfaceConverter(AbortSignal), O6.converters.RequestInit = O6.dictionaryConverter([{ key: "method", converter: O6.converters.ByteString }, { key: "headers", converter: O6.converters.HeadersInit }, { key: "body", converter: O6.nullableConverter(O6.converters.BodyInit) }, { key: "referrer", converter: O6.converters.USVString }, { key: "referrerPolicy", converter: O6.converters.DOMString, allowedValues: J4 }, { key: "mode", converter: O6.converters.DOMString, allowedValues: H4 }, { key: "credentials", converter: O6.converters.DOMString, allowedValues: h7 }, { key: "cache", converter: O6.converters.DOMString, allowedValues: I5 }, { key: "redirect", converter: O6.converters.DOMString, allowedValues: V5 }, { key: "integrity", converter: O6.converters.DOMString }, { key: "keepalive", converter: O6.converters.boolean }, { key: "signal", converter: O6.nullableConverter(($4) => O6.converters.AbortSignal($4, "RequestInit", "signal", { strict: false })) }, { key: "window", converter: O6.converters.any }, { key: "duplex", converter: O6.converters.DOMString, allowedValues: k5 }, { key: "dispatcher", converter: O6.converters.any }]), request2 = { Request: eA, makeRequest: lA, fromInnerRequest: nA, cloneRequest: YA }, request2;
+    return e10(nA, "fromInnerRequest"), Object.defineProperties(eA.prototype, { method: i6, url: i6, headers: i6, redirect: i6, clone: i6, signal: i6, duplex: i6, destination: i6, body: i6, bodyUsed: i6, isHistoryNavigation: i6, isReloadNavigation: i6, keepalive: i6, integrity: i6, cache: i6, credentials: i6, attribute: i6, referrerPolicy: i6, referrer: i6, mode: i6, [Symbol.toStringTag]: { value: "Request", configurable: true } }), O6.converters.Request = O6.interfaceConverter(eA), O6.converters.RequestInfo = function($5, sA, BA) {
+      return typeof $5 == "string" ? O6.converters.USVString($5, sA, BA) : $5 instanceof eA ? O6.converters.Request($5, sA, BA) : O6.converters.USVString($5, sA, BA);
+    }, O6.converters.AbortSignal = O6.interfaceConverter(AbortSignal), O6.converters.RequestInit = O6.dictionaryConverter([{ key: "method", converter: O6.converters.ByteString }, { key: "headers", converter: O6.converters.HeadersInit }, { key: "body", converter: O6.nullableConverter(O6.converters.BodyInit) }, { key: "referrer", converter: O6.converters.USVString }, { key: "referrerPolicy", converter: O6.converters.DOMString, allowedValues: J4 }, { key: "mode", converter: O6.converters.DOMString, allowedValues: H4 }, { key: "credentials", converter: O6.converters.DOMString, allowedValues: h7 }, { key: "cache", converter: O6.converters.DOMString, allowedValues: I5 }, { key: "redirect", converter: O6.converters.DOMString, allowedValues: V5 }, { key: "integrity", converter: O6.converters.DOMString }, { key: "keepalive", converter: O6.converters.boolean }, { key: "signal", converter: O6.nullableConverter(($5) => O6.converters.AbortSignal($5, "RequestInit", "signal", { strict: false })) }, { key: "window", converter: O6.converters.any }, { key: "duplex", converter: O6.converters.DOMString, allowedValues: k5 }, { key: "dispatcher", converter: O6.converters.any }]), request2 = { Request: eA, makeRequest: lA, fromInnerRequest: nA, cloneRequest: YA }, request2;
   }
   e10(requireRequest, "requireRequest");
   var fetch_1;
@@ -245669,7 +247758,7 @@ ${h7.format(I5)}
     if (hasRequiredFetch)
       return fetch_1;
     hasRequiredFetch = 1;
-    const { makeNetworkError: A5, makeAppropriateNetworkError: p6, filterResponse: c3, makeResponse: E6, fromInnerResponse: t8 } = requireResponse(), { HeadersList: B4 } = requireHeaders(), { Request: f6, cloneRequest: l3 } = requireRequest(), Q4 = zlib__default, { bytesMatch: u6, makePolicyContainer: n6, clonePolicyContainer: r6, requestBadPort: o8, TAOCheck: a7, appendRequestOriginHeader: g6, responseLocationURL: d6, requestCurrentURL: N6, setRequestReferrerPolicyOnRedirect: M5, tryUpgradeRequestToAPotentiallyTrustworthyURL: Y4, createOpaqueTimingInfo: J4, appendFetchMetadata: V5, corsCheck: H4, crossOriginResourcePolicyCheck: h7, determineRequestsReferrer: I5, coarsenedSharedCurrentTime: k5, createDeferredPromise: i6, isBlobLike: F3, sameOrigin: m6, isCancelled: D3, isAborted: S4, isErrorLike: W4, fullyReadBody: q5, readableStreamClose: O6, isomorphicEncode: P4, urlIsLocal: Z4, urlIsHttpHttpsScheme: cA, urlHasHttpsScheme: EA, clampAndCoarsenConnectionTimingInfo: fA, simpleRangeHeaderValue: uA, buildContentRange: pA, createInflate: RA, extractMimeType: DA } = requireUtil$6(), { kState: TA, kDispatcher: UA } = requireSymbols$3(), QA = require$$0__default, { safelyExtractBody: eA, extractBody: lA } = requireBody(), { redirectStatusSet: YA, nullBodyStatus: nA, safeMethodsSet: $4, requestBodyHeader: sA, subresourceSet: BA } = requireConstants$2(), dA = require$$8__default, { Readable: CA, pipeline: mA, finished: xA } = Stream__default, { addAbortListener: bA, isErrored: WA, isReadable: LA, bufferToLowerCasedHeaderName: GA } = requireUtil$7(), { dataURLProcessor: NA, serializeAMimeType: KA, minimizeSupportedMimeType: ZA } = requireDataUrl(), { getGlobalDispatcher: PA } = requireGlobal(), { webidl: oA } = requireWebidl(), { STATUS_CODES: L4 } = http__default, AA = ["GET", "HEAD"], IA = typeof __UNDICI_IS_NODE__ < "u" || typeof esbuildDetection < "u" ? "node" : "undici";
+    const { makeNetworkError: A5, makeAppropriateNetworkError: p6, filterResponse: c3, makeResponse: E6, fromInnerResponse: t8 } = requireResponse(), { HeadersList: B4 } = requireHeaders(), { Request: f6, cloneRequest: l3 } = requireRequest(), Q4 = zlib__default, { bytesMatch: u6, makePolicyContainer: n6, clonePolicyContainer: r6, requestBadPort: o8, TAOCheck: a7, appendRequestOriginHeader: g6, responseLocationURL: d6, requestCurrentURL: N6, setRequestReferrerPolicyOnRedirect: M5, tryUpgradeRequestToAPotentiallyTrustworthyURL: Y4, createOpaqueTimingInfo: J4, appendFetchMetadata: V5, corsCheck: H4, crossOriginResourcePolicyCheck: h7, determineRequestsReferrer: I5, coarsenedSharedCurrentTime: k5, createDeferredPromise: i6, isBlobLike: F3, sameOrigin: m6, isCancelled: D3, isAborted: S4, isErrorLike: W4, fullyReadBody: q5, readableStreamClose: O6, isomorphicEncode: P4, urlIsLocal: Z4, urlIsHttpHttpsScheme: cA, urlHasHttpsScheme: EA, clampAndCoarsenConnectionTimingInfo: fA, simpleRangeHeaderValue: uA, buildContentRange: pA, createInflate: RA, extractMimeType: DA } = requireUtil$6(), { kState: TA, kDispatcher: UA } = requireSymbols$3(), QA = require$$0__default, { safelyExtractBody: eA, extractBody: lA } = requireBody(), { redirectStatusSet: YA, nullBodyStatus: nA, safeMethodsSet: $5, requestBodyHeader: sA, subresourceSet: BA } = requireConstants$2(), dA = require$$8__default, { Readable: CA, pipeline: mA, finished: xA } = Stream__default, { addAbortListener: bA, isErrored: WA, isReadable: LA, bufferToLowerCasedHeaderName: GA } = requireUtil$7(), { dataURLProcessor: NA, serializeAMimeType: KA, minimizeSupportedMimeType: ZA } = requireDataUrl(), { getGlobalDispatcher: PA } = requireGlobal(), { webidl: oA } = requireWebidl(), { STATUS_CODES: L4 } = http__default, AA = ["GET", "HEAD"], IA = typeof __UNDICI_IS_NODE__ < "u" || typeof esbuildDetection < "u" ? "node" : "undici";
     let wA;
 
     class FA extends dA {
@@ -245926,7 +248015,7 @@ ${h7.format(I5)}
         if (tA.cache === "only-if-cached")
           return A5("only if cached");
         const zA = await j3(gA, JA, K4);
-        !$4.has(tA.method) && zA.status >= 200 && zA.status <= 399, hA == null && (hA = zA);
+        !$5.has(tA.method) && zA.status >= 200 && zA.status <= 399, hA == null && (hA = zA);
       }
       if (hA.urlList = [...tA.urlList], tA.headersList.contains("range", true) && (hA.rangeRequested = true), hA.requestIncludesCredentials = JA, hA.status === 407)
         return _5.window === "no-window" ? A5() : D3(T4) ? p6(T4) : A5("proxy authentication required");
@@ -247249,14 +249338,14 @@ ${h7.format(I5)}
     return A5.converters.MessageEventInit = A5.dictionaryConverter([...Q4, { key: "data", converter: A5.converters.any, defaultValue: e10(() => null, "defaultValue") }, { key: "origin", converter: A5.converters.USVString, defaultValue: e10(() => "", "defaultValue") }, { key: "lastEventId", converter: A5.converters.DOMString, defaultValue: e10(() => "", "defaultValue") }, { key: "source", converter: A5.nullableConverter(A5.converters.MessagePort), defaultValue: e10(() => null, "defaultValue") }, { key: "ports", converter: A5.converters["sequence<MessagePort>"], defaultValue: e10(() => new Array(0), "defaultValue") }]), A5.converters.CloseEventInit = A5.dictionaryConverter([...Q4, { key: "wasClean", converter: A5.converters.boolean, defaultValue: e10(() => false, "defaultValue") }, { key: "code", converter: A5.converters["unsigned short"], defaultValue: e10(() => 0, "defaultValue") }, { key: "reason", converter: A5.converters.USVString, defaultValue: e10(() => "", "defaultValue") }]), A5.converters.ErrorEventInit = A5.dictionaryConverter([...Q4, { key: "message", converter: A5.converters.DOMString, defaultValue: e10(() => "", "defaultValue") }, { key: "filename", converter: A5.converters.USVString, defaultValue: e10(() => "", "defaultValue") }, { key: "lineno", converter: A5.converters["unsigned long"], defaultValue: e10(() => 0, "defaultValue") }, { key: "colno", converter: A5.converters["unsigned long"], defaultValue: e10(() => 0, "defaultValue") }, { key: "error", converter: A5.converters.any }]), events = { MessageEvent: t8, CloseEvent: f6, ErrorEvent: l3, createFastMessageEvent: B4 }, events;
   }
   e10(requireEvents, "requireEvents");
-  var constants;
+  var constants3;
   var hasRequiredConstants;
   function requireConstants() {
     if (hasRequiredConstants)
-      return constants;
+      return constants3;
     hasRequiredConstants = 1;
     const A5 = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", p6 = { enumerable: true, writable: false, configurable: false }, c3 = { CONNECTING: 0, OPEN: 1, CLOSING: 2, CLOSED: 3 }, E6 = { NOT_SENT: 0, PROCESSING: 1, SENT: 2 }, t8 = { CONTINUATION: 0, TEXT: 1, BINARY: 2, CLOSE: 8, PING: 9, PONG: 10 }, B4 = 2 ** 16 - 1, f6 = { INFO: 0, PAYLOADLENGTH_16: 2, PAYLOADLENGTH_64: 3, READ_DATA: 4 }, l3 = Buffer.allocUnsafe(0);
-    return constants = { uid: A5, sentCloseFrameState: E6, staticPropertyDescriptors: p6, states: c3, opcodes: t8, maxUnsigned16Bit: B4, parserStates: f6, emptyBuffer: l3, sendHints: { string: 1, typedArray: 2, arrayBuffer: 3, blob: 4 } }, constants;
+    return constants3 = { uid: A5, sentCloseFrameState: E6, staticPropertyDescriptors: p6, states: c3, opcodes: t8, maxUnsigned16Bit: B4, parserStates: f6, emptyBuffer: l3, sendHints: { string: 1, typedArray: 2, arrayBuffer: 3, blob: 4 } }, constants3;
   }
   e10(requireConstants, "requireConstants");
   var symbols;
@@ -249016,8 +251105,8 @@ ${g6}`;
   }
   e10(requireDist, "requireDist");
   var distExports = requireDist();
-  var x7 = Object.defineProperty;
-  var s8 = e10((A5, p6) => x7(A5, "name", { value: p6, configurable: true }), "s");
+  var x6 = Object.defineProperty;
+  var s8 = e10((A5, p6) => x6(A5, "name", { value: p6, configurable: true }), "s");
   function w5(...A5) {
     process.env.DEBUG && console.debug("[node-fetch-native] [proxy]", ...A5);
   }
@@ -249162,13 +251251,13 @@ var require_identity = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/visit.js
 var require_visit = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var BREAK = Symbol("break visit");
   var SKIP = Symbol("skip children");
   var REMOVE = Symbol("remove node");
   function visit2(node, visitor) {
     const visitor_ = initVisitor(visitor);
-    if (identity2.isDocument(node)) {
+    if (identity3.isDocument(node)) {
       const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
       if (cd === REMOVE)
         node.contents = null;
@@ -249178,17 +251267,17 @@ var require_visit = __commonJS((exports) => {
   visit2.BREAK = BREAK;
   visit2.SKIP = SKIP;
   visit2.REMOVE = REMOVE;
-  function visit_(key2, node, visitor, path5) {
-    const ctrl = callVisitor(key2, node, visitor, path5);
-    if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-      replaceNode(key2, path5, ctrl);
-      return visit_(key2, ctrl, visitor, path5);
+  function visit_(key2, node, visitor, path8) {
+    const ctrl = callVisitor(key2, node, visitor, path8);
+    if (identity3.isNode(ctrl) || identity3.isPair(ctrl)) {
+      replaceNode(key2, path8, ctrl);
+      return visit_(key2, ctrl, visitor, path8);
     }
     if (typeof ctrl !== "symbol") {
-      if (identity2.isCollection(node)) {
-        path5 = Object.freeze(path5.concat(node));
+      if (identity3.isCollection(node)) {
+        path8 = Object.freeze(path8.concat(node));
         for (let i6 = 0;i6 < node.items.length; ++i6) {
-          const ci = visit_(i6, node.items[i6], visitor, path5);
+          const ci = visit_(i6, node.items[i6], visitor, path8);
           if (typeof ci === "number")
             i6 = ci - 1;
           else if (ci === BREAK)
@@ -249198,14 +251287,14 @@ var require_visit = __commonJS((exports) => {
             i6 -= 1;
           }
         }
-      } else if (identity2.isPair(node)) {
-        path5 = Object.freeze(path5.concat(node));
-        const ck = visit_("key", node.key, visitor, path5);
+      } else if (identity3.isPair(node)) {
+        path8 = Object.freeze(path8.concat(node));
+        const ck = visit_("key", node.key, visitor, path8);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path5);
+        const cv = visit_("value", node.value, visitor, path8);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -249216,7 +251305,7 @@ var require_visit = __commonJS((exports) => {
   }
   async function visitAsync(node, visitor) {
     const visitor_ = initVisitor(visitor);
-    if (identity2.isDocument(node)) {
+    if (identity3.isDocument(node)) {
       const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));
       if (cd === REMOVE)
         node.contents = null;
@@ -249226,17 +251315,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key2, node, visitor, path5) {
-    const ctrl = await callVisitor(key2, node, visitor, path5);
-    if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-      replaceNode(key2, path5, ctrl);
-      return visitAsync_(key2, ctrl, visitor, path5);
+  async function visitAsync_(key2, node, visitor, path8) {
+    const ctrl = await callVisitor(key2, node, visitor, path8);
+    if (identity3.isNode(ctrl) || identity3.isPair(ctrl)) {
+      replaceNode(key2, path8, ctrl);
+      return visitAsync_(key2, ctrl, visitor, path8);
     }
     if (typeof ctrl !== "symbol") {
-      if (identity2.isCollection(node)) {
-        path5 = Object.freeze(path5.concat(node));
+      if (identity3.isCollection(node)) {
+        path8 = Object.freeze(path8.concat(node));
         for (let i6 = 0;i6 < node.items.length; ++i6) {
-          const ci = await visitAsync_(i6, node.items[i6], visitor, path5);
+          const ci = await visitAsync_(i6, node.items[i6], visitor, path8);
           if (typeof ci === "number")
             i6 = ci - 1;
           else if (ci === BREAK)
@@ -249246,14 +251335,14 @@ var require_visit = __commonJS((exports) => {
             i6 -= 1;
           }
         }
-      } else if (identity2.isPair(node)) {
-        path5 = Object.freeze(path5.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path5);
+      } else if (identity3.isPair(node)) {
+        path8 = Object.freeze(path8.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path8);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path5);
+        const cv = await visitAsync_("value", node.value, visitor, path8);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -249280,34 +251369,34 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key2, node, visitor, path5) {
+  function callVisitor(key2, node, visitor, path8) {
     if (typeof visitor === "function")
-      return visitor(key2, node, path5);
-    if (identity2.isMap(node))
-      return visitor.Map?.(key2, node, path5);
-    if (identity2.isSeq(node))
-      return visitor.Seq?.(key2, node, path5);
-    if (identity2.isPair(node))
-      return visitor.Pair?.(key2, node, path5);
-    if (identity2.isScalar(node))
-      return visitor.Scalar?.(key2, node, path5);
-    if (identity2.isAlias(node))
-      return visitor.Alias?.(key2, node, path5);
+      return visitor(key2, node, path8);
+    if (identity3.isMap(node))
+      return visitor.Map?.(key2, node, path8);
+    if (identity3.isSeq(node))
+      return visitor.Seq?.(key2, node, path8);
+    if (identity3.isPair(node))
+      return visitor.Pair?.(key2, node, path8);
+    if (identity3.isScalar(node))
+      return visitor.Scalar?.(key2, node, path8);
+    if (identity3.isAlias(node))
+      return visitor.Alias?.(key2, node, path8);
     return;
   }
-  function replaceNode(key2, path5, node) {
-    const parent = path5[path5.length - 1];
-    if (identity2.isCollection(parent)) {
+  function replaceNode(key2, path8, node) {
+    const parent = path8[path8.length - 1];
+    if (identity3.isCollection(parent)) {
       parent.items[key2] = node;
-    } else if (identity2.isPair(parent)) {
+    } else if (identity3.isPair(parent)) {
       if (key2 === "key")
         parent.key = node;
       else
         parent.value = node;
-    } else if (identity2.isDocument(parent)) {
+    } else if (identity3.isDocument(parent)) {
       parent.contents = node;
     } else {
-      const pt2 = identity2.isAlias(parent) ? "alias" : "scalar";
+      const pt2 = identity3.isAlias(parent) ? "alias" : "scalar";
       throw new Error(`Cannot replace node with ${pt2} parent`);
     }
   }
@@ -249317,7 +251406,7 @@ var require_visit = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/doc/directives.js
 var require_directives2 = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var visit2 = require_visit();
   var escapeChars = {
     "!": "%21",
@@ -249443,10 +251532,10 @@ var require_directives2 = __commonJS((exports) => {
       const lines2 = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : [];
       const tagEntries = Object.entries(this.tags);
       let tagNames;
-      if (doc && tagEntries.length > 0 && identity2.isNode(doc.contents)) {
+      if (doc && tagEntries.length > 0 && identity3.isNode(doc.contents)) {
         const tags = {};
         visit2.visit(doc.contents, (_key, node) => {
-          if (identity2.isNode(node) && node.tag)
+          if (identity3.isNode(node) && node.tag)
             tags[node.tag] = true;
         });
         tagNames = Object.keys(tags);
@@ -249469,7 +251558,7 @@ var require_directives2 = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/doc/anchors.js
 var require_anchors = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var visit2 = require_visit();
   function anchorIsValid(anchor) {
     if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
@@ -249512,7 +251601,7 @@ var require_anchors = __commonJS((exports) => {
       setAnchors: () => {
         for (const source of aliasObjects) {
           const ref = sourceObjects.get(source);
-          if (typeof ref === "object" && ref.anchor && (identity2.isScalar(ref.node) || identity2.isCollection(ref.node))) {
+          if (typeof ref === "object" && ref.anchor && (identity3.isScalar(ref.node) || identity3.isCollection(ref.node))) {
             ref.node.anchor = ref.anchor;
           } else {
             const error5 = new Error("Failed to resolve repeated object (this should not happen)");
@@ -249579,12 +251668,12 @@ var require_applyReviver = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/nodes/toJS.js
 var require_toJS = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   function toJS(value4, arg, ctx) {
     if (Array.isArray(value4))
       return value4.map((v7, i6) => toJS(v7, String(i6), ctx));
     if (value4 && typeof value4.toJSON === "function") {
-      if (!ctx || !identity2.hasAnchor(value4))
+      if (!ctx || !identity3.hasAnchor(value4))
         return value4.toJSON(arg, ctx);
       const data = { aliasCount: 0, count: 1, res: undefined };
       ctx.anchors.set(value4, data);
@@ -249607,12 +251696,12 @@ var require_toJS = __commonJS((exports) => {
 // ../../node_modules/yaml/dist/nodes/Node.js
 var require_Node = __commonJS((exports) => {
   var applyReviver = require_applyReviver();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var toJS = require_toJS();
 
   class NodeBase {
     constructor(type4) {
-      Object.defineProperty(this, identity2.NODE_TYPE, { value: type4 });
+      Object.defineProperty(this, identity3.NODE_TYPE, { value: type4 });
     }
     clone() {
       const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
@@ -249621,7 +251710,7 @@ var require_Node = __commonJS((exports) => {
       return copy;
     }
     toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
-      if (!identity2.isDocument(doc))
+      if (!identity3.isDocument(doc))
         throw new TypeError("A document argument is required");
       const ctx = {
         anchors: new Map,
@@ -249645,13 +251734,13 @@ var require_Node = __commonJS((exports) => {
 var require_Alias = __commonJS((exports) => {
   var anchors = require_anchors();
   var visit2 = require_visit();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Node2 = require_Node();
   var toJS = require_toJS();
 
   class Alias extends Node2.NodeBase {
     constructor(source) {
-      super(identity2.ALIAS);
+      super(identity3.ALIAS);
       this.source = source;
       Object.defineProperty(this, "tag", {
         set() {
@@ -249715,11 +251804,11 @@ var require_Alias = __commonJS((exports) => {
     }
   }
   function getAliasCount(doc, node, anchors2) {
-    if (identity2.isAlias(node)) {
+    if (identity3.isAlias(node)) {
       const source = node.resolve(doc);
       const anchor = anchors2 && source && anchors2.get(source);
       return anchor ? anchor.count * anchor.aliasCount : 0;
-    } else if (identity2.isCollection(node)) {
+    } else if (identity3.isCollection(node)) {
       let count = 0;
       for (const item of node.items) {
         const c3 = getAliasCount(doc, item, anchors2);
@@ -249727,7 +251816,7 @@ var require_Alias = __commonJS((exports) => {
           count = c3;
       }
       return count;
-    } else if (identity2.isPair(node)) {
+    } else if (identity3.isPair(node)) {
       const kc = getAliasCount(doc, node.key, anchors2);
       const vc = getAliasCount(doc, node.value, anchors2);
       return Math.max(kc, vc);
@@ -249739,14 +251828,14 @@ var require_Alias = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/nodes/Scalar.js
 var require_Scalar = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Node2 = require_Node();
   var toJS = require_toJS();
   var isScalarValue = (value4) => !value4 || typeof value4 !== "function" && typeof value4 !== "object";
 
   class Scalar extends Node2.NodeBase {
     constructor(value4) {
-      super(identity2.SCALAR);
+      super(identity3.SCALAR);
       this.value = value4;
     }
     toJSON(arg, ctx) {
@@ -249768,7 +251857,7 @@ var require_Scalar = __commonJS((exports) => {
 // ../../node_modules/yaml/dist/doc/createNode.js
 var require_createNode = __commonJS((exports) => {
   var Alias = require_Alias();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var defaultTagPrefix = "tag:yaml.org,2002:";
   function findTagObject(value4, tagName, tags) {
@@ -249782,12 +251871,12 @@ var require_createNode = __commonJS((exports) => {
     return tags.find((t8) => t8.identify?.(value4) && !t8.format);
   }
   function createNode(value4, tagName, ctx) {
-    if (identity2.isDocument(value4))
+    if (identity3.isDocument(value4))
       value4 = value4.contents;
-    if (identity2.isNode(value4))
+    if (identity3.isNode(value4))
       return value4;
-    if (identity2.isPair(value4)) {
-      const map3 = ctx.schema[identity2.MAP].createNode?.(ctx.schema, null, ctx);
+    if (identity3.isPair(value4)) {
+      const map3 = ctx.schema[identity3.MAP].createNode?.(ctx.schema, null, ctx);
       map3.items.push(value4);
       return map3;
     }
@@ -249820,7 +251909,7 @@ var require_createNode = __commonJS((exports) => {
           ref.node = node2;
         return node2;
       }
-      tagObj = value4 instanceof Map ? schema[identity2.MAP] : (Symbol.iterator in Object(value4)) ? schema[identity2.SEQ] : schema[identity2.MAP];
+      tagObj = value4 instanceof Map ? schema[identity3.MAP] : (Symbol.iterator in Object(value4)) ? schema[identity3.SEQ] : schema[identity3.MAP];
     }
     if (onTagObj) {
       onTagObj(tagObj);
@@ -249841,12 +251930,12 @@ var require_createNode = __commonJS((exports) => {
 // ../../node_modules/yaml/dist/nodes/Collection.js
 var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Node2 = require_Node();
-  function collectionFromPath(schema, path5, value4) {
+  function collectionFromPath(schema, path8, value4) {
     let v7 = value4;
-    for (let i6 = path5.length - 1;i6 >= 0; --i6) {
-      const k5 = path5[i6];
+    for (let i6 = path8.length - 1;i6 >= 0; --i6) {
+      const k5 = path8[i6];
       if (typeof k5 === "number" && Number.isInteger(k5) && k5 >= 0) {
         const a7 = [];
         a7[k5] = v7;
@@ -249865,7 +251954,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path5) => path5 == null || typeof path5 === "object" && !!path5[Symbol.iterator]().next().done;
+  var isEmptyPath = (path8) => path8 == null || typeof path8 === "object" && !!path8[Symbol.iterator]().next().done;
 
   class Collection extends Node2.NodeBase {
     constructor(type4, schema) {
@@ -249881,18 +251970,18 @@ var require_Collection = __commonJS((exports) => {
       const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
       if (schema)
         copy.schema = schema;
-      copy.items = copy.items.map((it2) => identity2.isNode(it2) || identity2.isPair(it2) ? it2.clone(schema) : it2);
+      copy.items = copy.items.map((it2) => identity3.isNode(it2) || identity3.isPair(it2) ? it2.clone(schema) : it2);
       if (this.range)
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path5, value4) {
-      if (isEmptyPath(path5))
+    addIn(path8, value4) {
+      if (isEmptyPath(path8))
         this.add(value4);
       else {
-        const [key2, ...rest] = path5;
+        const [key2, ...rest] = path8;
         const node = this.get(key2, true);
-        if (identity2.isCollection(node))
+        if (identity3.isCollection(node))
           node.addIn(rest, value4);
         else if (node === undefined && this.schema)
           this.set(key2, collectionFromPath(this.schema, rest, value4));
@@ -249900,46 +251989,46 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path5) {
-      const [key2, ...rest] = path5;
+    deleteIn(path8) {
+      const [key2, ...rest] = path8;
       if (rest.length === 0)
         return this.delete(key2);
       const node = this.get(key2, true);
-      if (identity2.isCollection(node))
+      if (identity3.isCollection(node))
         return node.deleteIn(rest);
       else
         throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
     }
-    getIn(path5, keepScalar) {
-      const [key2, ...rest] = path5;
+    getIn(path8, keepScalar) {
+      const [key2, ...rest] = path8;
       const node = this.get(key2, true);
       if (rest.length === 0)
-        return !keepScalar && identity2.isScalar(node) ? node.value : node;
+        return !keepScalar && identity3.isScalar(node) ? node.value : node;
       else
-        return identity2.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+        return identity3.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
     }
     hasAllNullValues(allowScalar) {
       return this.items.every((node) => {
-        if (!identity2.isPair(node))
+        if (!identity3.isPair(node))
           return false;
         const n6 = node.value;
-        return n6 == null || allowScalar && identity2.isScalar(n6) && n6.value == null && !n6.commentBefore && !n6.comment && !n6.tag;
+        return n6 == null || allowScalar && identity3.isScalar(n6) && n6.value == null && !n6.commentBefore && !n6.comment && !n6.tag;
       });
     }
-    hasIn(path5) {
-      const [key2, ...rest] = path5;
+    hasIn(path8) {
+      const [key2, ...rest] = path8;
       if (rest.length === 0)
         return this.has(key2);
       const node = this.get(key2, true);
-      return identity2.isCollection(node) ? node.hasIn(rest) : false;
+      return identity3.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path5, value4) {
-      const [key2, ...rest] = path5;
+    setIn(path8, value4) {
+      const [key2, ...rest] = path8;
       if (rest.length === 0) {
         this.set(key2, value4);
       } else {
         const node = this.get(key2, true);
-        if (identity2.isCollection(node))
+        if (identity3.isCollection(node))
           node.setIn(rest, value4);
         else if (node === undefined && this.schema)
           this.set(key2, collectionFromPath(this.schema, rest, value4));
@@ -250408,7 +252497,7 @@ ${indent2}`);
 // ../../node_modules/yaml/dist/stringify/stringify.js
 var require_stringify = __commonJS((exports) => {
   var anchors = require_anchors();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var stringifyComment = require_stringifyComment();
   var stringifyString = require_stringifyString();
   function createStringifyContext(doc, options) {
@@ -250460,7 +252549,7 @@ var require_stringify = __commonJS((exports) => {
     }
     let tagObj = undefined;
     let obj;
-    if (identity2.isScalar(item)) {
+    if (identity3.isScalar(item)) {
       obj = item.value;
       let match2 = tags.filter((t8) => t8.identify?.(obj));
       if (match2.length > 1) {
@@ -250483,7 +252572,7 @@ var require_stringify = __commonJS((exports) => {
     if (!doc.directives)
       return "";
     const props = [];
-    const anchor = (identity2.isScalar(node) || identity2.isCollection(node)) && node.anchor;
+    const anchor = (identity3.isScalar(node) || identity3.isCollection(node)) && node.anchor;
     if (anchor && anchors.anchorIsValid(anchor)) {
       anchors$1.add(anchor);
       props.push(`&${anchor}`);
@@ -250494,9 +252583,9 @@ var require_stringify = __commonJS((exports) => {
     return props.join(" ");
   }
   function stringify3(item, ctx, onComment, onChompKeep) {
-    if (identity2.isPair(item))
+    if (identity3.isPair(item))
       return item.toString(ctx, onComment, onChompKeep);
-    if (identity2.isAlias(item)) {
+    if (identity3.isAlias(item)) {
       if (ctx.doc.directives)
         return item.toString(ctx);
       if (ctx.resolvedAliases?.has(item)) {
@@ -250510,16 +252599,16 @@ var require_stringify = __commonJS((exports) => {
       }
     }
     let tagObj = undefined;
-    const node = identity2.isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o8) => tagObj = o8 });
+    const node = identity3.isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o8) => tagObj = o8 });
     if (!tagObj)
       tagObj = getTagObject(ctx.doc.schema.tags, node);
     const props = stringifyProps(node, tagObj, ctx);
     if (props.length > 0)
       ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
-    const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity2.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+    const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity3.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
     if (!props)
       return str;
-    return identity2.isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
+    return identity3.isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
 ${ctx.indent}${str}`;
   }
   exports.createStringifyContext = createStringifyContext;
@@ -250528,23 +252617,23 @@ ${ctx.indent}${str}`;
 
 // ../../node_modules/yaml/dist/stringify/stringifyPair.js
 var require_stringifyPair = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var stringify3 = require_stringify();
   var stringifyComment = require_stringifyComment();
   function stringifyPair2({ key: key2, value: value4 }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent: indent2, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
-    let keyComment = identity2.isNode(key2) && key2.comment || null;
+    let keyComment = identity3.isNode(key2) && key2.comment || null;
     if (simpleKeys) {
       if (keyComment) {
         throw new Error("With simple keys, key nodes cannot have comments");
       }
-      if (identity2.isCollection(key2) || !identity2.isNode(key2) && typeof key2 === "object") {
+      if (identity3.isCollection(key2) || !identity3.isNode(key2) && typeof key2 === "object") {
         const msg = "With simple keys, collection cannot be used as a key value";
         throw new Error(msg);
       }
     }
-    let explicitKey = !simpleKeys && (!key2 || keyComment && value4 == null && !ctx.inFlow || identity2.isCollection(key2) || (identity2.isScalar(key2) ? key2.type === Scalar.Scalar.BLOCK_FOLDED || key2.type === Scalar.Scalar.BLOCK_LITERAL : typeof key2 === "object"));
+    let explicitKey = !simpleKeys && (!key2 || keyComment && value4 == null && !ctx.inFlow || identity3.isCollection(key2) || (identity3.isScalar(key2) ? key2.type === Scalar.Scalar.BLOCK_FOLDED || key2.type === Scalar.Scalar.BLOCK_LITERAL : typeof key2 === "object"));
     ctx = Object.assign({}, ctx, {
       allNullValues: false,
       implicitKey: !explicitKey && (simpleKeys || !allNullValues),
@@ -250585,7 +252674,7 @@ ${indent2}:`;
         str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
     }
     let vsb, vcb, valueComment;
-    if (identity2.isNode(value4)) {
+    if (identity3.isNode(value4)) {
       vsb = !!value4.spaceBefore;
       vcb = value4.commentBefore;
       valueComment = value4.comment;
@@ -250597,10 +252686,10 @@ ${indent2}:`;
         value4 = doc.createNode(value4);
     }
     ctx.implicitKey = false;
-    if (!explicitKey && !keyComment && identity2.isScalar(value4))
+    if (!explicitKey && !keyComment && identity3.isScalar(value4))
       ctx.indentAtStart = str.length + 1;
     chompKeep = false;
-    if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity2.isSeq(value4) && !value4.flow && !value4.tag && !value4.anchor) {
+    if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity3.isSeq(value4) && !value4.flow && !value4.tag && !value4.anchor) {
       ctx.indent = ctx.indent.substring(2);
     }
     let valueCommentDone = false;
@@ -250624,7 +252713,7 @@ ${stringifyComment.indentComment(cs, ctx.indent)}`;
         ws += `
 ${ctx.indent}`;
       }
-    } else if (!explicitKey && identity2.isCollection(value4)) {
+    } else if (!explicitKey && identity3.isCollection(value4)) {
       const vs0 = valueStr[0];
       const nl0 = valueStr.indexOf(`
 `);
@@ -250683,7 +252772,7 @@ var require_log = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/merge.js
 var require_merge = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var MERGE_KEY = "<<";
   var merge3 = {
@@ -250696,10 +252785,10 @@ var require_merge = __commonJS((exports) => {
     }),
     stringify: () => MERGE_KEY
   };
-  var isMergeKey = (ctx, key2) => (merge3.identify(key2) || identity2.isScalar(key2) && (!key2.type || key2.type === Scalar.Scalar.PLAIN) && merge3.identify(key2.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge3.tag && tag.default);
+  var isMergeKey = (ctx, key2) => (merge3.identify(key2) || identity3.isScalar(key2) && (!key2.type || key2.type === Scalar.Scalar.PLAIN) && merge3.identify(key2.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge3.tag && tag.default);
   function addMergeToJSMap(ctx, map3, value4) {
-    value4 = ctx && identity2.isAlias(value4) ? value4.resolve(ctx.doc) : value4;
-    if (identity2.isSeq(value4))
+    value4 = ctx && identity3.isAlias(value4) ? value4.resolve(ctx.doc) : value4;
+    if (identity3.isSeq(value4))
       for (const it2 of value4.items)
         mergeValue(ctx, map3, it2);
     else if (Array.isArray(value4))
@@ -250709,8 +252798,8 @@ var require_merge = __commonJS((exports) => {
       mergeValue(ctx, map3, value4);
   }
   function mergeValue(ctx, map3, value4) {
-    const source = ctx && identity2.isAlias(value4) ? value4.resolve(ctx.doc) : value4;
-    if (!identity2.isMap(source))
+    const source = ctx && identity3.isAlias(value4) ? value4.resolve(ctx.doc) : value4;
+    if (!identity3.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
     const srcMap = source.toJSON(null, ctx, Map);
     for (const [key2, value5] of srcMap) {
@@ -250740,10 +252829,10 @@ var require_addPairToJSMap = __commonJS((exports) => {
   var log = require_log();
   var merge3 = require_merge();
   var stringify3 = require_stringify();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var toJS = require_toJS();
   function addPairToJSMap(ctx, map3, { key: key2, value: value4 }) {
-    if (identity2.isNode(key2) && key2.addToJSMap)
+    if (identity3.isNode(key2) && key2.addToJSMap)
       key2.addToJSMap(ctx, map3, value4);
     else if (merge3.isMergeKey(ctx, key2))
       merge3.addMergeToJSMap(ctx, map3, value4);
@@ -250774,7 +252863,7 @@ var require_addPairToJSMap = __commonJS((exports) => {
       return "";
     if (typeof jsKey !== "object")
       return String(jsKey);
-    if (identity2.isNode(key2) && ctx?.doc) {
+    if (identity3.isNode(key2) && ctx?.doc) {
       const strCtx = stringify3.createStringifyContext(ctx.doc, {});
       strCtx.anchors = new Set;
       for (const node of ctx.anchors.keys())
@@ -250801,7 +252890,7 @@ var require_Pair = __commonJS((exports) => {
   var createNode = require_createNode();
   var stringifyPair2 = require_stringifyPair();
   var addPairToJSMap = require_addPairToJSMap();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   function createPair(key2, value4, ctx) {
     const k5 = createNode.createNode(key2, undefined, ctx);
     const v7 = createNode.createNode(value4, undefined, ctx);
@@ -250810,15 +252899,15 @@ var require_Pair = __commonJS((exports) => {
 
   class Pair {
     constructor(key2, value4 = null) {
-      Object.defineProperty(this, identity2.NODE_TYPE, { value: identity2.PAIR });
+      Object.defineProperty(this, identity3.NODE_TYPE, { value: identity3.PAIR });
       this.key = key2;
       this.value = value4;
     }
     clone(schema) {
       let { key: key2, value: value4 } = this;
-      if (identity2.isNode(key2))
+      if (identity3.isNode(key2))
         key2 = key2.clone(schema);
-      if (identity2.isNode(value4))
+      if (identity3.isNode(value4))
         value4 = value4.clone(schema);
       return new Pair(key2, value4);
     }
@@ -250836,7 +252925,7 @@ var require_Pair = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/stringify/stringifyCollection.js
 var require_stringifyCollection = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var stringify3 = require_stringify();
   var stringifyComment = require_stringifyComment();
   function stringifyCollection(collection, ctx, options) {
@@ -250852,14 +252941,14 @@ var require_stringifyCollection = __commonJS((exports) => {
     for (let i6 = 0;i6 < items.length; ++i6) {
       const item = items[i6];
       let comment2 = null;
-      if (identity2.isNode(item)) {
+      if (identity3.isNode(item)) {
         if (!chompKeep && item.spaceBefore)
           lines2.push("");
         addCommentBefore(ctx, lines2, item.commentBefore, chompKeep);
         if (item.comment)
           comment2 = item.comment;
-      } else if (identity2.isPair(item)) {
-        const ik = identity2.isNode(item.key) ? item.key : null;
+      } else if (identity3.isPair(item)) {
+        const ik = identity3.isNode(item.key) ? item.key : null;
         if (ik) {
           if (!chompKeep && ik.spaceBefore)
             lines2.push("");
@@ -250909,14 +252998,14 @@ ${indent2}${line}` : `
     for (let i6 = 0;i6 < items.length; ++i6) {
       const item = items[i6];
       let comment = null;
-      if (identity2.isNode(item)) {
+      if (identity3.isNode(item)) {
         if (item.spaceBefore)
           lines2.push("");
         addCommentBefore(ctx, lines2, item.commentBefore, false);
         if (item.comment)
           comment = item.comment;
-      } else if (identity2.isPair(item)) {
-        const ik = identity2.isNode(item.key) ? item.key : null;
+      } else if (identity3.isPair(item)) {
+        const ik = identity3.isNode(item.key) ? item.key : null;
         if (ik) {
           if (ik.spaceBefore)
             lines2.push("");
@@ -250924,7 +253013,7 @@ ${indent2}${line}` : `
           if (ik.comment)
             reqNewline = true;
         }
-        const iv = identity2.isNode(item.value) ? item.value : null;
+        const iv = identity3.isNode(item.value) ? item.value : null;
         if (iv) {
           if (iv.comment)
             comment = iv.comment;
@@ -250984,16 +253073,16 @@ var require_YAMLMap = __commonJS((exports) => {
   var stringifyCollection = require_stringifyCollection();
   var addPairToJSMap = require_addPairToJSMap();
   var Collection = require_Collection();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Pair = require_Pair();
   var Scalar = require_Scalar();
   function findPair(items, key2) {
-    const k5 = identity2.isScalar(key2) ? key2.value : key2;
+    const k5 = identity3.isScalar(key2) ? key2.value : key2;
     for (const it2 of items) {
-      if (identity2.isPair(it2)) {
+      if (identity3.isPair(it2)) {
         if (it2.key === key2 || it2.key === k5)
           return it2;
-        if (identity2.isScalar(it2.key) && it2.key.value === k5)
+        if (identity3.isScalar(it2.key) && it2.key.value === k5)
           return it2;
       }
     }
@@ -251005,7 +253094,7 @@ var require_YAMLMap = __commonJS((exports) => {
       return "tag:yaml.org,2002:map";
     }
     constructor(schema) {
-      super(identity2.MAP, schema);
+      super(identity3.MAP, schema);
       this.items = [];
     }
     static from(schema, obj, ctx) {
@@ -251033,7 +253122,7 @@ var require_YAMLMap = __commonJS((exports) => {
     }
     add(pair, overwrite) {
       let _pair;
-      if (identity2.isPair(pair))
+      if (identity3.isPair(pair))
         _pair = pair;
       else if (!pair || typeof pair !== "object" || !("key" in pair)) {
         _pair = new Pair.Pair(pair, pair?.value);
@@ -251044,7 +253133,7 @@ var require_YAMLMap = __commonJS((exports) => {
       if (prev) {
         if (!overwrite)
           throw new Error(`Key ${_pair.key} already set`);
-        if (identity2.isScalar(prev.value) && Scalar.isScalarValue(_pair.value))
+        if (identity3.isScalar(prev.value) && Scalar.isScalarValue(_pair.value))
           prev.value.value = _pair.value;
         else
           prev.value = _pair.value;
@@ -251068,7 +253157,7 @@ var require_YAMLMap = __commonJS((exports) => {
     get(key2, keepScalar) {
       const it2 = findPair(this.items, key2);
       const node = it2?.value;
-      return (!keepScalar && identity2.isScalar(node) ? node.value : node) ?? undefined;
+      return (!keepScalar && identity3.isScalar(node) ? node.value : node) ?? undefined;
     }
     has(key2) {
       return !!findPair(this.items, key2);
@@ -251088,7 +253177,7 @@ var require_YAMLMap = __commonJS((exports) => {
       if (!ctx)
         return JSON.stringify(this);
       for (const item of this.items) {
-        if (!identity2.isPair(item))
+        if (!identity3.isPair(item))
           throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
       }
       if (!ctx.allNullValues && this.hasAllNullValues(false))
@@ -251108,7 +253197,7 @@ var require_YAMLMap = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/common/map.js
 var require_map = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var YAMLMap = require_YAMLMap();
   var map3 = {
     collection: "map",
@@ -251116,7 +253205,7 @@ var require_map = __commonJS((exports) => {
     nodeClass: YAMLMap.YAMLMap,
     tag: "tag:yaml.org,2002:map",
     resolve(map4, onError) {
-      if (!identity2.isMap(map4))
+      if (!identity3.isMap(map4))
         onError("Expected a mapping for this tag");
       return map4;
     },
@@ -251130,7 +253219,7 @@ var require_YAMLSeq = __commonJS((exports) => {
   var createNode = require_createNode();
   var stringifyCollection = require_stringifyCollection();
   var Collection = require_Collection();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var toJS = require_toJS();
 
@@ -251139,7 +253228,7 @@ var require_YAMLSeq = __commonJS((exports) => {
       return "tag:yaml.org,2002:seq";
     }
     constructor(schema) {
-      super(identity2.SEQ, schema);
+      super(identity3.SEQ, schema);
       this.items = [];
     }
     add(value4) {
@@ -251157,7 +253246,7 @@ var require_YAMLSeq = __commonJS((exports) => {
       if (typeof idx !== "number")
         return;
       const it2 = this.items[idx];
-      return !keepScalar && identity2.isScalar(it2) ? it2.value : it2;
+      return !keepScalar && identity3.isScalar(it2) ? it2.value : it2;
     }
     has(key2) {
       const idx = asItemIndex(key2);
@@ -251168,7 +253257,7 @@ var require_YAMLSeq = __commonJS((exports) => {
       if (typeof idx !== "number")
         throw new Error(`Expected a valid index, not ${key2}.`);
       const prev = this.items[idx];
-      if (identity2.isScalar(prev) && Scalar.isScalarValue(value4))
+      if (identity3.isScalar(prev) && Scalar.isScalarValue(value4))
         prev.value = value4;
       else
         this.items[idx] = value4;
@@ -251210,7 +253299,7 @@ var require_YAMLSeq = __commonJS((exports) => {
     }
   }
   function asItemIndex(key2) {
-    let idx = identity2.isScalar(key2) ? key2.value : key2;
+    let idx = identity3.isScalar(key2) ? key2.value : key2;
     if (idx && typeof idx === "string")
       idx = Number(idx);
     return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
@@ -251220,7 +253309,7 @@ var require_YAMLSeq = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/common/seq.js
 var require_seq = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var YAMLSeq = require_YAMLSeq();
   var seq = {
     collection: "seq",
@@ -251228,7 +253317,7 @@ var require_seq = __commonJS((exports) => {
     nodeClass: YAMLSeq.YAMLSeq,
     tag: "tag:yaml.org,2002:seq",
     resolve(seq2, onError) {
-      if (!identity2.isSeq(seq2))
+      if (!identity3.isSeq(seq2))
         onError("Expected a sequence for this tag");
       return seq2;
     },
@@ -251543,17 +253632,17 @@ var require_binary = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/pairs.js
 var require_pairs = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Pair = require_Pair();
   var Scalar = require_Scalar();
   var YAMLSeq = require_YAMLSeq();
   function resolvePairs(seq, onError) {
-    if (identity2.isSeq(seq)) {
+    if (identity3.isSeq(seq)) {
       for (let i6 = 0;i6 < seq.items.length; ++i6) {
         let item = seq.items[i6];
-        if (identity2.isPair(item))
+        if (identity3.isPair(item))
           continue;
-        else if (identity2.isMap(item)) {
+        else if (identity3.isMap(item)) {
           if (item.items.length > 1)
             onError("Each pair must have its own sequence indicator");
           const pair = item.items[0] || new Pair.Pair(new Scalar.Scalar(null));
@@ -251567,7 +253656,7 @@ ${cn.comment}` : item.comment;
           }
           item = pair;
         }
-        seq.items[i6] = identity2.isPair(item) ? item : new Pair.Pair(item);
+        seq.items[i6] = identity3.isPair(item) ? item : new Pair.Pair(item);
       }
     } else
       onError("Expected a sequence for this tag");
@@ -251618,7 +253707,7 @@ ${cn.comment}` : item.comment;
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/omap.js
 var require_omap = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var toJS = require_toJS();
   var YAMLMap = require_YAMLMap();
   var YAMLSeq = require_YAMLSeq();
@@ -251642,7 +253731,7 @@ var require_omap = __commonJS((exports) => {
         ctx.onCreate(map3);
       for (const pair of this.items) {
         let key2, value4;
-        if (identity2.isPair(pair)) {
+        if (identity3.isPair(pair)) {
           key2 = toJS.toJS(pair.key, "", ctx);
           value4 = toJS.toJS(pair.value, key2, ctx);
         } else {
@@ -251672,7 +253761,7 @@ var require_omap = __commonJS((exports) => {
       const pairs$1 = pairs.resolvePairs(seq, onError);
       const seenKeys = [];
       for (const { key: key2 } of pairs$1.items) {
-        if (identity2.isScalar(key2)) {
+        if (identity3.isScalar(key2)) {
           if (seenKeys.includes(key2.value)) {
             onError(`Ordered maps must not include duplicate keys: ${key2.value}`);
           } else {
@@ -251841,7 +253930,7 @@ var require_int2 = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/yaml-1.1/set.js
 var require_set = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Pair = require_Pair();
   var YAMLMap = require_YAMLMap();
 
@@ -251852,7 +253941,7 @@ var require_set = __commonJS((exports) => {
     }
     add(key2) {
       let pair;
-      if (identity2.isPair(key2))
+      if (identity3.isPair(key2))
         pair = key2;
       else if (key2 && typeof key2 === "object" && "key" in key2 && "value" in key2 && key2.value === null)
         pair = new Pair.Pair(key2.key, null);
@@ -251864,7 +253953,7 @@ var require_set = __commonJS((exports) => {
     }
     get(key2, keepPair) {
       const pair = YAMLMap.findPair(this.items, key2);
-      return !keepPair && identity2.isPair(pair) ? identity2.isScalar(pair.key) ? pair.key.value : pair.key : pair;
+      return !keepPair && identity3.isPair(pair) ? identity3.isScalar(pair.key) ? pair.key.value : pair.key : pair;
     }
     set(key2, value4) {
       if (typeof value4 !== "boolean")
@@ -251908,7 +253997,7 @@ var require_set = __commonJS((exports) => {
     tag: "tag:yaml.org,2002:set",
     createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
     resolve(map3, onError) {
-      if (identity2.isMap(map3)) {
+      if (identity3.isMap(map3)) {
         if (map3.hasAllNullValues(true))
           return Object.assign(new YAMLSet, map3);
         else
@@ -252138,7 +254227,7 @@ var require_tags = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/schema/Schema.js
 var require_Schema = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var map3 = require_map();
   var seq = require_seq();
   var string = require_string();
@@ -252152,9 +254241,9 @@ var require_Schema = __commonJS((exports) => {
       this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
       this.tags = tags.getTags(customTags, this.name, merge3);
       this.toStringOptions = toStringDefaults ?? null;
-      Object.defineProperty(this, identity2.MAP, { value: map3.map });
-      Object.defineProperty(this, identity2.SCALAR, { value: string.string });
-      Object.defineProperty(this, identity2.SEQ, { value: seq.seq });
+      Object.defineProperty(this, identity3.MAP, { value: map3.map });
+      Object.defineProperty(this, identity3.SCALAR, { value: string.string });
+      Object.defineProperty(this, identity3.SEQ, { value: seq.seq });
       this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
     }
     clone() {
@@ -252168,7 +254257,7 @@ var require_Schema = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/stringify/stringifyDocument.js
 var require_stringifyDocument = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var stringify3 = require_stringify();
   var stringifyComment = require_stringifyComment();
   function stringifyDocument2(doc, options) {
@@ -252195,7 +254284,7 @@ var require_stringifyDocument = __commonJS((exports) => {
     let chompKeep = false;
     let contentComment = null;
     if (doc.contents) {
-      if (identity2.isNode(doc.contents)) {
+      if (identity3.isNode(doc.contents)) {
         if (doc.contents.spaceBefore && hasDirectives)
           lines2.push("");
         if (doc.contents.commentBefore) {
@@ -252250,7 +254339,7 @@ var require_stringifyDocument = __commonJS((exports) => {
 var require_Document = __commonJS((exports) => {
   var Alias = require_Alias();
   var Collection = require_Collection();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Pair = require_Pair();
   var toJS = require_toJS();
   var Schema = require_Schema();
@@ -252266,7 +254355,7 @@ var require_Document = __commonJS((exports) => {
       this.comment = null;
       this.errors = [];
       this.warnings = [];
-      Object.defineProperty(this, identity2.NODE_TYPE, { value: identity2.DOC });
+      Object.defineProperty(this, identity3.NODE_TYPE, { value: identity3.DOC });
       let _replacer = null;
       if (typeof replacer === "function" || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -252297,7 +254386,7 @@ var require_Document = __commonJS((exports) => {
     }
     clone() {
       const copy = Object.create(Document.prototype, {
-        [identity2.NODE_TYPE]: { value: identity2.DOC }
+        [identity3.NODE_TYPE]: { value: identity3.DOC }
       });
       copy.commentBefore = this.commentBefore;
       copy.comment = this.comment;
@@ -252307,7 +254396,7 @@ var require_Document = __commonJS((exports) => {
       if (this.directives)
         copy.directives = this.directives.clone();
       copy.schema = this.schema.clone();
-      copy.contents = identity2.isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents;
+      copy.contents = identity3.isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents;
       if (this.range)
         copy.range = this.range.slice();
       return copy;
@@ -252316,9 +254405,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value4);
     }
-    addIn(path5, value4) {
+    addIn(path8, value4) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path5, value4);
+        this.contents.addIn(path8, value4);
     }
     createAlias(node, name2) {
       if (!node.anchor) {
@@ -252354,7 +254443,7 @@ var require_Document = __commonJS((exports) => {
         sourceObjects
       };
       const node = createNode.createNode(value4, tag, ctx);
-      if (flow && identity2.isCollection(node))
+      if (flow && identity3.isCollection(node))
         node.flow = true;
       setAnchors();
       return node;
@@ -252367,30 +254456,30 @@ var require_Document = __commonJS((exports) => {
     delete(key2) {
       return assertCollection(this.contents) ? this.contents.delete(key2) : false;
     }
-    deleteIn(path5) {
-      if (Collection.isEmptyPath(path5)) {
+    deleteIn(path8) {
+      if (Collection.isEmptyPath(path8)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path5) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path8) : false;
     }
     get(key2, keepScalar) {
-      return identity2.isCollection(this.contents) ? this.contents.get(key2, keepScalar) : undefined;
+      return identity3.isCollection(this.contents) ? this.contents.get(key2, keepScalar) : undefined;
     }
-    getIn(path5, keepScalar) {
-      if (Collection.isEmptyPath(path5))
-        return !keepScalar && identity2.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity2.isCollection(this.contents) ? this.contents.getIn(path5, keepScalar) : undefined;
+    getIn(path8, keepScalar) {
+      if (Collection.isEmptyPath(path8))
+        return !keepScalar && identity3.isScalar(this.contents) ? this.contents.value : this.contents;
+      return identity3.isCollection(this.contents) ? this.contents.getIn(path8, keepScalar) : undefined;
     }
     has(key2) {
-      return identity2.isCollection(this.contents) ? this.contents.has(key2) : false;
+      return identity3.isCollection(this.contents) ? this.contents.has(key2) : false;
     }
-    hasIn(path5) {
-      if (Collection.isEmptyPath(path5))
+    hasIn(path8) {
+      if (Collection.isEmptyPath(path8))
         return this.contents !== undefined;
-      return identity2.isCollection(this.contents) ? this.contents.hasIn(path5) : false;
+      return identity3.isCollection(this.contents) ? this.contents.hasIn(path8) : false;
     }
     set(key2, value4) {
       if (this.contents == null) {
@@ -252399,13 +254488,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key2, value4);
       }
     }
-    setIn(path5, value4) {
-      if (Collection.isEmptyPath(path5)) {
+    setIn(path8, value4) {
+      if (Collection.isEmptyPath(path8)) {
         this.contents = value4;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path5), value4);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path8), value4);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path5, value4);
+        this.contents.setIn(path8, value4);
       }
     }
     setSchema(version, options = {}) {
@@ -252474,7 +254563,7 @@ var require_Document = __commonJS((exports) => {
     }
   }
   function assertCollection(contents) {
-    if (identity2.isCollection(contents))
+    if (identity3.isCollection(contents))
       return true;
     throw new Error("Expected a YAML collection as document contents");
   }
@@ -252735,12 +254824,12 @@ var require_util_flow_indent_check = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/util-map-includes.js
 var require_util_map_includes = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   function mapIncludes(ctx, items, search) {
     const { uniqueKeys } = ctx.options;
     if (uniqueKeys === false)
       return false;
-    const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a7, b4) => a7 === b4 || identity2.isScalar(a7) && identity2.isScalar(b4) && a7.value === b4.value;
+    const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a7, b4) => a7 === b4 || identity3.isScalar(a7) && identity3.isScalar(b4) && a7.value === b4.value;
     return items.some((pair) => isEqual(pair.key, search));
   }
   exports.mapIncludes = mapIncludes;
@@ -252943,7 +255032,7 @@ var require_resolve_end = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/resolve-flow-collection.js
 var require_resolve_flow_collection = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Pair = require_Pair();
   var YAMLMap = require_YAMLMap();
   var YAMLSeq = require_YAMLSeq();
@@ -253019,7 +255108,7 @@ var require_resolve_flow_collection = __commonJS((exports) => {
             }
           if (prevItemComment) {
             let prev = coll.items[coll.items.length - 1];
-            if (identity2.isPair(prev))
+            if (identity3.isPair(prev))
               prev = prev.value ?? prev.key;
             if (prev.comment)
               prev.comment += `
@@ -253134,7 +255223,7 @@ var require_resolve_flow_collection = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/compose-collection.js
 var require_compose_collection = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var YAMLMap = require_YAMLMap();
   var YAMLSeq = require_YAMLSeq();
@@ -253184,7 +255273,7 @@ var require_compose_collection = __commonJS((exports) => {
     }
     const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
     const res = tag.resolve?.(coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options) ?? coll;
-    const node = identity2.isNode(res) ? res : new Scalar.Scalar(res);
+    const node = identity3.isNode(res) ? res : new Scalar.Scalar(res);
     node.range = coll.range;
     node.tag = tagName;
     if (tag?.format)
@@ -253462,9 +255551,9 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
   function foldLines(source) {
     let first, line;
     try {
-      first = new RegExp(`(.*?)(?<![ 	])[ 	]*\r?
+      first = new RegExp(`(.*?)(?<![ \t])[ \t]*\r?
 `, "sy");
-      line = new RegExp(`[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?
+      line = new RegExp(`[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?
 `, "sy");
     } catch {
       first = /(.*?)[ \t]*\r?\n/sy;
@@ -253605,7 +255694,7 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/compose-scalar.js
 var require_compose_scalar = __commonJS((exports) => {
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var Scalar = require_Scalar();
   var resolveBlockScalar = require_resolve_block_scalar();
   var resolveFlowScalar = require_resolve_flow_scalar();
@@ -253614,17 +255703,17 @@ var require_compose_scalar = __commonJS((exports) => {
     const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
     let tag;
     if (ctx.options.stringKeys && ctx.atKey) {
-      tag = ctx.schema[identity2.SCALAR];
+      tag = ctx.schema[identity3.SCALAR];
     } else if (tagName)
       tag = findScalarTagByName(ctx.schema, value4, tagName, tagToken, onError);
     else if (token.type === "scalar")
       tag = findScalarTagByTest(ctx, value4, token, onError);
     else
-      tag = ctx.schema[identity2.SCALAR];
+      tag = ctx.schema[identity3.SCALAR];
     let scalar;
     try {
       const res = tag.resolve(value4, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
-      scalar = identity2.isScalar(res) ? res : new Scalar.Scalar(res);
+      scalar = identity3.isScalar(res) ? res : new Scalar.Scalar(res);
     } catch (error5) {
       const msg = error5 instanceof Error ? error5.message : String(error5);
       onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
@@ -253644,7 +255733,7 @@ var require_compose_scalar = __commonJS((exports) => {
   }
   function findScalarTagByName(schema, value4, tagName, tagToken, onError) {
     if (tagName === "!")
-      return schema[identity2.SCALAR];
+      return schema[identity3.SCALAR];
     const matchWithTest = [];
     for (const tag of schema.tags) {
       if (!tag.collection && tag.tag === tagName) {
@@ -253663,12 +255752,12 @@ var require_compose_scalar = __commonJS((exports) => {
       return kt2;
     }
     onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
-    return schema[identity2.SCALAR];
+    return schema[identity3.SCALAR];
   }
   function findScalarTagByTest({ atKey, directives: directives4, schema }, value4, token, onError) {
-    const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value4)) || schema[identity2.SCALAR];
+    const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value4)) || schema[identity3.SCALAR];
     if (schema.compat) {
-      const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value4)) ?? schema[identity2.SCALAR];
+      const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value4)) ?? schema[identity3.SCALAR];
       if (tag.tag !== compat.tag) {
         const ts = directives4.tagString(tag.tag);
         const cs = directives4.tagString(compat.tag);
@@ -253712,7 +255801,7 @@ var require_util_empty_scalar_position = __commonJS((exports) => {
 // ../../node_modules/yaml/dist/compose/compose-node.js
 var require_compose_node = __commonJS((exports) => {
   var Alias = require_Alias();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var composeCollection = require_compose_collection();
   var composeScalar = require_compose_scalar();
   var resolveEnd = require_resolve_end();
@@ -253753,7 +255842,7 @@ var require_compose_node = __commonJS((exports) => {
     }
     if (anchor && node.anchor === "")
       onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
-    if (atKey && ctx.options.stringKeys && (!identity2.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
+    if (atKey && ctx.options.stringKeys && (!identity3.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
       const msg = "With stringKeys, all keys must be strings";
       onError(tag ?? token, "NON_STRING_KEY", msg);
     }
@@ -253853,7 +255942,7 @@ var require_composer = __commonJS((exports) => {
   var directives4 = require_directives2();
   var Document = require_Document();
   var errors2 = require_errors3();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var composeDoc = require_compose_doc();
   var resolveEnd = require_resolve_end();
   function getErrorPos(src) {
@@ -253919,9 +256008,9 @@ var require_composer = __commonJS((exports) => {
 ${comment}` : comment;
         } else if (afterEmptyLine || doc.directives.docStart || !dc) {
           doc.commentBefore = comment;
-        } else if (identity2.isCollection(dc) && !dc.flow && dc.items.length > 0) {
+        } else if (identity3.isCollection(dc) && !dc.flow && dc.items.length > 0) {
           let it2 = dc.items[0];
-          if (identity2.isPair(it2))
+          if (identity3.isPair(it2))
             it2 = it2.key;
           const cb = it2.commentBefore;
           it2.commentBefore = cb ? `${comment}
@@ -254297,9 +256386,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit2.BREAK = BREAK;
   visit2.SKIP = SKIP;
   visit2.REMOVE = REMOVE;
-  visit2.itemAtPath = (cst, path5) => {
+  visit2.itemAtPath = (cst, path8) => {
     let item = cst;
-    for (const [field2, index] of path5) {
+    for (const [field2, index] of path8) {
       const tok = item?.[field2];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -254308,23 +256397,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit2.parentCollection = (cst, path5) => {
-    const parent = visit2.itemAtPath(cst, path5.slice(0, -1));
-    const field2 = path5[path5.length - 1][0];
+  visit2.parentCollection = (cst, path8) => {
+    const parent = visit2.itemAtPath(cst, path8.slice(0, -1));
+    const field2 = path8[path8.length - 1][0];
     const coll = parent?.[field2];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path5, item, visitor) {
-    let ctrl = visitor(item, path5);
+  function _visit(path8, item, visitor) {
+    let ctrl = visitor(item, path8);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field2 of ["key", "value"]) {
       const token = item[field2];
       if (token && "items" in token) {
         for (let i6 = 0;i6 < token.items.length; ++i6) {
-          const ci = _visit(Object.freeze(path5.concat([[field2, i6]])), token.items[i6], visitor);
+          const ci = _visit(Object.freeze(path8.concat([[field2, i6]])), token.items[i6], visitor);
           if (typeof ci === "number")
             i6 = ci - 1;
           else if (ci === BREAK)
@@ -254335,10 +256424,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field2 === "key")
-          ctrl = ctrl(item, path5);
+          ctrl = ctrl(item, path8);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path5) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path8) : ctrl;
   }
   exports.visit = visit2;
 });
@@ -254464,7 +256553,7 @@ var require_lexer2 = __commonJS((exports) => {
   var tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
   var flowIndicatorChars = new Set(",[]{}");
   var invalidAnchorChars = new Set(` ,[]{}
-\r	`);
+\r\t`);
   var isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
 
   class Lexer {
@@ -255904,7 +257993,7 @@ var require_public_api = __commonJS((exports) => {
   var Document = require_Document();
   var errors2 = require_errors3();
   var log = require_log();
-  var identity2 = require_identity();
+  var identity3 = require_identity();
   var lineCounter = require_line_counter();
   var parser = require_parser2();
   function parseOptions(options) {
@@ -255982,7 +258071,7 @@ var require_public_api = __commonJS((exports) => {
       if (!keepUndefined)
         return;
     }
-    if (identity2.isDocument(value4) && !_replacer)
+    if (identity3.isDocument(value4) && !_replacer)
       return value4.toString(options);
     return new Document.Document(value4, _replacer, options).toString(options);
   }
@@ -267029,7 +269118,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "1.0.9-main73ff5050",
+  version: "1.0.9-main74c34848",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -267077,13 +269166,13 @@ var package_default = {
     "@inquirer/input": "4.1.3",
     "@inquirer/password": "4.0.6",
     "@inquirer/select": "4.0.6",
-    "@settlemint/sdk-js": "1.0.9-main73ff5050",
-    "@settlemint/sdk-utils": "1.0.9-main73ff5050",
-    "@types/node": "22.12.0",
+    "@settlemint/sdk-js": "1.0.9-main74c34848",
+    "@settlemint/sdk-utils": "1.0.9-main74c34848",
+    "@types/node": "22.10.10",
     "@types/semver": "7.5.8",
     "@types/which": "3.0.4",
     "get-tsconfig": "4.10.0",
-    giget: "1.2.4",
+    giget: "1.2.3",
     "is-in-ci": "1.0.0",
     semver: "7.6.3",
     slugify: "1.6.6",
@@ -271835,223 +273924,10 @@ function usePagination({ items, active, renderItem, pageSize, loop = true }) {
 }
 // ../../node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
 var import_mute_stream = __toESM(require_lib12(), 1);
+init_mjs();
 import * as readline2 from "node:readline";
 import { AsyncResource as AsyncResource3 } from "node:async_hooks";
 
-// ../../node_modules/signal-exit/dist/mjs/signals.js
-var signals = [];
-signals.push("SIGHUP", "SIGINT", "SIGTERM");
-if (process.platform !== "win32") {
-  signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
-}
-if (process.platform === "linux") {
-  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
-}
-
-// ../../node_modules/signal-exit/dist/mjs/index.js
-var processOk2 = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
-var kExitEmitter = Symbol.for("signal-exit emitter");
-var global2 = globalThis;
-var ObjectDefineProperty = Object.defineProperty.bind(Object);
-
-class Emitter2 {
-  emitted = {
-    afterExit: false,
-    exit: false
-  };
-  listeners = {
-    afterExit: [],
-    exit: []
-  };
-  count = 0;
-  id = Math.random();
-  constructor() {
-    if (global2[kExitEmitter]) {
-      return global2[kExitEmitter];
-    }
-    ObjectDefineProperty(global2, kExitEmitter, {
-      value: this,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  on(ev, fn) {
-    this.listeners[ev].push(fn);
-  }
-  removeListener(ev, fn) {
-    const list3 = this.listeners[ev];
-    const i6 = list3.indexOf(fn);
-    if (i6 === -1) {
-      return;
-    }
-    if (i6 === 0 && list3.length === 1) {
-      list3.length = 0;
-    } else {
-      list3.splice(i6, 1);
-    }
-  }
-  emit(ev, code2, signal) {
-    if (this.emitted[ev]) {
-      return false;
-    }
-    this.emitted[ev] = true;
-    let ret = false;
-    for (const fn of this.listeners[ev]) {
-      ret = fn(code2, signal) === true || ret;
-    }
-    if (ev === "exit") {
-      ret = this.emit("afterExit", code2, signal) || ret;
-    }
-    return ret;
-  }
-}
-
-class SignalExitBase2 {
-}
-var signalExitWrap = (handler) => {
-  return {
-    onExit(cb, opts) {
-      return handler.onExit(cb, opts);
-    },
-    load() {
-      return handler.load();
-    },
-    unload() {
-      return handler.unload();
-    }
-  };
-};
-
-class SignalExitFallback2 extends SignalExitBase2 {
-  onExit() {
-    return () => {
-    };
-  }
-  load() {
-  }
-  unload() {
-  }
-}
-
-class SignalExit2 extends SignalExitBase2 {
-  #hupSig = process7.platform === "win32" ? "SIGINT" : "SIGHUP";
-  #emitter = new Emitter2;
-  #process;
-  #originalProcessEmit;
-  #originalProcessReallyExit;
-  #sigListeners = {};
-  #loaded = false;
-  constructor(process7) {
-    super();
-    this.#process = process7;
-    this.#sigListeners = {};
-    for (const sig of signals) {
-      this.#sigListeners[sig] = () => {
-        const listeners = this.#process.listeners(sig);
-        let { count } = this.#emitter;
-        const p6 = process7;
-        if (typeof p6.__signal_exit_emitter__ === "object" && typeof p6.__signal_exit_emitter__.count === "number") {
-          count += p6.__signal_exit_emitter__.count;
-        }
-        if (listeners.length === count) {
-          this.unload();
-          const ret = this.#emitter.emit("exit", null, sig);
-          const s8 = sig === "SIGHUP" ? this.#hupSig : sig;
-          if (!ret)
-            process7.kill(process7.pid, s8);
-        }
-      };
-    }
-    this.#originalProcessReallyExit = process7.reallyExit;
-    this.#originalProcessEmit = process7.emit;
-  }
-  onExit(cb, opts) {
-    if (!processOk2(this.#process)) {
-      return () => {
-      };
-    }
-    if (this.#loaded === false) {
-      this.load();
-    }
-    const ev = opts?.alwaysLast ? "afterExit" : "exit";
-    this.#emitter.on(ev, cb);
-    return () => {
-      this.#emitter.removeListener(ev, cb);
-      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
-        this.unload();
-      }
-    };
-  }
-  load() {
-    if (this.#loaded) {
-      return;
-    }
-    this.#loaded = true;
-    this.#emitter.count += 1;
-    for (const sig of signals) {
-      try {
-        const fn = this.#sigListeners[sig];
-        if (fn)
-          this.#process.on(sig, fn);
-      } catch (_5) {
-      }
-    }
-    this.#process.emit = (ev, ...a7) => {
-      return this.#processEmit(ev, ...a7);
-    };
-    this.#process.reallyExit = (code2) => {
-      return this.#processReallyExit(code2);
-    };
-  }
-  unload() {
-    if (!this.#loaded) {
-      return;
-    }
-    this.#loaded = false;
-    signals.forEach((sig) => {
-      const listener = this.#sigListeners[sig];
-      if (!listener) {
-        throw new Error("Listener not defined for signal: " + sig);
-      }
-      try {
-        this.#process.removeListener(sig, listener);
-      } catch (_5) {
-      }
-    });
-    this.#process.emit = this.#originalProcessEmit;
-    this.#process.reallyExit = this.#originalProcessReallyExit;
-    this.#emitter.count -= 1;
-  }
-  #processReallyExit(code2) {
-    if (!processOk2(this.#process)) {
-      return 0;
-    }
-    this.#process.exitCode = code2 || 0;
-    this.#emitter.emit("exit", this.#process.exitCode, null);
-    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
-  }
-  #processEmit(ev, ...args) {
-    const og = this.#originalProcessEmit;
-    if (ev === "exit" && processOk2(this.#process)) {
-      if (typeof args[0] === "number") {
-        this.#process.exitCode = args[0];
-      }
-      const ret = og.call(this.#process, ev, ...args);
-      this.#emitter.emit("exit", this.#process.exitCode, null);
-      return ret;
-    } else {
-      return og.call(this.#process, ev, ...args);
-    }
-  }
-}
-var process7 = globalThis.process;
-var {
-  onExit,
-  load: load2,
-  unload
-} = signalExitWrap(processOk2(process7) ? new SignalExit2(process7) : new SignalExitFallback2);
-
 // ../../node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
 var import_strip_ansi = __toESM(require_strip_ansi(), 1);
 var import_ansi_escapes = __toESM(require_ansi_escapes(), 1);
@@ -273737,12 +275613,12 @@ async function templatePrompt(platformConfig, argument) {
 // src/utils/download-extract.ts
 import { mkdir as mkdir5 } from "node:fs/promises";
 
-// ../../node_modules/giget/dist/shared/giget.D-_6aM9e.mjs
+// ../../node_modules/giget/dist/index.mjs
 var import_tar = __toESM(require_tar(), 1);
 import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir4, rm as rm3 } from "node:fs/promises";
-import { existsSync as existsSync3, createWriteStream, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync3, createWriteStream as createWriteStream2, readdirSync as readdirSync2 } from "node:fs";
 
-// ../../node_modules/pathe/dist/shared/pathe.UZ-hd4nF.mjs
+// ../../node_modules/pathe/dist/shared/pathe.ff20891b.mjs
 var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   if (!input) {
@@ -273782,26 +275658,24 @@ var normalize3 = function(path5) {
   }
   return isPathAbsolute && !isAbsolute(path5) ? `/${path5}` : path5;
 };
-var join8 = function(...segments) {
-  let path5 = "";
-  for (const seg of segments) {
-    if (!seg) {
-      continue;
-    }
-    if (path5.length > 0) {
-      const pathTrailing = path5[path5.length - 1] === "/";
-      const segLeading = seg[0] === "/";
-      const both = pathTrailing && segLeading;
-      if (both) {
-        path5 += seg.slice(1);
+var join8 = function(...arguments_4) {
+  if (arguments_4.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_4) {
+    if (argument && argument.length > 0) {
+      if (joined === undefined) {
+        joined = argument;
       } else {
-        path5 += pathTrailing || segLeading ? seg : `/${seg}`;
+        joined += `/${argument}`;
       }
-    } else {
-      path5 += seg;
     }
   }
-  return normalize3(path5);
+  if (joined === undefined) {
+    return ".";
+  }
+  return normalize3(joined.replace(/\/\/+/g, "/"));
 };
 function cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
@@ -273899,15 +275773,7 @@ var dirname9 = function(p6) {
   return segments.join("/") || (isAbsolute(p6) ? "/" : ".");
 };
 var basename2 = function(p6, extension) {
-  const segments = normalizeWindowsPath(p6).split("/");
-  let lastSegment = "";
-  for (let i6 = segments.length - 1;i6 >= 0; i6--) {
-    const val = segments[i6];
-    if (val) {
-      lastSegment = val;
-      break;
-    }
-  }
+  const lastSegment = normalizeWindowsPath(p6).split("/").pop();
   return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
 // ../../node_modules/defu/dist/defu.mjs
@@ -273970,15 +275836,14 @@ var defuArrayFn = createDefu((object, key2, currentValue) => {
   }
 });
 
-// ../../node_modules/nypm/dist/shared/nypm.DqHADQHW.mjs
-import { x as x6 } from "tinyexec";
+// ../../node_modules/nypm/dist/index.mjs
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
 async function findup(cwd2, match2, options = {}) {
   const segments = normalize3(cwd2).split("/");
   while (segments.length > 0) {
-    const path5 = segments.join("/") || "/";
-    const result = await match2(path5);
+    const path8 = segments.join("/") || "/";
+    const result = await match2(path8);
     if (result || !options.includeParentDirs) {
       return result;
     }
@@ -273997,21 +275862,22 @@ function cached(fn) {
     return v7;
   };
 }
+var importExeca = cached(() => Promise.resolve().then(() => (init_execa(), exports_execa)).then((r6) => r6.execa));
 var hasCorepack = cached(async () => {
   try {
-    const { exitCode: exitCode2 } = await x6("corepack", ["--version"]);
-    return exitCode2 === 0;
+    const execa3 = await importExeca();
+    await execa3("corepack", ["--version"]);
+    return true;
   } catch {
     return false;
   }
 });
 async function executeCommand2(command, args, options = {}) {
-  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
-  await x6(xArgs[0], xArgs[1], {
-    nodeOptions: {
-      cwd: resolve6(options.cwd || process.cwd()),
-      stdio: options.silent ? "pipe" : "inherit"
-    }
+  const execaArgs = command === "npm" || command === "bun" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  const execa3 = await importExeca();
+  await execa3(execaArgs[0], execaArgs[1], {
+    cwd: resolve6(options.cwd || process.cwd()),
+    stdio: options.silent ? "pipe" : "inherit"
   });
 }
 var NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
@@ -274030,23 +275896,6 @@ async function resolveOperationOptions(options = {}) {
     global: options.global ?? false
   };
 }
-function parsePackageManagerField(packageManager) {
-  const [name2, _version] = (packageManager || "").split("@");
-  const [version, buildMeta] = _version?.split("+") || [];
-  if (name2 && name2 !== "-" && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name2)) {
-    return { name: name2, version, buildMeta };
-  }
-  const sanitized = name2.replace(/\W+/g, "");
-  const warnings = [
-    `Abnormal characters found in \`packageManager\` field, sanitizing from \`${name2}\` to \`${sanitized}\``
-  ];
-  return {
-    name: sanitized,
-    version,
-    buildMeta,
-    warnings
-  };
-}
 var packageManagers = [
   {
     name: "npm",
@@ -274076,46 +275925,27 @@ var packageManagers = [
     majorVersion: "3",
     lockFile: "yarn.lock",
     files: [".yarnrc.yml"]
-  },
-  {
-    name: "deno",
-    command: "deno",
-    lockFile: "deno.lock",
-    files: ["deno.json"]
   }
 ];
 async function detectPackageManager2(cwd2, options = {}) {
-  const detected = await findup(resolve6(cwd2 || "."), async (path5) => {
+  const detected = await findup(resolve6(cwd2 || "."), async (path8) => {
     if (!options.ignorePackageJSON) {
-      const packageJSONPath = join8(path5, "package.json");
+      const packageJSONPath = join8(path8, "package.json");
       if (existsSync2(packageJSONPath)) {
         const packageJSON = JSON.parse(await readFile5(packageJSONPath, "utf8"));
         if (packageJSON?.packageManager) {
-          const {
+          const [name2, version = "0.0.0"] = packageJSON.packageManager.split("@");
+          const majorVersion = version.split(".")[0];
+          const packageManager = packageManagers.find((pm) => pm.name === name2 && pm.majorVersion === majorVersion) || packageManagers.find((pm) => pm.name === name2);
+          return {
+            ...packageManager,
             name: name2,
-            version = "0.0.0",
-            buildMeta,
-            warnings
-          } = parsePackageManagerField(packageJSON.packageManager);
-          if (name2) {
-            const majorVersion = version.split(".")[0];
-            const packageManager = packageManagers.find((pm) => pm.name === name2 && pm.majorVersion === majorVersion) || packageManagers.find((pm) => pm.name === name2);
-            return {
-              name: name2,
-              command: name2,
-              version,
-              majorVersion,
-              buildMeta,
-              warnings,
-              ...packageManager
-            };
-          }
+            command: name2,
+            version,
+            majorVersion
+          };
         }
       }
-      const denoJSONPath = join8(path5, "deno.json");
-      if (existsSync2(denoJSONPath)) {
-        return packageManagers.find((pm) => pm.name === "deno");
-      }
     }
     if (!options.ignoreLockFile) {
       for (const packageManager of packageManagers) {
@@ -274123,7 +275953,7 @@ async function detectPackageManager2(cwd2, options = {}) {
           packageManager.lockFile,
           packageManager.files
         ].flat().filter(Boolean);
-        if (detectionsFiles.some((file) => existsSync2(resolve6(path5, file)))) {
+        if (detectionsFiles.some((file) => existsSync2(resolve6(path8, file)))) {
           return {
             ...packageManager
           };
@@ -274152,8 +275982,7 @@ async function installDependencies2(options = {}) {
     npm: ["ci"],
     yarn: ["install", "--immutable"],
     bun: ["install", "--frozen-lockfile"],
-    pnpm: ["install", "--frozen-lockfile"],
-    deno: ["install", "--frozen"]
+    pnpm: ["install", "--frozen-lockfile"]
   };
   const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
   await executeCommand2(resolvedOptions.packageManager.command, commandArgs, {
@@ -274161,10 +275990,8 @@ async function installDependencies2(options = {}) {
     silent: resolvedOptions.silent
   });
 }
-// ../../node_modules/nypm/dist/index.mjs
-import"tinyexec";
 
-// ../../node_modules/giget/dist/shared/giget.D-_6aM9e.mjs
+// ../../node_modules/giget/dist/index.mjs
 import { pipeline } from "node:stream";
 var import_proxy = __toESM(require_proxy(), 1);
 import { homedir as homedir2 } from "node:os";
@@ -274189,7 +276016,7 @@ async function download(url, filePath, options = {}) {
   if (response.status >= 400) {
     throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
   }
-  const stream2 = createWriteStream(filePath);
+  const stream2 = createWriteStream2(filePath);
   await promisify(pipeline)(response.body, stream2);
   await writeFile7(infoPath, JSON.stringify(info), "utf8");
 }
@@ -274380,10 +276207,10 @@ async function downloadTemplate(input, options = {}) {
   const registry = options.registry === false ? undefined : registryProvider(options.registry, { auth: options.auth });
   let providerName = options.provider || (registry ? "registry" : "github");
   let source = input;
-  const sourceProviderMatch = input.match(sourceProtoRe);
-  if (sourceProviderMatch) {
-    providerName = sourceProviderMatch[1];
-    source = input.slice(sourceProviderMatch[0].length);
+  const sourceProvierMatch = input.match(sourceProtoRe);
+  if (sourceProvierMatch) {
+    providerName = sourceProvierMatch[1];
+    source = input.slice(sourceProvierMatch[0].length);
     if (providerName === "http" || providerName === "https") {
       source = input;
     }
@@ -274464,9 +276291,6 @@ async function downloadTemplate(input, options = {}) {
     dir: extractPath
   };
 }
-// ../../node_modules/giget/dist/index.mjs
-var import_tar2 = __toESM(require_tar(), 1);
-var import_proxy2 = __toESM(require_proxy(), 1);
 
 // src/utils/download-extract.ts
 async function downloadAndExtractNpmPackage(template, targetDir) {
@@ -276415,7 +278239,7 @@ var Document = require_Document();
 var Schema = require_Schema();
 var errors2 = require_errors3();
 var Alias = require_Alias();
-var identity2 = require_identity();
+var identity3 = require_identity();
 var Pair = require_Pair();
 var Scalar = require_Scalar();
 var YAMLMap = require_YAMLMap();
@@ -276433,14 +278257,14 @@ var $YAMLError = errors2.YAMLError;
 var $YAMLParseError = errors2.YAMLParseError;
 var $YAMLWarning = errors2.YAMLWarning;
 var $Alias = Alias.Alias;
-var $isAlias = identity2.isAlias;
-var $isCollection = identity2.isCollection;
-var $isDocument = identity2.isDocument;
-var $isMap = identity2.isMap;
-var $isNode = identity2.isNode;
-var $isPair = identity2.isPair;
-var $isScalar = identity2.isScalar;
-var $isSeq = identity2.isSeq;
+var $isAlias = identity3.isAlias;
+var $isCollection = identity3.isCollection;
+var $isDocument = identity3.isDocument;
+var $isMap = identity3.isMap;
+var $isNode = identity3.isNode;
+var $isPair = identity3.isPair;
+var $isScalar = identity3.isScalar;
+var $isSeq = identity3.isSeq;
 var $Pair = Pair.Pair;
 var $Scalar = Scalar.Scalar;
 var $YAMLMap = YAMLMap.YAMLMap;
@@ -277512,22 +279336,22 @@ function sanitizeName(value4, length = 35) {
 import { readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
 import { basename as basename4, join as join11 } from "node:path";
 var CONFIG_FILE_PATH = "./subgraph/subgraph.config.json";
-var isGenerated = (path5 = process.cwd()) => exists3(join11(path5, CONFIG_FILE_PATH));
-var getSubgraphYamlFile = async (path5 = process.cwd()) => {
-  const generated = await isGenerated(path5);
-  if (generated && await exists3(join11(path5, "generated/scs.subgraph.yaml"))) {
-    return join11(path5, "generated/scs.subgraph.yaml");
+var isGenerated = (path8 = process.cwd()) => exists3(join11(path8, CONFIG_FILE_PATH));
+var getSubgraphYamlFile = async (path8 = process.cwd()) => {
+  const generated = await isGenerated(path8);
+  if (generated && await exists3(join11(path8, "generated/scs.subgraph.yaml"))) {
+    return join11(path8, "generated/scs.subgraph.yaml");
   }
-  if (await exists3(join11(path5, "subgraph/subgraph.yaml"))) {
-    return join11(path5, "subgraph/subgraph.yaml");
+  if (await exists3(join11(path8, "subgraph/subgraph.yaml"))) {
+    return join11(path8, "subgraph/subgraph.yaml");
   }
-  if (await exists3(join11(path5, "subgraph.yaml"))) {
-    return join11(path5, "subgraph.yaml");
+  if (await exists3(join11(path8, "subgraph.yaml"))) {
+    return join11(path8, "subgraph.yaml");
   }
   throw new Error("Subgraph configuration file not found");
 };
-var getSubgraphYamlConfig = async (path5 = process.cwd()) => {
-  const subgraphYamlFile = await getSubgraphYamlFile(path5);
+var getSubgraphYamlConfig = async (path8 = process.cwd()) => {
+  const subgraphYamlFile = await getSubgraphYamlFile(path8);
   const rawYamlConfig = await readFile7(subgraphYamlFile);
   return $parse(rawYamlConfig.toString());
 };
@@ -277535,9 +279359,9 @@ var updateSubgraphYamlConfig = async (config3, cwd2 = process.cwd()) => {
   const subgraphYamlFile = await getSubgraphYamlFile(cwd2);
   await writeFile8(subgraphYamlFile, $stringify(config3));
 };
-var getSubgraphConfig = async (path5 = process.cwd()) => {
+var getSubgraphConfig = async (path8 = process.cwd()) => {
   try {
-    const configContents = await readFile7(join11(path5, CONFIG_FILE_PATH));
+    const configContents = await readFile7(join11(path8, CONFIG_FILE_PATH));
     const currentConfig = tryParseJson3(configContents.toString());
     return currentConfig;
   } catch (err) {
@@ -277920,4 +279744,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=7977EF7194902FB964756E2164756E21
+//# debugId=298C47998A101FAA64756E2164756E21