@qwen-code/qwen-code 0.20.0-nightly.20260722.b98306b7e → 0.20.0

package/chunks/{chunk-67SZUDUH.js → chunk-542SK7KV.js}

@@ -8,18 +8,21 @@ import {
 } from "./chunk-QHTIBUWB.js";
 import {
   t
-} from "./chunk-3FML67YK.js";
-import {
-  require_diff,
-  require_gt,
-  require_semver
-} from "./chunk-XHATNRQA.js";
-import {
-  getNpmCliPath
-} from "./chunk-5TSCAYXT.js";
+} from "./chunk-TKLLK6XQ.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";
+import {
+  require_clean,
+  require_constants,
+  require_debug,
+  require_identifiers,
+  require_parse,
+  require_parse_options,
+  require_re,
+  require_semver,
+  require_valid
+} from "./chunk-URK542T4.js";
 import {
   ansi_regex_exports,
   init_ansi_regex,
@@ -30,7 +33,7 @@ import {
 } from "./chunk-E2UVIFI2.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-C27BYUX6.js";
 import {
   __qwen_dirname,
   init_esbuild_shims
@@ -43,6 +46,73 @@ import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";
 
+// node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "node_modules/semver/functions/diff.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = diff;
+  }
+});
+
+// node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var SemVer = require_semver();
+    var compare = /* @__PURE__ */ __name((a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose)), "compare");
+    module.exports = compare;
+  }
+});
+
+// node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "node_modules/semver/functions/gt.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var gt = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) > 0, "gt");
+    module.exports = gt;
+  }
+});
+
 // node_modules/rc/node_modules/ini/ini.js
 var require_ini = __commonJS({
   "node_modules/rc/node_modules/ini/ini.js"(exports) {
@@ -289,7 +359,7 @@ var require_utils = __commonJS({
     init_esbuild_shims();
     var fs5 = __require("fs");
     var ini2 = require_ini();
-    var path10 = __require("path");
+    var path9 = __require("path");
     var stripJsonComments = require_strip_json_comments();
     var parse = exports.parse = function(content) {
       if (/^\s*{/.test(content))
@@ -303,7 +373,7 @@ var require_utils = __commonJS({
       for (var i in args)
         if ("string" !== typeof args[i])
           return;
-      var file2 = path10.join.apply(null, args);
+      var file2 = path9.join.apply(null, args);
       var content;
       try {
         return fs5.readFileSync(file2, "utf-8");
@@ -341,15 +411,15 @@ var require_utils = __commonJS({
       return obj;
     };
     var find = exports.find = function() {
-      var rel = path10.join.apply(null, [].slice.call(arguments));
+      var rel = path9.join.apply(null, [].slice.call(arguments));
       function find2(start, rel2) {
-        var file2 = path10.join(start, rel2);
+        var file2 = path9.join(start, rel2);
         try {
           fs5.statSync(file2);
           return file2;
         } catch (err) {
-          if (path10.dirname(start) !== start)
-            return find2(path10.dirname(start), rel2);
+          if (path9.dirname(start) !== start)
+            return find2(path9.dirname(start), rel2);
         }
       }
       __name(find2, "find");
@@ -781,14 +851,14 @@ var require_polyfills = __commonJS({
       fs5.fstatSync = statFixSync(fs5.fstatSync);
       fs5.lstatSync = statFixSync(fs5.lstatSync);
       if (fs5.chmod && !fs5.lchmod) {
-        fs5.lchmod = function(path10, mode, cb) {
+        fs5.lchmod = function(path9, mode, cb) {
           if (cb) process.nextTick(cb);
         };
         fs5.lchmodSync = function() {
         };
       }
       if (fs5.chown && !fs5.lchown) {
-        fs5.lchown = function(path10, uid, gid, cb) {
+        fs5.lchown = function(path9, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
         fs5.lchownSync = function() {
@@ -857,9 +927,9 @@ var require_polyfills = __commonJS({
         };
       }(fs5.readSync);
       function patchLchmod(fs6) {
-        fs6.lchmod = function(path10, mode, callback) {
+        fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
-            path10,
+            path9,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -875,8 +945,8 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs6.lchmodSync = function(path10, mode) {
-          var fd = fs6.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs6.lchmodSync = function(path9, mode) {
+          var fd = fs6.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -898,8 +968,8 @@ var require_polyfills = __commonJS({
       __name(patchLchmod, "patchLchmod");
       function patchLutimes(fs6) {
         if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
-          fs6.lutimes = function(path10, at, mt, cb) {
-            fs6.open(path10, constants.O_SYMLINK, function(er, fd) {
+          fs6.lutimes = function(path9, at, mt, cb) {
+            fs6.open(path9, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -911,8 +981,8 @@ var require_polyfills = __commonJS({
               });
             });
           };
-          fs6.lutimesSync = function(path10, at, mt) {
-            var fd = fs6.openSync(path10, constants.O_SYMLINK);
+          fs6.lutimesSync = function(path9, at, mt) {
+            var fd = fs6.openSync(path9, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -1041,11 +1111,11 @@ var require_legacy_streams = __commonJS({
         ReadStream,
         WriteStream
       };
-      function ReadStream(path10, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path10, options);
+      function ReadStream(path9, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
         Stream.call(this);
         var self = this;
-        this.path = path10;
+        this.path = path9;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -1091,10 +1161,10 @@ var require_legacy_streams = __commonJS({
         });
       }
       __name(ReadStream, "ReadStream");
-      function WriteStream(path10, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path10, options);
+      function WriteStream(path9, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
         Stream.call(this);
-        this.path = path10;
+        this.path = path9;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -1246,14 +1316,14 @@ var require_graceful_fs2 = __commonJS({
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
       fs6.readFile = readFile;
-      function readFile(path10, options, cb) {
+      function readFile(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path10, options, cb);
-        function go$readFile(path11, options2, cb2, startTime) {
-          return fs$readFile(path11, options2, function(err) {
+        return go$readFile(path9, options, cb);
+        function go$readFile(path10, options2, cb2, startTime) {
+          return fs$readFile(path10, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1265,14 +1335,14 @@ var require_graceful_fs2 = __commonJS({
       __name(readFile, "readFile");
       var fs$writeFile = fs6.writeFile;
       fs6.writeFile = writeFile;
-      function writeFile(path10, data, options, cb) {
+      function writeFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path10, data, options, cb);
-        function go$writeFile(path11, data2, options2, cb2, startTime) {
-          return fs$writeFile(path11, data2, options2, function(err) {
+        return go$writeFile(path9, data, options, cb);
+        function go$writeFile(path10, data2, options2, cb2, startTime) {
+          return fs$writeFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1285,14 +1355,14 @@ var require_graceful_fs2 = __commonJS({
       var fs$appendFile = fs6.appendFile;
       if (fs$appendFile)
         fs6.appendFile = appendFile;
-      function appendFile(path10, data, options, cb) {
+      function appendFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path10, data, options, cb);
-        function go$appendFile(path11, data2, options2, cb2, startTime) {
-          return fs$appendFile(path11, data2, options2, function(err) {
+        return go$appendFile(path9, data, options, cb);
+        function go$appendFile(path10, data2, options2, cb2, startTime) {
+          return fs$appendFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1327,31 +1397,31 @@ var require_graceful_fs2 = __commonJS({
       var fs$readdir = fs6.readdir;
       fs6.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path10, options, cb) {
+      function readdir(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path11, options2, cb2, startTime) {
-          return fs$readdir(path11, fs$readdirCallback(
-            path11,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? /* @__PURE__ */ __name(function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
-        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path11, options2, cb2, startTime) {
-          return fs$readdir(path11, options2, fs$readdirCallback(
-            path11,
+        }, "go$readdir") : /* @__PURE__ */ __name(function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, options2, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
         }, "go$readdir");
-        return go$readdir(path10, options, cb);
-        function fs$readdirCallback(path11, options2, cb2, startTime) {
+        return go$readdir(path9, options, cb);
+        function fs$readdirCallback(path10, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path11, options2, cb2],
+                [path10, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -1424,7 +1494,7 @@ var require_graceful_fs2 = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path10, options) {
+      function ReadStream(path9, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -1446,7 +1516,7 @@ var require_graceful_fs2 = __commonJS({
         });
       }
       __name(ReadStream$open, "ReadStream$open");
-      function WriteStream(path10, options) {
+      function WriteStream(path9, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -1466,24 +1536,24 @@ var require_graceful_fs2 = __commonJS({
         });
       }
       __name(WriteStream$open, "WriteStream$open");
-      function createReadStream(path10, options) {
-        return new fs6.ReadStream(path10, options);
+      function createReadStream(path9, options) {
+        return new fs6.ReadStream(path9, options);
       }
       __name(createReadStream, "createReadStream");
-      function createWriteStream(path10, options) {
-        return new fs6.WriteStream(path10, options);
+      function createWriteStream(path9, options) {
+        return new fs6.WriteStream(path9, options);
       }
       __name(createWriteStream, "createWriteStream");
       var fs$open = fs6.open;
       fs6.open = open;
-      function open(path10, flags, mode, cb) {
+      function open(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path10, flags, mode, cb);
-        function go$open(path11, flags2, mode2, cb2, startTime) {
-          return fs$open(path11, flags2, mode2, function(err, fd) {
+        return go$open(path9, flags, mode, cb);
+        function go$open(path10, flags2, mode2, cb2, startTime) {
+          return fs$open(path10, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -1878,7 +1948,7 @@ var require_config_chain = __commonJS({
   "node_modules/config-chain/index.js"(exports, module) {
     init_esbuild_shims();
     var ProtoList = require_proto_list();
-    var path10 = __require("path");
+    var path9 = __require("path");
     var fs5 = __require("fs");
     var ini2 = require_ini2();
     var EE = __require("events").EventEmitter;
@@ -1893,15 +1963,15 @@ var require_config_chain = __commonJS({
       return conf;
     };
     var find = exports.find = function() {
-      var rel = path10.join.apply(null, [].slice.call(arguments));
+      var rel = path9.join.apply(null, [].slice.call(arguments));
       function find2(start, rel2) {
-        var file = path10.join(start, rel2);
+        var file = path9.join(start, rel2);
         try {
           fs5.statSync(file);
           return file;
         } catch (err) {
-          if (path10.dirname(start) !== start)
-            return find2(path10.dirname(start), rel2);
+          if (path9.dirname(start) !== start)
+            return find2(path9.dirname(start), rel2);
         }
       }
       __name(find2, "find");
@@ -1933,7 +2003,7 @@ var require_config_chain = __commonJS({
       var args = [].slice.call(arguments).filter(function(arg) {
         return arg != null;
       });
-      var file = path10.join.apply(null, args);
+      var file = path9.join.apply(null, args);
       var content;
       try {
         content = fs5.readFileSync(file, "utf-8");
@@ -2204,7 +2274,7 @@ var require_util = __commonJS({
     "use strict";
     init_esbuild_shims();
     var fs5 = __require("fs");
-    var path10 = __require("path");
+    var path9 = __require("path");
     var { envReplace } = require_dist2();
     var parseKey = /* @__PURE__ */ __name((key) => {
       if (typeof key !== "string") {
@@ -2217,7 +2287,7 @@ var require_util = __commonJS({
         return field;
       }
       const typeList = [].concat(types[key]);
-      const isPath = typeList.indexOf(path10) !== -1;
+      const isPath = typeList.indexOf(path9) !== -1;
       const isBool = typeList.indexOf(Boolean) !== -1;
       const isString2 = typeList.indexOf(String) !== -1;
       const isNumber = typeList.indexOf(Number) !== -1;
@@ -2251,9 +2321,9 @@ var require_util = __commonJS({
       if (isPath) {
         const regex = process.platform === "win32" ? /^~(\/|\\)/ : /^~\//;
         if (regex.test(field) && process.env.HOME) {
-          field = path10.resolve(process.env.HOME, field.substr(2));
+          field = path9.resolve(process.env.HOME, field.substr(2));
         }
-        field = path10.resolve(field);
+        field = path9.resolve(field);
       }
       if (isNumber && !isNaN(field)) {
         field = Number(field);
@@ -2261,10 +2331,10 @@ var require_util = __commonJS({
       return field;
     }, "parseField");
     var findPrefix = /* @__PURE__ */ __name((name) => {
-      name = path10.resolve(name);
+      name = path9.resolve(name);
       let walkedUp = false;
-      while (path10.basename(name) === "node_modules") {
-        name = path10.dirname(name);
+      while (path9.basename(name) === "node_modules") {
+        name = path9.dirname(name);
         walkedUp = true;
       }
       if (walkedUp) {
@@ -2280,7 +2350,7 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname = path10.dirname(name2);
+          const dirname = path9.dirname(name2);
           if (dirname === name2) {
             return original;
           }
@@ -2309,7 +2379,7 @@ var require_types = __commonJS({
   "node_modules/@pnpm/npm-conf/lib/types.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var path10 = __require("path");
+    var path9 = __require("path");
     var Stream = __require("stream").Stream;
     var url = __require("url");
     var Umask = /* @__PURE__ */ __name(() => {
@@ -2327,8 +2397,8 @@ var require_types = __commonJS({
       "bin-links": Boolean,
       browser: [null, String],
       ca: [null, String, Array],
-      cafile: path10,
-      cache: path10,
+      cafile: path9,
+      cache: path9,
       "cache-lock-stale": Number,
       "cache-lock-retries": Number,
       "cache-lock-wait": Number,
@@ -2352,7 +2422,7 @@ var require_types = __commonJS({
       "git-tag-version": Boolean,
       "commit-hooks": Boolean,
       global: Boolean,
-      globalconfig: path10,
+      globalconfig: path9,
       "global-style": Boolean,
       group: [Number, String],
       "https-proxy": [null, url],
@@ -2362,7 +2432,7 @@ var require_types = __commonJS({
       "if-present": Boolean,
       "ignore-prepublish": Boolean,
       "ignore-scripts": Boolean,
-      "init-module": path10,
+      "init-module": path9,
       "init-author-name": String,
       "init-author-email": String,
       "init-author-url": ["", url],
@@ -2395,7 +2465,7 @@ var require_types = __commonJS({
       parseable: Boolean,
       "prefer-offline": Boolean,
       "prefer-online": Boolean,
-      prefix: path10,
+      prefix: path9,
       production: Boolean,
       progress: Boolean,
       proxy: [null, false, url],
@@ -2428,12 +2498,12 @@ var require_types = __commonJS({
       "strict-ssl": Boolean,
       tag: String,
       timing: Boolean,
-      tmp: path10,
+      tmp: path9,
       unicode: Boolean,
       "unsafe-perm": Boolean,
       usage: Boolean,
       user: [Number, String],
-      userconfig: path10,
+      userconfig: path9,
       umask: Umask,
       version: Boolean,
       "tag-version-prefix": String,
@@ -2451,7 +2521,7 @@ var require_conf = __commonJS({
     init_esbuild_shims();
     var { readCAFileSync } = require_dist();
     var fs5 = __require("fs");
-    var path10 = __require("path");
+    var path9 = __require("path");
     var { ConfigChain } = require_config_chain();
     var envKeyToSetting = require_envKeyToSetting();
     var util = require_util();
@@ -2532,7 +2602,7 @@ var require_conf = __commonJS({
             this.set("prefix", prefix);
           }, "set"),
           get: /* @__PURE__ */ __name(() => {
-            return path10.resolve(this.get("prefix"));
+            return path9.resolve(this.get("prefix"));
           }, "get")
         });
         let p;
@@ -2546,7 +2616,7 @@ var require_conf = __commonJS({
           }, "get")
         });
         if (Object.prototype.hasOwnProperty.call(cli, "prefix")) {
-          p = path10.resolve(cli.prefix);
+          p = path9.resolve(cli.prefix);
         } else {
           try {
             const prefix = util.findPrefix(process.cwd());
@@ -2577,7 +2647,7 @@ var require_conf = __commonJS({
           defConf.user = Number(process.env.SUDO_UID);
           return;
         }
-        const prefix = path10.resolve(this.get("prefix"));
+        const prefix = path9.resolve(this.get("prefix"));
         try {
           const stats = fs5.statSync(prefix);
           defConf.user = stats.uid;
@@ -2616,7 +2686,7 @@ var require_defaults = __commonJS({
     "use strict";
     init_esbuild_shims();
     var os6 = __require("os");
-    var path10 = __require("path");
+    var path9 = __require("path");
     var temp = os6.tmpdir();
     var uidOrPid = process.getuid ? process.getuid() : process.pid;
     var hasUnicode = /* @__PURE__ */ __name(() => true, "hasUnicode");
@@ -2632,11 +2702,11 @@ var require_defaults = __commonJS({
     if (home) {
       process.env.HOME = home;
     } else {
-      home = path10.resolve(temp, "npm-" + uidOrPid);
+      home = path9.resolve(temp, "npm-" + uidOrPid);
     }
     var cacheExtra = process.platform === "win32" ? "npm-cache" : ".npm";
     var cacheRoot = process.platform === "win32" && process.env.APPDATA || home;
-    var cache = path10.resolve(cacheRoot, cacheExtra);
+    var cache = path9.resolve(cacheRoot, cacheExtra);
     var defaults;
     var globalPrefix;
     Object.defineProperty(exports, "defaults", {
@@ -2645,11 +2715,11 @@ var require_defaults = __commonJS({
         if (process.env.PREFIX) {
           globalPrefix = process.env.PREFIX;
         } else if (process.platform === "win32") {
-          globalPrefix = path10.dirname(process.execPath);
+          globalPrefix = path9.dirname(process.execPath);
         } else {
-          globalPrefix = path10.dirname(path10.dirname(process.execPath));
+          globalPrefix = path9.dirname(path9.dirname(process.execPath));
           if (process.env.DESTDIR) {
-            globalPrefix = path10.join(process.env.DESTDIR, globalPrefix);
+            globalPrefix = path9.join(process.env.DESTDIR, globalPrefix);
           }
         }
         defaults = {
@@ -2687,7 +2757,7 @@ var require_defaults = __commonJS({
           "git-tag-version": true,
           "commit-hooks": true,
           global: false,
-          globalconfig: path10.resolve(globalPrefix, "etc", "npmrc"),
+          globalconfig: path9.resolve(globalPrefix, "etc", "npmrc"),
           "global-style": false,
           group: process.platform === "win32" ? 0 : process.env.SUDO_GID || process.getgid && process.getgid(),
           "ham-it-up": false,
@@ -2695,7 +2765,7 @@ var require_defaults = __commonJS({
           "if-present": false,
           "ignore-prepublish": false,
           "ignore-scripts": false,
-          "init-module": path10.resolve(home, ".npm-init.js"),
+          "init-module": path9.resolve(home, ".npm-init.js"),
           "init-author-name": "",
           "init-author-email": "",
           "init-author-url": "",
@@ -2766,7 +2836,7 @@ var require_defaults = __commonJS({
           "unsafe-perm": process.platform === "win32" || process.platform === "cygwin" || !(process.getuid && process.setuid && process.getgid && process.setgid) || process.getuid() !== 0,
           usage: false,
           user: process.platform === "win32" ? 0 : "nobody",
-          userconfig: path10.resolve(home, ".npmrc"),
+          userconfig: path9.resolve(home, ".npmrc"),
           umask: process.umask ? process.umask() : umask.fromString("022"),
           version: false,
           versions: false,
@@ -2784,7 +2854,7 @@ var require_npm_conf = __commonJS({
   "node_modules/@pnpm/npm-conf/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    var path10 = __require("path");
+    var path9 = __require("path");
     var Conf = require_conf();
     var _defaults = require_defaults();
     module.exports = (opts, types, defaults) => {
@@ -2801,12 +2871,12 @@ var require_npm_conf = __commonJS({
           failedToLoadBuiltInConfig = true;
         }
         if (npmPath) {
-          warnings.push(conf.addFile(path10.resolve(path10.dirname(npmPath), "..", "npmrc"), "builtin"));
+          warnings.push(conf.addFile(path9.resolve(path9.dirname(npmPath), "..", "npmrc"), "builtin"));
         }
       }
       conf.addEnv();
       conf.loadPrefix();
-      const projectConf = path10.resolve(conf.localPrefix, ".npmrc");
+      const projectConf = path9.resolve(conf.localPrefix, ".npmrc");
       const userConf = conf.get("userconfig");
       if (!conf.get("global") && projectConf !== userConf) {
         warnings.push(conf.addFile(projectConf, "project"));
@@ -2814,14 +2884,14 @@ var require_npm_conf = __commonJS({
         conf.add({}, "project");
       }
       if (conf.get("workspace-prefix") && conf.get("workspace-prefix") !== projectConf) {
-        const workspaceConf = path10.resolve(conf.get("workspace-prefix"), ".npmrc");
+        const workspaceConf = path9.resolve(conf.get("workspace-prefix"), ".npmrc");
         warnings.push(conf.addFile(workspaceConf, "workspace"));
       }
       warnings.push(conf.addFile(conf.get("userconfig"), "user"));
       if (conf.get("prefix")) {
-        const etc = path10.resolve(conf.get("prefix"), "etc");
-        conf.root.globalconfig = path10.resolve(etc, "npmrc");
-        conf.root.globalignorefile = path10.resolve(etc, "npmignore");
+        const etc = path9.resolve(conf.get("prefix"), "etc");
+        conf.root.globalconfig = path9.resolve(etc, "npmrc");
+        conf.root.globalignorefile = path9.resolve(etc, "npmignore");
       }
       warnings.push(conf.addFile(conf.get("globalconfig"), "global"));
       conf.loadUser();
@@ -2909,8 +2979,8 @@ var require_registry_auth_token = __commonJS({
       return { token, type: "Basic" };
     }
     __name(getLegacyAuthInfo, "getLegacyAuthInfo");
-    function normalizePath(path10) {
-      return path10[path10.length - 1] === "/" ? path10 : path10 + "/";
+    function normalizePath(path9) {
+      return path9[path9.length - 1] === "/" ? path9 : path9 + "/";
     }
     __name(normalizePath, "normalizePath");
     function getAuthInfoForUrl(regUrl, npmrc) {
@@ -2970,6 +3040,1413 @@ var require_registry_auth_token = __commonJS({
   }
 });
 
+// node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "node_modules/semver/functions/inc.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = inc;
+  }
+});
+
+// node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "node_modules/semver/functions/major.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var SemVer = require_semver();
+    var major = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).major, "major");
+    module.exports = major;
+  }
+});
+
+// node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "node_modules/semver/functions/minor.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var SemVer = require_semver();
+    var minor = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).minor, "minor");
+    module.exports = minor;
+  }
+});
+
+// node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "node_modules/semver/functions/patch.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var SemVer = require_semver();
+    var patch = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).patch, "patch");
+    module.exports = patch;
+  }
+});
+
+// node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "node_modules/semver/functions/prerelease.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var parse = require_parse();
+    var prerelease = /* @__PURE__ */ __name((version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    }, "prerelease");
+    module.exports = prerelease;
+  }
+});
+
+// node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "node_modules/semver/functions/rcompare.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var rcompare = /* @__PURE__ */ __name((a, b, loose) => compare(b, a, loose), "rcompare");
+    module.exports = rcompare;
+  }
+});
+
+// node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "node_modules/semver/functions/compare-loose.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var compareLoose = /* @__PURE__ */ __name((a, b) => compare(a, b, true), "compareLoose");
+    module.exports = compareLoose;
+  }
+});
+
+// node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "node_modules/semver/functions/compare-build.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = compareBuild;
+  }
+});
+
+// node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "node_modules/semver/functions/sort.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compareBuild = require_compare_build();
+    var sort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(a, b, loose)), "sort");
+    module.exports = sort;
+  }
+});
+
+// node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "node_modules/semver/functions/rsort.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compareBuild = require_compare_build();
+    var rsort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(b, a, loose)), "rsort");
+    module.exports = rsort;
+  }
+});
+
+// node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "node_modules/semver/functions/lt.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var lt = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) < 0, "lt");
+    module.exports = lt;
+  }
+});
+
+// node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "node_modules/semver/functions/eq.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var eq = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) === 0, "eq");
+    module.exports = eq;
+  }
+});
+
+// node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "node_modules/semver/functions/neq.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var neq = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) !== 0, "neq");
+    module.exports = neq;
+  }
+});
+
+// node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "node_modules/semver/functions/gte.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var gte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) >= 0, "gte");
+    module.exports = gte;
+  }
+});
+
+// node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "node_modules/semver/functions/lte.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var compare = require_compare();
+    var lte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) <= 0, "lte");
+    module.exports = lte;
+  }
+});
+
+// node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "node_modules/semver/functions/cmp.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = cmp;
+  }
+});
+
+// node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "node_modules/semver/functions/coerce.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t: t2 } = 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[t2.COERCEFULL] : re[t2.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t2.COERCERTLFULL] : re[t2.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");
+    module.exports = coerce;
+  }
+});
+
+// node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "node_modules/semver/internal/lrucache.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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;
+      }
+    };
+    module.exports = LRUCache;
+  }
+});
+
+// node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "node_modules/semver/classes/range.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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[t2.HYPHENRANGELOOSE] : re[t2.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t2.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t2.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t2.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[t2.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;
+      }
+    };
+    module.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: t2,
+      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) => {
+      comp = comp.replace(re[t2.BUILD], "");
+      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[t2.TILDELOOSE] : re[t2.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[t2.CARETLOOSE] : re[t2.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[t2.XRANGELOOSE] : re[t2.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[t2.STAR], "");
+    }, "replaceStars");
+    var replaceGTE0 = /* @__PURE__ */ __name((comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t2.GTE0PRE : t2.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/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "node_modules/semver/classes/comparator.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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[t2.COMPARATORLOOSE] : re[t2.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;
+      }
+    };
+    module.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t: t2 } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "node_modules/semver/functions/satisfies.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = satisfies;
+  }
+});
+
+// node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "node_modules/semver/ranges/to-comparators.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = toComparators;
+  }
+});
+
+// node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = maxSatisfying;
+  }
+});
+
+// node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = minSatisfying;
+  }
+});
+
+// node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "node_modules/semver/ranges/min-version.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = minVersion;
+  }
+});
+
+// node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "node_modules/semver/ranges/valid.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var Range = require_range();
+    var validRange = /* @__PURE__ */ __name((range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    }, "validRange");
+    module.exports = validRange;
+  }
+});
+
+// node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "node_modules/semver/ranges/outside.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = outside;
+  }
+});
+
+// node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "node_modules/semver/ranges/gtr.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var outside = require_outside();
+    var gtr = /* @__PURE__ */ __name((version, range, options) => outside(version, range, ">", options), "gtr");
+    module.exports = gtr;
+  }
+});
+
+// node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "node_modules/semver/ranges/ltr.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var outside = require_outside();
+    var ltr = /* @__PURE__ */ __name((version, range, options) => outside(version, range, "<", options), "ltr");
+    module.exports = ltr;
+  }
+});
+
+// node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "node_modules/semver/ranges/intersects.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = intersects;
+  }
+});
+
+// node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "node_modules/semver/ranges/simplify.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module.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/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "node_modules/semver/ranges/subset.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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");
+    module.exports = subset;
+  }
+});
+
+// node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "node_modules/semver/index.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    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();
+    module.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/ini/lib/ini.js
 var require_ini3 = __commonJS({
   "node_modules/ini/lib/ini.js"(exports, module) {
@@ -3957,12 +5434,12 @@ var disallowedKeys = /* @__PURE__ */ new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path10) {
+function getPathSegments(path9) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path10) {
+  for (const character of path9) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -4087,11 +5564,11 @@ function assertNotStringIndex(object, key) {
   }
 }
 __name(assertNotStringIndex, "assertNotStringIndex");
-function getProperty(object, path10, value) {
-  if (!isObject(object) || typeof path10 !== "string") {
+function getProperty(object, path9, value) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return value === void 0 ? object : value;
   }
-  const pathArray = getPathSegments(path10);
+  const pathArray = getPathSegments(path9);
   if (pathArray.length === 0) {
     return value;
   }
@@ -4112,12 +5589,12 @@ function getProperty(object, path10, value) {
   return object === void 0 ? value : object;
 }
 __name(getProperty, "getProperty");
-function setProperty(object, path10, value) {
-  if (!isObject(object) || typeof path10 !== "string") {
+function setProperty(object, path9, value) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path10);
+  const pathArray = getPathSegments(path9);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -4131,11 +5608,11 @@ function setProperty(object, path10, value) {
   return root;
 }
 __name(setProperty, "setProperty");
-function deleteProperty(object, path10) {
-  if (!isObject(object) || typeof path10 !== "string") {
+function deleteProperty(object, path9) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path10);
+  const pathArray = getPathSegments(path9);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -4150,11 +5627,11 @@ function deleteProperty(object, path10) {
   }
 }
 __name(deleteProperty, "deleteProperty");
-function hasProperty(object, path10) {
-  if (!isObject(object) || typeof path10 !== "string") {
+function hasProperty(object, path9) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path10);
+  const pathArray = getPathSegments(path9);
   if (pathArray.length === 0) {
     return false;
   }
@@ -5407,7 +6884,7 @@ __name(registryUrl, "registryUrl");
 
 // node_modules/package-json/index.js
 var import_registry_auth_token = __toESM(require_registry_auth_token(), 1);
-var import_semver = __toESM(require_semver(), 1);
+var import_semver = __toESM(require_semver2(), 1);
 var PackageNotFoundError = class extends Error {
   static {
     __name(this, "PackageNotFoundError");
@@ -6637,13 +8114,9 @@ function updateNotifier(options) {
 __name(updateNotifier, "updateNotifier");
 
 // packages/cli/src/ui/utils/updateCheck.ts
-var import_semver2 = __toESM(require_semver(), 1);
-import { execFile } from "node:child_process";
-import { realpath } from "node:fs/promises";
-import path9 from "node:path";
-import { promisify as promisify2 } from "node:util";
+var import_semver2 = __toESM(require_semver2(), 1);
 var debugLogger = createDebugLogger("UPDATE_CHECK");
-var FETCH_TIMEOUT_MS = 5e3;
+var FETCH_TIMEOUT_MS = 2e3;
 var UpdateCheckTimeoutError = class extends Error {
   static {
     __name(this, "UpdateCheckTimeoutError");
@@ -6656,40 +8129,6 @@ var UpdateCheckTimeoutError = class extends Error {
     this.distTag = distTag;
   }
 };
-var NETWORK_ERROR_CODES = [
-  "ENOTFOUND",
-  "ECONNREFUSED",
-  "EAI_AGAIN",
-  "ENETUNREACH"
-];
-function classifyUpdateCheckError(error) {
-  if (error instanceof Error) {
-    const errors = [error];
-    if (error.cause instanceof Error) errors.push(error.cause);
-    const matchesCode = /* @__PURE__ */ __name((code) => errors.some(
-      (error2) => error2.code === code || error2.message.includes(code)
-    ), "matchesCode");
-    if (errors.some((error2) => error2 instanceof UpdateCheckTimeoutError) || "killed" in error && error.killed === true && "signal" in error && error.signal === "SIGTERM" || matchesCode("ETIMEDOUT")) {
-      return "timeout";
-    }
-    if (NETWORK_ERROR_CODES.some(matchesCode)) return "offline";
-  }
-  return "registry";
-}
-__name(classifyUpdateCheckError, "classifyUpdateCheckError");
-function describeUpdateCheckFailure(error, timeoutMs = FETCH_TIMEOUT_MS) {
-  switch (classifyUpdateCheckError(error)) {
-    case "timeout":
-      return t("registry did not respond within {{seconds}}s", {
-        seconds: String(Math.round(timeoutMs / 1e3))
-      });
-    case "offline":
-      return t("registry unreachable");
-    default:
-      return t("registry error");
-  }
-}
-__name(describeUpdateCheckFailure, "describeUpdateCheckFailure");
 async function fetchInfoWithTimeout(notifier, timeoutMs, distTag) {
   let timer;
   try {
@@ -6707,72 +8146,6 @@ async function fetchInfoWithTimeout(notifier, timeoutMs, distTag) {
   }
 }
 __name(fetchInfoWithTimeout, "fetchInfoWithTimeout");
-var execFileAsync = promisify2(execFile);
-async function runGlobalNpm(args, run = execFileAsync, platform = process.platform, nodePath = process.execPath, resolveNpmCliPath = getNpmCliPath) {
-  const { stdout } = await run(
-    nodePath,
-    [resolveNpmCliPath(nodePath, platform), ...args],
-    {
-      encoding: "utf8",
-      timeout: FETCH_TIMEOUT_MS
-    }
-  );
-  return String(stdout).trim();
-}
-__name(runGlobalNpm, "runGlobalNpm");
-function looksLikeNpmPackagePath(cliPath) {
-  const normalized = cliPath.replace(/\\/g, "/");
-  return normalized.includes("/node_modules/@qwen-code/qwen-code/") && !normalized.includes("/.pnpm/");
-}
-__name(looksLikeNpmPackagePath, "looksLikeNpmPackagePath");
-async function isGlobalNpmInstallation(cliPath = process.argv[1], run = execFileAsync, canonicalize = realpath) {
-  if (process.env["QWEN_CODE_MANAGED_NPM_UPDATE"] === "true") return true;
-  if (!cliPath) return false;
-  let resolvedCliPath;
-  try {
-    resolvedCliPath = await canonicalize(cliPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-  if (!looksLikeNpmPackagePath(resolvedCliPath)) return false;
-  const unresolvedGlobalRoot = await runGlobalNpm(["root", "--global"], run);
-  let globalRoot;
-  try {
-    globalRoot = await canonicalize(unresolvedGlobalRoot);
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-  const relative = path9.relative(globalRoot, resolvedCliPath);
-  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path9.sep}`) && !path9.isAbsolute(relative);
-}
-__name(isGlobalNpmInstallation, "isGlobalNpmInstallation");
-async function fetchGlobalNpmUpdateInfo(packageName, currentVersion, distTag, run = execFileAsync) {
-  const output = await runGlobalNpm(
-    ["view", packageName, `dist-tags.${distTag}`, "--json", "--global"],
-    run
-  );
-  if (output === "") {
-    return {
-      latest: currentVersion,
-      current: currentVersion,
-      type: "latest",
-      name: packageName
-    };
-  }
-  const latest = JSON.parse(output);
-  if (typeof latest !== "string") {
-    throw new Error(`Invalid npm ${distTag} version response`);
-  }
-  return {
-    latest,
-    current: currentVersion,
-    type: "latest",
-    name: packageName
-  };
-}
-__name(fetchGlobalNpmUpdateInfo, "fetchGlobalNpmUpdateInfo");
 function getBestAvailableUpdate(nightly, stable) {
   if (!nightly) return stable || null;
   if (!stable) return nightly || null;
@@ -6784,7 +8157,7 @@ function getBestAvailableUpdate(nightly, stable) {
   return import_semver2.default.gt(stableVer, nightlyVer) ? stable : nightly;
 }
 __name(getBestAvailableUpdate, "getBestAvailableUpdate");
-async function checkForUpdatesDetailed(detectGlobalNpm = isGlobalNpmInstallation, fetchGlobalNpm = fetchGlobalNpmUpdateInfo) {
+async function checkForUpdatesDetailed() {
   let currentVersion;
   try {
     if (process.env["DEV"] === "true") {
@@ -6795,12 +8168,9 @@ async function checkForUpdatesDetailed(detectGlobalNpm = isGlobalNpmInstallation
       return { status: "skipped", reason: "package metadata unavailable" };
     }
     const { name, version } = packageJson3;
-    const isGlobalNpm = await detectGlobalNpm();
     currentVersion = version;
     const isNightly = version.includes("nightly");
-    const createNotifier = /* @__PURE__ */ __name((distTag) => isGlobalNpm ? {
-      fetchInfo: /* @__PURE__ */ __name(() => fetchGlobalNpm(name, version, distTag), "fetchInfo")
-    } : updateNotifier({
+    const createNotifier = /* @__PURE__ */ __name((distTag) => updateNotifier({
       pkg: {
         name,
         version
@@ -6880,11 +8250,6 @@ __name(checkForUpdates, "checkForUpdates");
 export {
   FETCH_TIMEOUT_MS,
   UpdateCheckTimeoutError,
-  classifyUpdateCheckError,
-  describeUpdateCheckFailure,
-  runGlobalNpm,
-  isGlobalNpmInstallation,
-  fetchGlobalNpmUpdateInfo,
   checkForUpdatesDetailed,
   checkForUpdates
 };