@pioneer-platform/pioneer-react 0.2.47 → 0.2.49

package/dist/index_849386d3.js

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