@music-lyric-player/base 0.14.0 → 0.15.0

package/dist/index.ecma.js

@@ -1,191 +1,660 @@
-import { freezeObjectDeep as or, ConfigManager as lr, Event as cr } from "@music-lyric-player/utils";
+import { freezeObjectDeep as fr, ConfigManager as mr, Event as pr } from "@music-lyric-player/utils";
 import "lodash-es";
-const Wt = or({
+const Ht = fr({
   driver: "animation",
   bridgeActive: !0,
   mergeWindow: 300,
+  mergeLimit: 3,
   offset: {
     global: 0,
     useMeta: !0,
     resetTempOnLyricChange: !0
   }
-}), es = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), ns = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DEFAULT: Wt
-}, Symbol.toStringTag, { value: "Module" })), We = (t = 8) => {
-  const s = new Uint8Array(t);
-  if (typeof globalThis.crypto?.getRandomValues == "function")
-    crypto.getRandomValues(s);
-  else
-    for (let r = 0; r < s.length; r++)
-      s[r] = Math.floor(Math.random() * 256);
-  return Array.from(s).map((r) => r.toString(16).padStart(2, "0")).join("");
+  DEFAULT: Ht
+}, Symbol.toStringTag, { value: "Module" })), B = (s = 8) => {
+  let e = "";
+  for (; e.length < s; )
+    e += Math.random().toString(36).slice(2);
+  return e.slice(0, s);
 };
-class W {
+var zt = /* @__PURE__ */ ((s) => (s.ChineseSimplified = "zh-hans", s.ChineseTraditional = "zh-hant", s.English = "en", s.Japanese = "ja", s.Korean = "ko", s.Russian = "ru", s.French = "fr", s.German = "de", s.Spanish = "es", s.Italian = "it", s.Portuguese = "pt", s))(zt || {});
+class dr {
+  /**
+   * Language tag.
+   */
+  tag = "";
+  /**
+   * Share within the lyric, ranging from 0 to 100.
+   * Recommended to be computed from word-level language counts.
+   */
+  percent = 0;
+}
+class Yt {
+  /**
+   * All languages with their shares.
+   */
+  list = [];
+  /**
+   * The language with the highest share.
+   */
+  get primary() {
+    let e;
+    for (let t = 0, n = this.list.length; t < n; t++)
+      (!e || this.list[t].percent > e.percent) && (e = this.list[t]);
+    return e;
+  }
+}
+class Kt {
+  /**
+   * Start time in milliseconds.
+   */
   start = 0;
+  /**
+   * End time in milliseconds.
+   */
   end = 0;
+  /**
+   * Duration in milliseconds, derived from end minus start.
+   */
   get duration() {
     return this.end - this.start;
   }
-  toJSON() {
-    return {
-      start: this.start,
-      end: this.end,
-      duration: this.duration
-    };
+}
+class Er {
+  /**
+   * Unique identifier of the token.
+   */
+  id = B(6).toUpperCase();
+  /**
+   * Time range of the token.
+   */
+  time;
+  /**
+   * Text content of the token.
+   */
+  content = "";
+}
+class Jt {
+  /**
+   * Unique identifier of the item.
+   */
+  id = B(6).toUpperCase();
+  /**
+   * Time range of the item, independent from its words.
+   */
+  time;
+  /**
+   * Tokens composing the item in order.
+   */
+  words = [];
+  /**
+   * Language or transliteration scheme of this item.
+   * Should be set when multiple languages coexist, since line-level aggregation groups items by it.
+   */
+  language;
+  /**
+   * Flat text joined from every word.
+   */
+  get content() {
+    let e = "";
+    for (let t = 0, n = this.words.length; t < n; t++)
+      e += this.words[t].content;
+    return e;
   }
 }
-var Ye = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Space = "Space", t))(Ye || {});
-class Yt {
-  stress = !1;
+class gr extends Jt {
+  /**
+   * Original annotation type name.
+   */
+  key = "";
+}
+class Rr {
+  /**
+   * Ruby annotation such as furigana.
+   */
+  ruby;
+  /**
+   * Romanized transliterations.
+   */
+  romans;
+  /**
+   * Unknown annotations keyed by their original type name.
+   */
+  unknowns;
 }
-class ur {
+var k = /* @__PURE__ */ ((s) => (s.Normal = "Normal", s.Space = "Space", s))(k || {});
+class vr {
+  /**
+   * Unique identifier of the word.
+   */
+  id = B(6).toUpperCase();
+  /**
+   * Discriminant marking this as a normal word.
+   */
   type = "Normal";
-  time = new W();
+  /**
+   * Time range of the word.
+   */
+  time;
+  /**
+   * Text content of the word.
+   */
   content = "";
-  extended = [];
-  config = new Yt();
+  /**
+   * Language of this word.
+   */
+  language;
+  /**
+   * Annotations attached to this word.
+   */
+  annotation;
+  /**
+   * Whether the word is stressed.
+   */
+  stress = !1;
 }
-class fr {
+class Ir {
+  /**
+   * Discriminant marking this as a space.
+   */
   type = "Space";
+  /**
+   * Number of consecutive space characters.
+   */
   count = 1;
 }
-var zt = /* @__PURE__ */ ((t) => (t.Unknown = "Unknown", t.Translate = "Translate", t.Roman = "Roman", t))(zt || {});
-class hr {
-  type = "Unknown";
+class Y {
+  /**
+   * Language or transliteration scheme of this item.
+   * Should be set when multiple languages coexist, since aggregation from words groups by it.
+   */
+  language;
+  /**
+   * Original text.
+   */
   content = "";
 }
-var Jt = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Interlude = "Interlude", t))(Jt || {});
-class dr {
-  id = We(4).toUpperCase();
-  type = "Interlude";
-  time = new W();
+class Zt extends Y {
+  /**
+   * Original annotation type name.
+   */
+  key = "";
 }
-class Kt {
-  words = [];
-  extended = [];
-  get original() {
-    return this.words.map((s) => s.type === Ye.Normal ? s.content : " ".repeat(s.count)).join("");
+class Qt {
+  #e;
+  constructor(e) {
+    this.#e = e;
   }
-  toJSON() {
-    return {
-      words: this.words,
-      extended: this.extended,
-      original: this.original
-    };
+  /**
+   * Aggregate one per-word item into a single line item, padding spaces to follow word spacing.
+   */
+  #i(e) {
+    let t = "", n = 0, i, c = !1;
+    for (let h = 0, o = this.#e.words.length; h < o; h++) {
+      const a = this.#e.words[h];
+      if (a.type === k.Space) {
+        n += a.count;
+        continue;
+      }
+      const r = e(a);
+      r && (c && (t += " ".repeat(n)), t += r.content, i ??= r.language, n = 0, c = !0);
+    }
+    if (!c)
+      return;
+    const l = new Y();
+    return l.content = t, l.language = i, l;
+  }
+  /**
+   * Aggregate multi-value per-word items into line items, one per language.
+   */
+  #a(e) {
+    const t = [];
+    for (let i = 0, c = this.#e.words.length; i < c; i++) {
+      const l = this.#e.words[i];
+      if (l.type === k.Space)
+        continue;
+      const h = e(l);
+      if (h)
+        for (const o of h) {
+          const a = o.language ?? "";
+          t.includes(a) || t.push(a);
+        }
+    }
+    if (!t.length)
+      return;
+    const n = [];
+    for (const i of t) {
+      let c = "", l = 0, h = !1;
+      for (let a = 0, r = this.#e.words.length; a < r; a++) {
+        const u = this.#e.words[a];
+        if (u.type === k.Space) {
+          l += u.count;
+          continue;
+        }
+        const f = e(u)?.find((E) => (E.language ?? "") === i);
+        f && (h && (c += " ".repeat(l)), c += f.content, l = 0, h = !0);
+      }
+      const o = new Y();
+      o.content = c, o.language = i || void 0, n.push(o);
+    }
+    return n;
   }
+  /**
+   * Aggregate unknown per-word items into line items, one per key.
+   */
+  #o() {
+    const e = [];
+    for (let n = 0, i = this.#e.words.length; n < i; n++) {
+      const c = this.#e.words[n];
+      if (c.type === k.Space)
+        continue;
+      const l = c.annotation?.unknowns;
+      if (l)
+        for (const h of l)
+          e.includes(h.key) || e.push(h.key);
+    }
+    if (!e.length)
+      return;
+    const t = [];
+    for (const n of e) {
+      let i = "", c = 0, l, h = !1;
+      for (let a = 0, r = this.#e.words.length; a < r; a++) {
+        const u = this.#e.words[a];
+        if (u.type === k.Space) {
+          c += u.count;
+          continue;
+        }
+        const f = u.annotation?.unknowns?.find((E) => E.key === n);
+        f && (h && (i += " ".repeat(c)), i += f.content, l ??= f.language, c = 0, h = !0);
+      }
+      const o = new Zt();
+      o.key = n, o.content = i, o.language = l, t.push(o);
+    }
+    return t;
+  }
+  #t;
+  /**
+   * Ruby annotation: the explicit value, otherwise aggregated from words.
+   */
+  get ruby() {
+    return this.#t ?? this.#i((e) => e.annotation?.ruby);
+  }
+  /**
+   * Override the words-derived ruby with an explicit value.
+   */
+  set ruby(e) {
+    this.#t = e;
+  }
+  #r;
+  /**
+   * Romanized transliterations: the explicit value, otherwise aggregated from words grouped by language.
+   */
+  get romans() {
+    return this.#r ?? this.#a((e) => e.annotation?.romans);
+  }
+  /**
+   * Override the words-derived romans with explicit values.
+   */
+  set romans(e) {
+    this.#r = e;
+  }
+  #s;
+  /**
+   * Translations, explicit only since words carry no line-level translation.
+   */
+  get translates() {
+    return this.#s;
+  }
+  /**
+   * Set the explicit translations.
+   */
+  set translates(e) {
+    this.#s = e;
+  }
+  #n;
+  /**
+   * Unknown annotations: the explicit value, otherwise aggregated from words grouped by key.
+   */
+  get unknowns() {
+    return this.#n ?? this.#o();
+  }
+  /**
+   * Override the words-derived unknowns with explicit values.
+   */
+  set unknowns(e) {
+    this.#n = e;
+  }
+}
+var er = /* @__PURE__ */ ((s) => (s.Normal = "Normal", s.Interlude = "Interlude", s))(er || {});
+class tr {
+  /**
+   * Unique identifier of the line.
+   */
+  id = B(6).toUpperCase();
+  /**
+   * Time range of the line.
+   */
+  time = new Kt();
 }
-class Zt {
+class rr extends tr {
+  /**
+   * Discriminant marking this as a normal line.
+   */
   type = "Normal";
-  id = We(4).toUpperCase();
-  time = new W();
-  content = new Kt();
+  /**
+   * Performing agent of this line.
+   */
   agent;
+  /**
+   * Words composing the line in order.
+   */
+  words = [];
+  /**
+   * Plain text of the line joined from every word.
+   */
+  get original() {
+    let e = "";
+    for (let t = 0, n = this.words.length; t < n; t++) {
+      const i = this.words[t];
+      e += i.type === k.Normal ? i.content : " ".repeat(i.count);
+    }
+    return e;
+  }
+  /**
+   * Annotations applied to the whole line, derived from words unless set explicitly.
+   */
+  annotation = new Qt(this);
+  #e;
+  /**
+   * Language tags of this line: the value set explicitly, otherwise collected from words.
+   */
+  get languages() {
+    if (this.#e?.length)
+      return this.#e;
+    const e = /* @__PURE__ */ new Set();
+    for (let t = 0, n = this.words.length; t < n; t++) {
+      const i = this.words[t];
+      i.type === k.Normal && i.language && e.add(i.language);
+    }
+    return [...e];
+  }
+  /**
+   * Override the words-derived languages with explicit tags.
+   */
+  set languages(e) {
+    this.#e = e;
+  }
 }
-class mr extends Zt {
-}
-class Er extends Zt {
+class $r extends rr {
+  /**
+   * Background lines attached to this line.
+   */
   background;
 }
-var Qt = /* @__PURE__ */ ((t) => (t.Offset = "Offset", t.Duration = "Duration", t.Title = "Title", t.Singer = "Singer", t.Album = "Album", t.Creator = "Creator", t.Unknown = "Unknown", t))(Qt || {});
-class F {
-  id = We(4).toUpperCase();
-}
-class pr extends F {
-  type = "Offset";
-  content = 0;
-}
-class Rr extends F {
-  type = "Duration";
-  content = 0;
-}
-class vr extends F {
-  type = "Title";
-  content = "";
-}
-class Ir extends F {
-  type = "Singer";
-  content = "";
-}
-class gr extends F {
-  type = "Album";
-  content = "";
-}
-class $r extends F {
-  type = "Creator";
-  content = {
-    role: "",
-    name: []
-  };
+class Lr extends tr {
+  /**
+   * Discriminant marking this as an interlude line.
+   */
+  type = "Interlude";
 }
-class Lr extends F {
-  type = "Unknown";
-  content = "";
+var _ = /* @__PURE__ */ ((s) => (s.Offset = "Offset", s.Duration = "Duration", s.Title = "Title", s.Singer = "Singer", s.Album = "Album", s.Creator = "Creator", s.Author = "Author", s.Isrc = "Isrc", s.Unknown = "Unknown", s))(_ || {});
+const Tr = (s, e, t) => ({
+  id: B(6).toUpperCase(),
+  type: s,
+  key: e,
+  value: t
+});
+class sr {
+  /**
+   * All meta entries in order.
+   */
+  list = [];
+  listOf(e) {
+    return this.list.filter((t) => t.type === e);
+  }
+  /**
+   * All offset meta entries.
+   */
+  get offsets() {
+    return this.listOf(_.Offset);
+  }
+  /**
+   * All duration meta entries.
+   */
+  get durations() {
+    return this.listOf(_.Duration);
+  }
+  /**
+   * All title meta entries.
+   */
+  get titles() {
+    return this.listOf(_.Title);
+  }
+  /**
+   * All singer meta entries.
+   */
+  get singers() {
+    return this.listOf(_.Singer);
+  }
+  /**
+   * All album meta entries.
+   */
+  get albums() {
+    return this.listOf(_.Album);
+  }
+  /**
+   * All creator meta entries.
+   */
+  get creators() {
+    return this.listOf(_.Creator);
+  }
+  /**
+   * All author meta entries.
+   */
+  get authors() {
+    return this.listOf(_.Author);
+  }
+  /**
+   * All isrc meta entries.
+   */
+  get isrcs() {
+    return this.listOf(_.Isrc);
+  }
+  /**
+   * All unknown meta entries.
+   */
+  get unknowns() {
+    return this.listOf(_.Unknown);
+  }
 }
-class Tr {
+var nr = /* @__PURE__ */ ((s) => (s.Person = "Person", s.Group = "Group", s.Other = "Other", s.Unknown = "Unknown", s))(nr || {});
+class Or {
+  /**
+   * Unique identifier of the agent.
+   */
   id = "";
-  name = "";
+  /**
+   * Performing type of the agent.
+   */
+  type = "Unknown";
+  /**
+   * Number of lines performed by this agent.
+   */
   count = 0;
+  /**
+   * Display names of the agent; a group may carry more than one.
+   */
+  names = [];
 }
-class er {
-  // index in global
-  global = 0;
-  // index in block
-  block = 0;
-}
-class Nr {
+class Sr {
+  /**
+   * Identifier of the referenced Agent.
+   */
   id = "";
-  index = new er();
+  /**
+   * Index of this agent occurrence among all lines.
+   */
+  globalIndex = 0;
+  /**
+   * Index of this agent occurrence within its block.
+   */
+  blockIndex = 0;
 }
-const tr = "0.6.0";
-var rr = /* @__PURE__ */ ((t) => (t.Invalid = "Invalid", t.Normal = "Normal", t.Syllable = "Syllable", t.Pure = "Pure", t.Empty = "Empty", t.NoTime = "NoTime", t))(rr || {});
-class Sr {
-  version = tr;
+const ir = "0.8.0";
+var ar = /* @__PURE__ */ ((s) => (s.Invalid = "Invalid", s.Empty = "Empty", s.Normal = "Normal", s))(ar || {}), or = /* @__PURE__ */ ((s) => (s.None = "None", s.Line = "Line", s.Syllable = "Syllable", s))(or || {});
+class Nr {
+  /**
+   * Schema version of this data model.
+   */
+  version = ir;
+  /**
+   * Overall classification of the lyric.
+   */
   type = "Invalid";
-  metas = [];
-  lines = [];
+  /**
+   * Timing precision of the lyric.
+   */
+  timing = "None";
+  /**
+   * Metadata of the lyric.
+   */
+  meta = new sr();
+  /**
+   * Language distribution of the lyric.
+   */
+  language = new Yt();
+  /**
+   * Performing agents referenced by lines.
+   */
   agents = [];
+  /**
+   * Lyric lines in order.
+   */
+  lines = [];
 }
-const X = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  Agent: Tr,
-  Extended: hr,
-  ExtendedType: zt,
-  Info: Sr,
-  InfoType: rr,
-  LineAgent: Nr,
-  LineAgentIndex: er,
-  LineInterlude: dr,
-  LineNormal: Er,
-  LineNormalBackground: mr,
-  LineNormalContent: Kt,
-  LineType: Jt,
-  MetaAlbum: gr,
-  MetaCreator: $r,
-  MetaDuration: Rr,
-  MetaOffset: pr,
-  MetaSinger: Ir,
-  MetaTitle: vr,
-  MetaType: Qt,
-  MetaUnknown: Lr,
-  Time: W,
-  Version: tr,
-  WordNormal: ur,
-  WordNormalConfig: Yt,
-  WordSpace: fr,
-  WordType: Ye
+  Agent: Or,
+  AgentType: nr,
+  Info: Nr,
+  InfoTiming: or,
+  InfoType: ar,
+  Language: Yt,
+  LanguageItem: dr,
+  LanguageType: zt,
+  LineAgent: Sr,
+  LineAnnotation: Qt,
+  LineAnnotationItem: Y,
+  LineInterlude: Lr,
+  LineNormal: $r,
+  LineNormalBase: rr,
+  LineType: er,
+  LineUnknownAnnotation: Zt,
+  Meta: sr,
+  MetaType: _,
+  Time: Kt,
+  Version: ir,
+  WordAnnotation: Rr,
+  WordAnnotationContent: Er,
+  WordAnnotationItem: Jt,
+  WordNormal: vr,
+  WordSpace: Ir,
+  WordType: k,
+  WordUnknownAnnotation: gr,
+  createMetaItem: Tr
 }, Symbol.toStringTag, { value: "Module" }));
-var H = { exports: {} }, se, tt;
-function Y() {
-  if (tt) return se;
+class wr {
+  lines = [];
+  mergedEnd = [];
+  /**
+   * Raw deactivation time of a line: the later of its own end and the next line's start.
+   *
+   * The final line never deactivates, and out-of-range indices resolve to 0.
+   */
+  getRawTime(e) {
+    const t = this.lines;
+    return e < 0 || e >= t.length ? 0 : e === t.length - 1 ? 1 / 0 : Math.max(t[e].time.end, t[e + 1].time.start);
+  }
+  /**
+   * Rebuild the merged end-time table from the given lines and merge settings.
+   */
+  build(e, t, n) {
+    this.lines = e;
+    const i = e.length, c = new Array(i);
+    if (i === 0) {
+      this.mergedEnd = c;
+      return;
+    }
+    const l = Math.max(0, t), h = n > 0 ? n : 1 / 0;
+    let o = this.getRawTime(i - 1);
+    c[i - 1] = o;
+    let a = 1;
+    for (let r = i - 2; r >= 0; r--) {
+      const u = this.getRawTime(r);
+      l > 0 && a < h && Math.abs(o - u) < l ? (c[r] = Math.max(u, c[r + 1]), a++) : (c[r] = u, a = 1), o = u;
+    }
+    this.mergedEnd = c;
+  }
+  /**
+   * Merged deactivation time of a line, falling back to the raw time when unbuilt.
+   */
+  getMergedTime(e) {
+    const t = this.mergedEnd[e];
+    return t === void 0 ? this.getRawTime(e) : t;
+  }
+}
+class Ar {
+  temp = 0;
+  meta = 0;
+  setTemp(e) {
+    this.temp = Number.isFinite(e) ? e : 0;
+  }
+  resetTemp() {
+    this.temp = 0;
+  }
+  refreshFromMeta(e, t) {
+    if (!t) {
+      this.meta = 0;
+      return;
+    }
+    const n = e.meta.offsets[0]?.value;
+    this.meta = typeof n == "number" && Number.isFinite(n) ? n : 0;
+  }
+  resolve(e) {
+    const t = e + this.meta + this.temp;
+    return Number.isFinite(t) ? t : 0;
+  }
+}
+class yr {
+  frameId = null;
+  timerId = null;
+  schedule(e, t) {
+    switch (e) {
+      case "animation":
+        this.frameId = globalThis.requestAnimationFrame(t);
+        break;
+      case "timer":
+        this.timerId = globalThis.setTimeout(t, 16);
+        break;
+    }
+  }
+  cancel() {
+    this.frameId !== null && (globalThis.cancelAnimationFrame(this.frameId), this.frameId = null), this.timerId !== null && (globalThis.clearTimeout(this.timerId), this.timerId = null);
+  }
+}
+var H = { exports: {} }, ie, tt;
+function K() {
+  if (tt) return ie;
   tt = 1;
-  const t = "2.0.0", s = 256, r = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
-  9007199254740991, n = 16, i = s - 6;
-  return se = {
-    MAX_LENGTH: s,
+  const s = "2.0.0", e = 256, t = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, n = 16, i = e - 6;
+  return ie = {
+    MAX_LENGTH: e,
     MAX_SAFE_COMPONENT_LENGTH: n,
     MAX_SAFE_BUILD_LENGTH: i,
-    MAX_SAFE_INTEGER: r,
+    MAX_SAFE_INTEGER: t,
     RELEASE_TYPES: [
       "major",
       "premajor",
@@ -195,96 +664,96 @@ function Y() {
       "prepatch",
       "prerelease"
     ],
-    SEMVER_SPEC_VERSION: t,
+    SEMVER_SPEC_VERSION: s,
     FLAG_INCLUDE_PRERELEASE: 1,
     FLAG_LOOSE: 2
-  }, se;
+  }, ie;
 }
-var ne, rt;
-function z() {
-  return rt || (rt = 1, ne = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...s) => console.error("SEMVER", ...s) : () => {
-  }), ne;
+var ae, rt;
+function J() {
+  return rt || (rt = 1, ae = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...e) => console.error("SEMVER", ...e) : () => {
+  }), ae;
 }
 var st;
-function B() {
-  return st || (st = 1, (function(t, s) {
+function W() {
+  return st || (st = 1, (function(s, e) {
     const {
-      MAX_SAFE_COMPONENT_LENGTH: r,
+      MAX_SAFE_COMPONENT_LENGTH: t,
       MAX_SAFE_BUILD_LENGTH: n,
       MAX_LENGTH: i
-    } = Y(), c = z();
-    s = t.exports = {};
-    const l = s.re = [], h = s.safeRe = [], o = s.src = [], a = s.safeSrc = [], e = s.t = {};
+    } = K(), c = J();
+    e = s.exports = {};
+    const l = e.re = [], h = e.safeRe = [], o = e.src = [], a = e.safeSrc = [], r = e.t = {};
     let u = 0;
-    const f = "[a-zA-Z0-9-]", p = [
+    const f = "[a-zA-Z0-9-]", E = [
       ["\\s", 1],
       ["\\d", i],
       [f, n]
-    ], S = (N) => {
-      for (const [A, G] of p)
-        N = N.split(`${A}*`).join(`${A}{0,${G}}`).split(`${A}+`).join(`${A}{1,${G}}`);
-      return N;
-    }, m = (N, A, G) => {
-      const w = S(A), x = u++;
-      c(N, x, A), e[N] = x, o[x] = A, a[x] = w, l[x] = new RegExp(A, G ? "g" : void 0), h[x] = new RegExp(w, G ? "g" : void 0);
+    ], S = (O) => {
+      for (const [w, G] of E)
+        O = O.split(`${w}*`).join(`${w}{0,${G}}`).split(`${w}+`).join(`${w}{1,${G}}`);
+      return O;
+    }, p = (O, w, G) => {
+      const A = S(w), b = u++;
+      c(O, b, w), r[O] = b, o[b] = w, a[b] = A, l[b] = new RegExp(w, G ? "g" : void 0), h[b] = new RegExp(A, G ? "g" : void 0);
     };
-    m("NUMERICIDENTIFIER", "0|[1-9]\\d*"), m("NUMERICIDENTIFIERLOOSE", "\\d+"), m("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`), m("MAINVERSION", `(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})`), m("MAINVERSIONLOOSE", `(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})`), m("PRERELEASEIDENTIFIER", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIER]})`), m("PRERELEASEIDENTIFIERLOOSE", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIERLOOSE]})`), m("PRERELEASE", `(?:-(${o[e.PRERELEASEIDENTIFIER]}(?:\\.${o[e.PRERELEASEIDENTIFIER]})*))`), m("PRERELEASELOOSE", `(?:-?(${o[e.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[e.PRERELEASEIDENTIFIERLOOSE]})*))`), m("BUILDIDENTIFIER", `${f}+`), m("BUILD", `(?:\\+(${o[e.BUILDIDENTIFIER]}(?:\\.${o[e.BUILDIDENTIFIER]})*))`), m("FULLPLAIN", `v?${o[e.MAINVERSION]}${o[e.PRERELEASE]}?${o[e.BUILD]}?`), m("FULL", `^${o[e.FULLPLAIN]}$`), m("LOOSEPLAIN", `[v=\\s]*${o[e.MAINVERSIONLOOSE]}${o[e.PRERELEASELOOSE]}?${o[e.BUILD]}?`), m("LOOSE", `^${o[e.LOOSEPLAIN]}$`), m("GTLT", "((?:<|>)?=?)"), m("XRANGEIDENTIFIERLOOSE", `${o[e.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), m("XRANGEIDENTIFIER", `${o[e.NUMERICIDENTIFIER]}|x|X|\\*`), m("XRANGEPLAIN", `[v=\\s]*(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:${o[e.PRERELEASE]})?${o[e.BUILD]}?)?)?`), m("XRANGEPLAINLOOSE", `[v=\\s]*(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:${o[e.PRERELEASELOOSE]})?${o[e.BUILD]}?)?)?`), m("XRANGE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAIN]}$`), m("XRANGELOOSE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAINLOOSE]}$`), m("COERCEPLAIN", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?`), m("COERCE", `${o[e.COERCEPLAIN]}(?:$|[^\\d])`), m("COERCEFULL", o[e.COERCEPLAIN] + `(?:${o[e.PRERELEASE]})?(?:${o[e.BUILD]})?(?:$|[^\\d])`), m("COERCERTL", o[e.COERCE], !0), m("COERCERTLFULL", o[e.COERCEFULL], !0), m("LONETILDE", "(?:~>?)"), m("TILDETRIM", `(\\s*)${o[e.LONETILDE]}\\s+`, !0), s.tildeTrimReplace = "$1~", m("TILDE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAIN]}$`), m("TILDELOOSE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAINLOOSE]}$`), m("LONECARET", "(?:\\^)"), m("CARETTRIM", `(\\s*)${o[e.LONECARET]}\\s+`, !0), s.caretTrimReplace = "$1^", m("CARET", `^${o[e.LONECARET]}${o[e.XRANGEPLAIN]}$`), m("CARETLOOSE", `^${o[e.LONECARET]}${o[e.XRANGEPLAINLOOSE]}$`), m("COMPARATORLOOSE", `^${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]})$|^$`), m("COMPARATOR", `^${o[e.GTLT]}\\s*(${o[e.FULLPLAIN]})$|^$`), m("COMPARATORTRIM", `(\\s*)${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]}|${o[e.XRANGEPLAIN]})`, !0), s.comparatorTrimReplace = "$1$2$3", m("HYPHENRANGE", `^\\s*(${o[e.XRANGEPLAIN]})\\s+-\\s+(${o[e.XRANGEPLAIN]})\\s*$`), m("HYPHENRANGELOOSE", `^\\s*(${o[e.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[e.XRANGEPLAINLOOSE]})\\s*$`), m("STAR", "(<|>)?=?\\s*\\*"), m("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), m("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+    p("NUMERICIDENTIFIER", "0|[1-9]\\d*"), p("NUMERICIDENTIFIERLOOSE", "\\d+"), p("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`), p("MAINVERSION", `(${o[r.NUMERICIDENTIFIER]})\\.(${o[r.NUMERICIDENTIFIER]})\\.(${o[r.NUMERICIDENTIFIER]})`), p("MAINVERSIONLOOSE", `(${o[r.NUMERICIDENTIFIERLOOSE]})\\.(${o[r.NUMERICIDENTIFIERLOOSE]})\\.(${o[r.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASEIDENTIFIER", `(?:${o[r.NONNUMERICIDENTIFIER]}|${o[r.NUMERICIDENTIFIER]})`), p("PRERELEASEIDENTIFIERLOOSE", `(?:${o[r.NONNUMERICIDENTIFIER]}|${o[r.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASE", `(?:-(${o[r.PRERELEASEIDENTIFIER]}(?:\\.${o[r.PRERELEASEIDENTIFIER]})*))`), p("PRERELEASELOOSE", `(?:-?(${o[r.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[r.PRERELEASEIDENTIFIERLOOSE]})*))`), p("BUILDIDENTIFIER", `${f}+`), p("BUILD", `(?:\\+(${o[r.BUILDIDENTIFIER]}(?:\\.${o[r.BUILDIDENTIFIER]})*))`), p("FULLPLAIN", `v?${o[r.MAINVERSION]}${o[r.PRERELEASE]}?${o[r.BUILD]}?`), p("FULL", `^${o[r.FULLPLAIN]}$`), p("LOOSEPLAIN", `[v=\\s]*${o[r.MAINVERSIONLOOSE]}${o[r.PRERELEASELOOSE]}?${o[r.BUILD]}?`), p("LOOSE", `^${o[r.LOOSEPLAIN]}$`), p("GTLT", "((?:<|>)?=?)"), p("XRANGEIDENTIFIERLOOSE", `${o[r.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), p("XRANGEIDENTIFIER", `${o[r.NUMERICIDENTIFIER]}|x|X|\\*`), p("XRANGEPLAIN", `[v=\\s]*(${o[r.XRANGEIDENTIFIER]})(?:\\.(${o[r.XRANGEIDENTIFIER]})(?:\\.(${o[r.XRANGEIDENTIFIER]})(?:${o[r.PRERELEASE]})?${o[r.BUILD]}?)?)?`), p("XRANGEPLAINLOOSE", `[v=\\s]*(${o[r.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[r.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[r.XRANGEIDENTIFIERLOOSE]})(?:${o[r.PRERELEASELOOSE]})?${o[r.BUILD]}?)?)?`), p("XRANGE", `^${o[r.GTLT]}\\s*${o[r.XRANGEPLAIN]}$`), p("XRANGELOOSE", `^${o[r.GTLT]}\\s*${o[r.XRANGEPLAINLOOSE]}$`), p("COERCEPLAIN", `(^|[^\\d])(\\d{1,${t}})(?:\\.(\\d{1,${t}}))?(?:\\.(\\d{1,${t}}))?`), p("COERCE", `${o[r.COERCEPLAIN]}(?:$|[^\\d])`), p("COERCEFULL", o[r.COERCEPLAIN] + `(?:${o[r.PRERELEASE]})?(?:${o[r.BUILD]})?(?:$|[^\\d])`), p("COERCERTL", o[r.COERCE], !0), p("COERCERTLFULL", o[r.COERCEFULL], !0), p("LONETILDE", "(?:~>?)"), p("TILDETRIM", `(\\s*)${o[r.LONETILDE]}\\s+`, !0), e.tildeTrimReplace = "$1~", p("TILDE", `^${o[r.LONETILDE]}${o[r.XRANGEPLAIN]}$`), p("TILDELOOSE", `^${o[r.LONETILDE]}${o[r.XRANGEPLAINLOOSE]}$`), p("LONECARET", "(?:\\^)"), p("CARETTRIM", `(\\s*)${o[r.LONECARET]}\\s+`, !0), e.caretTrimReplace = "$1^", p("CARET", `^${o[r.LONECARET]}${o[r.XRANGEPLAIN]}$`), p("CARETLOOSE", `^${o[r.LONECARET]}${o[r.XRANGEPLAINLOOSE]}$`), p("COMPARATORLOOSE", `^${o[r.GTLT]}\\s*(${o[r.LOOSEPLAIN]})$|^$`), p("COMPARATOR", `^${o[r.GTLT]}\\s*(${o[r.FULLPLAIN]})$|^$`), p("COMPARATORTRIM", `(\\s*)${o[r.GTLT]}\\s*(${o[r.LOOSEPLAIN]}|${o[r.XRANGEPLAIN]})`, !0), e.comparatorTrimReplace = "$1$2$3", p("HYPHENRANGE", `^\\s*(${o[r.XRANGEPLAIN]})\\s+-\\s+(${o[r.XRANGEPLAIN]})\\s*$`), p("HYPHENRANGELOOSE", `^\\s*(${o[r.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[r.XRANGEPLAINLOOSE]})\\s*$`), p("STAR", "(<|>)?=?\\s*\\*"), p("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), p("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
   })(H, H.exports)), H.exports;
 }
-var ie, nt;
-function ze() {
-  if (nt) return ie;
+var oe, nt;
+function Ye() {
+  if (nt) return oe;
   nt = 1;
-  const t = Object.freeze({ loose: !0 }), s = Object.freeze({});
-  return ie = (n) => n ? typeof n != "object" ? t : n : s, ie;
+  const s = Object.freeze({ loose: !0 }), e = Object.freeze({});
+  return oe = (n) => n ? typeof n != "object" ? s : n : e, oe;
 }
-var ae, it;
-function sr() {
-  if (it) return ae;
+var le, it;
+function lr() {
+  if (it) return le;
   it = 1;
-  const t = /^[0-9]+$/, s = (n, i) => {
+  const s = /^[0-9]+$/, e = (n, i) => {
     if (typeof n == "number" && typeof i == "number")
       return n === i ? 0 : n < i ? -1 : 1;
-    const c = t.test(n), l = t.test(i);
+    const c = s.test(n), l = s.test(i);
     return c && l && (n = +n, i = +i), n === i ? 0 : c && !l ? -1 : l && !c ? 1 : n < i ? -1 : 1;
   };
-  return ae = {
-    compareIdentifiers: s,
-    rcompareIdentifiers: (n, i) => s(i, n)
-  }, ae;
-}
-var oe, at;
-function b() {
-  if (at) return oe;
+  return le = {
+    compareIdentifiers: e,
+    rcompareIdentifiers: (n, i) => e(i, n)
+  }, le;
+}
+var ce, at;
+function x() {
+  if (at) return ce;
   at = 1;
-  const t = z(), { MAX_LENGTH: s, MAX_SAFE_INTEGER: r } = Y(), { safeRe: n, t: i } = B(), c = ze(), { compareIdentifiers: l } = sr();
+  const s = J(), { MAX_LENGTH: e, MAX_SAFE_INTEGER: t } = K(), { safeRe: n, t: i } = W(), c = Ye(), { compareIdentifiers: l } = lr();
   class h {
-    constructor(a, e) {
-      if (e = c(e), a instanceof h) {
-        if (a.loose === !!e.loose && a.includePrerelease === !!e.includePrerelease)
+    constructor(a, r) {
+      if (r = c(r), a instanceof h) {
+        if (a.loose === !!r.loose && a.includePrerelease === !!r.includePrerelease)
           return a;
         a = a.version;
       } else if (typeof a != "string")
         throw new TypeError(`Invalid version. Must be a string. Got type "${typeof a}".`);
-      if (a.length > s)
+      if (a.length > e)
         throw new TypeError(
-          `version is longer than ${s} characters`
+          `version is longer than ${e} characters`
         );
-      t("SemVer", a, e), this.options = e, this.loose = !!e.loose, this.includePrerelease = !!e.includePrerelease;
-      const u = a.trim().match(e.loose ? n[i.LOOSE] : n[i.FULL]);
+      s("SemVer", a, r), this.options = r, this.loose = !!r.loose, this.includePrerelease = !!r.includePrerelease;
+      const u = a.trim().match(r.loose ? n[i.LOOSE] : n[i.FULL]);
       if (!u)
         throw new TypeError(`Invalid Version: ${a}`);
-      if (this.raw = a, this.major = +u[1], this.minor = +u[2], this.patch = +u[3], this.major > r || this.major < 0)
+      if (this.raw = a, this.major = +u[1], this.minor = +u[2], this.patch = +u[3], this.major > t || this.major < 0)
         throw new TypeError("Invalid major version");
-      if (this.minor > r || this.minor < 0)
+      if (this.minor > t || this.minor < 0)
         throw new TypeError("Invalid minor version");
-      if (this.patch > r || this.patch < 0)
+      if (this.patch > t || this.patch < 0)
         throw new TypeError("Invalid patch version");
       u[4] ? this.prerelease = u[4].split(".").map((f) => {
         if (/^[0-9]+$/.test(f)) {
-          const p = +f;
-          if (p >= 0 && p < r)
-            return p;
+          const E = +f;
+          if (E >= 0 && E < t)
+            return E;
         }
         return f;
       }) : this.prerelease = [], this.build = u[5] ? u[5].split(".") : [], this.format();
@@ -296,7 +765,7 @@ function b() {
       return this.version;
     }
     compare(a) {
-      if (t("SemVer.compare", this.version, this.options, a), !(a instanceof h)) {
+      if (s("SemVer.compare", this.version, this.options, a), !(a instanceof h)) {
         if (typeof a == "string" && a === this.version)
           return 0;
         a = new h(a, this.options);
@@ -313,10 +782,10 @@ function b() {
         return 1;
       if (!this.prerelease.length && !a.prerelease.length)
         return 0;
-      let e = 0;
+      let r = 0;
       do {
-        const u = this.prerelease[e], f = a.prerelease[e];
-        if (t("prerelease compare", e, u, f), u === void 0 && f === void 0)
+        const u = this.prerelease[r], f = a.prerelease[r];
+        if (s("prerelease compare", r, u, f), u === void 0 && f === void 0)
           return 0;
         if (f === void 0)
           return 1;
@@ -325,14 +794,14 @@ function b() {
         if (u === f)
           continue;
         return l(u, f);
-      } while (++e);
+      } while (++r);
     }
     compareBuild(a) {
       a instanceof h || (a = new h(a, this.options));
-      let e = 0;
+      let r = 0;
       do {
-        const u = this.build[e], f = a.build[e];
-        if (t("build compare", e, u, f), u === void 0 && f === void 0)
+        const u = this.build[r], f = a.build[r];
+        if (s("build compare", r, u, f), u === void 0 && f === void 0)
           return 0;
         if (f === void 0)
           return 1;
@@ -341,34 +810,34 @@ function b() {
         if (u === f)
           continue;
         return l(u, f);
-      } while (++e);
+      } 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(a, e, u) {
+    inc(a, r, u) {
       if (a.startsWith("pre")) {
-        if (!e && u === !1)
+        if (!r && u === !1)
           throw new Error("invalid increment argument: identifier is empty");
-        if (e) {
-          const f = `-${e}`.match(this.options.loose ? n[i.PRERELEASELOOSE] : n[i.PRERELEASE]);
-          if (!f || f[1] !== e)
-            throw new Error(`invalid identifier: ${e}`);
+        if (r) {
+          const f = `-${r}`.match(this.options.loose ? n[i.PRERELEASELOOSE] : n[i.PRERELEASE]);
+          if (!f || f[1] !== r)
+            throw new Error(`invalid identifier: ${r}`);
         }
       }
       switch (a) {
         case "premajor":
-          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", e, u);
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", r, u);
           break;
         case "preminor":
-          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", e, u);
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", r, u);
           break;
         case "prepatch":
-          this.prerelease.length = 0, this.inc("patch", e, u), this.inc("pre", e, u);
+          this.prerelease.length = 0, this.inc("patch", r, u), this.inc("pre", r, u);
           break;
         // If the input is a non-prerelease version, this acts the same as
         // prepatch.
         case "prerelease":
-          this.prerelease.length === 0 && this.inc("patch", e, u), this.inc("pre", e, u);
+          this.prerelease.length === 0 && this.inc("patch", r, u), this.inc("pre", r, u);
           break;
         case "release":
           if (this.prerelease.length === 0)
@@ -391,18 +860,18 @@ function b() {
           if (this.prerelease.length === 0)
             this.prerelease = [f];
           else {
-            let p = this.prerelease.length;
-            for (; --p >= 0; )
-              typeof this.prerelease[p] == "number" && (this.prerelease[p]++, p = -2);
-            if (p === -1) {
-              if (e === this.prerelease.join(".") && u === !1)
+            let E = this.prerelease.length;
+            for (; --E >= 0; )
+              typeof this.prerelease[E] == "number" && (this.prerelease[E]++, E = -2);
+            if (E === -1) {
+              if (r === this.prerelease.join(".") && u === !1)
                 throw new Error("invalid increment argument: identifier already exists");
               this.prerelease.push(f);
             }
           }
-          if (e) {
-            let p = [e, f];
-            u === !1 && (p = [e]), l(this.prerelease[0], e) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = p) : this.prerelease = p;
+          if (r) {
+            let E = [r, f];
+            u === !1 && (E = [r]), l(this.prerelease[0], r) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = E) : this.prerelease = E;
           }
           break;
         }
@@ -412,206 +881,206 @@ function b() {
       return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
     }
   }
-  return oe = h, oe;
+  return ce = h, ce;
 }
-var le, ot;
+var ue, ot;
 function M() {
-  if (ot) return le;
+  if (ot) return ue;
   ot = 1;
-  const t = b();
-  return le = (r, n, i = !1) => {
-    if (r instanceof t)
-      return r;
+  const s = x();
+  return ue = (t, n, i = !1) => {
+    if (t instanceof s)
+      return t;
     try {
-      return new t(r, n);
+      return new s(t, n);
     } catch (c) {
       if (!i)
         return null;
       throw c;
     }
-  }, le;
+  }, ue;
 }
-var ce, lt;
-function Or() {
-  if (lt) return ce;
+var he, lt;
+function Cr() {
+  if (lt) return he;
   lt = 1;
-  const t = M();
-  return ce = (r, n) => {
-    const i = t(r, n);
+  const s = M();
+  return he = (t, n) => {
+    const i = s(t, n);
     return i ? i.version : null;
-  }, ce;
+  }, he;
 }
-var ue, ct;
-function Ar() {
-  if (ct) return ue;
+var fe, ct;
+function Pr() {
+  if (ct) return fe;
   ct = 1;
-  const t = M();
-  return ue = (r, n) => {
-    const i = t(r.trim().replace(/^[=v]+/, ""), n);
+  const s = M();
+  return fe = (t, n) => {
+    const i = s(t.trim().replace(/^[=v]+/, ""), n);
     return i ? i.version : null;
-  }, ue;
+  }, fe;
 }
-var fe, ut;
-function wr() {
-  if (ut) return fe;
+var me, ut;
+function qr() {
+  if (ut) return me;
   ut = 1;
-  const t = b();
-  return fe = (r, n, i, c, l) => {
+  const s = x();
+  return me = (t, n, i, c, l) => {
     typeof i == "string" && (l = c, c = i, i = void 0);
     try {
-      return new t(
-        r instanceof t ? r.version : r,
+      return new s(
+        t instanceof s ? t.version : t,
         i
       ).inc(n, c, l).version;
     } catch {
       return null;
     }
-  }, fe;
+  }, me;
 }
-var he, ft;
-function yr() {
-  if (ft) return he;
-  ft = 1;
-  const t = M();
-  return he = (r, n) => {
-    const i = t(r, null, !0), c = t(n, null, !0), l = i.compare(c);
+var pe, ht;
+function Gr() {
+  if (ht) return pe;
+  ht = 1;
+  const s = M();
+  return pe = (t, n) => {
+    const i = s(t, null, !0), c = s(n, null, !0), l = i.compare(c);
     if (l === 0)
       return null;
-    const h = l > 0, o = h ? i : c, a = h ? c : i, e = !!o.prerelease.length;
-    if (!!a.prerelease.length && !e) {
+    const h = l > 0, o = h ? i : c, a = h ? c : i, r = !!o.prerelease.length;
+    if (!!a.prerelease.length && !r) {
       if (!a.patch && !a.minor)
         return "major";
       if (a.compareMain(o) === 0)
         return a.minor && !a.patch ? "minor" : "patch";
     }
-    const f = e ? "pre" : "";
+    const f = r ? "pre" : "";
     return i.major !== c.major ? f + "major" : i.minor !== c.minor ? f + "minor" : i.patch !== c.patch ? f + "patch" : "prerelease";
-  }, he;
-}
-var de, ht;
-function Cr() {
-  if (ht) return de;
-  ht = 1;
-  const t = b();
-  return de = (r, n) => new t(r, n).major, de;
+  }, pe;
 }
-var me, dt;
-function qr() {
-  if (dt) return me;
-  dt = 1;
-  const t = b();
-  return me = (r, n) => new t(r, n).minor, me;
+var de, ft;
+function br() {
+  if (ft) return de;
+  ft = 1;
+  const s = x();
+  return de = (t, n) => new s(t, n).major, de;
 }
 var Ee, mt;
-function Pr() {
+function Dr() {
   if (mt) return Ee;
   mt = 1;
-  const t = b();
-  return Ee = (r, n) => new t(r, n).patch, Ee;
+  const s = x();
+  return Ee = (t, n) => new s(t, n).minor, Ee;
 }
-var pe, Et;
-function Gr() {
-  if (Et) return pe;
-  Et = 1;
-  const t = M();
-  return pe = (r, n) => {
-    const i = t(r, n);
+var ge, pt;
+function xr() {
+  if (pt) return ge;
+  pt = 1;
+  const s = x();
+  return ge = (t, n) => new s(t, n).patch, ge;
+}
+var Re, dt;
+function Ur() {
+  if (dt) return Re;
+  dt = 1;
+  const s = M();
+  return Re = (t, n) => {
+    const i = s(t, n);
     return i && i.prerelease.length ? i.prerelease : null;
-  }, pe;
+  }, Re;
 }
-var Re, pt;
-function U() {
-  if (pt) return Re;
-  pt = 1;
-  const t = b();
-  return Re = (r, n, i) => new t(r, i).compare(new t(n, i)), Re;
+var ve, Et;
+function F() {
+  if (Et) return ve;
+  Et = 1;
+  const s = x();
+  return ve = (t, n, i) => new s(t, i).compare(new s(n, i)), ve;
 }
-var ve, Rt;
-function xr() {
-  if (Rt) return ve;
+var Ie, gt;
+function _r() {
+  if (gt) return Ie;
+  gt = 1;
+  const s = F();
+  return Ie = (t, n, i) => s(n, t, i), Ie;
+}
+var $e, Rt;
+function Fr() {
+  if (Rt) return $e;
   Rt = 1;
-  const t = U();
-  return ve = (r, n, i) => t(n, r, i), ve;
+  const s = F();
+  return $e = (t, n) => s(t, n, !0), $e;
 }
-var Ie, vt;
-function Dr() {
-  if (vt) return Ie;
+var Le, vt;
+function Ke() {
+  if (vt) return Le;
   vt = 1;
-  const t = U();
-  return Ie = (r, n) => t(r, n, !0), Ie;
-}
-var ge, It;
-function Je() {
-  if (It) return ge;
-  It = 1;
-  const t = b();
-  return ge = (r, n, i) => {
-    const c = new t(r, i), l = new t(n, i);
+  const s = x();
+  return Le = (t, n, i) => {
+    const c = new s(t, i), l = new s(n, i);
     return c.compare(l) || c.compareBuild(l);
-  }, ge;
+  }, Le;
 }
-var $e, gt;
-function br() {
-  if (gt) return $e;
-  gt = 1;
-  const t = Je();
-  return $e = (r, n) => r.sort((i, c) => t(i, c, n)), $e;
+var Te, It;
+function jr() {
+  if (It) return Te;
+  It = 1;
+  const s = Ke();
+  return Te = (t, n) => t.sort((i, c) => s(i, c, n)), Te;
 }
-var Le, $t;
-function _r() {
-  if ($t) return Le;
+var Oe, $t;
+function kr() {
+  if ($t) return Oe;
   $t = 1;
-  const t = Je();
-  return Le = (r, n) => r.sort((i, c) => t(c, i, n)), Le;
+  const s = Ke();
+  return Oe = (t, n) => t.sort((i, c) => s(c, i, n)), Oe;
 }
-var Te, Lt;
-function J() {
-  if (Lt) return Te;
+var Se, Lt;
+function Z() {
+  if (Lt) return Se;
   Lt = 1;
-  const t = U();
-  return Te = (r, n, i) => t(r, n, i) > 0, Te;
+  const s = F();
+  return Se = (t, n, i) => s(t, n, i) > 0, Se;
 }
 var Ne, Tt;
-function Ke() {
+function Je() {
   if (Tt) return Ne;
   Tt = 1;
-  const t = U();
-  return Ne = (r, n, i) => t(r, n, i) < 0, Ne;
+  const s = F();
+  return Ne = (t, n, i) => s(t, n, i) < 0, Ne;
 }
-var Se, Nt;
-function nr() {
-  if (Nt) return Se;
-  Nt = 1;
-  const t = U();
-  return Se = (r, n, i) => t(r, n, i) === 0, Se;
+var we, Ot;
+function cr() {
+  if (Ot) return we;
+  Ot = 1;
+  const s = F();
+  return we = (t, n, i) => s(t, n, i) === 0, we;
 }
-var Oe, St;
-function ir() {
-  if (St) return Oe;
+var Ae, St;
+function ur() {
+  if (St) return Ae;
   St = 1;
-  const t = U();
-  return Oe = (r, n, i) => t(r, n, i) !== 0, Oe;
+  const s = F();
+  return Ae = (t, n, i) => s(t, n, i) !== 0, Ae;
 }
-var Ae, Ot;
+var ye, Nt;
 function Ze() {
-  if (Ot) return Ae;
-  Ot = 1;
-  const t = U();
-  return Ae = (r, n, i) => t(r, n, i) >= 0, Ae;
+  if (Nt) return ye;
+  Nt = 1;
+  const s = F();
+  return ye = (t, n, i) => s(t, n, i) >= 0, ye;
 }
-var we, At;
+var Ce, wt;
 function Qe() {
-  if (At) return we;
-  At = 1;
-  const t = U();
-  return we = (r, n, i) => t(r, n, i) <= 0, we;
-}
-var ye, wt;
-function ar() {
-  if (wt) return ye;
+  if (wt) return Ce;
   wt = 1;
-  const t = nr(), s = ir(), r = J(), n = Ze(), i = Ke(), c = Qe();
-  return ye = (h, o, a, e) => {
+  const s = F();
+  return Ce = (t, n, i) => s(t, n, i) <= 0, Ce;
+}
+var Pe, At;
+function hr() {
+  if (At) return Pe;
+  At = 1;
+  const s = cr(), e = ur(), t = Z(), n = Ze(), i = Je(), c = Qe();
+  return Pe = (h, o, a, r) => {
     switch (o) {
       case "===":
         return typeof h == "object" && (h = h.version), typeof a == "object" && (a = a.version), h === a;
@@ -620,99 +1089,99 @@ function ar() {
       case "":
       case "=":
       case "==":
-        return t(h, a, e);
+        return s(h, a, r);
       case "!=":
-        return s(h, a, e);
+        return e(h, a, r);
       case ">":
-        return r(h, a, e);
+        return t(h, a, r);
       case ">=":
-        return n(h, a, e);
+        return n(h, a, r);
       case "<":
-        return i(h, a, e);
+        return i(h, a, r);
       case "<=":
-        return c(h, a, e);
+        return c(h, a, r);
       default:
         throw new TypeError(`Invalid operator: ${o}`);
     }
-  }, ye;
+  }, Pe;
 }
-var Ce, yt;
-function Ur() {
-  if (yt) return Ce;
+var qe, yt;
+function Mr() {
+  if (yt) return qe;
   yt = 1;
-  const t = b(), s = M(), { safeRe: r, t: n } = B();
-  return Ce = (c, l) => {
-    if (c instanceof t)
+  const s = x(), e = M(), { safeRe: t, t: n } = W();
+  return qe = (c, l) => {
+    if (c instanceof s)
       return c;
     if (typeof c == "number" && (c = String(c)), typeof c != "string")
       return null;
     l = l || {};
     let h = null;
     if (!l.rtl)
-      h = c.match(l.includePrerelease ? r[n.COERCEFULL] : r[n.COERCE]);
+      h = c.match(l.includePrerelease ? t[n.COERCEFULL] : t[n.COERCE]);
     else {
-      const p = l.includePrerelease ? r[n.COERCERTLFULL] : r[n.COERCERTL];
+      const E = l.includePrerelease ? t[n.COERCERTLFULL] : t[n.COERCERTL];
       let S;
-      for (; (S = p.exec(c)) && (!h || h.index + h[0].length !== c.length); )
-        (!h || S.index + S[0].length !== h.index + h[0].length) && (h = S), p.lastIndex = S.index + S[1].length + S[2].length;
-      p.lastIndex = -1;
+      for (; (S = E.exec(c)) && (!h || h.index + h[0].length !== c.length); )
+        (!h || S.index + S[0].length !== h.index + h[0].length) && (h = S), E.lastIndex = S.index + S[1].length + S[2].length;
+      E.lastIndex = -1;
     }
     if (h === null)
       return null;
-    const o = h[2], a = h[3] || "0", e = h[4] || "0", u = l.includePrerelease && h[5] ? `-${h[5]}` : "", f = l.includePrerelease && h[6] ? `+${h[6]}` : "";
-    return s(`${o}.${a}.${e}${u}${f}`, l);
-  }, Ce;
+    const o = h[2], a = h[3] || "0", r = h[4] || "0", u = l.includePrerelease && h[5] ? `-${h[5]}` : "", f = l.includePrerelease && h[6] ? `+${h[6]}` : "";
+    return e(`${o}.${a}.${r}${u}${f}`, l);
+  }, qe;
 }
-var qe, Ct;
-function jr() {
-  if (Ct) return qe;
+var Ge, Ct;
+function Vr() {
+  if (Ct) return Ge;
   Ct = 1;
-  class t {
+  class s {
     constructor() {
       this.max = 1e3, this.map = /* @__PURE__ */ new Map();
     }
-    get(r) {
-      const n = this.map.get(r);
+    get(t) {
+      const n = this.map.get(t);
       if (n !== void 0)
-        return this.map.delete(r), this.map.set(r, n), n;
+        return this.map.delete(t), this.map.set(t, n), n;
     }
-    delete(r) {
-      return this.map.delete(r);
+    delete(t) {
+      return this.map.delete(t);
     }
-    set(r, n) {
-      if (!this.delete(r) && n !== void 0) {
+    set(t, n) {
+      if (!this.delete(t) && n !== void 0) {
         if (this.map.size >= this.max) {
           const c = this.map.keys().next().value;
           this.delete(c);
         }
-        this.map.set(r, n);
+        this.map.set(t, n);
       }
       return this;
     }
   }
-  return qe = t, qe;
+  return Ge = s, Ge;
 }
-var Pe, qt;
+var be, Pt;
 function j() {
-  if (qt) return Pe;
-  qt = 1;
-  const t = /\s+/g;
-  class s {
-    constructor(d, I) {
-      if (I = i(I), d instanceof s)
-        return d.loose === !!I.loose && d.includePrerelease === !!I.includePrerelease ? d : new s(d.raw, I);
-      if (d instanceof c)
-        return this.raw = d.value, this.set = [[d]], this.formatted = void 0, this;
-      if (this.options = I, this.loose = !!I.loose, this.includePrerelease = !!I.includePrerelease, this.raw = d.trim().replace(t, " "), this.set = this.raw.split("||").map((R) => this.parseRange(R.trim())).filter((R) => R.length), !this.set.length)
+  if (Pt) return be;
+  Pt = 1;
+  const s = /\s+/g;
+  class e {
+    constructor(m, v) {
+      if (v = i(v), m instanceof e)
+        return m.loose === !!v.loose && m.includePrerelease === !!v.includePrerelease ? m : new e(m.raw, v);
+      if (m instanceof c)
+        return this.raw = m.value, this.set = [[m]], this.formatted = void 0, this;
+      if (this.options = v, this.loose = !!v.loose, this.includePrerelease = !!v.includePrerelease, this.raw = m.trim().replace(s, " "), this.set = this.raw.split("||").map((g) => this.parseRange(g.trim())).filter((g) => g.length), !this.set.length)
         throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
       if (this.set.length > 1) {
-        const R = this.set[0];
-        if (this.set = this.set.filter((g) => !m(g[0])), this.set.length === 0)
-          this.set = [R];
+        const g = this.set[0];
+        if (this.set = this.set.filter((I) => !p(I[0])), this.set.length === 0)
+          this.set = [g];
         else if (this.set.length > 1) {
-          for (const g of this.set)
-            if (g.length === 1 && N(g[0])) {
-              this.set = [g];
+          for (const I of this.set)
+            if (I.length === 1 && O(I[0])) {
+              this.set = [I];
               break;
             }
         }
@@ -722,11 +1191,11 @@ function j() {
     get range() {
       if (this.formatted === void 0) {
         this.formatted = "";
-        for (let d = 0; d < this.set.length; d++) {
-          d > 0 && (this.formatted += "||");
-          const I = this.set[d];
-          for (let R = 0; R < I.length; R++)
-            R > 0 && (this.formatted += " "), this.formatted += I[R].toString().trim();
+        for (let m = 0; m < this.set.length; m++) {
+          m > 0 && (this.formatted += "||");
+          const v = this.set[m];
+          for (let g = 0; g < v.length; g++)
+            g > 0 && (this.formatted += " "), this.formatted += v[g].toString().trim();
         }
       }
       return this.formatted;
@@ -737,479 +1206,478 @@ function j() {
     toString() {
       return this.range;
     }
-    parseRange(d) {
-      const R = ((this.options.includePrerelease && p) | (this.options.loose && S)) + ":" + d, g = n.get(R);
-      if (g)
-        return g;
-      const v = this.options.loose, $ = v ? o[a.HYPHENRANGELOOSE] : o[a.HYPHENRANGE];
-      d = d.replace($, te(this.options.includePrerelease)), l("hyphen replace", d), d = d.replace(o[a.COMPARATORTRIM], e), l("comparator trim", d), d = d.replace(o[a.TILDETRIM], u), l("tilde trim", d), d = d.replace(o[a.CARETTRIM], f), l("caret trim", d);
-      let O = d.split(" ").map((q) => G(q, this.options)).join(" ").split(/\s+/).map((q) => ee(q, this.options));
-      v && (O = O.filter((q) => (l("loose invalid filter", q, this.options), !!q.match(o[a.COMPARATORLOOSE])))), l("range list", O);
-      const T = /* @__PURE__ */ new Map(), y = O.map((q) => new c(q, this.options));
-      for (const q of y) {
-        if (m(q))
-          return [q];
-        T.set(q.value, q);
+    parseRange(m) {
+      const g = ((this.options.includePrerelease && E) | (this.options.loose && S)) + ":" + m, I = n.get(g);
+      if (I)
+        return I;
+      const R = this.options.loose, $ = R ? o[a.HYPHENRANGELOOSE] : o[a.HYPHENRANGE];
+      m = m.replace($, se(this.options.includePrerelease)), l("hyphen replace", m), m = m.replace(o[a.COMPARATORTRIM], r), l("comparator trim", m), m = m.replace(o[a.TILDETRIM], u), l("tilde trim", m), m = m.replace(o[a.CARETTRIM], f), l("caret trim", m);
+      let N = m.split(" ").map((P) => G(P, this.options)).join(" ").split(/\s+/).map((P) => re(P, this.options));
+      R && (N = N.filter((P) => (l("loose invalid filter", P, this.options), !!P.match(o[a.COMPARATORLOOSE])))), l("range list", N);
+      const T = /* @__PURE__ */ new Map(), y = N.map((P) => new c(P, this.options));
+      for (const P of y) {
+        if (p(P))
+          return [P];
+        T.set(P.value, P);
       }
       T.size > 1 && T.has("") && T.delete("");
       const D = [...T.values()];
-      return n.set(R, D), D;
+      return n.set(g, D), D;
     }
-    intersects(d, I) {
-      if (!(d instanceof s))
+    intersects(m, v) {
+      if (!(m instanceof e))
         throw new TypeError("a Range is required");
-      return this.set.some((R) => A(R, I) && d.set.some((g) => A(g, I) && R.every((v) => g.every(($) => v.intersects($, I)))));
+      return this.set.some((g) => w(g, v) && m.set.some((I) => w(I, v) && g.every((R) => I.every(($) => R.intersects($, v)))));
     }
     // if ANY of the sets match ALL of its comparators, then pass
-    test(d) {
-      if (!d)
+    test(m) {
+      if (!m)
         return !1;
-      if (typeof d == "string")
+      if (typeof m == "string")
         try {
-          d = new h(d, this.options);
+          m = new h(m, this.options);
         } catch {
           return !1;
         }
-      for (let I = 0; I < this.set.length; I++)
-        if (re(this.set[I], d, this.options))
+      for (let v = 0; v < this.set.length; v++)
+        if (ne(this.set[v], m, this.options))
           return !0;
       return !1;
     }
   }
-  Pe = s;
-  const r = jr(), n = new r(), i = ze(), c = K(), l = z(), h = b(), {
+  be = e;
+  const t = Vr(), n = new t(), i = Ye(), c = Q(), l = J(), h = x(), {
     safeRe: o,
     t: a,
-    comparatorTrimReplace: e,
+    comparatorTrimReplace: r,
     tildeTrimReplace: u,
     caretTrimReplace: f
-  } = B(), { FLAG_INCLUDE_PRERELEASE: p, FLAG_LOOSE: S } = Y(), m = (E) => E.value === "<0.0.0-0", N = (E) => E.value === "", A = (E, d) => {
-    let I = !0;
-    const R = E.slice();
-    let g = R.pop();
-    for (; I && R.length; )
-      I = R.every((v) => g.intersects(v, d)), g = R.pop();
-    return I;
-  }, G = (E, d) => (E = E.replace(o[a.BUILD], ""), l("comp", E, d), E = C(E, d), l("caret", E), E = x(E, d), l("tildes", E), E = L(E, d), l("xrange", E), E = Q(E, d), l("stars", E), E), w = (E) => !E || E.toLowerCase() === "x" || E === "*", x = (E, d) => E.trim().split(/\s+/).map((I) => _(I, d)).join(" "), _ = (E, d) => {
-    const I = d.loose ? o[a.TILDELOOSE] : o[a.TILDE];
-    return E.replace(I, (R, g, v, $, O) => {
-      l("tilde", E, R, g, v, $, O);
+  } = W(), { FLAG_INCLUDE_PRERELEASE: E, FLAG_LOOSE: S } = K(), p = (d) => d.value === "<0.0.0-0", O = (d) => d.value === "", w = (d, m) => {
+    let v = !0;
+    const g = d.slice();
+    let I = g.pop();
+    for (; v && g.length; )
+      v = g.every((R) => I.intersects(R, m)), I = g.pop();
+    return v;
+  }, G = (d, m) => (d = d.replace(o[a.BUILD], ""), l("comp", d, m), d = C(d, m), l("caret", d), d = b(d, m), l("tildes", d), d = L(d, m), l("xrange", d), d = te(d, m), l("stars", d), d), A = (d) => !d || d.toLowerCase() === "x" || d === "*", b = (d, m) => d.trim().split(/\s+/).map((v) => U(v, m)).join(" "), U = (d, m) => {
+    const v = m.loose ? o[a.TILDELOOSE] : o[a.TILDE];
+    return d.replace(v, (g, I, R, $, N) => {
+      l("tilde", d, g, I, R, $, N);
       let T;
-      return w(g) ? T = "" : w(v) ? T = `>=${g}.0.0 <${+g + 1}.0.0-0` : w($) ? T = `>=${g}.${v}.0 <${g}.${+v + 1}.0-0` : O ? (l("replaceTilde pr", O), T = `>=${g}.${v}.${$}-${O} <${g}.${+v + 1}.0-0`) : T = `>=${g}.${v}.${$} <${g}.${+v + 1}.0-0`, l("tilde return", T), T;
+      return A(I) ? T = "" : A(R) ? T = `>=${I}.0.0 <${+I + 1}.0.0-0` : A($) ? T = `>=${I}.${R}.0 <${I}.${+R + 1}.0-0` : N ? (l("replaceTilde pr", N), T = `>=${I}.${R}.${$}-${N} <${I}.${+R + 1}.0-0`) : T = `>=${I}.${R}.${$} <${I}.${+R + 1}.0-0`, l("tilde return", T), T;
     });
-  }, C = (E, d) => E.trim().split(/\s+/).map((I) => P(I, d)).join(" "), P = (E, d) => {
-    l("caret", E, d);
-    const I = d.loose ? o[a.CARETLOOSE] : o[a.CARET], R = d.includePrerelease ? "-0" : "";
-    return E.replace(I, (g, v, $, O, T) => {
-      l("caret", E, g, v, $, O, T);
+  }, C = (d, m) => d.trim().split(/\s+/).map((v) => q(v, m)).join(" "), q = (d, m) => {
+    l("caret", d, m);
+    const v = m.loose ? o[a.CARETLOOSE] : o[a.CARET], g = m.includePrerelease ? "-0" : "";
+    return d.replace(v, (I, R, $, N, T) => {
+      l("caret", d, I, R, $, N, T);
       let y;
-      return w(v) ? y = "" : w($) ? y = `>=${v}.0.0${R} <${+v + 1}.0.0-0` : w(O) ? v === "0" ? y = `>=${v}.${$}.0${R} <${v}.${+$ + 1}.0-0` : y = `>=${v}.${$}.0${R} <${+v + 1}.0.0-0` : T ? (l("replaceCaret pr", T), v === "0" ? $ === "0" ? y = `>=${v}.${$}.${O}-${T} <${v}.${$}.${+O + 1}-0` : y = `>=${v}.${$}.${O}-${T} <${v}.${+$ + 1}.0-0` : y = `>=${v}.${$}.${O}-${T} <${+v + 1}.0.0-0`) : (l("no pr"), v === "0" ? $ === "0" ? y = `>=${v}.${$}.${O}${R} <${v}.${$}.${+O + 1}-0` : y = `>=${v}.${$}.${O}${R} <${v}.${+$ + 1}.0-0` : y = `>=${v}.${$}.${O} <${+v + 1}.0.0-0`), l("caret return", y), y;
+      return A(R) ? y = "" : A($) ? y = `>=${R}.0.0${g} <${+R + 1}.0.0-0` : A(N) ? R === "0" ? y = `>=${R}.${$}.0${g} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.0${g} <${+R + 1}.0.0-0` : T ? (l("replaceCaret pr", T), R === "0" ? $ === "0" ? y = `>=${R}.${$}.${N}-${T} <${R}.${$}.${+N + 1}-0` : y = `>=${R}.${$}.${N}-${T} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.${N}-${T} <${+R + 1}.0.0-0`) : (l("no pr"), R === "0" ? $ === "0" ? y = `>=${R}.${$}.${N}${g} <${R}.${$}.${+N + 1}-0` : y = `>=${R}.${$}.${N}${g} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.${N} <${+R + 1}.0.0-0`), l("caret return", y), y;
     });
-  }, L = (E, d) => (l("replaceXRanges", E, d), E.split(/\s+/).map((I) => V(I, d)).join(" ")), V = (E, d) => {
-    E = E.trim();
-    const I = d.loose ? o[a.XRANGELOOSE] : o[a.XRANGE];
-    return E.replace(I, (R, g, v, $, O, T) => {
-      l("xRange", E, R, g, v, $, O, T);
-      const y = w(v), D = y || w($), q = D || w(O), k = q;
-      return g === "=" && k && (g = ""), T = d.includePrerelease ? "-0" : "", y ? g === ">" || g === "<" ? R = "<0.0.0-0" : R = "*" : g && k ? (D && ($ = 0), O = 0, g === ">" ? (g = ">=", D ? (v = +v + 1, $ = 0, O = 0) : ($ = +$ + 1, O = 0)) : g === "<=" && (g = "<", D ? v = +v + 1 : $ = +$ + 1), g === "<" && (T = "-0"), R = `${g + v}.${$}.${O}${T}`) : D ? R = `>=${v}.0.0${T} <${+v + 1}.0.0-0` : q && (R = `>=${v}.${$}.0${T} <${v}.${+$ + 1}.0-0`), l("xRange return", R), R;
+  }, L = (d, m) => (l("replaceXRanges", d, m), d.split(/\s+/).map((v) => V(v, m)).join(" ")), V = (d, m) => {
+    d = d.trim();
+    const v = m.loose ? o[a.XRANGELOOSE] : o[a.XRANGE];
+    return d.replace(v, (g, I, R, $, N, T) => {
+      l("xRange", d, g, I, R, $, N, T);
+      const y = A(R), D = y || A($), P = D || A(N), X = P;
+      return I === "=" && X && (I = ""), T = m.includePrerelease ? "-0" : "", y ? I === ">" || I === "<" ? g = "<0.0.0-0" : g = "*" : I && X ? (D && ($ = 0), N = 0, I === ">" ? (I = ">=", D ? (R = +R + 1, $ = 0, N = 0) : ($ = +$ + 1, N = 0)) : I === "<=" && (I = "<", D ? R = +R + 1 : $ = +$ + 1), I === "<" && (T = "-0"), g = `${I + R}.${$}.${N}${T}`) : D ? g = `>=${R}.0.0${T} <${+R + 1}.0.0-0` : P && (g = `>=${R}.${$}.0${T} <${R}.${+$ + 1}.0-0`), l("xRange return", g), g;
     });
-  }, Q = (E, d) => (l("replaceStars", E, d), E.trim().replace(o[a.STAR], "")), ee = (E, d) => (l("replaceGTE0", E, d), E.trim().replace(o[d.includePrerelease ? a.GTE0PRE : a.GTE0], "")), te = (E) => (d, I, R, g, v, $, O, T, y, D, q, k) => (w(R) ? I = "" : w(g) ? I = `>=${R}.0.0${E ? "-0" : ""}` : w(v) ? I = `>=${R}.${g}.0${E ? "-0" : ""}` : $ ? I = `>=${I}` : I = `>=${I}${E ? "-0" : ""}`, w(y) ? T = "" : w(D) ? T = `<${+y + 1}.0.0-0` : w(q) ? T = `<${y}.${+D + 1}.0-0` : k ? T = `<=${y}.${D}.${q}-${k}` : E ? T = `<${y}.${D}.${+q + 1}-0` : T = `<=${T}`, `${I} ${T}`.trim()), re = (E, d, I) => {
-    for (let R = 0; R < E.length; R++)
-      if (!E[R].test(d))
+  }, te = (d, m) => (l("replaceStars", d, m), d.trim().replace(o[a.STAR], "")), re = (d, m) => (l("replaceGTE0", d, m), d.trim().replace(o[m.includePrerelease ? a.GTE0PRE : a.GTE0], "")), se = (d) => (m, v, g, I, R, $, N, T, y, D, P, X) => (A(g) ? v = "" : A(I) ? v = `>=${g}.0.0${d ? "-0" : ""}` : A(R) ? v = `>=${g}.${I}.0${d ? "-0" : ""}` : $ ? v = `>=${v}` : v = `>=${v}${d ? "-0" : ""}`, A(y) ? T = "" : A(D) ? T = `<${+y + 1}.0.0-0` : A(P) ? T = `<${y}.${+D + 1}.0-0` : X ? T = `<=${y}.${D}.${P}-${X}` : d ? T = `<${y}.${D}.${+P + 1}-0` : T = `<=${T}`, `${v} ${T}`.trim()), ne = (d, m, v) => {
+    for (let g = 0; g < d.length; g++)
+      if (!d[g].test(m))
         return !1;
-    if (d.prerelease.length && !I.includePrerelease) {
-      for (let R = 0; R < E.length; R++)
-        if (l(E[R].semver), E[R].semver !== c.ANY && E[R].semver.prerelease.length > 0) {
-          const g = E[R].semver;
-          if (g.major === d.major && g.minor === d.minor && g.patch === d.patch)
+    if (m.prerelease.length && !v.includePrerelease) {
+      for (let g = 0; g < d.length; g++)
+        if (l(d[g].semver), d[g].semver !== c.ANY && d[g].semver.prerelease.length > 0) {
+          const I = d[g].semver;
+          if (I.major === m.major && I.minor === m.minor && I.patch === m.patch)
             return !0;
         }
       return !1;
     }
     return !0;
   };
-  return Pe;
+  return be;
 }
-var Ge, Pt;
-function K() {
-  if (Pt) return Ge;
-  Pt = 1;
-  const t = /* @__PURE__ */ Symbol("SemVer ANY");
-  class s {
+var De, qt;
+function Q() {
+  if (qt) return De;
+  qt = 1;
+  const s = /* @__PURE__ */ Symbol("SemVer ANY");
+  class e {
     static get ANY() {
-      return t;
+      return s;
     }
-    constructor(e, u) {
-      if (u = r(u), e instanceof s) {
-        if (e.loose === !!u.loose)
-          return e;
-        e = e.value;
+    constructor(r, u) {
+      if (u = t(u), r instanceof e) {
+        if (r.loose === !!u.loose)
+          return r;
+        r = r.value;
       }
-      e = e.trim().split(/\s+/).join(" "), l("comparator", e, u), this.options = u, this.loose = !!u.loose, this.parse(e), this.semver === t ? this.value = "" : this.value = this.operator + this.semver.version, l("comp", this);
+      r = r.trim().split(/\s+/).join(" "), l("comparator", r, u), this.options = u, this.loose = !!u.loose, this.parse(r), this.semver === s ? this.value = "" : this.value = this.operator + this.semver.version, l("comp", this);
     }
-    parse(e) {
-      const u = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], f = e.match(u);
+    parse(r) {
+      const u = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], f = r.match(u);
       if (!f)
-        throw new TypeError(`Invalid comparator: ${e}`);
-      this.operator = f[1] !== void 0 ? f[1] : "", this.operator === "=" && (this.operator = ""), f[2] ? this.semver = new h(f[2], this.options.loose) : this.semver = t;
+        throw new TypeError(`Invalid comparator: ${r}`);
+      this.operator = f[1] !== void 0 ? f[1] : "", this.operator === "=" && (this.operator = ""), f[2] ? this.semver = new h(f[2], this.options.loose) : this.semver = s;
     }
     toString() {
       return this.value;
     }
-    test(e) {
-      if (l("Comparator.test", e, this.options.loose), this.semver === t || e === t)
+    test(r) {
+      if (l("Comparator.test", r, this.options.loose), this.semver === s || r === s)
         return !0;
-      if (typeof e == "string")
+      if (typeof r == "string")
         try {
-          e = new h(e, this.options);
+          r = new h(r, this.options);
         } catch {
           return !1;
         }
-      return c(e, this.operator, this.semver, this.options);
+      return c(r, this.operator, this.semver, this.options);
     }
-    intersects(e, u) {
-      if (!(e instanceof s))
+    intersects(r, u) {
+      if (!(r instanceof e))
         throw new TypeError("a Comparator is required");
-      return this.operator === "" ? this.value === "" ? !0 : new o(e.value, u).test(this.value) : e.operator === "" ? e.value === "" ? !0 : new o(this.value, u).test(e.semver) : (u = r(u), u.includePrerelease && (this.value === "<0.0.0-0" || e.value === "<0.0.0-0") || !u.includePrerelease && (this.value.startsWith("<0.0.0") || e.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && e.operator.startsWith(">") || this.operator.startsWith("<") && e.operator.startsWith("<") || this.semver.version === e.semver.version && this.operator.includes("=") && e.operator.includes("=") || c(this.semver, "<", e.semver, u) && this.operator.startsWith(">") && e.operator.startsWith("<") || c(this.semver, ">", e.semver, u) && this.operator.startsWith("<") && e.operator.startsWith(">")));
+      return this.operator === "" ? this.value === "" ? !0 : new o(r.value, u).test(this.value) : r.operator === "" ? r.value === "" ? !0 : new o(this.value, u).test(r.semver) : (u = t(u), u.includePrerelease && (this.value === "<0.0.0-0" || r.value === "<0.0.0-0") || !u.includePrerelease && (this.value.startsWith("<0.0.0") || r.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && r.operator.startsWith(">") || this.operator.startsWith("<") && r.operator.startsWith("<") || this.semver.version === r.semver.version && this.operator.includes("=") && r.operator.includes("=") || c(this.semver, "<", r.semver, u) && this.operator.startsWith(">") && r.operator.startsWith("<") || c(this.semver, ">", r.semver, u) && this.operator.startsWith("<") && r.operator.startsWith(">")));
     }
   }
-  Ge = s;
-  const r = ze(), { safeRe: n, t: i } = B(), c = ar(), l = z(), h = b(), o = j();
-  return Ge;
+  De = e;
+  const t = Ye(), { safeRe: n, t: i } = W(), c = hr(), l = J(), h = x(), o = j();
+  return De;
 }
 var xe, Gt;
-function Z() {
+function ee() {
   if (Gt) return xe;
   Gt = 1;
-  const t = j();
-  return xe = (r, n, i) => {
+  const s = j();
+  return xe = (t, n, i) => {
     try {
-      n = new t(n, i);
+      n = new s(n, i);
     } catch {
       return !1;
     }
-    return n.test(r);
+    return n.test(t);
   }, xe;
 }
-var De, xt;
-function Fr() {
-  if (xt) return De;
-  xt = 1;
-  const t = j();
-  return De = (r, n) => new t(r, n).set.map((i) => i.map((c) => c.value).join(" ").trim().split(" ")), De;
+var Ue, bt;
+function Xr() {
+  if (bt) return Ue;
+  bt = 1;
+  const s = j();
+  return Ue = (t, n) => new s(t, n).set.map((i) => i.map((c) => c.value).join(" ").trim().split(" ")), Ue;
 }
-var be, Dt;
-function Mr() {
-  if (Dt) return be;
+var _e, Dt;
+function Br() {
+  if (Dt) return _e;
   Dt = 1;
-  const t = b(), s = j();
-  return be = (n, i, c) => {
+  const s = x(), e = j();
+  return _e = (n, i, c) => {
     let l = null, h = null, o = null;
     try {
-      o = new s(i, c);
+      o = new e(i, c);
     } catch {
       return null;
     }
     return n.forEach((a) => {
-      o.test(a) && (!l || h.compare(a) === -1) && (l = a, h = new t(l, c));
+      o.test(a) && (!l || h.compare(a) === -1) && (l = a, h = new s(l, c));
     }), l;
-  }, be;
+  }, _e;
 }
-var _e, bt;
-function Vr() {
-  if (bt) return _e;
-  bt = 1;
-  const t = b(), s = j();
-  return _e = (n, i, c) => {
+var Fe, xt;
+function Wr() {
+  if (xt) return Fe;
+  xt = 1;
+  const s = x(), e = j();
+  return Fe = (n, i, c) => {
     let l = null, h = null, o = null;
     try {
-      o = new s(i, c);
+      o = new e(i, c);
     } catch {
       return null;
     }
     return n.forEach((a) => {
-      o.test(a) && (!l || h.compare(a) === 1) && (l = a, h = new t(l, c));
+      o.test(a) && (!l || h.compare(a) === 1) && (l = a, h = new s(l, c));
     }), l;
-  }, _e;
+  }, Fe;
 }
-var Ue, _t;
-function kr() {
-  if (_t) return Ue;
-  _t = 1;
-  const t = b(), s = j(), r = J();
-  return Ue = (i, c) => {
-    i = new s(i, c);
-    let l = new t("0.0.0");
-    if (i.test(l) || (l = new t("0.0.0-0"), i.test(l)))
+var je, Ut;
+function Hr() {
+  if (Ut) return je;
+  Ut = 1;
+  const s = x(), e = j(), t = Z();
+  return je = (i, c) => {
+    i = new e(i, c);
+    let l = new s("0.0.0");
+    if (i.test(l) || (l = new s("0.0.0-0"), i.test(l)))
       return l;
     l = null;
     for (let h = 0; h < i.set.length; ++h) {
       const o = i.set[h];
       let a = null;
-      o.forEach((e) => {
-        const u = new t(e.semver.version);
-        switch (e.operator) {
+      o.forEach((r) => {
+        const u = new s(r.semver.version);
+        switch (r.operator) {
           case ">":
             u.prerelease.length === 0 ? u.patch++ : u.prerelease.push(0), u.raw = u.format();
           /* fallthrough */
           case "":
           case ">=":
-            (!a || r(u, a)) && (a = u);
+            (!a || t(u, a)) && (a = u);
             break;
           case "<":
           case "<=":
             break;
           /* istanbul ignore next */
           default:
-            throw new Error(`Unexpected operation: ${e.operator}`);
+            throw new Error(`Unexpected operation: ${r.operator}`);
         }
-      }), a && (!l || r(l, a)) && (l = a);
+      }), a && (!l || t(l, a)) && (l = a);
     }
     return l && i.test(l) ? l : null;
-  }, Ue;
+  }, je;
 }
-var je, Ut;
-function Xr() {
-  if (Ut) return je;
-  Ut = 1;
-  const t = j();
-  return je = (r, n) => {
+var ke, _t;
+function zr() {
+  if (_t) return ke;
+  _t = 1;
+  const s = j();
+  return ke = (t, n) => {
     try {
-      return new t(r, n).range || "*";
+      return new s(t, n).range || "*";
     } catch {
       return null;
     }
-  }, je;
+  }, ke;
 }
-var Fe, jt;
+var Me, Ft;
 function et() {
-  if (jt) return Fe;
-  jt = 1;
-  const t = b(), s = K(), { ANY: r } = s, n = j(), i = Z(), c = J(), l = Ke(), h = Qe(), o = Ze();
-  return Fe = (e, u, f, p) => {
-    e = new t(e, p), u = new n(u, p);
-    let S, m, N, A, G;
+  if (Ft) return Me;
+  Ft = 1;
+  const s = x(), e = Q(), { ANY: t } = e, n = j(), i = ee(), c = Z(), l = Je(), h = Qe(), o = Ze();
+  return Me = (r, u, f, E) => {
+    r = new s(r, E), u = new n(u, E);
+    let S, p, O, w, G;
     switch (f) {
       case ">":
-        S = c, m = h, N = l, A = ">", G = ">=";
+        S = c, p = h, O = l, w = ">", G = ">=";
         break;
       case "<":
-        S = l, m = o, N = c, A = "<", G = "<=";
+        S = l, p = o, O = c, w = "<", G = "<=";
         break;
       default:
         throw new TypeError('Must provide a hilo val of "<" or ">"');
     }
-    if (i(e, u, p))
+    if (i(r, u, E))
       return !1;
-    for (let w = 0; w < u.set.length; ++w) {
-      const x = u.set[w];
-      let _ = null, C = null;
-      if (x.forEach((P) => {
-        P.semver === r && (P = new s(">=0.0.0")), _ = _ || P, C = C || P, S(P.semver, _.semver, p) ? _ = P : N(P.semver, C.semver, p) && (C = P);
-      }), _.operator === A || _.operator === G || (!C.operator || C.operator === A) && m(e, C.semver))
+    for (let A = 0; A < u.set.length; ++A) {
+      const b = u.set[A];
+      let U = null, C = null;
+      if (b.forEach((q) => {
+        q.semver === t && (q = new e(">=0.0.0")), U = U || q, C = C || q, S(q.semver, U.semver, E) ? U = q : O(q.semver, C.semver, E) && (C = q);
+      }), U.operator === w || U.operator === G || (!C.operator || C.operator === w) && p(r, C.semver))
         return !1;
-      if (C.operator === G && N(e, C.semver))
+      if (C.operator === G && O(r, C.semver))
         return !1;
     }
     return !0;
-  }, Fe;
-}
-var Me, Ft;
-function Br() {
-  if (Ft) return Me;
-  Ft = 1;
-  const t = et();
-  return Me = (r, n, i) => t(r, n, ">", i), Me;
-}
-var Ve, Mt;
-function Hr() {
-  if (Mt) return Ve;
-  Mt = 1;
-  const t = et();
-  return Ve = (r, n, i) => t(r, n, "<", i), Ve;
+  }, Me;
 }
-var ke, Vt;
-function Wr() {
-  if (Vt) return ke;
-  Vt = 1;
-  const t = j();
-  return ke = (r, n, i) => (r = new t(r, i), n = new t(n, i), r.intersects(n, i)), ke;
+var Ve, jt;
+function Yr() {
+  if (jt) return Ve;
+  jt = 1;
+  const s = et();
+  return Ve = (t, n, i) => s(t, n, ">", i), Ve;
 }
 var Xe, kt;
-function Yr() {
+function Kr() {
   if (kt) return Xe;
   kt = 1;
-  const t = Z(), s = U();
-  return Xe = (r, n, i) => {
+  const s = et();
+  return Xe = (t, n, i) => s(t, n, "<", i), Xe;
+}
+var Be, Mt;
+function Jr() {
+  if (Mt) return Be;
+  Mt = 1;
+  const s = j();
+  return Be = (t, n, i) => (t = new s(t, i), n = new s(n, i), t.intersects(n, i)), Be;
+}
+var We, Vt;
+function Zr() {
+  if (Vt) return We;
+  Vt = 1;
+  const s = ee(), e = F();
+  return We = (t, n, i) => {
     const c = [];
     let l = null, h = null;
-    const o = r.sort((f, p) => s(f, p, i));
+    const o = t.sort((f, E) => e(f, E, i));
     for (const f of o)
-      t(f, n, i) ? (h = f, l || (l = f)) : (h && c.push([l, h]), h = null, l = null);
+      s(f, n, i) ? (h = f, l || (l = f)) : (h && c.push([l, h]), h = null, l = null);
     l && c.push([l, null]);
     const a = [];
-    for (const [f, p] of c)
-      f === p ? a.push(f) : !p && f === o[0] ? a.push("*") : p ? f === o[0] ? a.push(`<=${p}`) : a.push(`${f} - ${p}`) : a.push(`>=${f}`);
-    const e = a.join(" || "), u = typeof n.raw == "string" ? n.raw : String(n);
-    return e.length < u.length ? e : n;
-  }, Xe;
-}
-var Be, Xt;
-function zr() {
-  if (Xt) return Be;
+    for (const [f, E] of c)
+      f === E ? a.push(f) : !E && f === o[0] ? a.push("*") : E ? f === o[0] ? a.push(`<=${E}`) : a.push(`${f} - ${E}`) : a.push(`>=${f}`);
+    const r = a.join(" || "), u = typeof n.raw == "string" ? n.raw : String(n);
+    return r.length < u.length ? r : n;
+  }, We;
+}
+var He, Xt;
+function Qr() {
+  if (Xt) return He;
   Xt = 1;
-  const t = j(), s = K(), { ANY: r } = s, n = Z(), i = U(), c = (u, f, p = {}) => {
+  const s = j(), e = Q(), { ANY: t } = e, n = ee(), i = F(), c = (u, f, E = {}) => {
     if (u === f)
       return !0;
-    u = new t(u, p), f = new t(f, p);
+    u = new s(u, E), f = new s(f, E);
     let S = !1;
-    e: for (const m of u.set) {
-      for (const N of f.set) {
-        const A = o(m, N, p);
-        if (S = S || A !== null, A)
+    e: for (const p of u.set) {
+      for (const O of f.set) {
+        const w = o(p, O, E);
+        if (S = S || w !== null, w)
           continue e;
       }
       if (S)
         return !1;
     }
     return !0;
-  }, l = [new s(">=0.0.0-0")], h = [new s(">=0.0.0")], o = (u, f, p) => {
+  }, l = [new e(">=0.0.0-0")], h = [new e(">=0.0.0")], o = (u, f, E) => {
     if (u === f)
       return !0;
-    if (u.length === 1 && u[0].semver === r) {
-      if (f.length === 1 && f[0].semver === r)
+    if (u.length === 1 && u[0].semver === t) {
+      if (f.length === 1 && f[0].semver === t)
         return !0;
-      p.includePrerelease ? u = l : u = h;
+      E.includePrerelease ? u = l : u = h;
     }
-    if (f.length === 1 && f[0].semver === r) {
-      if (p.includePrerelease)
+    if (f.length === 1 && f[0].semver === t) {
+      if (E.includePrerelease)
         return !0;
       f = h;
     }
     const S = /* @__PURE__ */ new Set();
-    let m, N;
+    let p, O;
     for (const L of u)
-      L.operator === ">" || L.operator === ">=" ? m = a(m, L, p) : L.operator === "<" || L.operator === "<=" ? N = e(N, L, p) : S.add(L.semver);
+      L.operator === ">" || L.operator === ">=" ? p = a(p, L, E) : L.operator === "<" || L.operator === "<=" ? O = r(O, L, E) : S.add(L.semver);
     if (S.size > 1)
       return null;
-    let A;
-    if (m && N) {
-      if (A = i(m.semver, N.semver, p), A > 0)
+    let w;
+    if (p && O) {
+      if (w = i(p.semver, O.semver, E), w > 0)
         return null;
-      if (A === 0 && (m.operator !== ">=" || N.operator !== "<="))
+      if (w === 0 && (p.operator !== ">=" || O.operator !== "<="))
         return null;
     }
     for (const L of S) {
-      if (m && !n(L, String(m), p) || N && !n(L, String(N), p))
+      if (p && !n(L, String(p), E) || O && !n(L, String(O), E))
         return null;
       for (const V of f)
-        if (!n(L, String(V), p))
+        if (!n(L, String(V), E))
           return !1;
       return !0;
     }
-    let G, w, x, _, C = N && !p.includePrerelease && N.semver.prerelease.length ? N.semver : !1, P = m && !p.includePrerelease && m.semver.prerelease.length ? m.semver : !1;
-    C && C.prerelease.length === 1 && N.operator === "<" && C.prerelease[0] === 0 && (C = !1);
+    let G, A, b, U, C = O && !E.includePrerelease && O.semver.prerelease.length ? O.semver : !1, q = p && !E.includePrerelease && p.semver.prerelease.length ? p.semver : !1;
+    C && C.prerelease.length === 1 && O.operator === "<" && C.prerelease[0] === 0 && (C = !1);
     for (const L of f) {
-      if (_ = _ || L.operator === ">" || L.operator === ">=", x = x || L.operator === "<" || L.operator === "<=", m) {
-        if (P && L.semver.prerelease && L.semver.prerelease.length && L.semver.major === P.major && L.semver.minor === P.minor && L.semver.patch === P.patch && (P = !1), L.operator === ">" || L.operator === ">=") {
-          if (G = a(m, L, p), G === L && G !== m)
+      if (U = U || L.operator === ">" || L.operator === ">=", b = b || L.operator === "<" || L.operator === "<=", p) {
+        if (q && L.semver.prerelease && L.semver.prerelease.length && L.semver.major === q.major && L.semver.minor === q.minor && L.semver.patch === q.patch && (q = !1), L.operator === ">" || L.operator === ">=") {
+          if (G = a(p, L, E), G === L && G !== p)
             return !1;
-        } else if (m.operator === ">=" && !n(m.semver, String(L), p))
+        } else if (p.operator === ">=" && !n(p.semver, String(L), E))
           return !1;
       }
-      if (N) {
+      if (O) {
         if (C && L.semver.prerelease && L.semver.prerelease.length && L.semver.major === C.major && L.semver.minor === C.minor && L.semver.patch === C.patch && (C = !1), L.operator === "<" || L.operator === "<=") {
-          if (w = e(N, L, p), w === L && w !== N)
+          if (A = r(O, L, E), A === L && A !== O)
             return !1;
-        } else if (N.operator === "<=" && !n(N.semver, String(L), p))
+        } else if (O.operator === "<=" && !n(O.semver, String(L), E))
           return !1;
       }
-      if (!L.operator && (N || m) && A !== 0)
+      if (!L.operator && (O || p) && w !== 0)
         return !1;
     }
-    return !(m && x && !N && A !== 0 || N && _ && !m && A !== 0 || P || C);
-  }, a = (u, f, p) => {
+    return !(p && b && !O && w !== 0 || O && U && !p && w !== 0 || q || C);
+  }, a = (u, f, E) => {
     if (!u)
       return f;
-    const S = i(u.semver, f.semver, p);
+    const S = i(u.semver, f.semver, E);
     return S > 0 ? u : S < 0 || f.operator === ">" && u.operator === ">=" ? f : u;
-  }, e = (u, f, p) => {
+  }, r = (u, f, E) => {
     if (!u)
       return f;
-    const S = i(u.semver, f.semver, p);
+    const S = i(u.semver, f.semver, E);
     return S < 0 ? u : S > 0 || f.operator === "<" && u.operator === "<=" ? f : u;
   };
-  return Be = c, Be;
+  return He = c, He;
 }
-var He, Bt;
-function Jr() {
-  if (Bt) return He;
+var ze, Bt;
+function es() {
+  if (Bt) return ze;
   Bt = 1;
-  const t = B(), s = Y(), r = b(), n = sr(), i = M(), c = Or(), l = Ar(), h = wr(), o = yr(), a = Cr(), e = qr(), u = Pr(), f = Gr(), p = U(), S = xr(), m = Dr(), N = Je(), A = br(), G = _r(), w = J(), x = Ke(), _ = nr(), C = ir(), P = Ze(), L = Qe(), V = ar(), Q = Ur(), ee = K(), te = j(), re = Z(), E = Fr(), d = Mr(), I = Vr(), R = kr(), g = Xr(), v = et(), $ = Br(), O = Hr(), T = Wr(), y = Yr(), D = zr();
-  return He = {
+  const s = W(), e = K(), t = x(), n = lr(), i = M(), c = Cr(), l = Pr(), h = qr(), o = Gr(), a = br(), r = Dr(), u = xr(), f = Ur(), E = F(), S = _r(), p = Fr(), O = Ke(), w = jr(), G = kr(), A = Z(), b = Je(), U = cr(), C = ur(), q = Ze(), L = Qe(), V = hr(), te = Mr(), re = Q(), se = j(), ne = ee(), d = Xr(), m = Br(), v = Wr(), g = Hr(), I = zr(), R = et(), $ = Yr(), N = Kr(), T = Jr(), y = Zr(), D = Qr();
+  return ze = {
     parse: i,
     valid: c,
     clean: l,
     inc: h,
     diff: o,
     major: a,
-    minor: e,
+    minor: r,
     patch: u,
     prerelease: f,
-    compare: p,
+    compare: E,
     rcompare: S,
-    compareLoose: m,
-    compareBuild: N,
-    sort: A,
+    compareLoose: p,
+    compareBuild: O,
+    sort: w,
     rsort: G,
-    gt: w,
-    lt: x,
-    eq: _,
+    gt: A,
+    lt: b,
+    eq: U,
     neq: C,
-    gte: P,
+    gte: q,
     lte: L,
     cmp: V,
-    coerce: Q,
-    Comparator: ee,
-    Range: te,
-    satisfies: re,
-    toComparators: E,
-    maxSatisfying: d,
-    minSatisfying: I,
-    minVersion: R,
-    validRange: g,
-    outside: v,
+    coerce: te,
+    Comparator: re,
+    Range: se,
+    satisfies: ne,
+    toComparators: d,
+    maxSatisfying: m,
+    minSatisfying: v,
+    minVersion: g,
+    validRange: I,
+    outside: R,
     gtr: $,
-    ltr: O,
+    ltr: N,
     intersects: T,
     simplifyRange: y,
     subset: D,
-    SemVer: r,
-    re: t.re,
-    src: t.src,
-    tokens: t.t,
-    SEMVER_SPEC_VERSION: s.SEMVER_SPEC_VERSION,
-    RELEASE_TYPES: s.RELEASE_TYPES,
+    SemVer: t,
+    re: s.re,
+    src: s.src,
+    tokens: s.t,
+    SEMVER_SPEC_VERSION: e.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: e.RELEASE_TYPES,
     compareIdentifiers: n.compareIdentifiers,
     rcompareIdentifiers: n.rcompareIdentifiers
-  }, He;
+  }, ze;
 }
-var Kr = Jr();
-const Ht = `^${X.Version}`;
-class ts {
-  config = new lr(Wt);
-  event = new cr();
+var ts = es();
+const Wt = `^${z.Version}`;
+class is {
+  config = new mr(Ht);
+  event = new pr();
   state;
   active;
   time;
-  offset;
   info;
-  mergedLineEnd = [];
+  merger = new wr();
+  offset = new Ar();
+  driver = new yr();
   constructor() {
     this.state = {
       playing: !1,
-      frameId: null,
-      timerId: null,
       scanIndex: 0
     }, this.active = {
       lines: [],
@@ -1217,14 +1685,11 @@ class ts {
     }, this.time = {
       start: 0,
       seek: 0
-    }, this.offset = {
-      temp: 0,
-      meta: 0
-    }, this.info = new X.Info(), this.config.event.add("update", this.onConfigUpdate);
-  }
-  onConfigUpdate = (s) => {
-    const r = s.has("offset.useMeta");
-    r && this.handleRefreshOffset(), (r || s.has("offset.global")) && this.handleSyncTime(), s.has("mergeWindow") && (this.handleBuildMergedLineEnd(), this.handleSyncTime());
+    }, this.info = new z.Info(), this.config.event.add("update", this.onConfigUpdate);
+  }
+  onConfigUpdate = (e) => {
+    const t = e.has("offset.useMeta");
+    t && this.offset.refreshFromMeta(this.info, this.config.current.offset.useMeta), (t || e.has("offset.global")) && this.handleSyncTime(), (e.has("mergeWindow") || e.has("mergeLimit")) && (this.handleBuildMergedLineEnd(), this.handleSyncTime());
   };
   // Get current playback time.
   handleGetCurrentTime() {
@@ -1234,53 +1699,24 @@ class ts {
   handleGetEffectiveTime() {
     return this.handleGetCurrentTime() + this.currentOffset;
   }
-  // Refresh meta offset.
-  handleRefreshOffset() {
-    if (this.config.current.offset.useMeta) {
-      const r = this.info.metas.find((i) => i.type === X.MetaType.Offset)?.content, n = typeof r == "number" && Number.isFinite(r) ? r : 0;
-      this.offset.meta = n;
-    } else
-      this.offset.meta = 0;
-  }
-  handleGetLineTime(s) {
-    if (s < 0 || s >= this.info.lines.length)
-      return 0;
-    if (s === this.info.lines.length - 1)
-      return 1 / 0;
-    const r = this.info.lines[s], n = this.info.lines[s + 1];
-    return Math.max(r.time.end, n.time.start);
-  }
+  /**
+   * Rebuild the merged line-end table from the current lyric and merge config.
+   */
   handleBuildMergedLineEnd() {
-    const s = this.info.lines.length, r = new Array(s);
-    if (s === 0) {
-      this.mergedLineEnd = r;
-      return;
-    }
-    const n = Math.max(0, this.config.current.mergeWindow);
-    let i = this.handleGetLineTime(s - 1);
-    r[s - 1] = i;
-    for (let c = s - 2; c >= 0; c--) {
-      const l = this.handleGetLineTime(c);
-      n > 0 && Math.abs(i - l) < n ? r[c] = Math.max(l, r[c + 1]) : r[c] = l, i = l;
-    }
-    this.mergedLineEnd = r;
-  }
-  handleGetMergedLineTime(s) {
-    const r = this.mergedLineEnd[s];
-    return r === void 0 ? this.handleGetLineTime(s) : r;
+    this.merger.build(this.info.lines, this.config.current.mergeWindow, this.config.current.mergeLimit);
   }
   handleGetActiveIndex() {
     return this.active.index.length > 0 ? this.active.index[0] : -1;
   }
-  handleBridgeActive(s, r) {
-    if (!this.config.current.bridgeActive || r.length < 2)
-      return { lines: s, index: r };
-    const n = r[0], i = r[r.length - 1];
-    if (i - n + 1 === r.length)
-      return { lines: s, index: r };
+  handleBridgeActive(e, t) {
+    if (!this.config.current.bridgeActive || t.length < 2)
+      return { lines: e, index: t };
+    const n = t[0], i = t[t.length - 1];
+    if (i - n + 1 === t.length)
+      return { lines: e, index: t };
     const c = /* @__PURE__ */ new Map();
-    for (let o = 0; o < r.length; o++)
-      c.set(r[o], s[o]);
+    for (let o = 0; o < t.length; o++)
+      c.set(t[o], e[o]);
     const l = [], h = [];
     for (let o = n; o <= i; o++) {
       const a = c.get(o) ?? this.info.lines[o];
@@ -1288,109 +1724,109 @@ class ts {
     }
     return { lines: l, index: h };
   }
-  handleEmitLinesUpdate(s) {
-    const r = this.handleBridgeActive(this.active.lines, this.active.index);
-    this.event.emit("linesUpdate", r.lines, r.index, this.handleGetActiveIndex(), s);
+  handleEmitLinesUpdate(e) {
+    const t = this.handleBridgeActive(this.active.lines, this.active.index);
+    this.event.emit("linesUpdate", t.lines, t.index, this.handleGetActiveIndex(), e);
   }
-  handleSyncTime(s) {
-    if (!this.info.lines.length || (s === void 0 && (s = this.handleGetEffectiveTime()), !Number.isFinite(s)))
+  handleSyncTime(e) {
+    if (!this.info.lines.length || (e === void 0 && (e = this.handleGetEffectiveTime()), !Number.isFinite(e)))
       return;
-    const r = [], n = [];
+    const t = [], n = [];
     let i = this.info.lines.length;
     for (let c = 0; c < this.info.lines.length; c++) {
       const l = this.info.lines[c];
-      if (l.time.start > s) {
+      if (l.time.start > e) {
         i = c;
         break;
       }
-      this.handleGetMergedLineTime(c) > s && (r.push(l), n.push(c));
+      this.merger.getMergedTime(c) > e && (t.push(l), n.push(c));
     }
-    this.state.scanIndex = i, this.active.lines = r, this.active.index = n, this.handleEmitLinesUpdate(!0);
+    this.state.scanIndex = i, this.active.lines = t, this.active.index = n, this.handleEmitLinesUpdate(!0);
   }
-  handleUpdateActiveLines(s) {
-    let r = !1;
+  handleUpdateActiveLines(e) {
+    let t = !1;
     const n = [], i = [];
     for (let c = 0; c < this.active.lines.length; c++) {
       const l = this.active.lines[c], h = this.active.index[c];
-      s >= this.handleGetMergedLineTime(h) ? r = !0 : (n.push(l), i.push(h));
+      e >= this.merger.getMergedTime(h) ? t = !0 : (n.push(l), i.push(h));
     }
     for (; this.state.scanIndex < this.info.lines.length; ) {
       const c = this.info.lines[this.state.scanIndex];
-      if (s >= c.time.start)
-        s < this.handleGetMergedLineTime(this.state.scanIndex) && (n.push(c), i.push(this.state.scanIndex), r = !0), this.state.scanIndex++;
+      if (e >= c.time.start)
+        e < this.merger.getMergedTime(this.state.scanIndex) && (n.push(c), i.push(this.state.scanIndex), t = !0), this.state.scanIndex++;
       else
         break;
     }
-    r && (this.active.lines = n, this.active.index = i, this.handleEmitLinesUpdate(!1));
+    t && (this.active.lines = n, this.active.index = i, this.handleEmitLinesUpdate(!1));
   }
   onTick = () => {
     if (!this.state.playing)
       return;
-    const s = this.handleGetEffectiveTime();
-    switch (this.handleUpdateActiveLines(s), this.config.current.driver) {
-      case "animation":
-        this.state.frameId = globalThis.requestAnimationFrame(this.onTick);
-        break;
-      case "timer":
-        this.state.timerId = globalThis.setTimeout(this.onTick, 16);
-        break;
-    }
+    const e = this.handleGetEffectiveTime();
+    this.handleUpdateActiveLines(e), this.driver.schedule(this.config.current.driver, this.onTick);
   };
-  updateLyric(s) {
-    if (!s)
+  updateLyric(e) {
+    if (!e)
       return;
-    let r = s;
-    Kr.satisfies(s.version, Ht) || (console.warn(`[music-lyric-player] ignored lyric with incompatible version "${s.version}", expected "${Ht}"`), r = new X.Info()), this.pause(), this.info = r, this.handleBuildMergedLineEnd(), this.handleRefreshOffset(), this.config.current.offset.resetTempOnLyricChange && (this.offset.temp = 0), this.active.lines = [], this.active.index = [], this.state.scanIndex = 0, this.time.seek = 0, this.event.emit("lyricUpdate", r), this.event.emit("linesUpdate", [], [], -1, !1);
+    let t = e;
+    ts.satisfies(e.version, Wt) || (console.warn(`[music-lyric-player] ignored lyric with incompatible version "${e.version}", expected "${Wt}"`), t = new z.Info()), this.pause(), this.info = t, this.handleBuildMergedLineEnd(), this.offset.refreshFromMeta(this.info, this.config.current.offset.useMeta), this.config.current.offset.resetTempOnLyricChange && this.offset.resetTemp(), this.active.lines = [], this.active.index = [], this.state.scanIndex = 0, this.time.seek = 0, this.event.emit("lyricUpdate", t), this.event.emit("linesUpdate", [], [], -1, !1);
   }
   /**
    * Start playback
+   *
    * @param time Optional time in ms to seek to before starting playback. If not provided, playback will start from the current position.
    */
-  play(s) {
-    this.pause(), typeof s == "number" && Number.isFinite(s) && (this.time.seek = s, this.handleSyncTime()), this.time.start = performance.now(), this.state.playing = !0, this.onTick(), this.event.emit("play", this.handleGetCurrentTime());
+  play(e) {
+    this.pause(), typeof e == "number" && Number.isFinite(e) && (this.time.seek = e, this.handleSyncTime()), this.time.start = performance.now(), this.state.playing = !0, this.onTick(), this.event.emit("play", this.handleGetCurrentTime());
   }
   /**
    * Pause playback
    */
   pause() {
-    this.state.playing && (this.time.seek = this.handleGetCurrentTime(), this.state.playing = !1, this.event.emit("pause", this.time.seek)), this.state.frameId !== null && (globalThis.cancelAnimationFrame(this.state.frameId), this.state.frameId = null), this.state.timerId !== null && (globalThis.clearTimeout(this.state.timerId), this.state.timerId = null);
+    this.state.playing && (this.time.seek = this.handleGetCurrentTime(), this.state.playing = !1, this.event.emit("pause", this.time.seek)), this.driver.cancel();
   }
   /**
    * Stop playback
    */
   dispose() {
-    this.pause(), this.event.clear(), this.config.event.remove("update", this.onConfigUpdate), this.active.lines = [], this.active.index = [], this.info = new X.Info();
+    this.pause(), this.event.clear(), this.config.event.remove("update", this.onConfigUpdate), this.active.lines = [], this.active.index = [], this.info = new z.Info();
   }
   /**
    * Update the temp offset in ms (the user's temporary adjustment).
+   *
    * Stacked on top of the global config offset and the lyric's meta offset, then resyncs immediately.
+   *
    * @param value temp offset in ms; non-finite values are treated as 0.
    */
-  updateTempOffset(s) {
-    this.offset.temp = Number.isFinite(s) ? s : 0, this.handleSyncTime();
+  updateTempOffset(e) {
+    this.offset.setTemp(e), this.handleSyncTime();
   }
   /**
    * Find all active lines at the given time (ms). Does not mutate internal state.
+   *
    * Assumes `info.lines` is sorted by `time.start` ascending.
+   *
    * @param time time in ms to find active lines for.
    */
-  matchLinesWithTime(s) {
-    const r = s + this.currentOffset, n = [], i = [];
+  matchLinesWithTime(e) {
+    const t = e + this.currentOffset, n = [], i = [];
     for (let c = 0; c < this.info.lines.length; c++) {
       const l = this.info.lines[c];
-      if (l.time.start > r)
+      if (l.time.start > t)
         break;
-      this.handleGetMergedLineTime(c) > r && (n.push(l), i.push(c));
+      this.merger.getMergedTime(c) > t && (n.push(l), i.push(c));
     }
     return this.handleBridgeActive(n, i);
   }
   /**
    * Convert a content (lyric) time to the playback clock by removing the active offset.
+   *
    * Seeking playback to the returned time makes a line at `contentTime` become active.
+   *
    * @param contentTime content time in ms (e.g. a line's start).
    */
-  convertContentTime(s) {
-    return s - this.currentOffset;
+  convertContentTime(e) {
+    return e - this.currentOffset;
   }
   /**
    * Whether the player is currently playing.
@@ -1432,12 +1868,11 @@ class ts {
    * The current effective lyric offset in ms (config offset + lyric meta offset + temp offset).
    */
   get currentOffset() {
-    const s = this.config.current.offset.global + this.offset.meta + this.offset.temp;
-    return Number.isFinite(s) ? s : 0;
+    return this.offset.resolve(this.config.current.offset.global);
   }
 }
 export {
-  ts as BaseLyricPlayer,
-  es as BaseLyricPlayerConfig
+  is as BaseLyricPlayer,
+  ns as BaseLyricPlayerConfig
 };
 //# sourceMappingURL=index.ecma.js.map