@socketsecurity/lib 5.19.0 → 5.19.1

package/dist/external/@npmcli/package-json.js

@@ -10067,11 +10067,3970 @@ var require_normalize_data = __commonJS({
   }
 });
 
-// stub:empty.cjs:@npmcli/git
-var require_git = __commonJS({
-  "stub:empty.cjs:@npmcli/git"(exports2, module2) {
+// node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/posix.js
+var require_posix = __commonJS({
+  "node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/posix.js"(exports2) {
     "use strict";
-    module2.exports = {};
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = void 0;
+    var fs_1 = require("fs");
+    var promises_1 = require("fs/promises");
+    var isexe = /* @__PURE__ */ __name(async (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    }, "isexe");
+    exports2.isexe = isexe;
+    var sync = /* @__PURE__ */ __name((path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    }, "sync");
+    exports2.sync = sync;
+    var checkStat = /* @__PURE__ */ __name((stat, options) => stat.isFile() && checkMode(stat, options), "checkStat");
+    var checkMode = /* @__PURE__ */ __name((stat, options) => {
+      const myUid = options.uid ?? process.getuid?.();
+      const myGroups = options.groups ?? process.getgroups?.() ?? [];
+      const myGid = options.gid ?? process.getgid?.() ?? myGroups[0];
+      if (myUid === void 0 || myGid === void 0) {
+        throw new Error("cannot get uid or gid");
+      }
+      const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
+      const mod = stat.mode;
+      const uid = stat.uid;
+      const gid = stat.gid;
+      const u = parseInt("100", 8);
+      const g = parseInt("010", 8);
+      const o = parseInt("001", 8);
+      const ug = u | g;
+      return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
+    }, "checkMode");
+  }
+});
+
+// node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/win32.js
+var require_win32 = __commonJS({
+  "node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/win32.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = void 0;
+    var fs_1 = require("fs");
+    var promises_1 = require("fs/promises");
+    var isexe = /* @__PURE__ */ __name(async (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path), path, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    }, "isexe");
+    exports2.isexe = isexe;
+    var sync = /* @__PURE__ */ __name((path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path), path, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    }, "sync");
+    exports2.sync = sync;
+    var checkPathExt = /* @__PURE__ */ __name((path, options) => {
+      const { pathExt = process.env.PATHEXT || "" } = options;
+      const peSplit = pathExt.split(";");
+      if (peSplit.indexOf("") !== -1) {
+        return true;
+      }
+      for (let i = 0; i < peSplit.length; i++) {
+        const p = peSplit[i].toLowerCase();
+        const ext = path.substring(path.length - p.length).toLowerCase();
+        if (p && ext === p) {
+          return true;
+        }
+      }
+      return false;
+    }, "checkPathExt");
+    var checkStat = /* @__PURE__ */ __name((stat, path, options) => stat.isFile() && checkPathExt(path, options), "checkStat");
+  }
+});
+
+// node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/options.js
+var require_options = __commonJS({
+  "node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/options.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/.pnpm/isexe@3.1.1/node_modules/isexe/dist/cjs/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
+          return m[k];
+        }, "get") };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
+    var posix = __importStar(require_posix());
+    exports2.posix = posix;
+    var win32 = __importStar(require_win32());
+    exports2.win32 = win32;
+    __exportStar(require_options(), exports2);
+    var platform = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+    var impl = platform === "win32" ? win32 : posix;
+    exports2.isexe = impl.isexe;
+    exports2.sync = impl.sync;
+  }
+});
+
+// node_modules/.pnpm/which@5.0.0/node_modules/which/lib/index.js
+var require_lib4 = __commonJS({
+  "node_modules/.pnpm/which@5.0.0/node_modules/which/lib/index.js"(exports2, module2) {
+    var { isexe, sync: isexeSync } = require_cjs();
+    var { join, delimiter, sep, posix } = require("path");
+    var isWindows = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = /* @__PURE__ */ __name((cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }), "getNotFoundError");
+    var getPathInfo = /* @__PURE__ */ __name((cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    }, "getPathInfo");
+    var getPathPart = /* @__PURE__ */ __name((raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join(pathPart, cmd);
+    }, "getPathPart");
+    var which = /* @__PURE__ */ __name(async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    }, "which");
+    var whichSync = /* @__PURE__ */ __name((cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    }, "whichSync");
+    module2.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// node_modules/.pnpm/@npmcli+promise-spawn@9.0.1/node_modules/@npmcli/promise-spawn/lib/escape.js
+var require_escape2 = __commonJS({
+  "node_modules/.pnpm/@npmcli+promise-spawn@9.0.1/node_modules/@npmcli/promise-spawn/lib/escape.js"(exports2, module2) {
+    "use strict";
+    var cmd = /* @__PURE__ */ __name((input, doubleEscape) => {
+      if (!input.length) {
+        return '""';
+      }
+      let result;
+      if (!/[ \t\n\v"]/.test(input)) {
+        result = input;
+      } else {
+        result = '"';
+        for (let i = 0; i <= input.length; ++i) {
+          let slashCount = 0;
+          while (input[i] === "\\") {
+            ++i;
+            ++slashCount;
+          }
+          if (i === input.length) {
+            result += "\\".repeat(slashCount * 2);
+            break;
+          }
+          if (input[i] === '"') {
+            result += "\\".repeat(slashCount * 2 + 1);
+            result += input[i];
+          } else {
+            result += "\\".repeat(slashCount);
+            result += input[i];
+          }
+        }
+        result += '"';
+      }
+      result = result.replace(/[ !%^&()<>|"]/g, "^$&");
+      if (doubleEscape) {
+        result = result.replace(/[ !%^&()<>|"]/g, "^$&");
+      }
+      return result;
+    }, "cmd");
+    var sh = /* @__PURE__ */ __name((input) => {
+      if (!input.length) {
+        return `''`;
+      }
+      if (!/[\t\n\r "#$&'()*;<>?\\`|~]/.test(input)) {
+        return input;
+      }
+      const result = `'${input.replace(/'/g, `'\\''`)}'`.replace(/^(?:'')+(?!$)/, "").replace(/\\'''/g, `\\'`);
+      return result;
+    }, "sh");
+    module2.exports = {
+      cmd,
+      sh
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+promise-spawn@9.0.1/node_modules/@npmcli/promise-spawn/lib/index.js
+var require_lib5 = __commonJS({
+  "node_modules/.pnpm/@npmcli+promise-spawn@9.0.1/node_modules/@npmcli/promise-spawn/lib/index.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("child_process");
+    var os = require("os");
+    var which = require_lib4();
+    var escape = require_escape2();
+    var promiseSpawn = /* @__PURE__ */ __name((cmd, args, opts = {}, extra = {}) => {
+      if (opts.shell) {
+        return spawnWithShell(cmd, args, opts, extra);
+      }
+      let resolve, reject;
+      const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+      });
+      const closeError = new Error("command failed");
+      const stdout = [];
+      const stderr = [];
+      const getResult = /* @__PURE__ */ __name((result) => ({
+        cmd,
+        args,
+        ...result,
+        ...stdioResult(stdout, stderr, opts),
+        ...extra
+      }), "getResult");
+      const rejectWithOpts = /* @__PURE__ */ __name((er, erOpts) => {
+        const resultError = getResult(erOpts);
+        reject(Object.assign(er, resultError));
+      }, "rejectWithOpts");
+      const proc = spawn(cmd, args, opts);
+      promise.stdin = proc.stdin;
+      promise.process = proc;
+      proc.on("error", rejectWithOpts);
+      if (proc.stdout) {
+        proc.stdout.on("data", (c) => stdout.push(c));
+        proc.stdout.on("error", rejectWithOpts);
+      }
+      if (proc.stderr) {
+        proc.stderr.on("data", (c) => stderr.push(c));
+        proc.stderr.on("error", rejectWithOpts);
+      }
+      proc.on("close", (code, signal) => {
+        if (code || signal) {
+          rejectWithOpts(closeError, { code, signal });
+        } else {
+          resolve(getResult({ code, signal }));
+        }
+      });
+      return promise;
+    }, "promiseSpawn");
+    var spawnWithShell = /* @__PURE__ */ __name((cmd, args, opts, extra) => {
+      let command = opts.shell;
+      if (command === true) {
+        command = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "sh";
+      }
+      const options = { ...opts, shell: false };
+      const realArgs = [];
+      let script = cmd;
+      const isCmd = /(?:^|\\)cmd(?:\.exe)?$/i.test(command);
+      if (isCmd) {
+        let doubleEscape = false;
+        let initialCmd = "";
+        let insideQuotes = false;
+        for (let i = 0; i < cmd.length; ++i) {
+          const char = cmd.charAt(i);
+          if (char === " " && !insideQuotes) {
+            break;
+          }
+          initialCmd += char;
+          if (char === '"' || char === "'") {
+            insideQuotes = !insideQuotes;
+          }
+        }
+        let pathToInitial;
+        try {
+          pathToInitial = which.sync(initialCmd, {
+            path: options.env && findInObject(options.env, "PATH") || process.env.PATH,
+            pathext: options.env && findInObject(options.env, "PATHEXT") || process.env.PATHEXT
+          }).toLowerCase();
+        } catch (err) {
+          pathToInitial = initialCmd.toLowerCase();
+        }
+        doubleEscape = pathToInitial.endsWith(".cmd") || pathToInitial.endsWith(".bat");
+        for (const arg of args) {
+          script += ` ${escape.cmd(arg, doubleEscape)}`;
+        }
+        realArgs.push("/d", "/s", "/c", script);
+        options.windowsVerbatimArguments = true;
+      } else {
+        for (const arg of args) {
+          script += ` ${escape.sh(arg)}`;
+        }
+        realArgs.push("-c", script);
+      }
+      return promiseSpawn(command, realArgs, options, extra);
+    }, "spawnWithShell");
+    var open = /* @__PURE__ */ __name((_args, opts = {}, extra = {}) => {
+      const options = { ...opts, shell: true };
+      const args = [].concat(_args);
+      let platform = process.platform;
+      if (platform === "linux" && os.release().toLowerCase().includes("microsoft")) {
+        platform = "wsl";
+        if (!process.env.BROWSER) {
+          return Promise.reject(
+            new Error("Set the BROWSER environment variable to your desired browser.")
+          );
+        }
+      }
+      let command = options.command;
+      if (!command) {
+        if (platform === "win32") {
+          options.shell = process.env.ComSpec;
+          command = 'start ""';
+        } else if (platform === "wsl") {
+          command = "sensible-browser";
+        } else if (platform === "darwin") {
+          command = "open";
+        } else {
+          command = "xdg-open";
+        }
+      }
+      return spawnWithShell(command, args, options, extra);
+    }, "open");
+    promiseSpawn.open = open;
+    var isPipe = /* @__PURE__ */ __name((stdio = "pipe", fd) => {
+      if (stdio === "pipe" || stdio === null) {
+        return true;
+      }
+      if (Array.isArray(stdio)) {
+        return isPipe(stdio[fd], fd);
+      }
+      return false;
+    }, "isPipe");
+    var stdioResult = /* @__PURE__ */ __name((stdout, stderr, { stdioString = true, stdio }) => {
+      const result = {
+        stdout: null,
+        stderr: null
+      };
+      if (isPipe(stdio, 1)) {
+        result.stdout = Buffer.concat(stdout);
+        if (stdioString) {
+          result.stdout = result.stdout.toString().trim();
+        }
+      }
+      if (isPipe(stdio, 2)) {
+        result.stderr = Buffer.concat(stderr);
+        if (stdioString) {
+          result.stderr = result.stderr.toString().trim();
+        }
+      }
+      return result;
+    }, "stdioResult");
+    var findInObject = /* @__PURE__ */ __name((obj, key) => {
+      key = key.toLowerCase();
+      for (const objKey of Object.keys(obj).sort()) {
+        if (objKey.toLowerCase() === key) {
+          return obj[objKey];
+        }
+      }
+    }, "findInObject");
+    module2.exports = promiseSpawn;
+  }
+});
+
+// node_modules/.pnpm/err-code@2.0.3/node_modules/err-code/index.js
+var require_err_code = __commonJS({
+  "node_modules/.pnpm/err-code@2.0.3/node_modules/err-code/index.js"(exports2, module2) {
+    "use strict";
+    function assign(obj, props) {
+      for (const key in props) {
+        Object.defineProperty(obj, key, {
+          value: props[key],
+          enumerable: true,
+          configurable: true
+        });
+      }
+      return obj;
+    }
+    __name(assign, "assign");
+    function createError(err, code, props) {
+      if (!err || typeof err === "string") {
+        throw new TypeError("Please pass an Error to err-code");
+      }
+      if (!props) {
+        props = {};
+      }
+      if (typeof code === "object") {
+        props = code;
+        code = void 0;
+      }
+      if (code != null) {
+        props.code = code;
+      }
+      try {
+        return assign(err, props);
+      } catch (_) {
+        props.message = err.message;
+        props.stack = err.stack;
+        const ErrClass = /* @__PURE__ */ __name(function() {
+        }, "ErrClass");
+        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
+        return assign(new ErrClass(), props);
+      }
+    }
+    __name(createError, "createError");
+    module2.exports = createError;
+  }
+});
+
+// node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports2, module2) {
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    __name(RetryOperation, "RetryOperation");
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts;
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(this._errors.length - 1, this._errors.length);
+          this._timeouts = this._cachedTimeouts.slice(0);
+          timeout = this._timeouts.shift();
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      var timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      /* @__PURE__ */ console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      /* @__PURE__ */ console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "node_modules/.pnpm/retry@0.12.0/node_modules/retry/lib/retry.js"(exports2) {
+    var RetryOperation = require_retry_operation();
+    exports2.operation = function(options) {
+      var timeouts = exports2.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && options.forever,
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports2.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports2.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports2.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = (/* @__PURE__ */ __name(function retryWrapper(original2) {
+          var op = exports2.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }, "retryWrapper")).bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "node_modules/.pnpm/retry@0.12.0/node_modules/retry/index.js"(exports2, module2) {
+    module2.exports = require_retry();
+  }
+});
+
+// node_modules/.pnpm/promise-retry@2.0.1/node_modules/promise-retry/index.js
+var require_promise_retry = __commonJS({
+  "node_modules/.pnpm/promise-retry@2.0.1/node_modules/promise-retry/index.js"(exports2, module2) {
+    "use strict";
+    var errcode = require_err_code();
+    var retry = require_retry2();
+    var hasOwn = Object.prototype.hasOwnProperty;
+    function isRetryError(err) {
+      return err && err.code === "EPROMISERETRY" && hasOwn.call(err, "retried");
+    }
+    __name(isRetryError, "isRetryError");
+    function promiseRetry(fn, options) {
+      var temp;
+      var operation;
+      if (typeof fn === "object" && typeof options === "function") {
+        temp = options;
+        options = fn;
+        fn = temp;
+      }
+      operation = retry.operation(options);
+      return new Promise(function(resolve, reject) {
+        operation.attempt(function(number) {
+          Promise.resolve().then(function() {
+            return fn(function(err) {
+              if (isRetryError(err)) {
+                err = err.retried;
+              }
+              throw errcode(new Error("Retrying"), "EPROMISERETRY", { retried: err });
+            }, number);
+          }).then(resolve, function(err) {
+            if (isRetryError(err)) {
+              err = err.retried;
+              if (operation.retry(err || new Error())) {
+                return;
+              }
+            }
+            reject(err);
+          });
+        });
+      });
+    }
+    __name(promiseRetry, "promiseRetry");
+    module2.exports = promiseRetry;
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/errors.js
+var require_errors = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/errors.js"(exports2, module2) {
+    var maxRetry = 3;
+    var GitError = class extends Error {
+      static {
+        __name(this, "GitError");
+      }
+      shouldRetry() {
+        return false;
+      }
+    };
+    var GitConnectionError = class extends GitError {
+      static {
+        __name(this, "GitConnectionError");
+      }
+      constructor() {
+        super("A git connection error occurred");
+      }
+      shouldRetry(number) {
+        return number < maxRetry;
+      }
+    };
+    var GitPathspecError = class extends GitError {
+      static {
+        __name(this, "GitPathspecError");
+      }
+      constructor() {
+        super("The git reference could not be found");
+      }
+    };
+    var GitUnknownError = class extends GitError {
+      static {
+        __name(this, "GitUnknownError");
+      }
+      constructor() {
+        super("An unknown git error occurred");
+      }
+    };
+    module2.exports = {
+      GitConnectionError,
+      GitPathspecError,
+      GitUnknownError
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/make-error.js
+var require_make_error = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/make-error.js"(exports2, module2) {
+    var {
+      GitConnectionError,
+      GitPathspecError,
+      GitUnknownError
+    } = require_errors();
+    var connectionErrorRe = new RegExp([
+      "remote error: Internal Server Error",
+      "The remote end hung up unexpectedly",
+      "Connection timed out",
+      "Operation timed out",
+      "Failed to connect to .* Timed out",
+      "Connection reset by peer",
+      "SSL_ERROR_SYSCALL",
+      "The requested URL returned error: 503"
+    ].join("|"));
+    var missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/;
+    function makeError(er) {
+      const message = er.stderr;
+      let gitEr;
+      if (connectionErrorRe.test(message)) {
+        gitEr = new GitConnectionError(message);
+      } else if (missingPathspecRe.test(message)) {
+        gitEr = new GitPathspecError(message);
+      } else {
+        gitEr = new GitUnknownError(message);
+      }
+      return Object.assign(gitEr, er);
+    }
+    __name(makeError, "makeError");
+    module2.exports = makeError;
+  }
+});
+
+// node_modules/.pnpm/ini@5.0.0/node_modules/ini/lib/ini.js
+var require_ini = __commonJS({
+  "node_modules/.pnpm/ini@5.0.0/node_modules/ini/lib/ini.js"(exports2, module2) {
+    var { hasOwnProperty } = Object.prototype;
+    var encode = /* @__PURE__ */ __name((obj, opt = {}) => {
+      if (typeof opt === "string") {
+        opt = { section: opt };
+      }
+      opt.align = opt.align === true;
+      opt.newline = opt.newline === true;
+      opt.sort = opt.sort === true;
+      opt.whitespace = opt.whitespace === true || opt.align === true;
+      opt.platform = opt.platform || typeof process !== "undefined" && process.platform;
+      opt.bracketedArray = opt.bracketedArray !== false;
+      const eol = opt.platform === "win32" ? "\r\n" : "\n";
+      const separator = opt.whitespace ? " = " : "=";
+      const children = [];
+      const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
+      let padToChars = 0;
+      if (opt.align) {
+        padToChars = safe(
+          keys.filter((k) => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== "object").map((k) => Array.isArray(obj[k]) ? `${k}[]` : k).concat([""]).reduce((a, b) => safe(a).length >= safe(b).length ? a : b)
+        ).length;
+      }
+      let out = "";
+      const arraySuffix = opt.bracketedArray ? "[]" : "";
+      for (const k of keys) {
+        const val = obj[k];
+        if (val && Array.isArray(val)) {
+          for (const item of val) {
+            out += safe(`${k}${arraySuffix}`).padEnd(padToChars, " ") + separator + safe(item) + eol;
+          }
+        } else if (val && typeof val === "object") {
+          children.push(k);
+        } else {
+          out += safe(k).padEnd(padToChars, " ") + separator + safe(val) + eol;
+        }
+      }
+      if (opt.section && out.length) {
+        out = "[" + safe(opt.section) + "]" + (opt.newline ? eol + eol : eol) + out;
+      }
+      for (const k of children) {
+        const nk = splitSections(k, ".").join("\\.");
+        const section = (opt.section ? opt.section + "." : "") + nk;
+        const child = encode(obj[k], {
+          ...opt,
+          section
+        });
+        if (out.length && child.length) {
+          out += eol;
+        }
+        out += child;
+      }
+      return out;
+    }, "encode");
+    function splitSections(str, separator) {
+      var lastMatchIndex = 0;
+      var lastSeparatorIndex = 0;
+      var nextIndex = 0;
+      var sections = [];
+      do {
+        nextIndex = str.indexOf(separator, lastMatchIndex);
+        if (nextIndex !== -1) {
+          lastMatchIndex = nextIndex + separator.length;
+          if (nextIndex > 0 && str[nextIndex - 1] === "\\") {
+            continue;
+          }
+          sections.push(str.slice(lastSeparatorIndex, nextIndex));
+          lastSeparatorIndex = nextIndex + separator.length;
+        }
+      } while (nextIndex !== -1);
+      sections.push(str.slice(lastSeparatorIndex));
+      return sections;
+    }
+    __name(splitSections, "splitSections");
+    var decode = /* @__PURE__ */ __name((str, opt = {}) => {
+      opt.bracketedArray = opt.bracketedArray !== false;
+      const out = /* @__PURE__ */ Object.create(null);
+      let p = out;
+      let section = null;
+      const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
+      const lines = str.split(/[\r\n]+/g);
+      const duplicates = {};
+      for (const line of lines) {
+        if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) {
+          continue;
+        }
+        const match = line.match(re);
+        if (!match) {
+          continue;
+        }
+        if (match[1] !== void 0) {
+          section = unsafe(match[1]);
+          if (section === "__proto__") {
+            p = /* @__PURE__ */ Object.create(null);
+            continue;
+          }
+          p = out[section] = out[section] || /* @__PURE__ */ Object.create(null);
+          continue;
+        }
+        const keyRaw = unsafe(match[2]);
+        let isArray;
+        if (opt.bracketedArray) {
+          isArray = keyRaw.length > 2 && keyRaw.slice(-2) === "[]";
+        } else {
+          duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
+          isArray = duplicates[keyRaw] > 1;
+        }
+        const key = isArray && keyRaw.endsWith("[]") ? keyRaw.slice(0, -2) : keyRaw;
+        if (key === "__proto__") {
+          continue;
+        }
+        const valueRaw = match[3] ? unsafe(match[4]) : true;
+        const value = valueRaw === "true" || valueRaw === "false" || valueRaw === "null" ? JSON.parse(valueRaw) : valueRaw;
+        if (isArray) {
+          if (!hasOwnProperty.call(p, key)) {
+            p[key] = [];
+          } else if (!Array.isArray(p[key])) {
+            p[key] = [p[key]];
+          }
+        }
+        if (Array.isArray(p[key])) {
+          p[key].push(value);
+        } else {
+          p[key] = value;
+        }
+      }
+      const remove = [];
+      for (const k of Object.keys(out)) {
+        if (!hasOwnProperty.call(out, k) || typeof out[k] !== "object" || Array.isArray(out[k])) {
+          continue;
+        }
+        const parts = splitSections(k, ".");
+        p = out;
+        const l = parts.pop();
+        const nl = l.replace(/\\\./g, ".");
+        for (const part of parts) {
+          if (part === "__proto__") {
+            continue;
+          }
+          if (!hasOwnProperty.call(p, part) || typeof p[part] !== "object") {
+            p[part] = /* @__PURE__ */ Object.create(null);
+          }
+          p = p[part];
+        }
+        if (p === out && nl === l) {
+          continue;
+        }
+        p[nl] = out[k];
+        remove.push(k);
+      }
+      for (const del of remove) {
+        delete out[del];
+      }
+      return out;
+    }, "decode");
+    var isQuoted = /* @__PURE__ */ __name((val) => {
+      return val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'");
+    }, "isQuoted");
+    var safe = /* @__PURE__ */ __name((val) => {
+      if (typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim()) {
+        return JSON.stringify(val);
+      }
+      return val.split(";").join("\\;").split("#").join("\\#");
+    }, "safe");
+    var unsafe = /* @__PURE__ */ __name((val) => {
+      val = (val || "").trim();
+      if (isQuoted(val)) {
+        if (val.charAt(0) === "'") {
+          val = val.slice(1, -1);
+        }
+        try {
+          val = JSON.parse(val);
+        } catch {
+        }
+      } else {
+        let esc = false;
+        let unesc = "";
+        for (let i = 0, l = val.length; i < l; i++) {
+          const c = val.charAt(i);
+          if (esc) {
+            if ("\\;#".indexOf(c) !== -1) {
+              unesc += c;
+            } else {
+              unesc += "\\" + c;
+            }
+            esc = false;
+          } else if (";#".indexOf(c) !== -1) {
+            break;
+          } else if (c === "\\") {
+            esc = true;
+          } else {
+            unesc += c;
+          }
+        }
+        if (esc) {
+          unesc += "\\";
+        }
+        return unesc.trim();
+      }
+      return val;
+    }, "unsafe");
+    module2.exports = {
+      parse: decode,
+      decode,
+      stringify: encode,
+      encode,
+      safe,
+      unsafe
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/opts.js
+var require_opts = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/opts.js"(exports2, module2) {
+    var fs = require("node:fs");
+    var os = require("node:os");
+    var path = require("node:path");
+    var ini = require_ini();
+    var gitConfigPath = path.join(os.homedir(), ".gitconfig");
+    var cachedConfig = null;
+    var loadGitConfig = /* @__PURE__ */ __name(() => {
+      if (cachedConfig === null) {
+        try {
+          cachedConfig = {};
+          if (fs.existsSync(gitConfigPath)) {
+            const configContent = fs.readFileSync(gitConfigPath, "utf-8");
+            cachedConfig = ini.parse(configContent);
+          }
+        } catch (error) {
+          cachedConfig = {};
+        }
+      }
+      return cachedConfig;
+    }, "loadGitConfig");
+    var checkGitConfigs = /* @__PURE__ */ __name(() => {
+      const config = loadGitConfig();
+      return {
+        sshCommandSetInConfig: config?.core?.sshCommand !== void 0,
+        askPassSetInConfig: config?.core?.askpass !== void 0
+      };
+    }, "checkGitConfigs");
+    var sshCommandSetInEnv = process.env.GIT_SSH_COMMAND !== void 0;
+    var askPassSetInEnv = process.env.GIT_ASKPASS !== void 0;
+    var { sshCommandSetInConfig, askPassSetInConfig } = checkGitConfigs();
+    var finalGitEnv = {
+      ...askPassSetInEnv || askPassSetInConfig ? {} : {
+        GIT_ASKPASS: "echo"
+      },
+      ...sshCommandSetInEnv || sshCommandSetInConfig ? {} : {
+        GIT_SSH_COMMAND: "ssh -oStrictHostKeyChecking=accept-new"
+      }
+    };
+    module2.exports = (opts = {}) => ({
+      stdioString: true,
+      ...opts,
+      shell: false,
+      env: opts.env || { ...finalGitEnv, ...process.env }
+    });
+    module2.exports.loadGitConfig = loadGitConfig;
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/which.js
+var require_which = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/which.js"(exports2, module2) {
+    var which = require_lib4();
+    var gitPath;
+    try {
+      gitPath = which.sync("git");
+    } catch {
+    }
+    module2.exports = (opts = {}) => {
+      if (opts.git) {
+        return opts.git;
+      }
+      if (!gitPath || opts.git === false) {
+        return Object.assign(new Error("No git binary found in $PATH"), { code: "ENOGIT" });
+      }
+      return gitPath;
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/spawn.js
+var require_spawn = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/spawn.js"(exports2, module2) {
+    var spawn = require_lib5();
+    var promiseRetry = require_promise_retry();
+    var { log } = require_lib2();
+    var makeError = require_make_error();
+    var makeOpts = require_opts();
+    module2.exports = (gitArgs, opts = {}) => {
+      const whichGit = require_which();
+      const gitPath = whichGit(opts);
+      if (gitPath instanceof Error) {
+        return Promise.reject(gitPath);
+      }
+      const args = opts.allowReplace || gitArgs[0] === "--no-replace-objects" ? gitArgs : ["--no-replace-objects", ...gitArgs];
+      let retryOpts = opts.retry;
+      if (retryOpts === null || retryOpts === void 0) {
+        retryOpts = {
+          retries: opts.fetchRetries || 2,
+          factor: opts.fetchRetryFactor || 10,
+          maxTimeout: opts.fetchRetryMaxtimeout || 6e4,
+          minTimeout: opts.fetchRetryMintimeout || 1e3
+        };
+      }
+      return promiseRetry((retryFn, number) => {
+        if (number !== 1) {
+          log.silly("git", `Retrying git command: ${args.join(" ")} attempt # ${number}`);
+        }
+        return spawn(gitPath, args, makeOpts(opts)).catch((er) => {
+          const gitError = makeError(er);
+          if (!gitError.shouldRetry(number)) {
+            throw gitError;
+          }
+          retryFn(gitError);
+        });
+      }, retryOpts);
+    };
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = /* @__PURE__ */ __name((version, release, options, identifier, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version instanceof SemVer ? version.version : version,
+          options
+        ).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    }, "inc");
+    module2.exports = inc;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var diff = /* @__PURE__ */ __name((version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    }, "diff");
+    module2.exports = diff;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).major, "major");
+    module2.exports = major;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).minor, "minor");
+    module2.exports = minor;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).patch, "patch");
+    module2.exports = patch;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease = /* @__PURE__ */ __name((version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    }, "prerelease");
+    module2.exports = prerelease;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = /* @__PURE__ */ __name((a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose)), "compare");
+    module2.exports = compare;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = /* @__PURE__ */ __name((a, b, loose) => compare(b, a, loose), "rcompare");
+    module2.exports = rcompare;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = /* @__PURE__ */ __name((a, b) => compare(a, b, true), "compareLoose");
+    module2.exports = compareLoose;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = /* @__PURE__ */ __name((a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    }, "compareBuild");
+    module2.exports = compareBuild;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(a, b, loose)), "sort");
+    module2.exports = sort;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(b, a, loose)), "rsort");
+    module2.exports = rsort;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gt = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) > 0, "gt");
+    module2.exports = gt;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lt = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) < 0, "lt");
+    module2.exports = lt;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var eq = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) === 0, "eq");
+    module2.exports = eq;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var neq = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) !== 0, "neq");
+    module2.exports = neq;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) >= 0, "gte");
+    module2.exports = gte;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) <= 0, "lte");
+    module2.exports = lte;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js"(exports2, module2) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = /* @__PURE__ */ __name((a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    }, "cmp");
+    module2.exports = cmp;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t } = require_re();
+    var coerce = /* @__PURE__ */ __name((version, options) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      if (typeof version === "number") {
+        version = String(version);
+      }
+      if (typeof version !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    }, "coerce");
+    module2.exports = coerce;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js"(exports2, module2) {
+    "use strict";
+    var LRUCache = class {
+      static {
+        __name(this, "LRUCache");
+      }
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js"(exports2, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      static {
+        __name(this, "Range");
+      }
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module2.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var isNullSet = /* @__PURE__ */ __name((c) => c.value === "<0.0.0-0", "isNullSet");
+    var isAny = /* @__PURE__ */ __name((c) => c.value === "", "isAny");
+    var isSatisfiable = /* @__PURE__ */ __name((comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    }, "isSatisfiable");
+    var parseComparator = /* @__PURE__ */ __name((comp, options) => {
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    }, "parseComparator");
+    var isX = /* @__PURE__ */ __name((id) => !id || id.toLowerCase() === "x" || id === "*", "isX");
+    var replaceTildes = /* @__PURE__ */ __name((comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    }, "replaceTildes");
+    var replaceTilde = /* @__PURE__ */ __name((comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    }, "replaceTilde");
+    var replaceCarets = /* @__PURE__ */ __name((comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    }, "replaceCarets");
+    var replaceCaret = /* @__PURE__ */ __name((comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    }, "replaceCaret");
+    var replaceXRanges = /* @__PURE__ */ __name((comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    }, "replaceXRanges");
+    var replaceXRange = /* @__PURE__ */ __name((comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    }, "replaceXRange");
+    var replaceStars = /* @__PURE__ */ __name((comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    }, "replaceStars");
+    var replaceGTE0 = /* @__PURE__ */ __name((comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    }, "replaceGTE0");
+    var hyphenReplace = /* @__PURE__ */ __name((incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    }, "hyphenReplace");
+    var testSet = /* @__PURE__ */ __name((set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    }, "testSet");
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js"(exports2, module2) {
+    "use strict";
+    var ANY = Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static {
+        __name(this, "Comparator");
+      }
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var satisfies = /* @__PURE__ */ __name((version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    }, "satisfies");
+    module2.exports = satisfies;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = /* @__PURE__ */ __name((range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" ")), "toComparators");
+    module2.exports = toComparators;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = /* @__PURE__ */ __name((versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    }, "maxSatisfying");
+    module2.exports = maxSatisfying;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = /* @__PURE__ */ __name((versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    }, "minSatisfying");
+    module2.exports = minSatisfying;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = /* @__PURE__ */ __name((range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    }, "minVersion");
+    module2.exports = minVersion;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var validRange = /* @__PURE__ */ __name((range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    }, "validRange");
+    module2.exports = validRange;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = /* @__PURE__ */ __name((version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    }, "outside");
+    module2.exports = outside;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = /* @__PURE__ */ __name((version, range, options) => outside(version, range, ">", options), "gtr");
+    module2.exports = gtr;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = /* @__PURE__ */ __name((version, range, options) => outside(version, range, "<", options), "ltr");
+    module2.exports = ltr;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var intersects = /* @__PURE__ */ __name((r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    }, "intersects");
+    module2.exports = intersects;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js"(exports2, module2) {
+    "use strict";
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module2.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) {
+            first = version;
+          }
+        } else {
+          if (prev) {
+            set.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    var subset = /* @__PURE__ */ __name((sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    }, "subset");
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = /* @__PURE__ */ __name((sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    }, "simpleSubset");
+    var higherGT = /* @__PURE__ */ __name((a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    }, "higherGT");
+    var lowerLT = /* @__PURE__ */ __name((a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    }, "lowerLT");
+    module2.exports = subset;
+  }
+});
+
+// node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js"(exports2, module2) {
+    "use strict";
+    var internalRe = require_re();
+    var constants = require_constants();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse = require_parse();
+    var valid = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module2.exports = {
+      parse,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      Comparator,
+      Range,
+      satisfies,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/lines-to-revs.js
+var require_lines_to_revs = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/lines-to-revs.js"(exports2, module2) {
+    var semver = require_semver2();
+    module2.exports = (lines) => finish(lines.reduce(linesToRevsReducer, {
+      versions: {},
+      "dist-tags": {},
+      refs: {},
+      shas: {}
+    }));
+    var finish = /* @__PURE__ */ __name((revs) => distTags(shaList(peelTags(revs))), "finish");
+    var shaList = /* @__PURE__ */ __name((revs) => {
+      Object.keys(revs.refs).forEach((ref) => {
+        const doc = revs.refs[ref];
+        if (!revs.shas[doc.sha]) {
+          revs.shas[doc.sha] = [ref];
+        } else {
+          revs.shas[doc.sha].push(ref);
+        }
+      });
+      return revs;
+    }, "shaList");
+    var peelTags = /* @__PURE__ */ __name((revs) => {
+      Object.keys(revs.refs).filter((ref) => ref.endsWith("^{}")).forEach((ref) => {
+        const peeled = revs.refs[ref];
+        const unpeeled = revs.refs[ref.replace(/\^\{\}$/, "")];
+        if (unpeeled) {
+          unpeeled.sha = peeled.sha;
+          delete revs.refs[ref];
+        }
+      });
+      return revs;
+    }, "peelTags");
+    var distTags = /* @__PURE__ */ __name((revs) => {
+      const HEAD = revs.refs.HEAD || /* istanbul ignore next */
+      {};
+      const versions = Object.keys(revs.versions);
+      versions.forEach((v) => {
+        const ver = revs.versions[v];
+        if (revs.refs.latest && ver.sha === revs.refs.latest.sha) {
+          revs["dist-tags"].latest = v;
+        } else if (ver.sha === HEAD.sha) {
+          revs["dist-tags"].HEAD = v;
+          if (!revs.refs.latest) {
+            revs["dist-tags"].latest = v;
+          }
+        }
+      });
+      return revs;
+    }, "distTags");
+    var refType = /* @__PURE__ */ __name((ref) => {
+      if (ref.startsWith("refs/tags/")) {
+        return "tag";
+      }
+      if (ref.startsWith("refs/heads/")) {
+        return "branch";
+      }
+      if (ref.startsWith("refs/pull/")) {
+        return "pull";
+      }
+      if (ref === "HEAD") {
+        return "head";
+      }
+      return "other";
+    }, "refType");
+    var lineToRevDoc = /* @__PURE__ */ __name((line) => {
+      const split = line.trim().split(/\s+/, 2);
+      if (split.length < 2) {
+        return null;
+      }
+      const sha = split[0].trim();
+      const rawRef = split[1].trim();
+      const type = refType(rawRef);
+      if (type === "tag") {
+        const ref = rawRef.slice("refs/tags/".length);
+        return { sha, ref, rawRef, type };
+      }
+      if (type === "branch") {
+        const ref = rawRef.slice("refs/heads/".length);
+        return { sha, ref, rawRef, type };
+      }
+      if (type === "pull") {
+        const ref = rawRef.slice("refs/".length).replace(/\/head$/, "");
+        return { sha, ref, rawRef, type };
+      }
+      if (type === "head") {
+        const ref = "HEAD";
+        return { sha, ref, rawRef, type };
+      }
+      return { sha, ref: rawRef, rawRef, type };
+    }, "lineToRevDoc");
+    var linesToRevsReducer = /* @__PURE__ */ __name((revs, line) => {
+      const doc = lineToRevDoc(line);
+      if (!doc) {
+        return revs;
+      }
+      revs.refs[doc.ref] = doc;
+      revs.refs[doc.rawRef] = doc;
+      if (doc.type === "tag") {
+        const match = !doc.ref.endsWith("^{}") && doc.ref.match(/v?(\d+\.\d+\.\d+(?:[-+].+)?)$/);
+        if (match && semver.valid(match[1], true)) {
+          revs.versions[semver.clean(match[1], true)] = doc;
+        }
+      }
+      return revs;
+    }, "linesToRevsReducer");
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/revs.js
+var require_revs = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/revs.js"(exports2, module2) {
+    var spawn = require_spawn();
+    var { LRUCache } = require_commonjs();
+    var linesToRevs = require_lines_to_revs();
+    var revsCache = new LRUCache({
+      max: 100,
+      ttl: 5 * 60 * 1e3
+    });
+    module2.exports = async (repo, opts = {}) => {
+      if (!opts.noGitRevCache) {
+        const cached = revsCache.get(repo);
+        if (cached) {
+          return cached;
+        }
+      }
+      const { stdout } = await spawn(["ls-remote", repo], opts);
+      const revs = linesToRevs(stdout.trim().split("\n"));
+      revsCache.set(repo, revs);
+      return revs;
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/utils.js"(exports2) {
+    var isWindows = /* @__PURE__ */ __name((opts) => (opts.fakePlatform || process.platform) === "win32", "isWindows");
+    exports2.isWindows = isWindows;
+  }
+});
+
+// node_modules/.pnpm/validate-npm-package-name@6.0.2/node_modules/validate-npm-package-name/lib/index.js
+var require_lib6 = __commonJS({
+  "node_modules/.pnpm/validate-npm-package-name@6.0.2/node_modules/validate-npm-package-name/lib/index.js"(exports2, module2) {
+    "use strict";
+    var { builtinModules: builtins } = require("module");
+    var scopedPackagePattern = new RegExp("^(?:@([^/]+?)[/])?([^/]+?)$");
+    var exclusionList = [
+      "node_modules",
+      "favicon.ico"
+    ];
+    function validate(name) {
+      var warnings = [];
+      var errors = [];
+      if (name === null) {
+        errors.push("name cannot be null");
+        return done(warnings, errors);
+      }
+      if (name === void 0) {
+        errors.push("name cannot be undefined");
+        return done(warnings, errors);
+      }
+      if (typeof name !== "string") {
+        errors.push("name must be a string");
+        return done(warnings, errors);
+      }
+      if (!name.length) {
+        errors.push("name length must be greater than zero");
+      }
+      if (name.startsWith(".")) {
+        errors.push("name cannot start with a period");
+      }
+      if (name.match(/^_/)) {
+        errors.push("name cannot start with an underscore");
+      }
+      if (name.trim() !== name) {
+        errors.push("name cannot contain leading or trailing spaces");
+      }
+      exclusionList.forEach(function(excludedName) {
+        if (name.toLowerCase() === excludedName) {
+          errors.push(excludedName + " is not a valid package name");
+        }
+      });
+      if (builtins.includes(name.toLowerCase())) {
+        warnings.push(name + " is a core module name");
+      }
+      if (name.length > 214) {
+        warnings.push("name can no longer contain more than 214 characters");
+      }
+      if (name.toLowerCase() !== name) {
+        warnings.push("name can no longer contain capital letters");
+      }
+      if (/[~'!()*]/.test(name.split("/").slice(-1)[0])) {
+        warnings.push(`name can no longer contain special characters ("~'!()*")`);
+      }
+      if (encodeURIComponent(name) !== name) {
+        var nameMatch = name.match(scopedPackagePattern);
+        if (nameMatch) {
+          var user = nameMatch[1];
+          var pkg = nameMatch[2];
+          if (pkg.startsWith(".")) {
+            errors.push("name cannot start with a period");
+          }
+          if (encodeURIComponent(user) === user && encodeURIComponent(pkg) === pkg) {
+            return done(warnings, errors);
+          }
+        }
+        errors.push("name can only contain URL-friendly characters");
+      }
+      return done(warnings, errors);
+    }
+    __name(validate, "validate");
+    var done = /* @__PURE__ */ __name(function(warnings, errors) {
+      var result = {
+        validForNewPackages: errors.length === 0 && warnings.length === 0,
+        validForOldPackages: errors.length === 0,
+        warnings,
+        errors
+      };
+      if (!result.warnings.length) {
+        delete result.warnings;
+      }
+      if (!result.errors.length) {
+        delete result.errors;
+      }
+      return result;
+    }, "done");
+    module2.exports = validate;
+  }
+});
+
+// node_modules/.pnpm/npm-package-arg@12.0.2/node_modules/npm-package-arg/lib/npa.js
+var require_npa = __commonJS({
+  "node_modules/.pnpm/npm-package-arg@12.0.2/node_modules/npm-package-arg/lib/npa.js"(exports2, module2) {
+    "use strict";
+    var isWindows = process.platform === "win32";
+    var { URL: URL2 } = require("node:url");
+    var path = isWindows ? require("node:path/win32") : require("node:path");
+    var { homedir } = require("node:os");
+    var HostedGit = require_lib3();
+    var semver = require_semver2();
+    var validatePackageName = require_lib6();
+    var { log } = require_lib2();
+    var hasSlashes = isWindows ? /\\|[/]/ : /[/]/;
+    var isURL = /^(?:git[+])?[a-z]+:/i;
+    var isGit = /^[^@]+@[^:.]+\.[^:]+:.+$/i;
+    var isFileType = /[.](?:tgz|tar.gz|tar)$/i;
+    var isPortNumber = /:[0-9]+(\/|$)/i;
+    var isWindowsFile = /^(?:[.]|~[/]|[/\\]|[a-zA-Z]:)/;
+    var isPosixFile = /^(?:[.]|~[/]|[/]|[a-zA-Z]:)/;
+    var defaultRegistry = "https://registry.npmjs.org";
+    function npa(arg, where) {
+      let name;
+      let spec;
+      if (typeof arg === "object") {
+        if (arg instanceof Result && (!where || where === arg.where)) {
+          return arg;
+        } else if (arg.name && arg.rawSpec) {
+          return npa.resolve(arg.name, arg.rawSpec, where || arg.where);
+        } else {
+          return npa(arg.raw, where || arg.where);
+        }
+      }
+      const nameEndsAt = arg.indexOf("@", 1);
+      const namePart = nameEndsAt > 0 ? arg.slice(0, nameEndsAt) : arg;
+      if (isURL.test(arg)) {
+        spec = arg;
+      } else if (isGit.test(arg)) {
+        spec = `git+ssh://${arg}`;
+      } else if (!namePart.startsWith("@") && (hasSlashes.test(namePart) || isFileType.test(namePart))) {
+        spec = arg;
+      } else if (nameEndsAt > 0) {
+        name = namePart;
+        spec = arg.slice(nameEndsAt + 1) || "*";
+      } else {
+        const valid = validatePackageName(arg);
+        if (valid.validForOldPackages) {
+          name = arg;
+          spec = "*";
+        } else {
+          spec = arg;
+        }
+      }
+      return resolve(name, spec, where, arg);
+    }
+    __name(npa, "npa");
+    function isFileSpec(spec) {
+      if (!spec) {
+        return false;
+      }
+      if (spec.toLowerCase().startsWith("file:")) {
+        return true;
+      }
+      if (isWindows) {
+        return isWindowsFile.test(spec);
+      }
+      return isPosixFile.test(spec);
+    }
+    __name(isFileSpec, "isFileSpec");
+    function isAliasSpec(spec) {
+      if (!spec) {
+        return false;
+      }
+      return spec.toLowerCase().startsWith("npm:");
+    }
+    __name(isAliasSpec, "isAliasSpec");
+    function resolve(name, spec, where, arg) {
+      const res = new Result({
+        raw: arg,
+        name,
+        rawSpec: spec,
+        fromArgument: arg != null
+      });
+      if (name) {
+        res.name = name;
+      }
+      if (!where) {
+        where = process.cwd();
+      }
+      if (isFileSpec(spec)) {
+        return fromFile(res, where);
+      } else if (isAliasSpec(spec)) {
+        return fromAlias(res, where);
+      }
+      const hosted = HostedGit.fromUrl(spec, {
+        noGitPlus: true,
+        noCommittish: true
+      });
+      if (hosted) {
+        return fromHostedGit(res, hosted);
+      } else if (spec && isURL.test(spec)) {
+        return fromURL(res);
+      } else if (spec && (hasSlashes.test(spec) || isFileType.test(spec))) {
+        return fromFile(res, where);
+      } else {
+        return fromRegistry(res);
+      }
+    }
+    __name(resolve, "resolve");
+    function toPurl(arg, reg = defaultRegistry) {
+      const res = npa(arg);
+      if (res.type !== "version") {
+        throw invalidPurlType(res.type, res.raw);
+      }
+      let purl = "pkg:npm/" + res.name.replace(/^@/, "%40") + "@" + res.rawSpec;
+      if (reg !== defaultRegistry) {
+        purl += "?repository_url=" + reg;
+      }
+      return purl;
+    }
+    __name(toPurl, "toPurl");
+    function invalidPackageName(name, valid, raw) {
+      const err = new Error(`Invalid package name "${name}" of package "${raw}": ${valid.errors.join("; ")}.`);
+      err.code = "EINVALIDPACKAGENAME";
+      return err;
+    }
+    __name(invalidPackageName, "invalidPackageName");
+    function invalidTagName(name, raw) {
+      const err = new Error(`Invalid tag name "${name}" of package "${raw}": Tags may not have any characters that encodeURIComponent encodes.`);
+      err.code = "EINVALIDTAGNAME";
+      return err;
+    }
+    __name(invalidTagName, "invalidTagName");
+    function invalidPurlType(type, raw) {
+      const err = new Error(`Invalid type "${type}" of package "${raw}": Purl can only be generated for "version" types.`);
+      err.code = "EINVALIDPURLTYPE";
+      return err;
+    }
+    __name(invalidPurlType, "invalidPurlType");
+    var Result = class {
+      static {
+        __name(this, "Result");
+      }
+      constructor(opts) {
+        this.type = opts.type;
+        this.registry = opts.registry;
+        this.where = opts.where;
+        if (opts.raw == null) {
+          this.raw = opts.name ? `${opts.name}@${opts.rawSpec}` : opts.rawSpec;
+        } else {
+          this.raw = opts.raw;
+        }
+        this.name = void 0;
+        this.escapedName = void 0;
+        this.scope = void 0;
+        this.rawSpec = opts.rawSpec || "";
+        this.saveSpec = opts.saveSpec;
+        this.fetchSpec = opts.fetchSpec;
+        if (opts.name) {
+          this.setName(opts.name);
+        }
+        this.gitRange = opts.gitRange;
+        this.gitCommittish = opts.gitCommittish;
+        this.gitSubdir = opts.gitSubdir;
+        this.hosted = opts.hosted;
+      }
+      // TODO move this to a getter/setter in a semver major
+      setName(name) {
+        const valid = validatePackageName(name);
+        if (!valid.validForOldPackages) {
+          throw invalidPackageName(name, valid, this.raw);
+        }
+        this.name = name;
+        this.scope = name[0] === "@" ? name.slice(0, name.indexOf("/")) : void 0;
+        this.escapedName = name.replace("/", "%2f");
+        return this;
+      }
+      toString() {
+        const full = [];
+        if (this.name != null && this.name !== "") {
+          full.push(this.name);
+        }
+        const spec = this.saveSpec || this.fetchSpec || this.rawSpec;
+        if (spec != null && spec !== "") {
+          full.push(spec);
+        }
+        return full.length ? full.join("@") : this.raw;
+      }
+      toJSON() {
+        const result = Object.assign({}, this);
+        delete result.hosted;
+        return result;
+      }
+    };
+    function setGitAttrs(res, committish) {
+      if (!committish) {
+        res.gitCommittish = null;
+        return;
+      }
+      for (const part of committish.split("::")) {
+        if (!part.includes(":")) {
+          if (res.gitRange) {
+            throw new Error("cannot override existing semver range with a committish");
+          }
+          if (res.gitCommittish) {
+            throw new Error("cannot override existing committish with a second committish");
+          }
+          res.gitCommittish = part;
+          continue;
+        }
+        const [name, value] = part.split(":");
+        if (name === "semver") {
+          if (res.gitCommittish) {
+            throw new Error("cannot override existing committish with a semver range");
+          }
+          if (res.gitRange) {
+            throw new Error("cannot override existing semver range with a second semver range");
+          }
+          res.gitRange = decodeURIComponent(value);
+          continue;
+        }
+        if (name === "path") {
+          if (res.gitSubdir) {
+            throw new Error("cannot override existing path with a second path");
+          }
+          res.gitSubdir = `/${value}`;
+          continue;
+        }
+        log.warn("npm-package-arg", `ignoring unknown key "${name}"`);
+      }
+    }
+    __name(setGitAttrs, "setGitAttrs");
+    var encodedPathChars = /* @__PURE__ */ new Map([
+      ["\0", "%00"],
+      ["	", "%09"],
+      ["\n", "%0A"],
+      ["\r", "%0D"],
+      [" ", "%20"],
+      ['"', "%22"],
+      ["#", "%23"],
+      ["%", "%25"],
+      ["?", "%3F"],
+      ["[", "%5B"],
+      ["\\", isWindows ? "/" : "%5C"],
+      ["]", "%5D"],
+      ["^", "%5E"],
+      ["|", "%7C"],
+      ["~", "%7E"]
+    ]);
+    function pathToFileURL(str) {
+      let result = "";
+      for (let i = 0; i < str.length; i++) {
+        result = `${result}${encodedPathChars.get(str[i]) ?? str[i]}`;
+      }
+      if (result.startsWith("file:")) {
+        return result;
+      }
+      return `file:${result}`;
+    }
+    __name(pathToFileURL, "pathToFileURL");
+    function fromFile(res, where) {
+      res.type = isFileType.test(res.rawSpec) ? "file" : "directory";
+      res.where = where;
+      let rawSpec = pathToFileURL(res.rawSpec);
+      if (rawSpec.startsWith("file:/")) {
+        if (/^file:\/\/[^/]/.test(rawSpec)) {
+          rawSpec = `file:/${rawSpec.slice(5)}`;
+        }
+        if (/^\/{1,3}\.\.?(\/|$)/.test(rawSpec.slice(5))) {
+          rawSpec = rawSpec.replace(/^file:\/{1,3}/, "file:");
+        }
+      }
+      let resolvedUrl;
+      let specUrl;
+      try {
+        resolvedUrl = new URL2(rawSpec, `${pathToFileURL(path.resolve(where))}/`);
+        specUrl = new URL2(rawSpec);
+      } catch (originalError) {
+        const er = new Error("Invalid file: URL, must comply with RFC 8089");
+        throw Object.assign(er, {
+          raw: res.rawSpec,
+          spec: res,
+          where,
+          originalError
+        });
+      }
+      let specPath = decodeURIComponent(specUrl.pathname);
+      let resolvedPath = decodeURIComponent(resolvedUrl.pathname);
+      if (isWindows) {
+        specPath = specPath.replace(/^\/+([a-z]:\/)/i, "$1");
+        resolvedPath = resolvedPath.replace(/^\/+([a-z]:\/)/i, "$1");
+      }
+      if (/^\/~(\/|$)/.test(specPath)) {
+        res.saveSpec = `file:${specPath.substr(1)}`;
+        resolvedPath = path.resolve(homedir(), specPath.substr(3));
+      } else if (!path.isAbsolute(rawSpec.slice(5))) {
+        res.saveSpec = `file:${path.relative(where, resolvedPath)}`;
+      } else {
+        res.saveSpec = `file:${path.resolve(resolvedPath)}`;
+      }
+      res.fetchSpec = path.resolve(where, resolvedPath);
+      res.saveSpec = res.saveSpec.split("\\").join("/");
+      if (res.saveSpec.startsWith("file://")) {
+        res.saveSpec = `file:/${res.saveSpec.slice(7)}`;
+      }
+      return res;
+    }
+    __name(fromFile, "fromFile");
+    function fromHostedGit(res, hosted) {
+      res.type = "git";
+      res.hosted = hosted;
+      res.saveSpec = hosted.toString({ noGitPlus: false, noCommittish: false });
+      res.fetchSpec = hosted.getDefaultRepresentation() === "shortcut" ? null : hosted.toString();
+      setGitAttrs(res, hosted.committish);
+      return res;
+    }
+    __name(fromHostedGit, "fromHostedGit");
+    function unsupportedURLType(protocol, spec) {
+      const err = new Error(`Unsupported URL Type "${protocol}": ${spec}`);
+      err.code = "EUNSUPPORTEDPROTOCOL";
+      return err;
+    }
+    __name(unsupportedURLType, "unsupportedURLType");
+    function fromURL(res) {
+      let rawSpec = res.rawSpec;
+      res.saveSpec = rawSpec;
+      if (rawSpec.startsWith("git+ssh:")) {
+        const matched = rawSpec.match(/^git\+ssh:\/\/([^:#]+:[^#]+(?:\.git)?)(?:#(.*))?$/i);
+        if (matched && !matched[1].match(isPortNumber)) {
+          res.type = "git";
+          setGitAttrs(res, matched[2]);
+          res.fetchSpec = matched[1];
+          return res;
+        }
+      } else if (rawSpec.startsWith("git+file://")) {
+        rawSpec = rawSpec.replace(/\\/g, "/");
+      }
+      const parsedUrl = new URL2(rawSpec);
+      switch (parsedUrl.protocol) {
+        case "git:":
+        case "git+http:":
+        case "git+https:":
+        case "git+rsync:":
+        case "git+ftp:":
+        case "git+file:":
+        case "git+ssh:":
+          res.type = "git";
+          setGitAttrs(res, parsedUrl.hash.slice(1));
+          if (parsedUrl.protocol === "git+file:" && /^git\+file:\/\/[a-z]:/i.test(rawSpec)) {
+            res.fetchSpec = `git+file://${parsedUrl.host.toLowerCase()}:${parsedUrl.pathname}`;
+          } else {
+            parsedUrl.hash = "";
+            res.fetchSpec = parsedUrl.toString();
+          }
+          if (res.fetchSpec.startsWith("git+")) {
+            res.fetchSpec = res.fetchSpec.slice(4);
+          }
+          break;
+        case "http:":
+        case "https:":
+          res.type = "remote";
+          res.fetchSpec = res.saveSpec;
+          break;
+        default:
+          throw unsupportedURLType(parsedUrl.protocol, rawSpec);
+      }
+      return res;
+    }
+    __name(fromURL, "fromURL");
+    function fromAlias(res, where) {
+      const subSpec = npa(res.rawSpec.substr(4), where);
+      if (subSpec.type === "alias") {
+        throw new Error("nested aliases not supported");
+      }
+      if (!subSpec.registry) {
+        throw new Error("aliases only work for registry deps");
+      }
+      if (!subSpec.name) {
+        throw new Error("aliases must have a name");
+      }
+      res.subSpec = subSpec;
+      res.registry = true;
+      res.type = "alias";
+      res.saveSpec = null;
+      res.fetchSpec = null;
+      return res;
+    }
+    __name(fromAlias, "fromAlias");
+    function fromRegistry(res) {
+      res.registry = true;
+      const spec = res.rawSpec.trim();
+      res.saveSpec = null;
+      res.fetchSpec = spec;
+      const version = semver.valid(spec, true);
+      const range = semver.validRange(spec, true);
+      if (version) {
+        res.type = "version";
+      } else if (range) {
+        res.type = "range";
+      } else {
+        if (encodeURIComponent(spec) !== spec) {
+          throw invalidTagName(spec, res.raw);
+        }
+        res.type = "tag";
+      }
+      return res;
+    }
+    __name(fromRegistry, "fromRegistry");
+    module2.exports = npa;
+    module2.exports.resolve = resolve;
+    module2.exports.toPurl = toPurl;
+    module2.exports.Result = Result;
+  }
+});
+
+// node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/current-env.js
+var require_current_env = __commonJS({
+  "node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/current-env.js"(exports2, module2) {
+    var process2 = require("node:process");
+    var nodeOs = require("node:os");
+    var fs = require("node:fs");
+    function isMusl(file) {
+      return file.includes("libc.musl-") || file.includes("ld-musl-");
+    }
+    __name(isMusl, "isMusl");
+    function os() {
+      return process2.platform;
+    }
+    __name(os, "os");
+    function cpu() {
+      return process2.arch;
+    }
+    __name(cpu, "cpu");
+    var LDD_PATH = "/usr/bin/ldd";
+    function getFamilyFromFilesystem() {
+      try {
+        const content = fs.readFileSync(LDD_PATH, "utf-8");
+        if (content.includes("musl")) {
+          return "musl";
+        }
+        if (content.includes("GNU C Library")) {
+          return "glibc";
+        }
+        return null;
+      } catch {
+        return void 0;
+      }
+    }
+    __name(getFamilyFromFilesystem, "getFamilyFromFilesystem");
+    function getFamilyFromReport() {
+      const originalExclude = process2.report.excludeNetwork;
+      process2.report.excludeNetwork = true;
+      const report = process2.report.getReport();
+      process2.report.excludeNetwork = originalExclude;
+      if (report.header?.glibcVersionRuntime) {
+        family = "glibc";
+      } else if (Array.isArray(report.sharedObjects) && report.sharedObjects.some(isMusl)) {
+        family = "musl";
+      } else {
+        family = null;
+      }
+      return family;
+    }
+    __name(getFamilyFromReport, "getFamilyFromReport");
+    var family;
+    function libc(osName) {
+      if (osName !== "linux") {
+        return void 0;
+      }
+      if (family === void 0) {
+        family = getFamilyFromFilesystem();
+        if (family === void 0) {
+          family = getFamilyFromReport();
+        }
+      }
+      return family;
+    }
+    __name(libc, "libc");
+    function devEngines(env = {}) {
+      const osName = env.os || os();
+      return {
+        cpu: {
+          name: env.cpu || cpu()
+        },
+        libc: {
+          name: env.libc || libc(osName)
+        },
+        os: {
+          name: osName,
+          version: env.osVersion || nodeOs.release()
+        },
+        packageManager: {
+          name: "npm",
+          version: env.npmVersion
+        },
+        runtime: {
+          name: "node",
+          version: env.nodeVersion || process2.version
+        }
+      };
+    }
+    __name(devEngines, "devEngines");
+    module2.exports = {
+      cpu,
+      libc,
+      os,
+      devEngines
+    };
+  }
+});
+
+// node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/dev-engines.js
+var require_dev_engines = __commonJS({
+  "node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/dev-engines.js"(exports2, module2) {
+    var satisfies = require_satisfies();
+    var validRange = require_valid2();
+    var recognizedOnFail = [
+      "ignore",
+      "warn",
+      "error",
+      "download"
+    ];
+    var recognizedProperties = [
+      "name",
+      "version",
+      "onFail"
+    ];
+    var recognizedEngines = [
+      "packageManager",
+      "runtime",
+      "cpu",
+      "libc",
+      "os"
+    ];
+    function checkDependency(wanted, current, opts) {
+      const { engine } = opts;
+      if (typeof wanted !== "object" || wanted === null || Array.isArray(wanted)) {
+        throw new Error(`Invalid non-object value for "${engine}"`);
+      }
+      const properties = Object.keys(wanted);
+      for (const prop of properties) {
+        if (!recognizedProperties.includes(prop)) {
+          throw new Error(`Invalid property "${prop}" for "${engine}"`);
+        }
+      }
+      if (!properties.includes("name")) {
+        throw new Error(`Missing "name" property for "${engine}"`);
+      }
+      if (typeof wanted.name !== "string") {
+        throw new Error(`Invalid non-string value for "name" within "${engine}"`);
+      }
+      if (typeof current.name !== "string" || current.name === "") {
+        throw new Error(`Unable to determine "name" for "${engine}"`);
+      }
+      if (properties.includes("onFail")) {
+        if (typeof wanted.onFail !== "string") {
+          throw new Error(`Invalid non-string value for "onFail" within "${engine}"`);
+        }
+        if (!recognizedOnFail.includes(wanted.onFail)) {
+          throw new Error(`Invalid onFail value "${wanted.onFail}" for "${engine}"`);
+        }
+      }
+      if (wanted.name !== current.name) {
+        return new Error(
+          `Invalid name "${wanted.name}" does not match "${current.name}" for "${engine}"`
+        );
+      }
+      if (properties.includes("version")) {
+        if (typeof wanted.version !== "string") {
+          throw new Error(`Invalid non-string value for "version" within "${engine}"`);
+        }
+        if (typeof current.version !== "string" || current.version === "") {
+          throw new Error(`Unable to determine "version" for "${engine}" "${wanted.name}"`);
+        }
+        if (validRange(wanted.version)) {
+          if (!satisfies(current.version, wanted.version, opts.semver)) {
+            return new Error(
+              // eslint-disable-next-line max-len
+              `Invalid semver version "${wanted.version}" does not match "${current.version}" for "${engine}"`
+            );
+          }
+        } else if (wanted.version !== current.version) {
+          return new Error(
+            `Invalid version "${wanted.version}" does not match "${current.version}" for "${engine}"`
+          );
+        }
+      }
+    }
+    __name(checkDependency, "checkDependency");
+    function checkDevEngines(wanted, current = {}, opts = {}) {
+      if (typeof wanted !== "object" || wanted === null || Array.isArray(wanted)) {
+        throw new Error(`Invalid non-object value for "devEngines"`);
+      }
+      const errors = [];
+      for (const engine of Object.keys(wanted)) {
+        if (!recognizedEngines.includes(engine)) {
+          throw new Error(`Invalid property "devEngines.${engine}"`);
+        }
+        const dependencyAsAuthored = wanted[engine];
+        const dependencies = [dependencyAsAuthored].flat();
+        const currentEngine = current[engine] || {};
+        if (dependencies.length === 0) {
+          continue;
+        }
+        const depErrors = [];
+        for (const dep of dependencies) {
+          const result = checkDependency(dep, currentEngine, { ...opts, engine });
+          if (result) {
+            depErrors.push(result);
+          }
+        }
+        const invalid = depErrors.length === dependencies.length;
+        if (invalid) {
+          const lastDependency = dependencies[dependencies.length - 1];
+          let onFail = lastDependency.onFail || "error";
+          if (onFail === "download") {
+            onFail = "error";
+          }
+          const err = Object.assign(new Error(`Invalid devEngines.${engine}`), {
+            errors: depErrors,
+            engine,
+            isWarn: onFail === "warn",
+            isError: onFail === "error",
+            current: currentEngine,
+            required: dependencyAsAuthored
+          });
+          errors.push(err);
+        }
+      }
+      return errors;
+    }
+    __name(checkDevEngines, "checkDevEngines");
+    module2.exports = {
+      checkDevEngines
+    };
+  }
+});
+
+// node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/index.js
+var require_lib7 = __commonJS({
+  "node_modules/.pnpm/npm-install-checks@7.1.2/node_modules/npm-install-checks/lib/index.js"(exports2, module2) {
+    var semver = require_semver2();
+    var currentEnv = require_current_env();
+    var { checkDevEngines } = require_dev_engines();
+    var checkEngine = /* @__PURE__ */ __name((target, npmVer, nodeVer, force = false) => {
+      const nodev = force ? null : nodeVer;
+      const eng = target.engines;
+      const opt = { includePrerelease: true };
+      if (!eng) {
+        return;
+      }
+      const nodeFail = nodev && eng.node && !semver.satisfies(nodev, eng.node, opt);
+      const npmFail = npmVer && eng.npm && !semver.satisfies(npmVer, eng.npm, opt);
+      if (nodeFail || npmFail) {
+        throw Object.assign(new Error("Unsupported engine"), {
+          pkgid: target._id,
+          current: { node: nodeVer, npm: npmVer },
+          required: eng,
+          code: "EBADENGINE"
+        });
+      }
+    }, "checkEngine");
+    var checkPlatform = /* @__PURE__ */ __name((target, force = false, environment = {}) => {
+      if (force) {
+        return;
+      }
+      const os = environment.os || currentEnv.os();
+      const cpu = environment.cpu || currentEnv.cpu();
+      const libc = environment.libc || currentEnv.libc(os);
+      const osOk = target.os ? checkList(os, target.os) : true;
+      const cpuOk = target.cpu ? checkList(cpu, target.cpu) : true;
+      let libcOk = target.libc ? checkList(libc, target.libc) : true;
+      if (target.libc && !libc) {
+        libcOk = false;
+      }
+      if (!osOk || !cpuOk || !libcOk) {
+        throw Object.assign(new Error("Unsupported platform"), {
+          pkgid: target._id,
+          current: {
+            os,
+            cpu,
+            libc
+          },
+          required: {
+            os: target.os,
+            cpu: target.cpu,
+            libc: target.libc
+          },
+          code: "EBADPLATFORM"
+        });
+      }
+    }, "checkPlatform");
+    var checkList = /* @__PURE__ */ __name((value, list) => {
+      if (typeof list === "string") {
+        list = [list];
+      }
+      if (list.length === 1 && list[0] === "any") {
+        return true;
+      }
+      let negated = 0;
+      let match = false;
+      for (const entry of list) {
+        const negate = entry.charAt(0) === "!";
+        const test = negate ? entry.slice(1) : entry;
+        if (negate) {
+          negated++;
+          if (value === test) {
+            return false;
+          }
+        } else {
+          match = match || value === test;
+        }
+      }
+      return match || negated === list.length;
+    }, "checkList");
+    module2.exports = {
+      checkEngine,
+      checkPlatform,
+      checkDevEngines,
+      currentEnv
+    };
+  }
+});
+
+// node_modules/.pnpm/npm-normalize-package-bin@5.0.0/node_modules/npm-normalize-package-bin/lib/index.js
+var require_lib8 = __commonJS({
+  "node_modules/.pnpm/npm-normalize-package-bin@5.0.0/node_modules/npm-normalize-package-bin/lib/index.js"(exports2, module2) {
+    var { join, basename } = require("path");
+    var normalize = /* @__PURE__ */ __name((pkg) => !pkg.bin ? removeBin(pkg) : typeof pkg.bin === "string" ? normalizeString(pkg) : Array.isArray(pkg.bin) ? normalizeArray(pkg) : typeof pkg.bin === "object" ? normalizeObject(pkg) : removeBin(pkg), "normalize");
+    var normalizeString = /* @__PURE__ */ __name((pkg) => {
+      if (!pkg.name) {
+        return removeBin(pkg);
+      }
+      pkg.bin = { [pkg.name]: pkg.bin };
+      return normalizeObject(pkg);
+    }, "normalizeString");
+    var normalizeArray = /* @__PURE__ */ __name((pkg) => {
+      pkg.bin = pkg.bin.reduce((acc, k) => {
+        acc[basename(k)] = k;
+        return acc;
+      }, {});
+      return normalizeObject(pkg);
+    }, "normalizeArray");
+    var removeBin = /* @__PURE__ */ __name((pkg) => {
+      delete pkg.bin;
+      return pkg;
+    }, "removeBin");
+    var normalizeObject = /* @__PURE__ */ __name((pkg) => {
+      const orig = pkg.bin;
+      const clean = {};
+      let hasBins = false;
+      Object.keys(orig).forEach((binKey) => {
+        const base = join("/", basename(binKey.replace(/\\|:/g, "/"))).slice(1);
+        if (typeof orig[binKey] !== "string" || !base) {
+          return;
+        }
+        const binTarget = join("/", orig[binKey].replace(/\\/g, "/")).replace(/\\/g, "/").slice(1);
+        if (!binTarget) {
+          return;
+        }
+        clean[base] = binTarget;
+        hasBins = true;
+      });
+      if (hasBins) {
+        pkg.bin = clean;
+      } else {
+        delete pkg.bin;
+      }
+      return pkg;
+    }, "normalizeObject");
+    module2.exports = normalize;
+  }
+});
+
+// node_modules/.pnpm/npm-pick-manifest@10.0.0/node_modules/npm-pick-manifest/lib/index.js
+var require_lib9 = __commonJS({
+  "node_modules/.pnpm/npm-pick-manifest@10.0.0/node_modules/npm-pick-manifest/lib/index.js"(exports2, module2) {
+    "use strict";
+    var npa = require_npa();
+    var semver = require_semver2();
+    var { checkEngine } = require_lib7();
+    var normalizeBin = require_lib8();
+    var engineOk = /* @__PURE__ */ __name((manifest, npmVersion, nodeVersion) => {
+      try {
+        checkEngine(manifest, npmVersion, nodeVersion);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }, "engineOk");
+    var isBefore = /* @__PURE__ */ __name((verTimes, ver, time) => !verTimes || !verTimes[ver] || Date.parse(verTimes[ver]) <= time, "isBefore");
+    var avoidSemverOpt = { includePrerelease: true, loose: true };
+    var shouldAvoid = /* @__PURE__ */ __name((ver, avoid) => avoid && semver.satisfies(ver, avoid, avoidSemverOpt), "shouldAvoid");
+    var decorateAvoid = /* @__PURE__ */ __name((result, avoid) => result && shouldAvoid(result.version, avoid) ? { ...result, _shouldAvoid: true } : result, "decorateAvoid");
+    var pickManifest = /* @__PURE__ */ __name((packument, wanted, opts) => {
+      const {
+        defaultTag = "latest",
+        before = null,
+        nodeVersion = process.version,
+        npmVersion = null,
+        includeStaged = false,
+        avoid = null,
+        avoidStrict = false
+      } = opts;
+      const { name, time: verTimes } = packument;
+      const versions = packument.versions || {};
+      if (avoidStrict) {
+        const looseOpts = {
+          ...opts,
+          avoidStrict: false
+        };
+        const result = pickManifest(packument, wanted, looseOpts);
+        if (!result || !result._shouldAvoid) {
+          return result;
+        }
+        const caret = pickManifest(packument, `^${result.version}`, looseOpts);
+        if (!caret || !caret._shouldAvoid) {
+          return {
+            ...caret,
+            _outsideDependencyRange: true,
+            _isSemVerMajor: false
+          };
+        }
+        const star = pickManifest(packument, "*", looseOpts);
+        if (!star || !star._shouldAvoid) {
+          return {
+            ...star,
+            _outsideDependencyRange: true,
+            _isSemVerMajor: true
+          };
+        }
+        throw Object.assign(new Error(`No avoidable versions for ${name}`), {
+          code: "ETARGET",
+          name,
+          wanted,
+          avoid,
+          before,
+          versions: Object.keys(versions)
+        });
+      }
+      const staged = includeStaged && packument.stagedVersions && packument.stagedVersions.versions || {};
+      const restricted = packument.policyRestrictions && packument.policyRestrictions.versions || {};
+      const time = before && verTimes ? +new Date(before) : Infinity;
+      const spec = npa.resolve(name, wanted || defaultTag);
+      const type = spec.type;
+      const distTags = packument["dist-tags"] || {};
+      if (type !== "tag" && type !== "version" && type !== "range") {
+        throw new Error("Only tag, version, and range are supported");
+      }
+      if (wanted && type === "tag") {
+        const ver = distTags[wanted];
+        if (isBefore(verTimes, ver, time)) {
+          return decorateAvoid(versions[ver] || staged[ver] || restricted[ver], avoid);
+        } else {
+          return pickManifest(packument, `<=${ver}`, opts);
+        }
+      }
+      if (wanted && type === "version") {
+        const ver = semver.clean(wanted, { loose: true });
+        const mani = versions[ver] || staged[ver] || restricted[ver];
+        return isBefore(verTimes, ver, time) ? decorateAvoid(mani, avoid) : null;
+      }
+      const range = type === "range" ? wanted : "*";
+      const defaultVer = distTags[defaultTag];
+      if (defaultVer && (range === "*" || semver.satisfies(defaultVer, range, { loose: true })) && !restricted[defaultVer] && !shouldAvoid(defaultVer, avoid)) {
+        const mani = versions[defaultVer];
+        const ok = mani && isBefore(verTimes, defaultVer, time) && engineOk(mani, npmVersion, nodeVersion) && !mani.deprecated && !staged[defaultVer];
+        if (ok) {
+          return mani;
+        }
+      }
+      const allEntries = Object.entries(versions).concat(Object.entries(staged)).concat(Object.entries(restricted)).filter(([ver]) => isBefore(verTimes, ver, time));
+      if (!allEntries.length) {
+        throw Object.assign(new Error(`No versions available for ${name}`), {
+          code: "ENOVERSIONS",
+          name,
+          type,
+          wanted,
+          before,
+          versions: Object.keys(versions)
+        });
+      }
+      const sortSemverOpt = { loose: true };
+      const entries = allEntries.filter(([ver]) => semver.satisfies(ver, range, { loose: true })).sort((a, b) => {
+        const [vera, mania] = a;
+        const [verb, manib] = b;
+        const notavoida = !shouldAvoid(vera, avoid);
+        const notavoidb = !shouldAvoid(verb, avoid);
+        const notrestra = !restricted[vera];
+        const notrestrb = !restricted[verb];
+        const notstagea = !staged[vera];
+        const notstageb = !staged[verb];
+        const notdepra = !mania.deprecated;
+        const notdeprb = !manib.deprecated;
+        const enginea = engineOk(mania, npmVersion, nodeVersion);
+        const engineb = engineOk(manib, npmVersion, nodeVersion);
+        return notavoidb - notavoida || notrestrb - notrestra || notstageb - notstagea || (notdeprb && engineb) - (notdepra && enginea) || engineb - enginea || notdeprb - notdepra || semver.rcompare(vera, verb, sortSemverOpt);
+      });
+      return decorateAvoid(entries[0] && entries[0][1], avoid);
+    }, "pickManifest");
+    module2.exports = (packument, wanted, opts = {}) => {
+      const mani = pickManifest(packument, wanted, opts);
+      const picked = mani && normalizeBin(mani);
+      const policyRestrictions = packument.policyRestrictions;
+      const restricted = policyRestrictions && policyRestrictions.versions || {};
+      if (picked && !restricted[picked.version]) {
+        return picked;
+      }
+      const { before = null, defaultTag = "latest" } = opts;
+      const bstr = before ? new Date(before).toLocaleString() : "";
+      const { name } = packument;
+      const pckg = `${name}@${wanted}` + (before ? ` with a date before ${bstr}` : "");
+      const isForbidden = picked && !!restricted[picked.version];
+      const polMsg = isForbidden ? policyRestrictions.message : "";
+      const msg = !isForbidden ? `No matching version found for ${pckg}.` : `Could not download ${pckg} due to policy violations:
+${polMsg}`;
+      const code = isForbidden ? "E403" : "ETARGET";
+      throw Object.assign(new Error(msg), {
+        code,
+        type: npa.resolve(packument.name, wanted).type,
+        wanted,
+        versions: Object.keys(packument.versions ?? {}),
+        name,
+        distTags: packument["dist-tags"],
+        defaultTag
+      });
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/clone.js
+var require_clone = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/clone.js"(exports2, module2) {
+    var shallowHosts = /* @__PURE__ */ new Set([
+      "github.com",
+      "gist.github.com",
+      "gitlab.com",
+      "bitbucket.com",
+      "bitbucket.org"
+    ]);
+    var { parse } = require("url");
+    var path = require("path");
+    var getRevs = require_revs();
+    var spawn = require_spawn();
+    var { isWindows } = require_utils();
+    var pickManifest = require_lib9();
+    var fs = require("fs/promises");
+    module2.exports = (repo, ref = "HEAD", target = null, opts = {}) => getRevs(repo, opts).then((revs) => clone(
+      repo,
+      revs,
+      ref,
+      resolveRef(revs, ref, opts),
+      target || defaultTarget(repo, opts.cwd),
+      opts
+    ));
+    var maybeShallow = /* @__PURE__ */ __name((repo, opts) => {
+      if (opts.gitShallow === false || opts.gitShallow) {
+        return opts.gitShallow;
+      }
+      return shallowHosts.has(parse(repo).host);
+    }, "maybeShallow");
+    var defaultTarget = /* @__PURE__ */ __name((repo, cwd = process.cwd()) => path.resolve(cwd, path.basename(repo.replace(/[/\\]?\.git$/, ""))), "defaultTarget");
+    var clone = /* @__PURE__ */ __name((repo, revs, ref, revDoc, target, opts) => {
+      if (!revDoc) {
+        return unresolved(repo, ref, target, opts);
+      }
+      if (revDoc.sha === revs.refs.HEAD.sha) {
+        return plain(repo, revDoc, target, opts);
+      }
+      if (revDoc.type === "tag" || revDoc.type === "branch") {
+        return branch(repo, revDoc, target, opts);
+      }
+      return other(repo, revDoc, target, opts);
+    }, "clone");
+    var resolveRef = /* @__PURE__ */ __name((revs, ref, opts) => {
+      const { spec = {} } = opts;
+      ref = spec.gitCommittish || ref;
+      if (!revs) {
+        return null;
+      }
+      if (spec.gitRange) {
+        return pickManifest(revs, spec.gitRange, opts);
+      }
+      if (!ref) {
+        return revs.refs.HEAD;
+      }
+      if (revs.refs[ref]) {
+        return revs.refs[ref];
+      }
+      if (revs.shas[ref]) {
+        return revs.refs[revs.shas[ref][0]];
+      }
+      return null;
+    }, "resolveRef");
+    var other = /* @__PURE__ */ __name((repo, revDoc, target, opts) => {
+      const shallow = maybeShallow(repo, opts);
+      const fetchOrigin = ["fetch", "origin", revDoc.rawRef].concat(shallow ? ["--depth=1"] : []);
+      const git = /* @__PURE__ */ __name((args) => spawn(args, { ...opts, cwd: target }), "git");
+      return fs.mkdir(target, { recursive: true }).then(() => git(["init"])).then(() => isWindows(opts) ? git(["config", "--local", "--add", "core.longpaths", "true"]) : null).then(() => git(["remote", "add", "origin", repo])).then(() => git(fetchOrigin)).then(() => git(["checkout", revDoc.sha])).then(() => updateSubmodules(target, opts)).then(() => revDoc.sha);
+    }, "other");
+    var branch = /* @__PURE__ */ __name((repo, revDoc, target, opts) => {
+      const args = [
+        "clone",
+        "-b",
+        revDoc.ref,
+        repo,
+        target,
+        "--recurse-submodules"
+      ];
+      if (maybeShallow(repo, opts)) {
+        args.push("--depth=1");
+      }
+      if (isWindows(opts)) {
+        args.push("--config", "core.longpaths=true");
+      }
+      return spawn(args, opts).then(() => revDoc.sha);
+    }, "branch");
+    var plain = /* @__PURE__ */ __name((repo, revDoc, target, opts) => {
+      const args = [
+        "clone",
+        repo,
+        target,
+        "--recurse-submodules"
+      ];
+      if (maybeShallow(repo, opts)) {
+        args.push("--depth=1");
+      }
+      if (isWindows(opts)) {
+        args.push("--config", "core.longpaths=true");
+      }
+      return spawn(args, opts).then(() => revDoc.sha);
+    }, "plain");
+    var updateSubmodules = /* @__PURE__ */ __name(async (target, opts) => {
+      const hasSubmodules = await fs.stat(`${target}/.gitmodules`).then(() => true).catch(() => false);
+      if (!hasSubmodules) {
+        return null;
+      }
+      return spawn([
+        "submodule",
+        "update",
+        "-q",
+        "--init",
+        "--recursive"
+      ], { ...opts, cwd: target });
+    }, "updateSubmodules");
+    var unresolved = /* @__PURE__ */ __name((repo, ref, target, opts) => {
+      const lp = isWindows(opts) ? ["--config", "core.longpaths=true"] : [];
+      const cloneArgs = ["clone", "--mirror", "-q", repo, target + "/.git"];
+      const git = /* @__PURE__ */ __name((args) => spawn(args, { ...opts, cwd: target }), "git");
+      return fs.mkdir(target, { recursive: true }).then(() => git(cloneArgs.concat(lp))).then(() => git(["init"])).then(() => git(["checkout", ref])).then(() => updateSubmodules(target, opts)).then(() => git(["rev-parse", "--revs-only", "HEAD"])).then(({ stdout }) => stdout.trim());
+    }, "unresolved");
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/is.js
+var require_is = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/is.js"(exports2, module2) {
+    var { stat } = require("fs/promises");
+    module2.exports = ({ cwd = process.cwd() } = {}) => stat(cwd + "/.git").then(() => true, () => false);
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/find.js
+var require_find = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/find.js"(exports2, module2) {
+    var is = require_is();
+    var { dirname } = require("path");
+    module2.exports = async ({ cwd = process.cwd(), root } = {}) => {
+      while (true) {
+        if (await is({ cwd })) {
+          return cwd;
+        }
+        const next = dirname(cwd);
+        if (cwd === root || cwd === next) {
+          return null;
+        }
+        cwd = next;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/is-clean.js
+var require_is_clean = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/is-clean.js"(exports2, module2) {
+    var spawn = require_spawn();
+    module2.exports = (opts = {}) => spawn(["status", "--porcelain=v1", "-uno"], opts).then((res) => !res.stdout.trim().split(/\r?\n+/).map((l) => l.trim()).filter((l) => l).length);
+  }
+});
+
+// node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/index.js
+var require_lib10 = __commonJS({
+  "node_modules/.pnpm/@npmcli+git@6.0.3/node_modules/@npmcli/git/lib/index.js"(exports2, module2) {
+    module2.exports = {
+      clone: require_clone(),
+      revs: require_revs(),
+      spawn: require_spawn(),
+      is: require_is(),
+      find: require_find(),
+      isClean: require_is_clean(),
+      errors: require_errors()
+    };
   }
 });
 
@@ -10484,7 +14443,7 @@ var require_normalize = __commonJS({
         normalizePackageBin(data, changes);
       }
       if (steps.includes("gitHead") && !data.gitHead) {
-        const git = require_git();
+        const git = require_lib10();
         const gitRoot = await git.find({ cwd: pkg.path, root });
         let head;
         if (gitRoot) {
@@ -10611,7 +14570,7 @@ var require_read_package = __commonJS({
 });
 
 // node_modules/.pnpm/@npmcli+package-json@7.0.0/node_modules/@npmcli/package-json/lib/sort.js
-var require_sort = __commonJS({
+var require_sort2 = __commonJS({
   "node_modules/.pnpm/@npmcli+package-json@7.0.0/node_modules/@npmcli/package-json/lib/sort.js"(exports2, module2) {
     function packageSort(json) {
       const {
@@ -10709,7 +14668,7 @@ var require_sort = __commonJS({
 });
 
 // node_modules/.pnpm/@npmcli+package-json@7.0.0/node_modules/@npmcli/package-json/lib/index.js
-var require_lib4 = __commonJS({
+var require_lib11 = __commonJS({
   "node_modules/.pnpm/@npmcli+package-json@7.0.0/node_modules/@npmcli/package-json/lib/index.js"(exports2, module2) {
     var { readFile, writeFile } = require("node:fs/promises");
     var { resolve } = require("node:path");
@@ -10719,7 +14678,7 @@ var require_lib4 = __commonJS({
     var updateWorkspaces = require_update_workspaces();
     var { normalize, syncNormalize } = require_normalize();
     var { read, parse } = require_read_package();
-    var { packageSort } = require_sort();
+    var { packageSort } = require_sort2();
     var knownSteps = /* @__PURE__ */ new Set([
       updateDeps,
       updateScripts,
@@ -10965,4 +14924,4 @@ var require_lib4 = __commonJS({
 });
 
 // src/external/@npmcli/package-json.js
-module.exports = require_lib4();
+module.exports = require_lib11();