semantic-release-lerna 3.0.1 → 3.1.0

package/dist/index.js

@@ -2508,9 +2508,9 @@ var require_semver2 = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/node/index.min.js
+// node_modules/npm-package-arg/node_modules/lru-cache/dist/commonjs/node/index.min.js
 var require_index_min = __commonJS({
-  "node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/node/index.min.js"(exports) {
+  "node_modules/npm-package-arg/node_modules/lru-cache/dist/commonjs/node/index.min.js"(exports) {
     "use strict";
     var M = (c3, t) => () => (t || c3((t = { exports: {} }).exports, t), t.exports);
     var U = M((O) => {
@@ -3108,9 +3108,9 @@ var require_index_min = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/lib/hosts.js
+// node_modules/npm-package-arg/node_modules/hosted-git-info/lib/hosts.js
 var require_hosts = __commonJS({
-  "node_modules/hosted-git-info/lib/hosts.js"(exports, module) {
+  "node_modules/npm-package-arg/node_modules/hosted-git-info/lib/hosts.js"(exports, module) {
     "use strict";
     var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "";
     var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "";
@@ -3274,17 +3274,16 @@ var require_hosts = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/lib/parse-url.js
+// node_modules/npm-package-arg/node_modules/hosted-git-info/lib/parse-url.js
 var require_parse_url = __commonJS({
-  "node_modules/hosted-git-info/lib/parse-url.js"(exports, module) {
-    var url = __require("url");
+  "node_modules/npm-package-arg/node_modules/hosted-git-info/lib/parse-url.js"(exports, module) {
     var lastIndexOfBefore = (str2, char, beforeChar) => {
       const startPosition = str2.indexOf(beforeChar);
       return str2.lastIndexOf(char, startPosition > -1 ? startPosition : Infinity);
     };
     var safeUrl = (u2) => {
       try {
-        return new url.URL(u2);
+        return new URL(u2);
       } catch {
       }
     };
@@ -3325,9 +3324,9 @@ var require_parse_url = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/lib/from-url.js
+// node_modules/npm-package-arg/node_modules/hosted-git-info/lib/from-url.js
 var require_from_url = __commonJS({
-  "node_modules/hosted-git-info/lib/from-url.js"(exports, module) {
+  "node_modules/npm-package-arg/node_modules/hosted-git-info/lib/from-url.js"(exports, module) {
     "use strict";
     var parseUrl = require_parse_url();
     var isGitHubShorthand = (arg) => {
@@ -3419,9 +3418,9 @@ var require_from_url = __commonJS({
   }
 });
 
-// node_modules/hosted-git-info/lib/index.js
+// node_modules/npm-package-arg/node_modules/hosted-git-info/lib/index.js
 var require_lib = __commonJS({
-  "node_modules/hosted-git-info/lib/index.js"(exports, module) {
+  "node_modules/npm-package-arg/node_modules/hosted-git-info/lib/index.js"(exports, module) {
     "use strict";
     var { LRUCache } = require_index_min();
     var hosts = require_hosts();
@@ -13852,175 +13851,1263 @@ var require_spdx_correct = __commonJS({
           return transformed;
         }
       }
-      return null;
-    };
-    var validLastResort = function(identifier) {
-      var upperCased = identifier.toUpperCase();
-      for (var i2 = 0; i2 < lastResorts.length; i2++) {
-        var lastResort = lastResorts[i2];
-        if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
-          return lastResort[IDENTIFIER];
+      return null;
+    };
+    var validLastResort = function(identifier) {
+      var upperCased = identifier.toUpperCase();
+      for (var i2 = 0; i2 < lastResorts.length; i2++) {
+        var lastResort = lastResorts[i2];
+        if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
+          return lastResort[IDENTIFIER];
+        }
+      }
+      return null;
+    };
+    var anyCorrection = function(identifier, check) {
+      for (var i2 = 0; i2 < transpositions.length; i2++) {
+        var transposition = transpositions[i2];
+        var transposed = transposition[TRANSPOSED];
+        if (identifier.indexOf(transposed) > -1) {
+          var corrected = identifier.replace(
+            transposed,
+            transposition[CORRECT]
+          );
+          var checked = check(corrected);
+          if (checked !== null) {
+            return checked;
+          }
+        }
+      }
+      return null;
+    };
+    module.exports = function(identifier, options) {
+      options = options || {};
+      var upgrade = options.upgrade === void 0 ? true : !!options.upgrade;
+      function postprocess(value) {
+        return upgrade ? upgradeGPLs(value) : value;
+      }
+      var validArugment = typeof identifier === "string" && identifier.trim().length !== 0;
+      if (!validArugment) {
+        throw Error("Invalid argument. Expected non-empty string.");
+      }
+      identifier = identifier.trim();
+      if (valid(identifier)) {
+        return postprocess(identifier);
+      }
+      var noPlus = identifier.replace(/\+$/, "").trim();
+      if (valid(noPlus)) {
+        return postprocess(noPlus);
+      }
+      var transformed = validTransformation(identifier);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = anyCorrection(identifier, function(argument) {
+        if (valid(argument)) {
+          return argument;
+        }
+        return validTransformation(argument);
+      });
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = validLastResort(identifier);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = anyCorrection(identifier, validLastResort);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      return null;
+    };
+    function upgradeGPLs(value) {
+      if ([
+        "GPL-1.0",
+        "LGPL-1.0",
+        "AGPL-1.0",
+        "GPL-2.0",
+        "LGPL-2.0",
+        "AGPL-2.0",
+        "LGPL-2.1"
+      ].indexOf(value) !== -1) {
+        return value + "-only";
+      } else if ([
+        "GPL-1.0+",
+        "GPL-2.0+",
+        "GPL-3.0+",
+        "LGPL-2.0+",
+        "LGPL-2.1+",
+        "LGPL-3.0+",
+        "AGPL-1.0+",
+        "AGPL-3.0+"
+      ].indexOf(value) !== -1) {
+        return value.replace(/\+$/, "-or-later");
+      } else if (["GPL-3.0", "LGPL-3.0", "AGPL-3.0"].indexOf(value) !== -1) {
+        return value + "-or-later";
+      } else {
+        return value;
+      }
+    }
+  }
+});
+
+// node_modules/validate-npm-package-license/index.js
+var require_validate_npm_package_license = __commonJS({
+  "node_modules/validate-npm-package-license/index.js"(exports, module) {
+    var parse2 = require_spdx_expression_parse();
+    var correct = require_spdx_correct();
+    var genericWarning = 'license should be a valid SPDX license expression (without "LicenseRef"), "UNLICENSED", or "SEE LICENSE IN <filename>"';
+    var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
+    function startsWith(prefix, string) {
+      return string.slice(0, prefix.length) === prefix;
+    }
+    function usesLicenseRef(ast) {
+      if (ast.hasOwnProperty("license")) {
+        var license = ast.license;
+        return startsWith("LicenseRef", license) || startsWith("DocumentRef", license);
+      } else {
+        return usesLicenseRef(ast.left) || usesLicenseRef(ast.right);
+      }
+    }
+    module.exports = function(argument) {
+      var ast;
+      try {
+        ast = parse2(argument);
+      } catch (e) {
+        var match2;
+        if (argument === "UNLICENSED" || argument === "UNLICENCED") {
+          return {
+            validForOldPackages: true,
+            validForNewPackages: true,
+            unlicensed: true
+          };
+        } else if (match2 = fileReferenceRE.exec(argument)) {
+          return {
+            validForOldPackages: true,
+            validForNewPackages: true,
+            inFile: match2[1]
+          };
+        } else {
+          var result = {
+            validForOldPackages: false,
+            validForNewPackages: false,
+            warnings: [genericWarning]
+          };
+          if (argument.trim().length !== 0) {
+            var corrected = correct(argument);
+            if (corrected) {
+              result.warnings.push(
+                'license is similar to the valid expression "' + corrected + '"'
+              );
+            }
+          }
+          return result;
+        }
+      }
+      if (usesLicenseRef(ast)) {
+        return {
+          validForNewPackages: false,
+          validForOldPackages: false,
+          spdx: true,
+          warnings: [genericWarning]
+        };
+      } else {
+        return {
+          validForNewPackages: true,
+          validForOldPackages: true,
+          spdx: true
+        };
+      }
+    };
+  }
+});
+
+// node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/node/index.min.js
+var require_index_min2 = __commonJS({
+  "node_modules/hosted-git-info/node_modules/lru-cache/dist/commonjs/node/index.min.js"(exports) {
+    "use strict";
+    var M = (c3, t) => () => (t || c3((t = { exports: {} }).exports, t), t.exports);
+    var U = M((O) => {
+      "use strict";
+      Object.defineProperty(O, "__esModule", { value: true });
+      O.tracing = O.metrics = void 0;
+      var j = __require("node:diagnostics_channel");
+      O.metrics = (0, j.channel)("lru-cache:metrics");
+      O.tracing = (0, j.tracingChannel)("lru-cache");
+    });
+    var I = M((R) => {
+      "use strict";
+      Object.defineProperty(R, "__esModule", { value: true });
+      R.defaultPerf = void 0;
+      R.defaultPerf = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+    });
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LRUCache = void 0;
+    var u2 = U();
+    var N = I();
+    var C = () => u2.metrics.hasSubscribers || u2.tracing.hasSubscribers;
+    var G = /* @__PURE__ */ new Set();
+    var P = typeof process == "object" && process ? process : {};
+    var k = (c3, t, e, i2) => {
+      typeof P.emitWarning == "function" ? P.emitWarning(c3, t, e, i2) : console.error(`[${e}] ${t}: ${c3}`);
+    };
+    var q = (c3) => !G.has(c3);
+    var F = (c3) => !!c3 && c3 === Math.floor(c3) && c3 > 0 && isFinite(c3);
+    var H = (c3) => F(c3) ? c3 <= Math.pow(2, 8) ? Uint8Array : c3 <= Math.pow(2, 16) ? Uint16Array : c3 <= Math.pow(2, 32) ? Uint32Array : c3 <= Number.MAX_SAFE_INTEGER ? W : null : null;
+    var W = class extends Array {
+      constructor(t) {
+        super(t), this.fill(0);
+      }
+    };
+    var x = class c3 {
+      heap;
+      length;
+      static #o = false;
+      static create(t) {
+        let e = H(t);
+        if (!e) return [];
+        c3.#o = true;
+        let i2 = new c3(t, e);
+        return c3.#o = false, i2;
+      }
+      constructor(t, e) {
+        if (!c3.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+        this.heap = new e(t), this.length = 0;
+      }
+      push(t) {
+        this.heap[this.length++] = t;
+      }
+      pop() {
+        return this.heap[--this.length];
+      }
+    };
+    var L = class c3 {
+      #o;
+      #c;
+      #m;
+      #D;
+      #w;
+      #M;
+      #j;
+      #S;
+      get perf() {
+        return this.#S;
+      }
+      ttl;
+      ttlResolution;
+      ttlAutopurge;
+      updateAgeOnGet;
+      updateAgeOnHas;
+      allowStale;
+      noDisposeOnSet;
+      noUpdateTTL;
+      maxEntrySize;
+      sizeCalculation;
+      noDeleteOnFetchRejection;
+      noDeleteOnStaleGet;
+      allowStaleOnFetchAbort;
+      allowStaleOnFetchRejection;
+      ignoreFetchAbort;
+      #n;
+      #b;
+      #s;
+      #i;
+      #t;
+      #l;
+      #u;
+      #a;
+      #h;
+      #_;
+      #r;
+      #y;
+      #F;
+      #d;
+      #g;
+      #T;
+      #O;
+      #f;
+      #U;
+      static unsafeExposeInternals(t) {
+        return { starts: t.#F, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#l, prev: t.#u, get head() {
+          return t.#a;
+        }, get tail() {
+          return t.#h;
+        }, free: t.#_, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i2, s, n2) => t.#G(e, i2, s, n2), moveToTail: (e) => t.#L(e), indexes: (e) => t.#A(e), rindexes: (e) => t.#v(e), isStale: (e) => t.#p(e) };
+      }
+      get max() {
+        return this.#o;
+      }
+      get maxSize() {
+        return this.#c;
+      }
+      get calculatedSize() {
+        return this.#b;
+      }
+      get size() {
+        return this.#n;
+      }
+      get fetchMethod() {
+        return this.#M;
+      }
+      get memoMethod() {
+        return this.#j;
+      }
+      get dispose() {
+        return this.#m;
+      }
+      get onInsert() {
+        return this.#D;
+      }
+      get disposeAfter() {
+        return this.#w;
+      }
+      constructor(t) {
+        let { max: e = 0, ttl: i2, ttlResolution: s = 1, ttlAutopurge: n2, updateAgeOnGet: o2, updateAgeOnHas: r, allowStale: h2, dispose: a2, onInsert: d, disposeAfter: f, noDisposeOnSet: p, noUpdateTTL: m, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: y, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: g, allowStaleOnFetchAbort: A, ignoreFetchAbort: v, perf: D } = t;
+        if (D !== void 0 && typeof D?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+        if (this.#S = D ?? N.defaultPerf, e !== 0 && !F(e)) throw new TypeError("max option must be a nonnegative integer");
+        let z = e ? H(e) : Array;
+        if (!z) throw new Error("invalid max value: " + e);
+        if (this.#o = e, this.#c = T, this.maxEntrySize = w || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+          if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+          if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+        }
+        if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+        if (this.#j = S, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+        if (this.#M = l, this.#O = !!l, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: e }).fill(void 0), this.#t = Array.from({ length: e }).fill(void 0), this.#l = new z(e), this.#u = new z(e), this.#a = 0, this.#h = 0, this.#_ = x.create(e), this.#n = 0, this.#b = 0, typeof a2 == "function" && (this.#m = a2), typeof d == "function" && (this.#D = d), typeof f == "function" ? (this.#w = f, this.#r = []) : (this.#w = void 0, this.#r = void 0), this.#T = !!this.#m, this.#U = !!this.#D, this.#f = !!this.#w, this.noDisposeOnSet = !!p, this.noUpdateTTL = !!m, this.noDeleteOnFetchRejection = !!y, this.allowStaleOnFetchRejection = !!g, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!v, this.maxEntrySize !== 0) {
+          if (this.#c !== 0 && !F(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+          if (!F(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+          this.#X();
+        }
+        if (this.allowStale = !!h2, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o2, this.updateAgeOnHas = !!r, this.ttlResolution = F(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n2, this.ttl = i2 || 0, this.ttl) {
+          if (!F(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+          this.#H();
+        }
+        if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+        if (!this.ttlAutopurge && !this.#o && !this.#c) {
+          let E = "LRU_CACHE_UNBOUNDED";
+          q(E) && (G.add(E), k("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c3));
+        }
+      }
+      getRemainingTTL(t) {
+        return this.#s.has(t) ? 1 / 0 : 0;
+      }
+      #H() {
+        let t = new W(this.#o), e = new W(this.#o);
+        this.#d = t, this.#F = e;
+        let i2 = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
+        this.#g = i2, this.#N = (r, h2, a2 = this.#S.now()) => {
+          e[r] = h2 !== 0 ? a2 : 0, t[r] = h2, s(r, h2);
+        }, this.#R = (r) => {
+          e[r] = t[r] !== 0 ? this.#S.now() : 0, s(r, t[r]);
+        };
+        let s = this.ttlAutopurge ? (r, h2) => {
+          if (i2?.[r] && (clearTimeout(i2[r]), i2[r] = void 0), h2 && h2 !== 0 && i2) {
+            let a2 = setTimeout(() => {
+              this.#p(r) && this.#z(this.#i[r], "expire");
+            }, h2 + 1);
+            a2.unref && a2.unref(), i2[r] = a2;
+          }
+        } : () => {
+        };
+        this.#E = (r, h2) => {
+          if (t[h2]) {
+            let a2 = t[h2], d = e[h2];
+            if (!a2 || !d) return;
+            r.ttl = a2, r.start = d, r.now = n2 || o2();
+            let f = r.now - d;
+            r.remainingTTL = a2 - f;
+          }
+        };
+        let n2 = 0, o2 = () => {
+          let r = this.#S.now();
+          if (this.ttlResolution > 0) {
+            n2 = r;
+            let h2 = setTimeout(() => n2 = 0, this.ttlResolution);
+            h2.unref && h2.unref();
+          }
+          return r;
+        };
+        this.getRemainingTTL = (r) => {
+          let h2 = this.#s.get(r);
+          if (h2 === void 0) return 0;
+          let a2 = t[h2], d = e[h2];
+          if (!a2 || !d) return 1 / 0;
+          let f = (n2 || o2()) - d;
+          return a2 - f;
+        }, this.#p = (r) => {
+          let h2 = e[r], a2 = t[r];
+          return !!a2 && !!h2 && (n2 || o2()) - h2 > a2;
+        };
+      }
+      #R = () => {
+      };
+      #E = () => {
+      };
+      #N = () => {
+      };
+      #p = () => false;
+      #X() {
+        let t = new W(this.#o);
+        this.#b = 0, this.#y = t, this.#C = (e) => {
+          this.#b -= t[e], t[e] = 0;
+        }, this.#k = (e, i2, s, n2) => {
+          if (this.#e(i2)) return 0;
+          if (!F(s)) if (n2) {
+            if (typeof n2 != "function") throw new TypeError("sizeCalculation must be a function");
+            if (s = n2(i2, e), !F(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+          } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+          return s;
+        }, this.#I = (e, i2, s) => {
+          if (t[e] = i2, this.#c) {
+            let n2 = this.#c - t[e];
+            for (; this.#b > n2; ) this.#P(true);
+          }
+          this.#b += t[e], s && (s.entrySize = i2, s.totalCalculatedSize = this.#b);
+        };
+      }
+      #C = (t) => {
+      };
+      #I = (t, e, i2) => {
+      };
+      #k = (t, e, i2, s) => {
+        if (i2 || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+        return 0;
+      };
+      *#A({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for (let e = this.#h; this.#q(e) && ((t || !this.#p(e)) && (yield e), e !== this.#a); ) e = this.#u[e];
+      }
+      *#v({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for (let e = this.#a; this.#q(e) && ((t || !this.#p(e)) && (yield e), e !== this.#h); ) e = this.#l[e];
+      }
+      #q(t) {
+        return t !== void 0 && this.#s.get(this.#i[t]) === t;
+      }
+      *entries() {
+        for (let t of this.#A()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+      }
+      *rentries() {
+        for (let t of this.#v()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+      }
+      *keys() {
+        for (let t of this.#A()) {
+          let e = this.#i[t];
+          e !== void 0 && !this.#e(this.#t[t]) && (yield e);
+        }
+      }
+      *rkeys() {
+        for (let t of this.#v()) {
+          let e = this.#i[t];
+          e !== void 0 && !this.#e(this.#t[t]) && (yield e);
+        }
+      }
+      *values() {
+        for (let t of this.#A()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
+      }
+      *rvalues() {
+        for (let t of this.#v()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+      [Symbol.toStringTag] = "LRUCache";
+      find(t, e = {}) {
+        for (let i2 of this.#A()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          if (n2 !== void 0 && t(n2, this.#i[i2], this)) return this.#x(this.#i[i2], e);
+        }
+      }
+      forEach(t, e = this) {
+        for (let i2 of this.#A()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          n2 !== void 0 && t.call(e, n2, this.#i[i2], this);
+        }
+      }
+      rforEach(t, e = this) {
+        for (let i2 of this.#v()) {
+          let s = this.#t[i2], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          n2 !== void 0 && t.call(e, n2, this.#i[i2], this);
+        }
+      }
+      purgeStale() {
+        let t = false;
+        for (let e of this.#v({ allowStale: true })) this.#p(e) && (this.#z(this.#i[e], "expire"), t = true);
+        return t;
+      }
+      info(t) {
+        let e = this.#s.get(t);
+        if (e === void 0) return;
+        let i2 = this.#t[e], s = this.#e(i2) ? i2.__staleWhileFetching : i2;
+        if (s === void 0) return;
+        let n2 = { value: s };
+        if (this.#d && this.#F) {
+          let o2 = this.#d[e], r = this.#F[e];
+          if (o2 && r) {
+            let h2 = o2 - (this.#S.now() - r);
+            n2.ttl = h2, n2.start = Date.now();
+          }
+        }
+        return this.#y && (n2.size = this.#y[e]), n2;
+      }
+      dump() {
+        let t = [];
+        for (let e of this.#A({ allowStale: true })) {
+          let i2 = this.#i[e], s = this.#t[e], n2 = this.#e(s) ? s.__staleWhileFetching : s;
+          if (n2 === void 0 || i2 === void 0) continue;
+          let o2 = { value: n2 };
+          if (this.#d && this.#F) {
+            o2.ttl = this.#d[e];
+            let r = this.#S.now() - this.#F[e];
+            o2.start = Math.floor(Date.now() - r);
+          }
+          this.#y && (o2.size = this.#y[e]), t.unshift([i2, o2]);
+        }
+        return t;
+      }
+      load(t) {
+        this.clear();
+        for (let [e, i2] of t) {
+          if (i2.start) {
+            let s = Date.now() - i2.start;
+            i2.start = this.#S.now() - s;
+          }
+          this.#W(e, i2.value, i2);
+        }
+      }
+      set(t, e, i2 = {}) {
+        let { status: s = u2.metrics.hasSubscribers ? {} : void 0 } = i2;
+        i2.status = s, s && (s.op = "set", s.key = t, e !== void 0 && (s.value = e));
+        let n2 = this.#W(t, e, i2);
+        return s && u2.metrics.hasSubscribers && u2.metrics.publish(s), n2;
+      }
+      #W(t, e, i2 = {}) {
+        let { ttl: s = this.ttl, start: n2, noDisposeOnSet: o2 = this.noDisposeOnSet, sizeCalculation: r = this.sizeCalculation, status: h2 } = i2;
+        if (e === void 0) return h2 && (h2.set = "deleted"), this.delete(t), this;
+        let { noUpdateTTL: a2 = this.noUpdateTTL } = i2;
+        h2 && !this.#e(e) && (h2.value = e);
+        let d = this.#k(t, e, i2.size || 0, r, h2);
+        if (this.maxEntrySize && d > this.maxEntrySize) return this.#z(t, "set"), h2 && (h2.set = "miss", h2.maxEntrySizeExceeded = true), this;
+        let f = this.#n === 0 ? void 0 : this.#s.get(t);
+        if (f === void 0) f = this.#n === 0 ? this.#h : this.#_.length !== 0 ? this.#_.pop() : this.#n === this.#o ? this.#P(false) : this.#n, this.#i[f] = t, this.#t[f] = e, this.#s.set(t, f), this.#l[this.#h] = f, this.#u[f] = this.#h, this.#h = f, this.#n++, this.#I(f, d, h2), h2 && (h2.set = "add"), a2 = false, this.#U && this.#D?.(e, t, "add");
+        else {
+          this.#L(f);
+          let p = this.#t[f];
+          if (e !== p) {
+            if (this.#O && this.#e(p)) {
+              p.__abortController.abort(new Error("replaced"));
+              let { __staleWhileFetching: m } = p;
+              m !== void 0 && !o2 && (this.#T && this.#m?.(m, t, "set"), this.#f && this.#r?.push([m, t, "set"]));
+            } else o2 || (this.#T && this.#m?.(p, t, "set"), this.#f && this.#r?.push([p, t, "set"]));
+            if (this.#C(f), this.#I(f, d, h2), this.#t[f] = e, h2) {
+              h2.set = "replace";
+              let m = p && this.#e(p) ? p.__staleWhileFetching : p;
+              m !== void 0 && (h2.oldValue = m);
+            }
+          } else h2 && (h2.set = "update");
+          this.#U && this.onInsert?.(e, t, e === p ? "update" : "replace");
+        }
+        if (s !== 0 && !this.#d && this.#H(), this.#d && (a2 || this.#N(f, s, n2), h2 && this.#E(h2, f)), !o2 && this.#f && this.#r) {
+          let p = this.#r, m;
+          for (; m = p?.shift(); ) this.#w?.(...m);
+        }
+        return this;
+      }
+      pop() {
+        try {
+          for (; this.#n; ) {
+            let t = this.#t[this.#a];
+            if (this.#P(true), this.#e(t)) {
+              if (t.__staleWhileFetching) return t.__staleWhileFetching;
+            } else if (t !== void 0) return t;
+          }
+        } finally {
+          if (this.#f && this.#r) {
+            let t = this.#r, e;
+            for (; e = t?.shift(); ) this.#w?.(...e);
+          }
+        }
+      }
+      #P(t) {
+        let e = this.#a, i2 = this.#i[e], s = this.#t[e];
+        return this.#O && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#m?.(s, i2, "evict"), this.#f && this.#r?.push([s, i2, "evict"])), this.#C(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#_.push(e)), this.#n === 1 ? (this.#a = this.#h = 0, this.#_.length = 0) : this.#a = this.#l[e], this.#s.delete(i2), this.#n--, e;
+      }
+      has(t, e = {}) {
+        let { status: i2 = u2.metrics.hasSubscribers ? {} : void 0 } = e;
+        e.status = i2, i2 && (i2.op = "has", i2.key = t);
+        let s = this.#Y(t, e);
+        return u2.metrics.hasSubscribers && u2.metrics.publish(i2), s;
+      }
+      #Y(t, e = {}) {
+        let { updateAgeOnHas: i2 = this.updateAgeOnHas, status: s } = e, n2 = this.#s.get(t);
+        if (n2 !== void 0) {
+          let o2 = this.#t[n2];
+          if (this.#e(o2) && o2.__staleWhileFetching === void 0) return false;
+          if (this.#p(n2)) s && (s.has = "stale", this.#E(s, n2));
+          else return i2 && this.#R(n2), s && (s.has = "hit", this.#E(s, n2)), true;
+        } else s && (s.has = "miss");
+        return false;
+      }
+      peek(t, e = {}) {
+        let { status: i2 = C() ? {} : void 0 } = e;
+        i2 && (i2.op = "peek", i2.key = t), e.status = i2;
+        let s = this.#J(t, e);
+        return u2.metrics.hasSubscribers && u2.metrics.publish(i2), s;
+      }
+      #J(t, e) {
+        let { status: i2, allowStale: s = this.allowStale } = e, n2 = this.#s.get(t);
+        if (n2 === void 0 || !s && this.#p(n2)) {
+          i2 && (i2.peek = n2 === void 0 ? "miss" : "stale");
+          return;
+        }
+        let o2 = this.#t[n2], r = this.#e(o2) ? o2.__staleWhileFetching : o2;
+        return i2 && (r !== void 0 ? (i2.peek = "hit", i2.value = r) : i2.peek = "miss"), r;
+      }
+      #G(t, e, i2, s) {
+        let n2 = e === void 0 ? void 0 : this.#t[e];
+        if (this.#e(n2)) return n2;
+        let o2 = new AbortController(), { signal: r } = i2;
+        r?.addEventListener("abort", () => o2.abort(r.reason), { signal: o2.signal });
+        let h2 = { signal: o2.signal, options: i2, context: s }, a2 = (w, _ = false) => {
+          let { aborted: l } = o2.signal, S = i2.ignoreFetchAbort && w !== void 0, y = i2.ignoreFetchAbort || !!(i2.allowStaleOnFetchAbort && w !== void 0);
+          if (i2.status && (l && !_ ? (i2.status.fetchAborted = true, i2.status.fetchError = o2.signal.reason, S && (i2.status.fetchAbortIgnored = true)) : i2.status.fetchResolved = true), l && !S && !_) return f(o2.signal.reason, y);
+          let b = m, g = this.#t[e];
+          return (g === m || g === void 0 && S && _) && (w === void 0 ? b.__staleWhileFetching !== void 0 ? this.#t[e] = b.__staleWhileFetching : this.#z(t, "fetch") : (i2.status && (i2.status.fetchUpdated = true), this.#W(t, w, h2.options))), w;
+        }, d = (w) => (i2.status && (i2.status.fetchRejected = true, i2.status.fetchError = w), f(w, false)), f = (w, _) => {
+          let { aborted: l } = o2.signal, S = l && i2.allowStaleOnFetchAbort, y = S || i2.allowStaleOnFetchRejection, b = y || i2.noDeleteOnFetchRejection, g = m;
+          if (this.#t[e] === m && (!b || !_ && g.__staleWhileFetching === void 0 ? this.#z(t, "fetch") : S || (this.#t[e] = g.__staleWhileFetching)), y) return i2.status && g.__staleWhileFetching !== void 0 && (i2.status.returnedStale = true), g.__staleWhileFetching;
+          if (g.__returned === g) throw w;
+        }, p = (w, _) => {
+          let l = this.#M?.(t, n2, h2);
+          l && l instanceof Promise && l.then((S) => w(S === void 0 ? void 0 : S), _), o2.signal.addEventListener("abort", () => {
+            (!i2.ignoreFetchAbort || i2.allowStaleOnFetchAbort) && (w(void 0), i2.allowStaleOnFetchAbort && (w = (S) => a2(S, true)));
+          });
+        };
+        i2.status && (i2.status.fetchDispatched = true);
+        let m = new Promise(p).then(a2, d), T = Object.assign(m, { __abortController: o2, __staleWhileFetching: n2, __returned: void 0 });
+        return e === void 0 ? (this.#W(t, T, { ...h2.options, status: void 0 }), e = this.#s.get(t)) : this.#t[e] = T, T;
+      }
+      #e(t) {
+        if (!this.#O) return false;
+        let e = t;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof AbortController;
+      }
+      fetch(t, e = {}) {
+        let i2 = u2.tracing.hasSubscribers, { status: s = C() ? {} : void 0 } = e;
+        e.status = s, s && e.context && (s.context = e.context);
+        let n2 = this.#V(t, e);
+        return s && i2 && (s.trace = true, u2.tracing.tracePromise(() => n2, s).catch(() => {
+        })), n2;
+      }
+      async #V(t, e = {}) {
+        let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n2 = this.noDeleteOnStaleGet, ttl: o2 = this.ttl, noDisposeOnSet: r = this.noDisposeOnSet, size: h2 = 0, sizeCalculation: a2 = this.sizeCalculation, noUpdateTTL: d = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: p = this.allowStaleOnFetchRejection, ignoreFetchAbort: m = this.ignoreFetchAbort, allowStaleOnFetchAbort: T = this.allowStaleOnFetchAbort, context: w, forceRefresh: _ = false, status: l, signal: S } = e;
+        if (l && (l.op = "fetch", l.key = t, _ && (l.forceRefresh = true)), !this.#O) return l && (l.fetch = "get"), this.#x(t, { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n2, status: l });
+        let y = { allowStale: i2, updateAgeOnGet: s, noDeleteOnStaleGet: n2, ttl: o2, noDisposeOnSet: r, size: h2, sizeCalculation: a2, noUpdateTTL: d, noDeleteOnFetchRejection: f, allowStaleOnFetchRejection: p, allowStaleOnFetchAbort: T, ignoreFetchAbort: m, status: l, signal: S }, b = this.#s.get(t);
+        if (b === void 0) {
+          l && (l.fetch = "miss");
+          let g = this.#G(t, b, y, w);
+          return g.__returned = g;
+        } else {
+          let g = this.#t[b];
+          if (this.#e(g)) {
+            let E = i2 && g.__staleWhileFetching !== void 0;
+            return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? g.__staleWhileFetching : g.__returned = g;
+          }
+          let A = this.#p(b);
+          if (!_ && !A) return l && (l.fetch = "hit"), this.#L(b), s && this.#R(b), l && this.#E(l, b), g;
+          let v = this.#G(t, b, y, w), z = v.__staleWhileFetching !== void 0 && i2;
+          return l && (l.fetch = A ? "stale" : "refresh", z && A && (l.returnedStale = true)), z ? v.__staleWhileFetching : v.__returned = v;
+        }
+      }
+      forceFetch(t, e = {}) {
+        let i2 = u2.tracing.hasSubscribers, { status: s = C() ? {} : void 0 } = e;
+        e.status = s, s && e.context && (s.context = e.context);
+        let n2 = this.#K(t, e);
+        return s && i2 && (s.trace = true, u2.tracing.tracePromise(() => n2, s).catch(() => {
+        })), n2;
+      }
+      async #K(t, e = {}) {
+        let i2 = await this.#V(t, e);
+        if (i2 === void 0) throw new Error("fetch() returned undefined");
+        return i2;
+      }
+      memo(t, e = {}) {
+        let { status: i2 = u2.metrics.hasSubscribers ? {} : void 0 } = e;
+        e.status = i2, i2 && (i2.op = "memo", i2.key = t, e.context && (i2.context = e.context));
+        let s = this.#Q(t, e);
+        return i2 && (i2.value = s), u2.metrics.hasSubscribers && u2.metrics.publish(i2), s;
+      }
+      #Q(t, e = {}) {
+        let i2 = this.#j;
+        if (!i2) throw new Error("no memoMethod provided to constructor");
+        let { context: s, status: n2, forceRefresh: o2, ...r } = e;
+        n2 && o2 && (n2.forceRefresh = true);
+        let h2 = this.#x(t, r), a2 = o2 || h2 === void 0;
+        if (n2 && (n2.memo = a2 ? "miss" : "hit", a2 || (n2.value = h2)), !a2) return h2;
+        let d = i2(t, h2, { options: r, context: s });
+        return n2 && (n2.value = d), this.#W(t, d, r), d;
+      }
+      get(t, e = {}) {
+        let { status: i2 = u2.metrics.hasSubscribers ? {} : void 0 } = e;
+        e.status = i2, i2 && (i2.op = "get", i2.key = t);
+        let s = this.#x(t, e);
+        return i2 && (s !== void 0 && (i2.value = s), u2.metrics.hasSubscribers && u2.metrics.publish(i2)), s;
+      }
+      #x(t, e = {}) {
+        let { allowStale: i2 = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n2 = this.noDeleteOnStaleGet, status: o2 } = e, r = this.#s.get(t);
+        if (r === void 0) {
+          o2 && (o2.get = "miss");
+          return;
+        }
+        let h2 = this.#t[r], a2 = this.#e(h2);
+        return o2 && this.#E(o2, r), this.#p(r) ? a2 ? (o2 && (o2.get = "stale-fetching"), i2 && h2.__staleWhileFetching !== void 0 ? (o2 && (o2.returnedStale = true), h2.__staleWhileFetching) : void 0) : (n2 || this.#z(t, "expire"), o2 && (o2.get = "stale"), i2 ? (o2 && (o2.returnedStale = true), h2) : void 0) : (o2 && (o2.get = a2 ? "fetching" : "hit"), this.#L(r), s && this.#R(r), a2 ? h2.__staleWhileFetching : h2);
+      }
+      #B(t, e) {
+        this.#u[e] = t, this.#l[t] = e;
+      }
+      #L(t) {
+        t !== this.#h && (t === this.#a ? this.#a = this.#l[t] : this.#B(this.#u[t], this.#l[t]), this.#B(this.#h, t), this.#h = t);
+      }
+      delete(t) {
+        return this.#z(t, "delete");
+      }
+      #z(t, e) {
+        u2.metrics.hasSubscribers && u2.metrics.publish({ op: "delete", delete: e, key: t });
+        let i2 = false;
+        if (this.#n !== 0) {
+          let s = this.#s.get(t);
+          if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i2 = true, this.#n === 1) this.#$(e);
+          else {
+            this.#C(s);
+            let n2 = this.#t[s];
+            if (this.#e(n2) ? n2.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#m?.(n2, t, e), this.#f && this.#r?.push([n2, t, e])), this.#s.delete(t), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+            else if (s === this.#a) this.#a = this.#l[s];
+            else {
+              let o2 = this.#u[s];
+              this.#l[o2] = this.#l[s];
+              let r = this.#l[s];
+              this.#u[r] = this.#u[s];
+            }
+            this.#n--, this.#_.push(s);
+          }
+        }
+        if (this.#f && this.#r?.length) {
+          let s = this.#r, n2;
+          for (; n2 = s?.shift(); ) this.#w?.(...n2);
+        }
+        return i2;
+      }
+      clear() {
+        return this.#$("delete");
+      }
+      #$(t) {
+        for (let e of this.#v({ allowStale: true })) {
+          let i2 = this.#t[e];
+          if (this.#e(i2)) i2.__abortController.abort(new Error("deleted"));
+          else {
+            let s = this.#i[e];
+            this.#T && this.#m?.(i2, s, t), this.#f && this.#r?.push([i2, s, t]);
+          }
+        }
+        if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
+          this.#d.fill(0), this.#F.fill(0);
+          for (let e of this.#g ?? []) e !== void 0 && clearTimeout(e);
+          this.#g?.fill(void 0);
+        }
+        if (this.#y && this.#y.fill(0), this.#a = 0, this.#h = 0, this.#_.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
+          let e = this.#r, i2;
+          for (; i2 = e?.shift(); ) this.#w?.(...i2);
+        }
+      }
+    };
+    exports.LRUCache = L;
+  }
+});
+
+// node_modules/hosted-git-info/lib/hosts.js
+var require_hosts2 = __commonJS({
+  "node_modules/hosted-git-info/lib/hosts.js"(exports, module) {
+    "use strict";
+    var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "";
+    var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "";
+    var formatHashFragment = (f) => f.toLowerCase().replace(/^\W+/g, "").replace(/(?<!\W)\W+$/, "").replace(/\//g, "").replace(/\W+/g, "-");
+    var defaults2 = {
+      sshtemplate: ({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`,
+      sshurltemplate: ({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+      edittemplate: ({ domain, user, project, committish, editpath, path: path26 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path26)}`,
+      browsetemplate: ({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`,
+      browsetreetemplate: ({ domain, user, project, committish, treepath, path: path26, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path26}${maybeJoin("#", hashformat(fragment || ""))}`,
+      browseblobtemplate: ({ domain, user, project, committish, blobpath, path: path26, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path26}${maybeJoin("#", hashformat(fragment || ""))}`,
+      docstemplate: ({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`,
+      httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+      filetemplate: ({ domain, user, project, committish, path: path26 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path26}`,
+      shortcuttemplate: ({ type: type2, user, project, committish }) => `${type2}:${user}/${project}${maybeJoin("#", committish)}`,
+      pathtemplate: ({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`,
+      bugstemplate: ({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`,
+      hashformat: formatHashFragment
+    };
+    var hosts = {};
+    hosts.github = {
+      // First two are insecure and generally shouldn't be used any more, but
+      // they are still supported.
+      protocols: ["git:", "http:", "git+ssh:", "git+https:", "ssh:", "https:"],
+      domain: "github.com",
+      treepath: "tree",
+      blobpath: "blob",
+      editpath: "edit",
+      filetemplate: ({ auth, user, project, committish, path: path26 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path26}`,
+      gittemplate: ({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
+      tarballtemplate: ({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
+      extract: (url) => {
+        let [, user, project, type2, committish] = url.pathname.split("/", 5);
+        if (type2 && type2 !== "tree") {
+          return;
+        }
+        if (!type2) {
+          committish = url.hash.slice(1);
+        }
+        if (project && project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        if (!user || !project) {
+          return;
+        }
+        return { user, project, committish };
+      }
+    };
+    hosts.bitbucket = {
+      protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
+      domain: "bitbucket.org",
+      treepath: "src",
+      blobpath: "src",
+      editpath: "?mode=edit",
+      edittemplate: ({ domain, user, project, committish, treepath, path: path26, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path26, editpath)}`,
+      tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`,
+      extract: (url) => {
+        let [, user, project, aux] = url.pathname.split("/", 4);
+        if (["get"].includes(aux)) {
+          return;
+        }
+        if (project && project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        if (!user || !project) {
+          return;
+        }
+        return { user, project, committish: url.hash.slice(1) };
+      }
+    };
+    hosts.gitlab = {
+      protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
+      domain: "gitlab.com",
+      treepath: "tree",
+      blobpath: "tree",
+      editpath: "-/edit",
+      tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/api/v4/projects/${maybeEncode(user + "/" + project)}/repository/archive.tar.gz?sha=${maybeEncode(committish || "HEAD")}`,
+      extract: (url) => {
+        const path26 = url.pathname.slice(1);
+        if (path26.includes("/-/") || path26.includes("/archive.tar.gz")) {
+          return;
+        }
+        const segments = path26.split("/");
+        let project = segments.pop();
+        if (project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        const user = segments.join("/");
+        if (!user || !project) {
+          return;
+        }
+        return { user, project, committish: url.hash.slice(1) };
+      }
+    };
+    hosts.gist = {
+      protocols: ["git:", "git+ssh:", "git+https:", "ssh:", "https:"],
+      domain: "gist.github.com",
+      editpath: "edit",
+      sshtemplate: ({ domain, project, committish }) => `git@${domain}:${project}.git${maybeJoin("#", committish)}`,
+      sshurltemplate: ({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`,
+      edittemplate: ({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`,
+      browsetemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
+      browsetreetemplate: ({ domain, project, committish, path: path26, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path26))}`,
+      browseblobtemplate: ({ domain, project, committish, path: path26, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path26))}`,
+      docstemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
+      httpstemplate: ({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`,
+      filetemplate: ({ user, project, committish, path: path26 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path26}`,
+      shortcuttemplate: ({ type: type2, project, committish }) => `${type2}:${project}${maybeJoin("#", committish)}`,
+      pathtemplate: ({ project, committish }) => `${project}${maybeJoin("#", committish)}`,
+      bugstemplate: ({ domain, project }) => `https://${domain}/${project}`,
+      gittemplate: ({ domain, project, committish }) => `git://${domain}/${project}.git${maybeJoin("#", committish)}`,
+      tarballtemplate: ({ project, committish }) => `https://codeload.github.com/gist/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
+      extract: (url) => {
+        let [, user, project, aux] = url.pathname.split("/", 4);
+        if (aux === "raw") {
+          return;
+        }
+        if (!project) {
+          if (!user) {
+            return;
+          }
+          project = user;
+          user = null;
+        }
+        if (project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        return { user, project, committish: url.hash.slice(1) };
+      },
+      hashformat: function(fragment) {
+        return fragment && "file-" + formatHashFragment(fragment);
+      }
+    };
+    hosts.sourcehut = {
+      protocols: ["git+ssh:", "https:"],
+      domain: "git.sr.ht",
+      treepath: "tree",
+      blobpath: "tree",
+      filetemplate: ({ domain, user, project, committish, path: path26 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path26}`,
+      httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}${maybeJoin("#", committish)}`,
+      tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
+      bugstemplate: () => null,
+      extract: (url) => {
+        let [, user, project, aux] = url.pathname.split("/", 4);
+        if (["archive"].includes(aux)) {
+          return;
+        }
+        if (project && project.endsWith(".git")) {
+          project = project.slice(0, -4);
+        }
+        if (!user || !project) {
+          return;
+        }
+        return { user, project, committish: url.hash.slice(1) };
+      }
+    };
+    for (const [name, host] of Object.entries(hosts)) {
+      hosts[name] = Object.assign({}, defaults2, host);
+    }
+    module.exports = hosts;
+  }
+});
+
+// node_modules/hosted-git-info/lib/parse-url.js
+var require_parse_url2 = __commonJS({
+  "node_modules/hosted-git-info/lib/parse-url.js"(exports, module) {
+    var url = __require("url");
+    var lastIndexOfBefore = (str2, char, beforeChar) => {
+      const startPosition = str2.indexOf(beforeChar);
+      return str2.lastIndexOf(char, startPosition > -1 ? startPosition : Infinity);
+    };
+    var safeUrl = (u2) => {
+      try {
+        return new url.URL(u2);
+      } catch {
+      }
+    };
+    var correctProtocol = (arg, protocols) => {
+      const firstColon = arg.indexOf(":");
+      const proto = arg.slice(0, firstColon + 1);
+      if (Object.prototype.hasOwnProperty.call(protocols, proto)) {
+        return arg;
+      }
+      if (arg.substr(firstColon, 3) === "://") {
+        return arg;
+      }
+      const firstAt = arg.indexOf("@");
+      if (firstAt > -1) {
+        if (firstAt > firstColon) {
+          return `git+ssh://${arg}`;
+        } else {
+          return arg;
+        }
+      }
+      return `${arg.slice(0, firstColon + 1)}//${arg.slice(firstColon + 1)}`;
+    };
+    var correctUrl = (giturl) => {
+      const firstAt = lastIndexOfBefore(giturl, "@", "#");
+      const lastColonBeforeHash = lastIndexOfBefore(giturl, ":", "#");
+      if (lastColonBeforeHash > firstAt) {
+        giturl = giturl.slice(0, lastColonBeforeHash) + "/" + giturl.slice(lastColonBeforeHash + 1);
+      }
+      if (lastIndexOfBefore(giturl, ":", "#") === -1 && giturl.indexOf("//") === -1) {
+        giturl = `git+ssh://${giturl}`;
+      }
+      return giturl;
+    };
+    module.exports = (giturl, protocols) => {
+      const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
+      return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
+    };
+  }
+});
+
+// node_modules/hosted-git-info/lib/from-url.js
+var require_from_url2 = __commonJS({
+  "node_modules/hosted-git-info/lib/from-url.js"(exports, module) {
+    "use strict";
+    var parseUrl = require_parse_url2();
+    var isGitHubShorthand = (arg) => {
+      const firstHash = arg.indexOf("#");
+      const firstSlash = arg.indexOf("/");
+      const secondSlash = arg.indexOf("/", firstSlash + 1);
+      const firstColon = arg.indexOf(":");
+      const firstSpace = /\s/.exec(arg);
+      const firstAt = arg.indexOf("@");
+      const spaceOnlyAfterHash = !firstSpace || firstHash > -1 && firstSpace.index > firstHash;
+      const atOnlyAfterHash = firstAt === -1 || firstHash > -1 && firstAt > firstHash;
+      const colonOnlyAfterHash = firstColon === -1 || firstHash > -1 && firstColon > firstHash;
+      const secondSlashOnlyAfterHash = secondSlash === -1 || firstHash > -1 && secondSlash > firstHash;
+      const hasSlash = firstSlash > 0;
+      const doesNotEndWithSlash = firstHash > -1 ? arg[firstHash - 1] !== "/" : !arg.endsWith("/");
+      const doesNotStartWithDot = !arg.startsWith(".");
+      return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
+    };
+    module.exports = (giturl, opts, { gitHosts, protocols }) => {
+      if (!giturl) {
+        return;
+      }
+      const correctedUrl = isGitHubShorthand(giturl) ? `github:${giturl}` : giturl;
+      const parsed = parseUrl(correctedUrl, protocols);
+      if (!parsed) {
+        return;
+      }
+      const gitHostShortcut = gitHosts.byShortcut[parsed.protocol];
+      const gitHostDomain = gitHosts.byDomain[parsed.hostname.startsWith("www.") ? parsed.hostname.slice(4) : parsed.hostname];
+      const gitHostName = gitHostShortcut || gitHostDomain;
+      if (!gitHostName) {
+        return;
+      }
+      const gitHostInfo = gitHosts[gitHostShortcut || gitHostDomain];
+      let auth = null;
+      if (protocols[parsed.protocol]?.auth && (parsed.username || parsed.password)) {
+        auth = `${parsed.username}${parsed.password ? ":" + parsed.password : ""}`;
+      }
+      let committish = null;
+      let user = null;
+      let project = null;
+      let defaultRepresentation = null;
+      try {
+        if (gitHostShortcut) {
+          let pathname = parsed.pathname.startsWith("/") ? parsed.pathname.slice(1) : parsed.pathname;
+          const firstAt = pathname.indexOf("@");
+          if (firstAt > -1) {
+            pathname = pathname.slice(firstAt + 1);
+          }
+          const lastSlash = pathname.lastIndexOf("/");
+          if (lastSlash > -1) {
+            user = decodeURIComponent(pathname.slice(0, lastSlash));
+            if (!user) {
+              user = null;
+            }
+            project = decodeURIComponent(pathname.slice(lastSlash + 1));
+          } else {
+            project = decodeURIComponent(pathname);
+          }
+          if (project.endsWith(".git")) {
+            project = project.slice(0, -4);
+          }
+          if (parsed.hash) {
+            committish = decodeURIComponent(parsed.hash.slice(1));
+          }
+          defaultRepresentation = "shortcut";
+        } else {
+          if (!gitHostInfo.protocols.includes(parsed.protocol)) {
+            return;
+          }
+          const segments = gitHostInfo.extract(parsed);
+          if (!segments) {
+            return;
+          }
+          user = segments.user && decodeURIComponent(segments.user);
+          project = decodeURIComponent(segments.project);
+          committish = decodeURIComponent(segments.committish);
+          defaultRepresentation = protocols[parsed.protocol]?.name || parsed.protocol.slice(0, -1);
+        }
+      } catch (err) {
+        if (err instanceof URIError) {
+          return;
+        } else {
+          throw err;
+        }
+      }
+      return [gitHostName, user, auth, project, committish, defaultRepresentation, opts];
+    };
+  }
+});
+
+// node_modules/hosted-git-info/lib/index.js
+var require_lib6 = __commonJS({
+  "node_modules/hosted-git-info/lib/index.js"(exports, module) {
+    "use strict";
+    var { LRUCache } = require_index_min2();
+    var hosts = require_hosts2();
+    var fromUrl = require_from_url2();
+    var parseUrl = require_parse_url2();
+    var cache2 = new LRUCache({ max: 1e3 });
+    function unknownHostedUrl(url) {
+      try {
+        const {
+          protocol,
+          hostname,
+          pathname
+        } = new URL(url);
+        if (!hostname) {
+          return null;
+        }
+        const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
+        const path26 = pathname.replace(/\.git$/, "");
+        return `${proto}//${hostname}${path26}`;
+      } catch {
+        return null;
+      }
+    }
+    var GitHost = class _GitHost {
+      constructor(type2, user, auth, project, committish, defaultRepresentation, opts = {}) {
+        Object.assign(this, _GitHost.#gitHosts[type2], {
+          type: type2,
+          user,
+          auth,
+          project,
+          committish,
+          default: defaultRepresentation,
+          opts
+        });
+      }
+      static #gitHosts = { byShortcut: {}, byDomain: {} };
+      static #protocols = {
+        "git+ssh:": { name: "sshurl" },
+        "ssh:": { name: "sshurl" },
+        "git+https:": { name: "https", auth: true },
+        "git:": { auth: true },
+        "http:": { auth: true },
+        "https:": { auth: true },
+        "git+http:": { auth: true }
+      };
+      static addHost(name, host) {
+        _GitHost.#gitHosts[name] = host;
+        _GitHost.#gitHosts.byDomain[host.domain] = name;
+        _GitHost.#gitHosts.byShortcut[`${name}:`] = name;
+        _GitHost.#protocols[`${name}:`] = { name };
+      }
+      static fromUrl(giturl, opts) {
+        if (typeof giturl !== "string") {
+          return;
+        }
+        const key = giturl + JSON.stringify(opts || {});
+        if (!cache2.has(key)) {
+          const hostArgs = fromUrl(giturl, opts, {
+            gitHosts: _GitHost.#gitHosts,
+            protocols: _GitHost.#protocols
+          });
+          cache2.set(key, hostArgs ? new _GitHost(...hostArgs) : void 0);
         }
+        return cache2.get(key);
       }
-      return null;
-    };
-    var anyCorrection = function(identifier, check) {
-      for (var i2 = 0; i2 < transpositions.length; i2++) {
-        var transposition = transpositions[i2];
-        var transposed = transposition[TRANSPOSED];
-        if (identifier.indexOf(transposed) > -1) {
-          var corrected = identifier.replace(
-            transposed,
-            transposition[CORRECT]
-          );
-          var checked = check(corrected);
-          if (checked !== null) {
-            return checked;
-          }
+      static fromManifest(manifest, opts = {}) {
+        if (!manifest || typeof manifest !== "object") {
+          return;
+        }
+        const r = manifest.repository;
+        const rurl = r && (typeof r === "string" ? r : typeof r === "object" && typeof r.url === "string" ? r.url : null);
+        if (!rurl) {
+          throw new Error("no repository");
+        }
+        const info = rurl && _GitHost.fromUrl(rurl.replace(/^git\+/, ""), opts) || null;
+        if (info) {
+          return info;
         }
+        const unk = unknownHostedUrl(rurl);
+        return _GitHost.fromUrl(unk, opts) || unk;
       }
-      return null;
-    };
-    module.exports = function(identifier, options) {
-      options = options || {};
-      var upgrade = options.upgrade === void 0 ? true : !!options.upgrade;
-      function postprocess(value) {
-        return upgrade ? upgradeGPLs(value) : value;
+      static parseUrl(url) {
+        return parseUrl(url);
       }
-      var validArugment = typeof identifier === "string" && identifier.trim().length !== 0;
-      if (!validArugment) {
-        throw Error("Invalid argument. Expected non-empty string.");
+      #fill(template, opts) {
+        if (typeof template !== "function") {
+          return null;
+        }
+        const options = { ...this, ...this.opts, ...opts };
+        if (!options.path) {
+          options.path = "";
+        }
+        if (options.path.startsWith("/")) {
+          options.path = options.path.slice(1);
+        }
+        if (options.noCommittish) {
+          options.committish = null;
+        }
+        const result = template(options);
+        return options.noGitPlus && result.startsWith("git+") ? result.slice(4) : result;
       }
-      identifier = identifier.trim();
-      if (valid(identifier)) {
-        return postprocess(identifier);
+      hash() {
+        return this.committish ? `#${this.committish}` : "";
       }
-      var noPlus = identifier.replace(/\+$/, "").trim();
-      if (valid(noPlus)) {
-        return postprocess(noPlus);
+      ssh(opts) {
+        return this.#fill(this.sshtemplate, opts);
       }
-      var transformed = validTransformation(identifier);
-      if (transformed !== null) {
-        return postprocess(transformed);
+      sshurl(opts) {
+        return this.#fill(this.sshurltemplate, opts);
       }
-      transformed = anyCorrection(identifier, function(argument) {
-        if (valid(argument)) {
-          return argument;
+      browse(path26, ...args) {
+        if (typeof path26 !== "string") {
+          return this.#fill(this.browsetemplate, path26);
         }
-        return validTransformation(argument);
-      });
-      if (transformed !== null) {
-        return postprocess(transformed);
+        if (typeof args[0] !== "string") {
+          return this.#fill(this.browsetreetemplate, { ...args[0], path: path26 });
+        }
+        return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path26 });
       }
-      transformed = validLastResort(identifier);
-      if (transformed !== null) {
-        return postprocess(transformed);
+      // If the path is known to be a file, then browseFile should be used. For some hosts
+      // the url is the same as browse, but for others like GitHub a file can use both `/tree/`
+      // and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
+      // path will redirect to a specific commit. Using the `/blob/` path avoids this and
+      // does not redirect to a different commit.
+      browseFile(path26, ...args) {
+        if (typeof args[0] !== "string") {
+          return this.#fill(this.browseblobtemplate, { ...args[0], path: path26 });
+        }
+        return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path26 });
       }
-      transformed = anyCorrection(identifier, validLastResort);
-      if (transformed !== null) {
-        return postprocess(transformed);
+      docs(opts) {
+        return this.#fill(this.docstemplate, opts);
       }
-      return null;
-    };
-    function upgradeGPLs(value) {
-      if ([
-        "GPL-1.0",
-        "LGPL-1.0",
-        "AGPL-1.0",
-        "GPL-2.0",
-        "LGPL-2.0",
-        "AGPL-2.0",
-        "LGPL-2.1"
-      ].indexOf(value) !== -1) {
-        return value + "-only";
-      } else if ([
-        "GPL-1.0+",
-        "GPL-2.0+",
-        "GPL-3.0+",
-        "LGPL-2.0+",
-        "LGPL-2.1+",
-        "LGPL-3.0+",
-        "AGPL-1.0+",
-        "AGPL-3.0+"
-      ].indexOf(value) !== -1) {
-        return value.replace(/\+$/, "-or-later");
-      } else if (["GPL-3.0", "LGPL-3.0", "AGPL-3.0"].indexOf(value) !== -1) {
-        return value + "-or-later";
-      } else {
-        return value;
+      bugs(opts) {
+        return this.#fill(this.bugstemplate, opts);
       }
-    }
-  }
-});
-
-// node_modules/validate-npm-package-license/index.js
-var require_validate_npm_package_license = __commonJS({
-  "node_modules/validate-npm-package-license/index.js"(exports, module) {
-    var parse2 = require_spdx_expression_parse();
-    var correct = require_spdx_correct();
-    var genericWarning = 'license should be a valid SPDX license expression (without "LicenseRef"), "UNLICENSED", or "SEE LICENSE IN <filename>"';
-    var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
-    function startsWith(prefix, string) {
-      return string.slice(0, prefix.length) === prefix;
-    }
-    function usesLicenseRef(ast) {
-      if (ast.hasOwnProperty("license")) {
-        var license = ast.license;
-        return startsWith("LicenseRef", license) || startsWith("DocumentRef", license);
-      } else {
-        return usesLicenseRef(ast.left) || usesLicenseRef(ast.right);
+      https(opts) {
+        return this.#fill(this.httpstemplate, opts);
       }
-    }
-    module.exports = function(argument) {
-      var ast;
-      try {
-        ast = parse2(argument);
-      } catch (e) {
-        var match2;
-        if (argument === "UNLICENSED" || argument === "UNLICENCED") {
-          return {
-            validForOldPackages: true,
-            validForNewPackages: true,
-            unlicensed: true
-          };
-        } else if (match2 = fileReferenceRE.exec(argument)) {
-          return {
-            validForOldPackages: true,
-            validForNewPackages: true,
-            inFile: match2[1]
-          };
-        } else {
-          var result = {
-            validForOldPackages: false,
-            validForNewPackages: false,
-            warnings: [genericWarning]
-          };
-          if (argument.trim().length !== 0) {
-            var corrected = correct(argument);
-            if (corrected) {
-              result.warnings.push(
-                'license is similar to the valid expression "' + corrected + '"'
-              );
-            }
-          }
-          return result;
-        }
+      git(opts) {
+        return this.#fill(this.gittemplate, opts);
       }
-      if (usesLicenseRef(ast)) {
-        return {
-          validForNewPackages: false,
-          validForOldPackages: false,
-          spdx: true,
-          warnings: [genericWarning]
-        };
-      } else {
-        return {
-          validForNewPackages: true,
-          validForOldPackages: true,
-          spdx: true
-        };
+      shortcut(opts) {
+        return this.#fill(this.shortcuttemplate, opts);
+      }
+      path(opts) {
+        return this.#fill(this.pathtemplate, opts);
+      }
+      tarball(opts) {
+        return this.#fill(this.tarballtemplate, { ...opts, noCommittish: false });
+      }
+      file(path26, opts) {
+        return this.#fill(this.filetemplate, { ...opts, path: path26 });
+      }
+      edit(path26, opts) {
+        return this.#fill(this.edittemplate, { ...opts, path: path26 });
+      }
+      getDefaultRepresentation() {
+        return this.default;
+      }
+      toString(opts) {
+        if (this.default && typeof this[this.default] === "function") {
+          return this[this.default](opts);
+        }
+        return this.sshurl(opts);
       }
     };
+    for (const [name, host] of Object.entries(hosts)) {
+      GitHost.addHost(name, host);
+    }
+    module.exports = GitHost;
   }
 });
 
@@ -14088,7 +15175,7 @@ var require_fixer = __commonJS({
     var isValidSemver = require_valid();
     var cleanSemver = require_clean();
     var validateLicense = require_validate_npm_package_license();
-    var hostedGitInfo = require_lib();
+    var hostedGitInfo = require_lib6();
     var { isBuiltin } = __require("node:module");
     var depTypes = ["dependencies", "devDependencies", "optionalDependencies"];
     var extractDescription = require_extract_description();
@@ -28401,6 +29488,9 @@ var getCustomProtocol = (urlString) => {
   try {
     const { protocol } = new URL(urlString);
     const hasAuthority = urlString.slice(0, protocol.length + 2).toLowerCase() === `${protocol}//`;
+    if (protocol === "localhost:" && !hasAuthority && /^\d{1,5}([/?#]|$)/.test(urlString.slice(protocol.length))) {
+      return void 0;
+    }
     if (protocol.endsWith(":") && (!protocol.includes(".") || hasAuthority) && !supportedProtocols.has(protocol)) {
       return protocol;
     }