"use client";
import { p as k, g as pt } from "./index.package-CyosW65c.js";
var Re = { exports: {} };
const $t = "2.0.0", Je = 256, mt = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
9007199254740991, vt = 16, Rt = Je - 6, gt = [
  "major",
  "premajor",
  "minor",
  "preminor",
  "patch",
  "prepatch",
  "prerelease"
];
var ie = {
  MAX_LENGTH: Je,
  MAX_SAFE_COMPONENT_LENGTH: vt,
  MAX_SAFE_BUILD_LENGTH: Rt,
  MAX_SAFE_INTEGER: mt,
  RELEASE_TYPES: gt,
  SEMVER_SPEC_VERSION: $t,
  FLAG_INCLUDE_PRERELEASE: 1,
  FLAG_LOOSE: 2
};
const It = typeof k == "object" && k.env && k.env.NODE_DEBUG && /\bsemver\b/i.test(k.env.NODE_DEBUG) ? (...r) => {
} : () => {
};
var ae = It;
(function(r, e) {
  const {
    MAX_SAFE_COMPONENT_LENGTH: t,
    MAX_SAFE_BUILD_LENGTH: s,
    MAX_LENGTH: n
  } = ie, a = ae;
  e = r.exports = {};
  const u = e.re = [], p = e.safeRe = [], i = e.src = [], l = e.t = {};
  let c = 0;
  const E = "[a-zA-Z0-9-]", A = [
    ["\\s", 1],
    ["\\d", n],
    [E, s]
  ], $ = (b) => {
    for (const [C, U] of A)
      b = b.split(`${C}*`).join(`${C}{0,${U}}`).split(`${C}+`).join(`${C}{1,${U}}`);
    return b;
  }, m = (b, C, U) => {
    const y = $(C), X = c++;
    a(b, X, C), l[b] = X, i[X] = C, u[X] = new RegExp(C, U ? "g" : void 0), p[X] = new RegExp(y, U ? "g" : void 0);
  };
  m("NUMERICIDENTIFIER", "0|[1-9]\\d*"), m("NUMERICIDENTIFIERLOOSE", "\\d+"), m("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${E}*`), m("MAINVERSION", `(${i[l.NUMERICIDENTIFIER]})\\.(${i[l.NUMERICIDENTIFIER]})\\.(${i[l.NUMERICIDENTIFIER]})`), m("MAINVERSIONLOOSE", `(${i[l.NUMERICIDENTIFIERLOOSE]})\\.(${i[l.NUMERICIDENTIFIERLOOSE]})\\.(${i[l.NUMERICIDENTIFIERLOOSE]})`), m("PRERELEASEIDENTIFIER", `(?:${i[l.NUMERICIDENTIFIER]}|${i[l.NONNUMERICIDENTIFIER]})`), m("PRERELEASEIDENTIFIERLOOSE", `(?:${i[l.NUMERICIDENTIFIERLOOSE]}|${i[l.NONNUMERICIDENTIFIER]})`), m("PRERELEASE", `(?:-(${i[l.PRERELEASEIDENTIFIER]}(?:\\.${i[l.PRERELEASEIDENTIFIER]})*))`), m("PRERELEASELOOSE", `(?:-?(${i[l.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${i[l.PRERELEASEIDENTIFIERLOOSE]})*))`), m("BUILDIDENTIFIER", `${E}+`), m("BUILD", `(?:\\+(${i[l.BUILDIDENTIFIER]}(?:\\.${i[l.BUILDIDENTIFIER]})*))`), m("FULLPLAIN", `v?${i[l.MAINVERSION]}${i[l.PRERELEASE]}?${i[l.BUILD]}?`), m("FULL", `^${i[l.FULLPLAIN]}$`), m("LOOSEPLAIN", `[v=\\s]*${i[l.MAINVERSIONLOOSE]}${i[l.PRERELEASELOOSE]}?${i[l.BUILD]}?`), m("LOOSE", `^${i[l.LOOSEPLAIN]}$`), m("GTLT", "((?:<|>)?=?)"), m("XRANGEIDENTIFIERLOOSE", `${i[l.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), m("XRANGEIDENTIFIER", `${i[l.NUMERICIDENTIFIER]}|x|X|\\*`), m("XRANGEPLAIN", `[v=\\s]*(${i[l.XRANGEIDENTIFIER]})(?:\\.(${i[l.XRANGEIDENTIFIER]})(?:\\.(${i[l.XRANGEIDENTIFIER]})(?:${i[l.PRERELEASE]})?${i[l.BUILD]}?)?)?`), m("XRANGEPLAINLOOSE", `[v=\\s]*(${i[l.XRANGEIDENTIFIERLOOSE]})(?:\\.(${i[l.XRANGEIDENTIFIERLOOSE]})(?:\\.(${i[l.XRANGEIDENTIFIERLOOSE]})(?:${i[l.PRERELEASELOOSE]})?${i[l.BUILD]}?)?)?`), m("XRANGE", `^${i[l.GTLT]}\\s*${i[l.XRANGEPLAIN]}$`), m("XRANGELOOSE", `^${i[l.GTLT]}\\s*${i[l.XRANGEPLAINLOOSE]}$`), m("COERCEPLAIN", `(^|[^\\d])(\\d{1,${t}})(?:\\.(\\d{1,${t}}))?(?:\\.(\\d{1,${t}}))?`), m("COERCE", `${i[l.COERCEPLAIN]}(?:$|[^\\d])`), m("COERCEFULL", i[l.COERCEPLAIN] + `(?:${i[l.PRERELEASE]})?(?:${i[l.BUILD]})?(?:$|[^\\d])`), m("COERCERTL", i[l.COERCE], !0), m("COERCERTLFULL", i[l.COERCEFULL], !0), m("LONETILDE", "(?:~>?)"), m("TILDETRIM", `(\\s*)${i[l.LONETILDE]}\\s+`, !0), e.tildeTrimReplace = "$1~", m("TILDE", `^${i[l.LONETILDE]}${i[l.XRANGEPLAIN]}$`), m("TILDELOOSE", `^${i[l.LONETILDE]}${i[l.XRANGEPLAINLOOSE]}$`), m("LONECARET", "(?:\\^)"), m("CARETTRIM", `(\\s*)${i[l.LONECARET]}\\s+`, !0), e.caretTrimReplace = "$1^", m("CARET", `^${i[l.LONECARET]}${i[l.XRANGEPLAIN]}$`), m("CARETLOOSE", `^${i[l.LONECARET]}${i[l.XRANGEPLAINLOOSE]}$`), m("COMPARATORLOOSE", `^${i[l.GTLT]}\\s*(${i[l.LOOSEPLAIN]})$|^$`), m("COMPARATOR", `^${i[l.GTLT]}\\s*(${i[l.FULLPLAIN]})$|^$`), m("COMPARATORTRIM", `(\\s*)${i[l.GTLT]}\\s*(${i[l.LOOSEPLAIN]}|${i[l.XRANGEPLAIN]})`, !0), e.comparatorTrimReplace = "$1$2$3", m("HYPHENRANGE", `^\\s*(${i[l.XRANGEPLAIN]})\\s+-\\s+(${i[l.XRANGEPLAIN]})\\s*$`), m("HYPHENRANGELOOSE", `^\\s*(${i[l.XRANGEPLAINLOOSE]})\\s+-\\s+(${i[l.XRANGEPLAINLOOSE]})\\s*$`), m("STAR", "(<|>)?=?\\s*\\*"), m("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), m("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
})(Re, Re.exports);
var Q = Re.exports;
const Lt = Object.freeze({ loose: !0 }), Nt = Object.freeze({}), dt = (r) => r ? typeof r != "object" ? Lt : r : Nt;
var ge = dt;
const Te = /^[0-9]+$/, Qe = (r, e) => {
  const t = Te.test(r), s = Te.test(e);
  return t && s && (r = +r, e = +e), r === e ? 0 : t && !s ? -1 : s && !t ? 1 : r < e ? -1 : 1;
}, At = (r, e) => Qe(e, r);
var ke = {
  compareIdentifiers: Qe,
  rcompareIdentifiers: At
};
const ee = ae, { MAX_LENGTH: ye, MAX_SAFE_INTEGER: te } = ie, { safeRe: we, t: Pe } = Q, St = ge, { compareIdentifiers: Y } = ke;
let Ot = class G {
  constructor(e, t) {
    if (t = St(t), e instanceof G) {
      if (e.loose === !!t.loose && e.includePrerelease === !!t.includePrerelease)
        return e;
      e = e.version;
    } else if (typeof e != "string")
      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof e}".`);
    if (e.length > ye)
      throw new TypeError(
        `version is longer than ${ye} characters`
      );
    ee("SemVer", e, t), this.options = t, this.loose = !!t.loose, this.includePrerelease = !!t.includePrerelease;
    const s = e.trim().match(t.loose ? we[Pe.LOOSE] : we[Pe.FULL]);
    if (!s)
      throw new TypeError(`Invalid Version: ${e}`);
    if (this.raw = e, this.major = +s[1], this.minor = +s[2], this.patch = +s[3], this.major > te || this.major < 0)
      throw new TypeError("Invalid major version");
    if (this.minor > te || this.minor < 0)
      throw new TypeError("Invalid minor version");
    if (this.patch > te || this.patch < 0)
      throw new TypeError("Invalid patch version");
    s[4] ? this.prerelease = s[4].split(".").map((n) => {
      if (/^[0-9]+$/.test(n)) {
        const a = +n;
        if (a >= 0 && a < te)
          return a;
      }
      return n;
    }) : this.prerelease = [], this.build = s[5] ? s[5].split(".") : [], this.format();
  }
  format() {
    return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
  }
  toString() {
    return this.version;
  }
  compare(e) {
    if (ee("SemVer.compare", this.version, this.options, e), !(e instanceof G)) {
      if (typeof e == "string" && e === this.version)
        return 0;
      e = new G(e, this.options);
    }
    return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e);
  }
  compareMain(e) {
    return e instanceof G || (e = new G(e, this.options)), Y(this.major, e.major) || Y(this.minor, e.minor) || Y(this.patch, e.patch);
  }
  comparePre(e) {
    if (e instanceof G || (e = new G(e, this.options)), this.prerelease.length && !e.prerelease.length)
      return -1;
    if (!this.prerelease.length && e.prerelease.length)
      return 1;
    if (!this.prerelease.length && !e.prerelease.length)
      return 0;
    let t = 0;
    do {
      const s = this.prerelease[t], n = e.prerelease[t];
      if (ee("prerelease compare", t, s, n), s === void 0 && n === void 0)
        return 0;
      if (n === void 0)
        return 1;
      if (s === void 0)
        return -1;
      if (s === n)
        continue;
      return Y(s, n);
    } while (++t);
  }
  compareBuild(e) {
    e instanceof G || (e = new G(e, this.options));
    let t = 0;
    do {
      const s = this.build[t], n = e.build[t];
      if (ee("prerelease compare", t, s, n), s === void 0 && n === void 0)
        return 0;
      if (n === void 0)
        return 1;
      if (s === void 0)
        return -1;
      if (s === n)
        continue;
      return Y(s, n);
    } while (++t);
  }
  // preminor will bump the version up to the next minor release, and immediately
  // down to pre-release. premajor and prepatch work the same way.
  inc(e, t, s) {
    switch (e) {
      case "premajor":
        this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", t, s);
        break;
      case "preminor":
        this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t, s);
        break;
      case "prepatch":
        this.prerelease.length = 0, this.inc("patch", t, s), this.inc("pre", t, s);
        break;
      case "prerelease":
        this.prerelease.length === 0 && this.inc("patch", t, s), this.inc("pre", t, s);
        break;
      case "major":
        (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
        break;
      case "minor":
        (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
        break;
      case "patch":
        this.prerelease.length === 0 && this.patch++, this.prerelease = [];
        break;
      case "pre": {
        const n = Number(s) ? 1 : 0;
        if (!t && s === !1)
          throw new Error("invalid increment argument: identifier is empty");
        if (this.prerelease.length === 0)
          this.prerelease = [n];
        else {
          let a = this.prerelease.length;
          for (; --a >= 0; )
            typeof this.prerelease[a] == "number" && (this.prerelease[a]++, a = -2);
          if (a === -1) {
            if (t === this.prerelease.join(".") && s === !1)
              throw new Error("invalid increment argument: identifier already exists");
            this.prerelease.push(n);
          }
        }
        if (t) {
          let a = [t, n];
          s === !1 && (a = [t]), Y(this.prerelease[0], t) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = a) : this.prerelease = a;
        }
        break;
      }
      default:
        throw new Error(`invalid increment argument: ${e}`);
    }
    return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
  }
};
var w = Ot;
const Ce = w, Tt = (r, e, t = !1) => {
  if (r instanceof Ce)
    return r;
  try {
    return new Ce(r, e);
  } catch (s) {
    if (!t)
      return null;
    throw s;
  }
};
var W = Tt;
const yt = W, wt = (r, e) => {
  const t = yt(r, e);
  return t ? t.version : null;
};
var Pt = wt;
const Ct = W, xt = (r, e) => {
  const t = Ct(r.trim().replace(/^[=v]+/, ""), e);
  return t ? t.version : null;
};
var Dt = xt;
const xe = w, _t = (r, e, t, s, n) => {
  typeof t == "string" && (n = s, s = t, t = void 0);
  try {
    return new xe(
      r instanceof xe ? r.version : r,
      t
    ).inc(e, s, n).version;
  } catch {
    return null;
  }
};
var Gt = _t;
const De = W, jt = (r, e) => {
  const t = De(r, null, !0), s = De(e, null, !0), n = t.compare(s);
  if (n === 0)
    return null;
  const a = n > 0, u = a ? t : s, p = a ? s : t, i = !!u.prerelease.length;
  if (!!p.prerelease.length && !i)
    return !p.patch && !p.minor ? "major" : u.patch ? "patch" : u.minor ? "minor" : "major";
  const c = i ? "pre" : "";
  return t.major !== s.major ? c + "major" : t.minor !== s.minor ? c + "minor" : t.patch !== s.patch ? c + "patch" : "prerelease";
};
var Ft = jt;
const bt = w, Ut = (r, e) => new bt(r, e).major;
var Xt = Ut;
const Vt = w, Ht = (r, e) => new Vt(r, e).minor;
var qt = Ht;
const Yt = w, Mt = (r, e) => new Yt(r, e).patch;
var Bt = Mt;
const Wt = W, zt = (r, e) => {
  const t = Wt(r, e);
  return t && t.prerelease.length ? t.prerelease : null;
};
var Zt = zt;
const _e = w, Kt = (r, e, t) => new _e(r, t).compare(new _e(e, t));
var D = Kt;
const Jt = D, Qt = (r, e, t) => Jt(e, r, t);
var kt = Qt;
const er = D, tr = (r, e) => er(r, e, !0);
var rr = tr;
const Ge = w, sr = (r, e, t) => {
  const s = new Ge(r, t), n = new Ge(e, t);
  return s.compare(n) || s.compareBuild(n);
};
var Ie = sr;
const nr = Ie, ir = (r, e) => r.sort((t, s) => nr(t, s, e));
var ar = ir;
const lr = Ie, or = (r, e) => r.sort((t, s) => lr(s, t, e));
var cr = or;
const hr = D, ur = (r, e, t) => hr(r, e, t) > 0;
var le = ur;
const fr = D, Er = (r, e, t) => fr(r, e, t) < 0;
var Le = Er;
const pr = D, $r = (r, e, t) => pr(r, e, t) === 0;
var et = $r;
const mr = D, vr = (r, e, t) => mr(r, e, t) !== 0;
var tt = vr;
const Rr = D, gr = (r, e, t) => Rr(r, e, t) >= 0;
var Ne = gr;
const Ir = D, Lr = (r, e, t) => Ir(r, e, t) <= 0;
var de = Lr;
const Nr = et, dr = tt, Ar = le, Sr = Ne, Or = Le, Tr = de, yr = (r, e, t, s) => {
  switch (e) {
    case "===":
      return typeof r == "object" && (r = r.version), typeof t == "object" && (t = t.version), r === t;
    case "!==":
      return typeof r == "object" && (r = r.version), typeof t == "object" && (t = t.version), r !== t;
    case "":
    case "=":
    case "==":
      return Nr(r, t, s);
    case "!=":
      return dr(r, t, s);
    case ">":
      return Ar(r, t, s);
    case ">=":
      return Sr(r, t, s);
    case "<":
      return Or(r, t, s);
    case "<=":
      return Tr(r, t, s);
    default:
      throw new TypeError(`Invalid operator: ${e}`);
  }
};
var rt = yr;
const wr = w, Pr = W, { safeRe: re, t: se } = Q, Cr = (r, e) => {
  if (r instanceof wr)
    return r;
  if (typeof r == "number" && (r = String(r)), typeof r != "string")
    return null;
  e = e || {};
  let t = null;
  if (!e.rtl)
    t = r.match(e.includePrerelease ? re[se.COERCEFULL] : re[se.COERCE]);
  else {
    const i = e.includePrerelease ? re[se.COERCERTLFULL] : re[se.COERCERTL];
    let l;
    for (; (l = i.exec(r)) && (!t || t.index + t[0].length !== r.length); )
      (!t || l.index + l[0].length !== t.index + t[0].length) && (t = l), i.lastIndex = l.index + l[1].length + l[2].length;
    i.lastIndex = -1;
  }
  if (t === null)
    return null;
  const s = t[2], n = t[3] || "0", a = t[4] || "0", u = e.includePrerelease && t[5] ? `-${t[5]}` : "", p = e.includePrerelease && t[6] ? `+${t[6]}` : "";
  return Pr(`${s}.${n}.${a}${u}${p}`, e);
};
var xr = Cr, he, je;
function Dr() {
  return je || (je = 1, he = function(r) {
    r.prototype[Symbol.iterator] = function* () {
      for (let e = this.head; e; e = e.next)
        yield e.value;
    };
  }), he;
}
var _r = N;
N.Node = q;
N.create = N;
function N(r) {
  var e = this;
  if (e instanceof N || (e = new N()), e.tail = null, e.head = null, e.length = 0, r && typeof r.forEach == "function")
    r.forEach(function(n) {
      e.push(n);
    });
  else if (arguments.length > 0)
    for (var t = 0, s = arguments.length; t < s; t++)
      e.push(arguments[t]);
  return e;
}
N.prototype.removeNode = function(r) {
  if (r.list !== this)
    throw new Error("removing node which does not belong to this list");
  var e = r.next, t = r.prev;
  return e && (e.prev = t), t && (t.next = e), r === this.head && (this.head = e), r === this.tail && (this.tail = t), r.list.length--, r.next = null, r.prev = null, r.list = null, e;
};
N.prototype.unshiftNode = function(r) {
  if (r !== this.head) {
    r.list && r.list.removeNode(r);
    var e = this.head;
    r.list = this, r.next = e, e && (e.prev = r), this.head = r, this.tail || (this.tail = r), this.length++;
  }
};
N.prototype.pushNode = function(r) {
  if (r !== this.tail) {
    r.list && r.list.removeNode(r);
    var e = this.tail;
    r.list = this, r.prev = e, e && (e.next = r), this.tail = r, this.head || (this.head = r), this.length++;
  }
};
N.prototype.push = function() {
  for (var r = 0, e = arguments.length; r < e; r++)
    jr(this, arguments[r]);
  return this.length;
};
N.prototype.unshift = function() {
  for (var r = 0, e = arguments.length; r < e; r++)
    Fr(this, arguments[r]);
  return this.length;
};
N.prototype.pop = function() {
  if (this.tail) {
    var r = this.tail.value;
    return this.tail = this.tail.prev, this.tail ? this.tail.next = null : this.head = null, this.length--, r;
  }
};
N.prototype.shift = function() {
  if (this.head) {
    var r = this.head.value;
    return this.head = this.head.next, this.head ? this.head.prev = null : this.tail = null, this.length--, r;
  }
};
N.prototype.forEach = function(r, e) {
  e = e || this;
  for (var t = this.head, s = 0; t !== null; s++)
    r.call(e, t.value, s, this), t = t.next;
};
N.prototype.forEachReverse = function(r, e) {
  e = e || this;
  for (var t = this.tail, s = this.length - 1; t !== null; s--)
    r.call(e, t.value, s, this), t = t.prev;
};
N.prototype.get = function(r) {
  for (var e = 0, t = this.head; t !== null && e < r; e++)
    t = t.next;
  if (e === r && t !== null)
    return t.value;
};
N.prototype.getReverse = function(r) {
  for (var e = 0, t = this.tail; t !== null && e < r; e++)
    t = t.prev;
  if (e === r && t !== null)
    return t.value;
};
N.prototype.map = function(r, e) {
  e = e || this;
  for (var t = new N(), s = this.head; s !== null; )
    t.push(r.call(e, s.value, this)), s = s.next;
  return t;
};
N.prototype.mapReverse = function(r, e) {
  e = e || this;
  for (var t = new N(), s = this.tail; s !== null; )
    t.push(r.call(e, s.value, this)), s = s.prev;
  return t;
};
N.prototype.reduce = function(r, e) {
  var t, s = this.head;
  if (arguments.length > 1)
    t = e;
  else if (this.head)
    s = this.head.next, t = this.head.value;
  else
    throw new TypeError("Reduce of empty list with no initial value");
  for (var n = 0; s !== null; n++)
    t = r(t, s.value, n), s = s.next;
  return t;
};
N.prototype.reduceReverse = function(r, e) {
  var t, s = this.tail;
  if (arguments.length > 1)
    t = e;
  else if (this.tail)
    s = this.tail.prev, t = this.tail.value;
  else
    throw new TypeError("Reduce of empty list with no initial value");
  for (var n = this.length - 1; s !== null; n--)
    t = r(t, s.value, n), s = s.prev;
  return t;
};
N.prototype.toArray = function() {
  for (var r = new Array(this.length), e = 0, t = this.head; t !== null; e++)
    r[e] = t.value, t = t.next;
  return r;
};
N.prototype.toArrayReverse = function() {
  for (var r = new Array(this.length), e = 0, t = this.tail; t !== null; e++)
    r[e] = t.value, t = t.prev;
  return r;
};
N.prototype.slice = function(r, e) {
  e = e || this.length, e < 0 && (e += this.length), r = r || 0, r < 0 && (r += this.length);
  var t = new N();
  if (e < r || e < 0)
    return t;
  r < 0 && (r = 0), e > this.length && (e = this.length);
  for (var s = 0, n = this.head; n !== null && s < r; s++)
    n = n.next;
  for (; n !== null && s < e; s++, n = n.next)
    t.push(n.value);
  return t;
};
N.prototype.sliceReverse = function(r, e) {
  e = e || this.length, e < 0 && (e += this.length), r = r || 0, r < 0 && (r += this.length);
  var t = new N();
  if (e < r || e < 0)
    return t;
  r < 0 && (r = 0), e > this.length && (e = this.length);
  for (var s = this.length, n = this.tail; n !== null && s > e; s--)
    n = n.prev;
  for (; n !== null && s > r; s--, n = n.prev)
    t.push(n.value);
  return t;
};
N.prototype.splice = function(r, e, ...t) {
  r > this.length && (r = this.length - 1), r < 0 && (r = this.length + r);
  for (var s = 0, n = this.head; n !== null && s < r; s++)
    n = n.next;
  for (var a = [], s = 0; n && s < e; s++)
    a.push(n.value), n = this.removeNode(n);
  n === null && (n = this.tail), n !== this.head && n !== this.tail && (n = n.prev);
  for (var s = 0; s < t.length; s++)
    n = Gr(this, n, t[s]);
  return a;
};
N.prototype.reverse = function() {
  for (var r = this.head, e = this.tail, t = r; t !== null; t = t.prev) {
    var s = t.prev;
    t.prev = t.next, t.next = s;
  }
  return this.head = e, this.tail = r, this;
};
function Gr(r, e, t) {
  var s = e === r.head ? new q(t, null, e, r) : new q(t, e, e.next, r);
  return s.next === null && (r.tail = s), s.prev === null && (r.head = s), r.length++, s;
}
function jr(r, e) {
  r.tail = new q(e, r.tail, null, r), r.head || (r.head = r.tail), r.length++;
}
function Fr(r, e) {
  r.head = new q(e, null, r.head, r), r.tail || (r.tail = r.head), r.length++;
}
function q(r, e, t, s) {
  if (!(this instanceof q))
    return new q(r, e, t, s);
  this.list = s, this.value = r, e ? (e.next = this, this.prev = e) : this.prev = null, t ? (t.prev = this, this.next = t) : this.next = null;
}
try {
  Dr()(N);
} catch {
}
const br = _r, V = Symbol("max"), F = Symbol("length"), M = Symbol("lengthCalculator"), J = Symbol("allowStale"), H = Symbol("maxAge"), j = Symbol("dispose"), Fe = Symbol("noDisposeOnSet"), T = Symbol("lruList"), x = Symbol("cache"), st = Symbol("updateAgeOnGet"), ue = () => 1;
class Ur {
  constructor(e) {
    if (typeof e == "number" && (e = { max: e }), e || (e = {}), e.max && (typeof e.max != "number" || e.max < 0))
      throw new TypeError("max must be a non-negative number");
    this[V] = e.max || 1 / 0;
    const t = e.length || ue;
    if (this[M] = typeof t != "function" ? ue : t, this[J] = e.stale || !1, e.maxAge && typeof e.maxAge != "number")
      throw new TypeError("maxAge must be a number");
    this[H] = e.maxAge || 0, this[j] = e.dispose, this[Fe] = e.noDisposeOnSet || !1, this[st] = e.updateAgeOnGet || !1, this.reset();
  }
  // resize the cache when the max changes.
  set max(e) {
    if (typeof e != "number" || e < 0)
      throw new TypeError("max must be a non-negative number");
    this[V] = e || 1 / 0, Z(this);
  }
  get max() {
    return this[V];
  }
  set allowStale(e) {
    this[J] = !!e;
  }
  get allowStale() {
    return this[J];
  }
  set maxAge(e) {
    if (typeof e != "number")
      throw new TypeError("maxAge must be a non-negative number");
    this[H] = e, Z(this);
  }
  get maxAge() {
    return this[H];
  }
  // resize the cache when the lengthCalculator changes.
  set lengthCalculator(e) {
    typeof e != "function" && (e = ue), e !== this[M] && (this[M] = e, this[F] = 0, this[T].forEach((t) => {
      t.length = this[M](t.value, t.key), this[F] += t.length;
    })), Z(this);
  }
  get lengthCalculator() {
    return this[M];
  }
  get length() {
    return this[F];
  }
  get itemCount() {
    return this[T].length;
  }
  rforEach(e, t) {
    t = t || this;
    for (let s = this[T].tail; s !== null; ) {
      const n = s.prev;
      be(this, e, s, t), s = n;
    }
  }
  forEach(e, t) {
    t = t || this;
    for (let s = this[T].head; s !== null; ) {
      const n = s.next;
      be(this, e, s, t), s = n;
    }
  }
  keys() {
    return this[T].toArray().map((e) => e.key);
  }
  values() {
    return this[T].toArray().map((e) => e.value);
  }
  reset() {
    this[j] && this[T] && this[T].length && this[T].forEach((e) => this[j](e.key, e.value)), this[x] = /* @__PURE__ */ new Map(), this[T] = new br(), this[F] = 0;
  }
  dump() {
    return this[T].map((e) => ne(this, e) ? !1 : {
      k: e.key,
      v: e.value,
      e: e.now + (e.maxAge || 0)
    }).toArray().filter((e) => e);
  }
  dumpLru() {
    return this[T];
  }
  set(e, t, s) {
    if (s = s || this[H], s && typeof s != "number")
      throw new TypeError("maxAge must be a number");
    const n = s ? Date.now() : 0, a = this[M](t, e);
    if (this[x].has(e)) {
      if (a > this[V])
        return B(this, this[x].get(e)), !1;
      const i = this[x].get(e).value;
      return this[j] && (this[Fe] || this[j](e, i.value)), i.now = n, i.maxAge = s, i.value = t, this[F] += a - i.length, i.length = a, this.get(e), Z(this), !0;
    }
    const u = new Xr(e, t, a, n, s);
    return u.length > this[V] ? (this[j] && this[j](e, t), !1) : (this[F] += u.length, this[T].unshift(u), this[x].set(e, this[T].head), Z(this), !0);
  }
  has(e) {
    if (!this[x].has(e)) return !1;
    const t = this[x].get(e).value;
    return !ne(this, t);
  }
  get(e) {
    return fe(this, e, !0);
  }
  peek(e) {
    return fe(this, e, !1);
  }
  pop() {
    const e = this[T].tail;
    return e ? (B(this, e), e.value) : null;
  }
  del(e) {
    B(this, this[x].get(e));
  }
  load(e) {
    this.reset();
    const t = Date.now();
    for (let s = e.length - 1; s >= 0; s--) {
      const n = e[s], a = n.e || 0;
      if (a === 0)
        this.set(n.k, n.v);
      else {
        const u = a - t;
        u > 0 && this.set(n.k, n.v, u);
      }
    }
  }
  prune() {
    this[x].forEach((e, t) => fe(this, t, !1));
  }
}
const fe = (r, e, t) => {
  const s = r[x].get(e);
  if (s) {
    const n = s.value;
    if (ne(r, n)) {
      if (B(r, s), !r[J])
        return;
    } else
      t && (r[st] && (s.value.now = Date.now()), r[T].unshiftNode(s));
    return n.value;
  }
}, ne = (r, e) => {
  if (!e || !e.maxAge && !r[H])
    return !1;
  const t = Date.now() - e.now;
  return e.maxAge ? t > e.maxAge : r[H] && t > r[H];
}, Z = (r) => {
  if (r[F] > r[V])
    for (let e = r[T].tail; r[F] > r[V] && e !== null; ) {
      const t = e.prev;
      B(r, e), e = t;
    }
}, B = (r, e) => {
  if (e) {
    const t = e.value;
    r[j] && r[j](t.key, t.value), r[F] -= t.length, r[x].delete(t.key), r[T].removeNode(e);
  }
};
class Xr {
  constructor(e, t, s, n, a) {
    this.key = e, this.value = t, this.length = s, this.now = n, this.maxAge = a || 0;
  }
}
const be = (r, e, t, s) => {
  let n = t.value;
  ne(r, n) && (B(r, t), r[J] || (n = void 0)), n && e.call(s, n.value, n.key, r);
};
var Vr = Ur, Ee, Ue;
function _() {
  if (Ue) return Ee;
  Ue = 1;
  class r {
    constructor(o, g) {
      if (g = s(g), o instanceof r)
        return o.loose === !!g.loose && o.includePrerelease === !!g.includePrerelease ? o : new r(o.raw, g);
      if (o instanceof n)
        return this.raw = o.value, this.set = [[o]], this.format(), this;
      if (this.options = g, this.loose = !!g.loose, this.includePrerelease = !!g.includePrerelease, this.raw = o.trim().split(/\s+/).join(" "), this.set = this.raw.split("||").map((v) => this.parseRange(v.trim())).filter((v) => v.length), !this.set.length)
        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
      if (this.set.length > 1) {
        const v = this.set[0];
        if (this.set = this.set.filter((R) => !m(R[0])), this.set.length === 0)
          this.set = [v];
        else if (this.set.length > 1) {
          for (const R of this.set)
            if (R.length === 1 && b(R[0])) {
              this.set = [R];
              break;
            }
        }
      }
      this.format();
    }
    format() {
      return this.range = this.set.map((o) => o.join(" ").trim()).join("||").trim(), this.range;
    }
    toString() {
      return this.range;
    }
    parseRange(o) {
      const v = ((this.options.includePrerelease && A) | (this.options.loose && $)) + ":" + o, R = t.get(v);
      if (R)
        return R;
      const f = this.options.loose, I = f ? p[i.HYPHENRANGELOOSE] : p[i.HYPHENRANGE];
      o = o.replace(I, ft(this.options.includePrerelease)), a("hyphen replace", o), o = o.replace(p[i.COMPARATORTRIM], l), a("comparator trim", o), o = o.replace(p[i.TILDETRIM], c), a("tilde trim", o), o = o.replace(p[i.CARETTRIM], E), a("caret trim", o);
      let d = o.split(" ").map((O) => U(O, this.options)).join(" ").split(/\s+/).map((O) => ut(O, this.options));
      f && (d = d.filter((O) => (a("loose invalid filter", O, this.options), !!O.match(p[i.COMPARATORLOOSE])))), a("range list", d);
      const L = /* @__PURE__ */ new Map(), S = d.map((O) => new n(O, this.options));
      for (const O of S) {
        if (m(O))
          return [O];
        L.set(O.value, O);
      }
      L.size > 1 && L.has("") && L.delete("");
      const P = [...L.values()];
      return t.set(v, P), P;
    }
    intersects(o, g) {
      if (!(o instanceof r))
        throw new TypeError("a Range is required");
      return this.set.some((v) => C(v, g) && o.set.some((R) => C(R, g) && v.every((f) => R.every((I) => f.intersects(I, g)))));
    }
    // if ANY of the sets match ALL of its comparators, then pass
    test(o) {
      if (!o)
        return !1;
      if (typeof o == "string")
        try {
          o = new u(o, this.options);
        } catch {
          return !1;
        }
      for (let g = 0; g < this.set.length; g++)
        if (Et(this.set[g], o, this.options))
          return !0;
      return !1;
    }
  }
  Ee = r;
  const e = Vr, t = new e({ max: 1e3 }), s = ge, n = oe(), a = ae, u = w, {
    safeRe: p,
    t: i,
    comparatorTrimReplace: l,
    tildeTrimReplace: c,
    caretTrimReplace: E
  } = Q, { FLAG_INCLUDE_PRERELEASE: A, FLAG_LOOSE: $ } = ie, m = (h) => h.value === "<0.0.0-0", b = (h) => h.value === "", C = (h, o) => {
    let g = !0;
    const v = h.slice();
    let R = v.pop();
    for (; g && v.length; )
      g = v.every((f) => R.intersects(f, o)), R = v.pop();
    return g;
  }, U = (h, o) => (a("comp", h, o), h = at(h, o), a("caret", h), h = X(h, o), a("tildes", h), h = ot(h, o), a("xrange", h), h = ht(h, o), a("stars", h), h), y = (h) => !h || h.toLowerCase() === "x" || h === "*", X = (h, o) => h.trim().split(/\s+/).map((g) => it(g, o)).join(" "), it = (h, o) => {
    const g = o.loose ? p[i.TILDELOOSE] : p[i.TILDE];
    return h.replace(g, (v, R, f, I, d) => {
      a("tilde", h, v, R, f, I, d);
      let L;
      return y(R) ? L = "" : y(f) ? L = `>=${R}.0.0 <${+R + 1}.0.0-0` : y(I) ? L = `>=${R}.${f}.0 <${R}.${+f + 1}.0-0` : d ? (a("replaceTilde pr", d), L = `>=${R}.${f}.${I}-${d} <${R}.${+f + 1}.0-0`) : L = `>=${R}.${f}.${I} <${R}.${+f + 1}.0-0`, a("tilde return", L), L;
    });
  }, at = (h, o) => h.trim().split(/\s+/).map((g) => lt(g, o)).join(" "), lt = (h, o) => {
    a("caret", h, o);
    const g = o.loose ? p[i.CARETLOOSE] : p[i.CARET], v = o.includePrerelease ? "-0" : "";
    return h.replace(g, (R, f, I, d, L) => {
      a("caret", h, R, f, I, d, L);
      let S;
      return y(f) ? S = "" : y(I) ? S = `>=${f}.0.0${v} <${+f + 1}.0.0-0` : y(d) ? f === "0" ? S = `>=${f}.${I}.0${v} <${f}.${+I + 1}.0-0` : S = `>=${f}.${I}.0${v} <${+f + 1}.0.0-0` : L ? (a("replaceCaret pr", L), f === "0" ? I === "0" ? S = `>=${f}.${I}.${d}-${L} <${f}.${I}.${+d + 1}-0` : S = `>=${f}.${I}.${d}-${L} <${f}.${+I + 1}.0-0` : S = `>=${f}.${I}.${d}-${L} <${+f + 1}.0.0-0`) : (a("no pr"), f === "0" ? I === "0" ? S = `>=${f}.${I}.${d}${v} <${f}.${I}.${+d + 1}-0` : S = `>=${f}.${I}.${d}${v} <${f}.${+I + 1}.0-0` : S = `>=${f}.${I}.${d} <${+f + 1}.0.0-0`), a("caret return", S), S;
    });
  }, ot = (h, o) => (a("replaceXRanges", h, o), h.split(/\s+/).map((g) => ct(g, o)).join(" ")), ct = (h, o) => {
    h = h.trim();
    const g = o.loose ? p[i.XRANGELOOSE] : p[i.XRANGE];
    return h.replace(g, (v, R, f, I, d, L) => {
      a("xRange", h, v, R, f, I, d, L);
      const S = y(f), P = S || y(I), O = P || y(d), z = O;
      return R === "=" && z && (R = ""), L = o.includePrerelease ? "-0" : "", S ? R === ">" || R === "<" ? v = "<0.0.0-0" : v = "*" : R && z ? (P && (I = 0), d = 0, R === ">" ? (R = ">=", P ? (f = +f + 1, I = 0, d = 0) : (I = +I + 1, d = 0)) : R === "<=" && (R = "<", P ? f = +f + 1 : I = +I + 1), R === "<" && (L = "-0"), v = `${R + f}.${I}.${d}${L}`) : P ? v = `>=${f}.0.0${L} <${+f + 1}.0.0-0` : O && (v = `>=${f}.${I}.0${L} <${f}.${+I + 1}.0-0`), a("xRange return", v), v;
    });
  }, ht = (h, o) => (a("replaceStars", h, o), h.trim().replace(p[i.STAR], "")), ut = (h, o) => (a("replaceGTE0", h, o), h.trim().replace(p[o.includePrerelease ? i.GTE0PRE : i.GTE0], "")), ft = (h) => (o, g, v, R, f, I, d, L, S, P, O, z, $n) => (y(v) ? g = "" : y(R) ? g = `>=${v}.0.0${h ? "-0" : ""}` : y(f) ? g = `>=${v}.${R}.0${h ? "-0" : ""}` : I ? g = `>=${g}` : g = `>=${g}${h ? "-0" : ""}`, y(S) ? L = "" : y(P) ? L = `<${+S + 1}.0.0-0` : y(O) ? L = `<${S}.${+P + 1}.0-0` : z ? L = `<=${S}.${P}.${O}-${z}` : h ? L = `<${S}.${P}.${+O + 1}-0` : L = `<=${L}`, `${g} ${L}`.trim()), Et = (h, o, g) => {
    for (let v = 0; v < h.length; v++)
      if (!h[v].test(o))
        return !1;
    if (o.prerelease.length && !g.includePrerelease) {
      for (let v = 0; v < h.length; v++)
        if (a(h[v].semver), h[v].semver !== n.ANY && h[v].semver.prerelease.length > 0) {
          const R = h[v].semver;
          if (R.major === o.major && R.minor === o.minor && R.patch === o.patch)
            return !0;
        }
      return !1;
    }
    return !0;
  };
  return Ee;
}
var pe, Xe;
function oe() {
  if (Xe) return pe;
  Xe = 1;
  const r = Symbol("SemVer ANY");
  class e {
    static get ANY() {
      return r;
    }
    constructor(c, E) {
      if (E = t(E), c instanceof e) {
        if (c.loose === !!E.loose)
          return c;
        c = c.value;
      }
      c = c.trim().split(/\s+/).join(" "), u("comparator", c, E), this.options = E, this.loose = !!E.loose, this.parse(c), this.semver === r ? this.value = "" : this.value = this.operator + this.semver.version, u("comp", this);
    }
    parse(c) {
      const E = this.options.loose ? s[n.COMPARATORLOOSE] : s[n.COMPARATOR], A = c.match(E);
      if (!A)
        throw new TypeError(`Invalid comparator: ${c}`);
      this.operator = A[1] !== void 0 ? A[1] : "", this.operator === "=" && (this.operator = ""), A[2] ? this.semver = new p(A[2], this.options.loose) : this.semver = r;
    }
    toString() {
      return this.value;
    }
    test(c) {
      if (u("Comparator.test", c, this.options.loose), this.semver === r || c === r)
        return !0;
      if (typeof c == "string")
        try {
          c = new p(c, this.options);
        } catch {
          return !1;
        }
      return a(c, this.operator, this.semver, this.options);
    }
    intersects(c, E) {
      if (!(c instanceof e))
        throw new TypeError("a Comparator is required");
      return this.operator === "" ? this.value === "" ? !0 : new i(c.value, E).test(this.value) : c.operator === "" ? c.value === "" ? !0 : new i(this.value, E).test(c.semver) : (E = t(E), E.includePrerelease && (this.value === "<0.0.0-0" || c.value === "<0.0.0-0") || !E.includePrerelease && (this.value.startsWith("<0.0.0") || c.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && c.operator.startsWith(">") || this.operator.startsWith("<") && c.operator.startsWith("<") || this.semver.version === c.semver.version && this.operator.includes("=") && c.operator.includes("=") || a(this.semver, "<", c.semver, E) && this.operator.startsWith(">") && c.operator.startsWith("<") || a(this.semver, ">", c.semver, E) && this.operator.startsWith("<") && c.operator.startsWith(">")));
    }
  }
  pe = e;
  const t = ge, { safeRe: s, t: n } = Q, a = rt, u = ae, p = w, i = _();
  return pe;
}
const Hr = _(), qr = (r, e, t) => {
  try {
    e = new Hr(e, t);
  } catch {
    return !1;
  }
  return e.test(r);
};
var ce = qr;
const Yr = _(), Mr = (r, e) => new Yr(r, e).set.map((t) => t.map((s) => s.value).join(" ").trim().split(" "));
var Br = Mr;
const Wr = w, zr = _(), Zr = (r, e, t) => {
  let s = null, n = null, a = null;
  try {
    a = new zr(e, t);
  } catch {
    return null;
  }
  return r.forEach((u) => {
    a.test(u) && (!s || n.compare(u) === -1) && (s = u, n = new Wr(s, t));
  }), s;
};
var Kr = Zr;
const Jr = w, Qr = _(), kr = (r, e, t) => {
  let s = null, n = null, a = null;
  try {
    a = new Qr(e, t);
  } catch {
    return null;
  }
  return r.forEach((u) => {
    a.test(u) && (!s || n.compare(u) === 1) && (s = u, n = new Jr(s, t));
  }), s;
};
var es = kr;
const $e = w, ts = _(), Ve = le, rs = (r, e) => {
  r = new ts(r, e);
  let t = new $e("0.0.0");
  if (r.test(t) || (t = new $e("0.0.0-0"), r.test(t)))
    return t;
  t = null;
  for (let s = 0; s < r.set.length; ++s) {
    const n = r.set[s];
    let a = null;
    n.forEach((u) => {
      const p = new $e(u.semver.version);
      switch (u.operator) {
        case ">":
          p.prerelease.length === 0 ? p.patch++ : p.prerelease.push(0), p.raw = p.format();
        case "":
        case ">=":
          (!a || Ve(p, a)) && (a = p);
          break;
        case "<":
        case "<=":
          break;
        default:
          throw new Error(`Unexpected operation: ${u.operator}`);
      }
    }), a && (!t || Ve(t, a)) && (t = a);
  }
  return t && r.test(t) ? t : null;
};
var ss = rs;
const ns = _(), is = (r, e) => {
  try {
    return new ns(r, e).range || "*";
  } catch {
    return null;
  }
};
var as = is;
const ls = w, nt = oe(), { ANY: os } = nt, cs = _(), hs = ce, He = le, qe = Le, us = de, fs = Ne, Es = (r, e, t, s) => {
  r = new ls(r, s), e = new cs(e, s);
  let n, a, u, p, i;
  switch (t) {
    case ">":
      n = He, a = us, u = qe, p = ">", i = ">=";
      break;
    case "<":
      n = qe, a = fs, u = He, p = "<", i = "<=";
      break;
    default:
      throw new TypeError('Must provide a hilo val of "<" or ">"');
  }
  if (hs(r, e, s))
    return !1;
  for (let l = 0; l < e.set.length; ++l) {
    const c = e.set[l];
    let E = null, A = null;
    if (c.forEach(($) => {
      $.semver === os && ($ = new nt(">=0.0.0")), E = E || $, A = A || $, n($.semver, E.semver, s) ? E = $ : u($.semver, A.semver, s) && (A = $);
    }), E.operator === p || E.operator === i || (!A.operator || A.operator === p) && a(r, A.semver))
      return !1;
    if (A.operator === i && u(r, A.semver))
      return !1;
  }
  return !0;
};
var Ae = Es;
const ps = Ae, $s = (r, e, t) => ps(r, e, ">", t);
var ms = $s;
const vs = Ae, Rs = (r, e, t) => vs(r, e, "<", t);
var gs = Rs;
const Ye = _(), Is = (r, e, t) => (r = new Ye(r, t), e = new Ye(e, t), r.intersects(e, t));
var Ls = Is;
const Ns = ce, ds = D;
var As = (r, e, t) => {
  const s = [];
  let n = null, a = null;
  const u = r.sort((c, E) => ds(c, E, t));
  for (const c of u)
    Ns(c, e, t) ? (a = c, n || (n = c)) : (a && s.push([n, a]), a = null, n = null);
  n && s.push([n, null]);
  const p = [];
  for (const [c, E] of s)
    c === E ? p.push(c) : !E && c === u[0] ? p.push("*") : E ? c === u[0] ? p.push(`<=${E}`) : p.push(`${c} - ${E}`) : p.push(`>=${c}`);
  const i = p.join(" || "), l = typeof e.raw == "string" ? e.raw : String(e);
  return i.length < l.length ? i : e;
};
const Me = _(), Se = oe(), { ANY: me } = Se, K = ce, Oe = D, Ss = (r, e, t = {}) => {
  if (r === e)
    return !0;
  r = new Me(r, t), e = new Me(e, t);
  let s = !1;
  e: for (const n of r.set) {
    for (const a of e.set) {
      const u = Ts(n, a, t);
      if (s = s || u !== null, u)
        continue e;
    }
    if (s)
      return !1;
  }
  return !0;
}, Os = [new Se(">=0.0.0-0")], Be = [new Se(">=0.0.0")], Ts = (r, e, t) => {
  if (r === e)
    return !0;
  if (r.length === 1 && r[0].semver === me) {
    if (e.length === 1 && e[0].semver === me)
      return !0;
    t.includePrerelease ? r = Os : r = Be;
  }
  if (e.length === 1 && e[0].semver === me) {
    if (t.includePrerelease)
      return !0;
    e = Be;
  }
  const s = /* @__PURE__ */ new Set();
  let n, a;
  for (const $ of r)
    $.operator === ">" || $.operator === ">=" ? n = We(n, $, t) : $.operator === "<" || $.operator === "<=" ? a = ze(a, $, t) : s.add($.semver);
  if (s.size > 1)
    return null;
  let u;
  if (n && a) {
    if (u = Oe(n.semver, a.semver, t), u > 0)
      return null;
    if (u === 0 && (n.operator !== ">=" || a.operator !== "<="))
      return null;
  }
  for (const $ of s) {
    if (n && !K($, String(n), t) || a && !K($, String(a), t))
      return null;
    for (const m of e)
      if (!K($, String(m), t))
        return !1;
    return !0;
  }
  let p, i, l, c, E = a && !t.includePrerelease && a.semver.prerelease.length ? a.semver : !1, A = n && !t.includePrerelease && n.semver.prerelease.length ? n.semver : !1;
  E && E.prerelease.length === 1 && a.operator === "<" && E.prerelease[0] === 0 && (E = !1);
  for (const $ of e) {
    if (c = c || $.operator === ">" || $.operator === ">=", l = l || $.operator === "<" || $.operator === "<=", n) {
      if (A && $.semver.prerelease && $.semver.prerelease.length && $.semver.major === A.major && $.semver.minor === A.minor && $.semver.patch === A.patch && (A = !1), $.operator === ">" || $.operator === ">=") {
        if (p = We(n, $, t), p === $ && p !== n)
          return !1;
      } else if (n.operator === ">=" && !K(n.semver, String($), t))
        return !1;
    }
    if (a) {
      if (E && $.semver.prerelease && $.semver.prerelease.length && $.semver.major === E.major && $.semver.minor === E.minor && $.semver.patch === E.patch && (E = !1), $.operator === "<" || $.operator === "<=") {
        if (i = ze(a, $, t), i === $ && i !== a)
          return !1;
      } else if (a.operator === "<=" && !K(a.semver, String($), t))
        return !1;
    }
    if (!$.operator && (a || n) && u !== 0)
      return !1;
  }
  return !(n && l && !a && u !== 0 || a && c && !n && u !== 0 || A || E);
}, We = (r, e, t) => {
  if (!r)
    return e;
  const s = Oe(r.semver, e.semver, t);
  return s > 0 ? r : s < 0 || e.operator === ">" && r.operator === ">=" ? e : r;
}, ze = (r, e, t) => {
  if (!r)
    return e;
  const s = Oe(r.semver, e.semver, t);
  return s < 0 ? r : s > 0 || e.operator === "<" && r.operator === "<=" ? e : r;
};
var ys = Ss;
const ve = Q, Ze = ie, ws = w, Ke = ke, Ps = W, Cs = Pt, xs = Dt, Ds = Gt, _s = Ft, Gs = Xt, js = qt, Fs = Bt, bs = Zt, Us = D, Xs = kt, Vs = rr, Hs = Ie, qs = ar, Ys = cr, Ms = le, Bs = Le, Ws = et, zs = tt, Zs = Ne, Ks = de, Js = rt, Qs = xr, ks = oe(), en = _(), tn = ce, rn = Br, sn = Kr, nn = es, an = ss, ln = as, on = Ae, cn = ms, hn = gs, un = Ls, fn = As, En = ys;
var pn = {
  parse: Ps,
  valid: Cs,
  clean: xs,
  inc: Ds,
  diff: _s,
  major: Gs,
  minor: js,
  patch: Fs,
  prerelease: bs,
  compare: Us,
  rcompare: Xs,
  compareLoose: Vs,
  compareBuild: Hs,
  sort: qs,
  rsort: Ys,
  gt: Ms,
  lt: Bs,
  eq: Ws,
  neq: zs,
  gte: Zs,
  lte: Ks,
  cmp: Js,
  coerce: Qs,
  Comparator: ks,
  Range: en,
  satisfies: tn,
  toComparators: rn,
  maxSatisfying: sn,
  minSatisfying: nn,
  minVersion: an,
  validRange: ln,
  outside: on,
  gtr: cn,
  ltr: hn,
  intersects: un,
  simplifyRange: fn,
  subset: En,
  SemVer: ws,
  re: ve.re,
  src: ve.src,
  tokens: ve.t,
  SEMVER_SPEC_VERSION: Ze.SEMVER_SPEC_VERSION,
  RELEASE_TYPES: Ze.RELEASE_TYPES,
  compareIdentifiers: Ke.compareIdentifiers,
  rcompareIdentifiers: Ke.rcompareIdentifiers
};
const vn = /* @__PURE__ */ pt(pn);
export {
  pn as a,
  vn as s
};
//# sourceMappingURL=index-sw54ver7.js.map
