@music-lyric-player/base 0.14.0 → 0.16.0

package/dist/index.ecma.js

@@ -1,191 +1,674 @@
-import { freezeObjectDeep as or, ConfigManager as lr, Event as cr } from "@music-lyric-player/utils";
-import "lodash-es";
-const Wt = or({
+import { freezeObjectDeep as mr, ConfigManager as dr, Event as pr } from "@music-lyric-player/utils";
+const Ht = mr({
   driver: "animation",
   bridgeActive: !0,
   mergeWindow: 300,
+  mergeLimit: 3,
   offset: {
     global: 0,
     useMeta: !0,
     resetTempOnLyricChange: !0
   }
-}), es = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), os = /* @__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("");
-};
-class W {
-  start = 0;
-  end = 0;
+  DEFAULT: Ht
+}, Symbol.toStringTag, { value: "Module" }));
+var zt = /* @__PURE__ */ ((r) => (r.ChineseSimplified = "zh-hans", r.ChineseTraditional = "zh-hant", r.English = "en", r.Japanese = "ja", r.Korean = "ko", r.Russian = "ru", r.French = "fr", r.German = "de", r.Spanish = "es", r.Italian = "it", r.Portuguese = "pt", r))(zt || {});
+class Er {
+  /**
+   * Language tag.
+   */
+  tag;
+  /**
+   * Share within the lyric, ranging from 0 to 100.
+   * Recommended to be computed from word-level language counts.
+   */
+  percent;
+  constructor(e = {}) {
+    this.tag = e.tag ?? "", this.percent = e.percent ?? 0;
+  }
+}
+class Yt {
+  /**
+   * All languages with their shares.
+   *
+   * Shares are a snapshot filled by the language transform; stale after lines change.
+   */
+  list;
+  constructor(e = {}) {
+    this.list = e.list ?? [];
+  }
+  /**
+   * Whether a language of the given tag is present.
+   */
+  has(e) {
+    return this.list.some((t) => t.tag === e);
+  }
+  /**
+   * The language entry of the given tag.
+   */
+  byType(e) {
+    return this.list.find((t) => t.tag === e);
+  }
+  /**
+   * 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;
+  /**
+   * End time in milliseconds.
+   */
+  end;
+  constructor(e = 0, t = 0) {
+    this.start = e, this.end = t;
+  }
+  /**
+   * 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 gr {
+  /**
+   * Time range of the token.
+   */
+  time;
+  /**
+   * Text content of the token.
+   */
+  content;
+  constructor(e = {}) {
+    this.time = e.time, this.content = e.content ?? "";
   }
 }
-var Ye = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Space = "Space", t))(Ye || {});
-class Yt {
-  stress = !1;
+class ze {
+  /**
+   * 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;
+  constructor(e = {}) {
+    this.time = e.time, this.words = e.words ?? [], this.language = e.language;
+  }
+  /**
+   * Flat text joined from every word.
+   *
+   * Live: recomputed on each access.
+   */
+  get content() {
+    let e = "";
+    for (let t = 0, n = this.words.length; t < n; t++)
+      e += this.words[t].content;
+    return e;
+  }
+}
+class Rr extends ze {
+  /**
+   * Whether this ruby marks the start of a phrase.
+   */
+  phraseStart;
+  constructor(e = {}) {
+    super(e), this.phraseStart = e.phraseStart ?? !1;
+  }
 }
-class ur {
+class vr extends ze {
+  /**
+   * Original annotation type name.
+   */
+  key;
+  constructor(e = {}) {
+    super(e), this.key = e.key ?? "";
+  }
+}
+class Ir {
+  /**
+   * Ruby annotation such as furigana.
+   */
+  ruby;
+  /**
+   * Romanized transliterations.
+   */
+  romans;
+  /**
+   * Unknown annotations keyed by their original type name.
+   */
+  unknowns;
+  constructor(e = {}) {
+    this.ruby = e.ruby, this.romans = e.romans, this.unknowns = e.unknowns;
+  }
+}
+var k = /* @__PURE__ */ ((r) => (r.Normal = "Normal", r.Space = "Space", r))(k || {});
+class $r {
+  /**
+   * Discriminant marking this as a normal word.
+   */
   type = "Normal";
-  time = new W();
-  content = "";
-  extended = [];
-  config = new Yt();
+  /**
+   * Time range of the word.
+   */
+  time;
+  /**
+   * Text content of the word.
+   */
+  content;
+  /**
+   * Language of this word.
+   */
+  language;
+  /**
+   * Annotations attached to this word.
+   */
+  annotation;
+  /**
+   * Whether the word is stressed.
+   */
+  stress;
+  constructor(e = {}) {
+    this.time = e.time, this.content = e.content ?? "", this.language = e.language, this.annotation = e.annotation, this.stress = e.stress ?? !1;
+  }
 }
-class fr {
+class Lr {
+  /**
+   * Discriminant marking this as a space.
+   */
   type = "Space";
-  count = 1;
-}
-var zt = /* @__PURE__ */ ((t) => (t.Unknown = "Unknown", t.Translate = "Translate", t.Roman = "Roman", t))(zt || {});
-class hr {
-  type = "Unknown";
-  content = "";
+  /**
+   * Number of consecutive space characters.
+   */
+  count;
+  constructor(e = {}) {
+    this.count = e.count ?? 1;
+  }
 }
-var Jt = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Interlude = "Interlude", t))(Jt || {});
-class dr {
-  id = We(4).toUpperCase();
-  type = "Interlude";
-  time = new W();
+var Zt = /* @__PURE__ */ ((r) => (r.Ruby = "Ruby", r.Roman = "Roman", r.Translate = "Translate", r.Unknown = "Unknown", r))(Zt || {});
+const Tr = [
+  "Ruby",
+  "Roman",
+  "Unknown"
+  /* Unknown */
+];
+class Jt {
+  /**
+   * All annotation items in order.
+   *
+   * Derived items are a snapshot from `deriveLineAnnotation`; re-run it after words change.
+   */
+  list;
+  constructor(e = {}) {
+    this.list = e.list ?? [];
+  }
+  /**
+   * Whether any item of a kind exists.
+   */
+  has(e) {
+    return this.list.some((t) => t.kind === e);
+  }
+  /**
+   * All items of a kind.
+   */
+  all(e) {
+    return this.list.filter((t) => t.kind === e);
+  }
+  /**
+   * The first item of a kind, preferring a language match then falling back to the first.
+   */
+  first(e, t) {
+    const n = this.all(e);
+    if (t !== void 0) {
+      const i = n.find((c) => c.language === t);
+      if (i)
+        return i;
+    }
+    return n[0];
+  }
 }
-class Kt {
-  words = [];
-  extended = [];
-  get original() {
-    return this.words.map((s) => s.type === Ye.Normal ? s.content : " ".repeat(s.count)).join("");
+const H = (r, e) => ({
+  derived: !1,
+  ...e,
+  kind: r
+}), se = (r, e, t, n) => {
+  const i = [];
+  for (let o = 0, h = r.length; o < h; o++) {
+    const a = r[o];
+    if (a.type === k.Space)
+      continue;
+    const l = e(a);
+    if (l)
+      for (const s of l) {
+        const u = t(s);
+        i.includes(u) || i.push(u);
+      }
   }
-  toJSON() {
-    return {
-      words: this.words,
-      extended: this.extended,
-      original: this.original
-    };
+  const c = [];
+  for (const o of i) {
+    let h = "", a = 0, l, s = !1;
+    for (let u = 0, f = r.length; u < f; u++) {
+      const E = r[u];
+      if (E.type === k.Space) {
+        a += E.count;
+        continue;
+      }
+      const S = e(E)?.find((d) => t(d) === o);
+      S && (s && (h += " ".repeat(a)), h += S.content, l ??= S.language, a = 0, s = !0);
+    }
+    s && c.push(n(o, h, l));
+  }
+  return c;
+}, Nr = (r) => {
+  const { words: e, annotation: t } = r;
+  for (const n of Tr) {
+    const i = t.list.some((o) => o.kind === n && !o.derived);
+    if (t.list = t.list.filter((o) => !(o.kind === n && o.derived)), i)
+      continue;
+    let c;
+    switch (n) {
+      case "Ruby":
+        c = se(
+          e,
+          (o) => {
+            const h = o.annotation?.ruby;
+            return h ? [h] : void 0;
+          },
+          () => "",
+          (o, h, a) => H("Ruby", { content: h, language: a, derived: !0 })
+        );
+        break;
+      case "Roman":
+        c = se(
+          e,
+          (o) => o.annotation?.romans,
+          (o) => o.language ?? "",
+          (o, h) => H("Roman", { content: h, language: o || void 0, derived: !0 })
+        );
+        break;
+      default:
+        c = se(
+          e,
+          (o) => o.annotation?.unknowns,
+          (o) => o.key,
+          (o, h, a) => H("Unknown", { content: h, language: a, key: o, derived: !0 })
+        );
+    }
+    t.list.push(...c);
+  }
+};
+var Qt = /* @__PURE__ */ ((r) => (r.Normal = "Normal", r.Interlude = "Interlude", r))(Qt || {});
+class er {
+  /**
+   * Time range of the line.
+   */
+  time;
+  constructor(e = {}) {
+    this.time = e.time ?? new Kt();
   }
 }
-class Zt {
+class tr extends er {
+  /**
+   * 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;
+  /**
+   * Annotations applied to the whole line, derived from words unless set explicitly.
+   */
+  annotation;
+  constructor(e = {}) {
+    super(e), this.agent = e.agent, this.words = e.words ?? [], this.annotation = e.annotation ?? new Jt(), e.languages && (this.languages = e.languages);
+  }
+  /**
+   * Plain text of the line joined from every word.
+   *
+   * Live: recomputed from words on each access.
+   */
+  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;
+  }
+  #e;
+  /**
+   * Language tags of this line: the explicit value, otherwise live-collected from words on each access.
+   */
+  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 Sr extends tr {
+  /**
+   * Background lines attached to this line.
+   */
   background;
+  constructor(e = {}) {
+    super(e), this.background = e.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 Or extends er {
+  /**
+   * Discriminant marking this as an interlude line.
+   */
+  type = "Interlude";
 }
-class gr extends F {
-  type = "Album";
-  content = "";
+var rr = /* @__PURE__ */ ((r) => (r.Offset = "Offset", r.Duration = "Duration", r.Title = "Title", r.Singer = "Singer", r.Album = "Album", r.Creator = "Creator", r.Author = "Author", r.Isrc = "Isrc", r.Unknown = "Unknown", r))(rr || {});
+const Ar = (r, e, t) => ({
+  type: r,
+  key: e,
+  value: t
+});
+class sr {
+  /**
+   * All meta entries in order.
+   */
+  list;
+  constructor(e = {}) {
+    this.list = e.list ?? [];
+  }
+  /**
+   * Whether any entry of a meta type exists.
+   */
+  has(e) {
+    return this.list.some((t) => t.type === e);
+  }
+  /**
+   * All entries of a meta type.
+   */
+  all(e) {
+    return this.list.filter((t) => t.type === e);
+  }
+  /**
+   * The first entry of a meta type.
+   */
+  first(e) {
+    return this.list.find((t) => t.type === e);
+  }
+  /**
+   * All entries with the given original key.
+   */
+  byKey(e) {
+    return this.list.filter((t) => t.key === e);
+  }
 }
-class $r extends F {
-  type = "Creator";
-  content = {
-    role: "",
-    name: []
-  };
+var nr = /* @__PURE__ */ ((r) => (r.Person = "Person", r.Group = "Group", r.Other = "Other", r.Unknown = "Unknown", r))(nr || {});
+class wr {
+  /**
+   * Unique identifier of the agent.
+   */
+  id;
+  /**
+   * Performing type of the agent.
+   */
+  type;
+  /**
+   * Number of lines performed by this agent.
+   *
+   * Snapshot filled by `calcAgentIndex` at parse time; stale after lines change.
+   */
+  count;
+  /**
+   * Display names of the agent; a group may carry more than one.
+   */
+  names;
+  constructor(e = {}) {
+    this.id = e.id ?? "", this.type = e.type ?? "Unknown", this.count = e.count ?? 0, this.names = e.names ?? [];
+  }
 }
-class Lr extends F {
-  type = "Unknown";
-  content = "";
+class yr {
+  /**
+   * Identifier of the referenced agent.
+   */
+  id;
+  /**
+   * Index of this agent occurrence among all lines.
+   *
+   * Snapshot filled by `calcAgentIndex` at parse time.
+   */
+  globalIndex;
+  /**
+   * Index of this agent occurrence within its block.
+   *
+   * Snapshot filled by `calcAgentIndex` at parse time.
+   */
+  blockIndex;
+  constructor(e = {}) {
+    this.id = e.id ?? "", this.globalIndex = e.globalIndex ?? 0, this.blockIndex = e.blockIndex ?? 0;
+  }
 }
-class Tr {
-  id = "";
-  name = "";
-  count = 0;
+class ir {
+  /**
+   * All agents in order.
+   */
+  list;
+  constructor(e = {}) {
+    this.list = e.list ?? [];
+  }
+  /**
+   * Whether any agent of a type exists.
+   */
+  has(e) {
+    return this.list.some((t) => t.type === e);
+  }
+  /**
+   * All agents of a type.
+   */
+  all(e) {
+    return this.list.filter((t) => t.type === e);
+  }
+  /**
+   * The agent with the given id, used to resolve a LineAgent reference.
+   */
+  byId(e) {
+    return this.list.find((t) => t.id === e);
+  }
+  /**
+   * The agent performing the most lines.
+   */
+  get primary() {
+    let e;
+    for (let t = 0, n = this.list.length; t < n; t++)
+      (!e || this.list[t].count > e.count) && (e = this.list[t]);
+    return e;
+  }
 }
-class er {
-  // index in global
-  global = 0;
-  // index in block
-  block = 0;
-}
-class Nr {
-  id = "";
-  index = new er();
-}
-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;
-  type = "Invalid";
-  metas = [];
-  lines = [];
-  agents = [];
+const ar = "0.9.0";
+var or = /* @__PURE__ */ ((r) => (r.Invalid = "Invalid", r.Empty = "Empty", r.Normal = "Normal", r))(or || {}), lr = /* @__PURE__ */ ((r) => (r.None = "None", r.Line = "Line", r.Syllable = "Syllable", r))(lr || {});
+class Cr {
+  /**
+   * Schema version of this data model.
+   */
+  version = ar;
+  /**
+   * Overall classification of the lyric.
+   */
+  type;
+  /**
+   * Timing precision of the lyric.
+   */
+  timing;
+  /**
+   * Metadata of the lyric.
+   */
+  meta;
+  /**
+   * Language distribution of the lyric.
+   */
+  language;
+  /**
+   * Performing agents referenced by lines.
+   */
+  agent;
+  /**
+   * Lyric lines in order.
+   */
+  lines;
+  constructor(e = {}) {
+    this.type = e.type ?? "Invalid", this.timing = e.timing ?? "None", this.meta = e.meta ?? new sr(), this.language = e.language ?? new Yt(), this.agent = e.agent ?? new ir(), this.lines = e.lines ?? [];
+  }
 }
 const X = /* @__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: ir,
+  AgentItem: wr,
+  AgentType: nr,
+  Info: Cr,
+  InfoTiming: lr,
+  InfoType: or,
+  Language: Yt,
+  LanguageItem: Er,
+  LanguageType: zt,
+  LineAgent: yr,
+  LineAnnotation: Jt,
+  LineAnnotationKind: Zt,
+  LineInterlude: Or,
+  LineNormal: Sr,
+  LineNormalBase: tr,
+  LineType: Qt,
+  Meta: sr,
+  MetaType: rr,
+  Time: Kt,
+  Version: ar,
+  WordAnnotation: Ir,
+  WordAnnotationContent: gr,
+  WordAnnotationItem: ze,
+  WordNormal: $r,
+  WordRubyAnnotation: Rr,
+  WordSpace: Lr,
+  WordType: k,
+  WordUnknownAnnotation: vr,
+  createLineAnnotationItem: H,
+  createMetaItem: Ar,
+  deriveLineAnnotation: Nr
 }, Symbol.toStringTag, { value: "Module" }));
-var H = { exports: {} }, se, tt;
-function Y() {
-  if (tt) return se;
+class Pr {
+  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 o = Math.max(0, t), h = n > 0 ? n : 1 / 0;
+    let a = this.getRawTime(i - 1);
+    c[i - 1] = a;
+    let l = 1;
+    for (let s = i - 2; s >= 0; s--) {
+      const u = this.getRawTime(s);
+      o > 0 && l < h && Math.abs(a - u) < o ? (c[s] = Math.max(u, c[s + 1]), l++) : (c[s] = u, l = 1), a = 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 qr {
+  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.first(X.MetaType.Offset)?.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 br {
+  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 W = { exports: {} }, ne, tt;
+function z() {
+  if (tt) return ne;
   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 r = "2.0.0", e = 256, t = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, n = 16, i = e - 6;
+  return ne = {
+    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 +678,96 @@ function Y() {
       "prepatch",
       "prerelease"
     ],
-    SEMVER_SPEC_VERSION: t,
+    SEMVER_SPEC_VERSION: r,
     FLAG_INCLUDE_PRERELEASE: 1,
     FLAG_LOOSE: 2
-  }, se;
+  }, ne;
 }
-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 ie, rt;
+function Y() {
+  return rt || (rt = 1, ie = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...e) => console.error("SEMVER", ...e) : () => {
+  }), ie;
 }
 var st;
 function B() {
-  return st || (st = 1, (function(t, s) {
+  return st || (st = 1, (function(r, 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 = {};
+    } = z(), c = Y();
+    e = r.exports = {};
+    const o = e.re = [], h = e.safeRe = [], a = e.src = [], l = e.safeSrc = [], s = 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}}`);
+      for (const [A, b] of E)
+        N = N.split(`${A}*`).join(`${A}{0,${b}}`).split(`${A}+`).join(`${A}{1,${b}}`);
       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);
+    }, d = (N, A, b) => {
+      const w = S(A), G = u++;
+      c(N, G, A), s[N] = G, a[G] = A, l[G] = w, o[G] = new RegExp(A, b ? "g" : void 0), h[G] = new RegExp(w, b ? "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*$");
-  })(H, H.exports)), H.exports;
+    d("NUMERICIDENTIFIER", "0|[1-9]\\d*"), d("NUMERICIDENTIFIERLOOSE", "\\d+"), d("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`), d("MAINVERSION", `(${a[s.NUMERICIDENTIFIER]})\\.(${a[s.NUMERICIDENTIFIER]})\\.(${a[s.NUMERICIDENTIFIER]})`), d("MAINVERSIONLOOSE", `(${a[s.NUMERICIDENTIFIERLOOSE]})\\.(${a[s.NUMERICIDENTIFIERLOOSE]})\\.(${a[s.NUMERICIDENTIFIERLOOSE]})`), d("PRERELEASEIDENTIFIER", `(?:${a[s.NONNUMERICIDENTIFIER]}|${a[s.NUMERICIDENTIFIER]})`), d("PRERELEASEIDENTIFIERLOOSE", `(?:${a[s.NONNUMERICIDENTIFIER]}|${a[s.NUMERICIDENTIFIERLOOSE]})`), d("PRERELEASE", `(?:-(${a[s.PRERELEASEIDENTIFIER]}(?:\\.${a[s.PRERELEASEIDENTIFIER]})*))`), d("PRERELEASELOOSE", `(?:-?(${a[s.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${a[s.PRERELEASEIDENTIFIERLOOSE]})*))`), d("BUILDIDENTIFIER", `${f}+`), d("BUILD", `(?:\\+(${a[s.BUILDIDENTIFIER]}(?:\\.${a[s.BUILDIDENTIFIER]})*))`), d("FULLPLAIN", `v?${a[s.MAINVERSION]}${a[s.PRERELEASE]}?${a[s.BUILD]}?`), d("FULL", `^${a[s.FULLPLAIN]}$`), d("LOOSEPLAIN", `[v=\\s]*${a[s.MAINVERSIONLOOSE]}${a[s.PRERELEASELOOSE]}?${a[s.BUILD]}?`), d("LOOSE", `^${a[s.LOOSEPLAIN]}$`), d("GTLT", "((?:<|>)?=?)"), d("XRANGEIDENTIFIERLOOSE", `${a[s.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), d("XRANGEIDENTIFIER", `${a[s.NUMERICIDENTIFIER]}|x|X|\\*`), d("XRANGEPLAIN", `[v=\\s]*(${a[s.XRANGEIDENTIFIER]})(?:\\.(${a[s.XRANGEIDENTIFIER]})(?:\\.(${a[s.XRANGEIDENTIFIER]})(?:${a[s.PRERELEASE]})?${a[s.BUILD]}?)?)?`), d("XRANGEPLAINLOOSE", `[v=\\s]*(${a[s.XRANGEIDENTIFIERLOOSE]})(?:\\.(${a[s.XRANGEIDENTIFIERLOOSE]})(?:\\.(${a[s.XRANGEIDENTIFIERLOOSE]})(?:${a[s.PRERELEASELOOSE]})?${a[s.BUILD]}?)?)?`), d("XRANGE", `^${a[s.GTLT]}\\s*${a[s.XRANGEPLAIN]}$`), d("XRANGELOOSE", `^${a[s.GTLT]}\\s*${a[s.XRANGEPLAINLOOSE]}$`), d("COERCEPLAIN", `(^|[^\\d])(\\d{1,${t}})(?:\\.(\\d{1,${t}}))?(?:\\.(\\d{1,${t}}))?`), d("COERCE", `${a[s.COERCEPLAIN]}(?:$|[^\\d])`), d("COERCEFULL", a[s.COERCEPLAIN] + `(?:${a[s.PRERELEASE]})?(?:${a[s.BUILD]})?(?:$|[^\\d])`), d("COERCERTL", a[s.COERCE], !0), d("COERCERTLFULL", a[s.COERCEFULL], !0), d("LONETILDE", "(?:~>?)"), d("TILDETRIM", `(\\s*)${a[s.LONETILDE]}\\s+`, !0), e.tildeTrimReplace = "$1~", d("TILDE", `^${a[s.LONETILDE]}${a[s.XRANGEPLAIN]}$`), d("TILDELOOSE", `^${a[s.LONETILDE]}${a[s.XRANGEPLAINLOOSE]}$`), d("LONECARET", "(?:\\^)"), d("CARETTRIM", `(\\s*)${a[s.LONECARET]}\\s+`, !0), e.caretTrimReplace = "$1^", d("CARET", `^${a[s.LONECARET]}${a[s.XRANGEPLAIN]}$`), d("CARETLOOSE", `^${a[s.LONECARET]}${a[s.XRANGEPLAINLOOSE]}$`), d("COMPARATORLOOSE", `^${a[s.GTLT]}\\s*(${a[s.LOOSEPLAIN]})$|^$`), d("COMPARATOR", `^${a[s.GTLT]}\\s*(${a[s.FULLPLAIN]})$|^$`), d("COMPARATORTRIM", `(\\s*)${a[s.GTLT]}\\s*(${a[s.LOOSEPLAIN]}|${a[s.XRANGEPLAIN]})`, !0), e.comparatorTrimReplace = "$1$2$3", d("HYPHENRANGE", `^\\s*(${a[s.XRANGEPLAIN]})\\s+-\\s+(${a[s.XRANGEPLAIN]})\\s*$`), d("HYPHENRANGELOOSE", `^\\s*(${a[s.XRANGEPLAINLOOSE]})\\s+-\\s+(${a[s.XRANGEPLAINLOOSE]})\\s*$`), d("STAR", "(<|>)?=?\\s*\\*"), d("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), d("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(W, W.exports)), W.exports;
 }
-var ie, nt;
-function ze() {
-  if (nt) return ie;
+var ae, nt;
+function Ye() {
+  if (nt) return ae;
   nt = 1;
-  const t = Object.freeze({ loose: !0 }), s = Object.freeze({});
-  return ie = (n) => n ? typeof n != "object" ? t : n : s, ie;
+  const r = Object.freeze({ loose: !0 }), e = Object.freeze({});
+  return ae = (n) => n ? typeof n != "object" ? r : n : e, ae;
 }
-var ae, it;
-function sr() {
-  if (it) return ae;
+var oe, it;
+function cr() {
+  if (it) return oe;
   it = 1;
-  const t = /^[0-9]+$/, s = (n, i) => {
+  const r = /^[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);
-    return c && l && (n = +n, i = +i), n === i ? 0 : c && !l ? -1 : l && !c ? 1 : n < i ? -1 : 1;
+    const c = r.test(n), o = r.test(i);
+    return c && o && (n = +n, i = +i), n === i ? 0 : c && !o ? -1 : o && !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 oe = {
+    compareIdentifiers: e,
+    rcompareIdentifiers: (n, i) => e(i, n)
+  }, oe;
+}
+var le, at;
+function D() {
+  if (at) return le;
   at = 1;
-  const t = z(), { MAX_LENGTH: s, MAX_SAFE_INTEGER: r } = Y(), { safeRe: n, t: i } = B(), c = ze(), { compareIdentifiers: l } = sr();
+  const r = Y(), { MAX_LENGTH: e, MAX_SAFE_INTEGER: t } = z(), { safeRe: n, t: i } = B(), c = Ye(), { compareIdentifiers: o } = cr();
   class h {
-    constructor(a, e) {
-      if (e = c(e), a instanceof h) {
-        if (a.loose === !!e.loose && a.includePrerelease === !!e.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)
+    constructor(l, s) {
+      if (s = c(s), l instanceof h) {
+        if (l.loose === !!s.loose && l.includePrerelease === !!s.includePrerelease)
+          return l;
+        l = l.version;
+      } else if (typeof l != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof l}".`);
+      if (l.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]);
+      r("SemVer", l, s), this.options = s, this.loose = !!s.loose, this.includePrerelease = !!s.includePrerelease;
+      const u = l.trim().match(s.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)
+        throw new TypeError(`Invalid Version: ${l}`);
+      if (this.raw = l, 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();
@@ -295,28 +778,28 @@ function b() {
     toString() {
       return this.version;
     }
-    compare(a) {
-      if (t("SemVer.compare", this.version, this.options, a), !(a instanceof h)) {
-        if (typeof a == "string" && a === this.version)
+    compare(l) {
+      if (r("SemVer.compare", this.version, this.options, l), !(l instanceof h)) {
+        if (typeof l == "string" && l === this.version)
           return 0;
-        a = new h(a, this.options);
+        l = new h(l, this.options);
       }
-      return a.version === this.version ? 0 : this.compareMain(a) || this.comparePre(a);
+      return l.version === this.version ? 0 : this.compareMain(l) || this.comparePre(l);
     }
-    compareMain(a) {
-      return a instanceof h || (a = new h(a, this.options)), this.major < a.major ? -1 : this.major > a.major ? 1 : this.minor < a.minor ? -1 : this.minor > a.minor ? 1 : this.patch < a.patch ? -1 : this.patch > a.patch ? 1 : 0;
+    compareMain(l) {
+      return l instanceof h || (l = new h(l, this.options)), this.major < l.major ? -1 : this.major > l.major ? 1 : this.minor < l.minor ? -1 : this.minor > l.minor ? 1 : this.patch < l.patch ? -1 : this.patch > l.patch ? 1 : 0;
     }
-    comparePre(a) {
-      if (a instanceof h || (a = new h(a, this.options)), this.prerelease.length && !a.prerelease.length)
+    comparePre(l) {
+      if (l instanceof h || (l = new h(l, this.options)), this.prerelease.length && !l.prerelease.length)
         return -1;
-      if (!this.prerelease.length && a.prerelease.length)
+      if (!this.prerelease.length && l.prerelease.length)
         return 1;
-      if (!this.prerelease.length && !a.prerelease.length)
+      if (!this.prerelease.length && !l.prerelease.length)
         return 0;
-      let e = 0;
+      let s = 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[s], f = l.prerelease[s];
+        if (r("prerelease compare", s, u, f), u === void 0 && f === void 0)
           return 0;
         if (f === void 0)
           return 1;
@@ -324,15 +807,15 @@ function b() {
           return -1;
         if (u === f)
           continue;
-        return l(u, f);
-      } while (++e);
+        return o(u, f);
+      } while (++s);
     }
-    compareBuild(a) {
-      a instanceof h || (a = new h(a, this.options));
-      let e = 0;
+    compareBuild(l) {
+      l instanceof h || (l = new h(l, this.options));
+      let s = 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[s], f = l.build[s];
+        if (r("build compare", s, u, f), u === void 0 && f === void 0)
           return 0;
         if (f === void 0)
           return 1;
@@ -340,35 +823,35 @@ function b() {
           return -1;
         if (u === f)
           continue;
-        return l(u, f);
-      } while (++e);
+        return o(u, f);
+      } while (++s);
     }
     // 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) {
-      if (a.startsWith("pre")) {
-        if (!e && u === !1)
+    inc(l, s, u) {
+      if (l.startsWith("pre")) {
+        if (!s && 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 (s) {
+          const f = `-${s}`.match(this.options.loose ? n[i.PRERELEASELOOSE] : n[i.PRERELEASE]);
+          if (!f || f[1] !== s)
+            throw new Error(`invalid identifier: ${s}`);
         }
       }
-      switch (a) {
+      switch (l) {
         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", s, 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", s, 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", s, u), this.inc("pre", s, 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", s, u), this.inc("pre", s, u);
           break;
         case "release":
           if (this.prerelease.length === 0)
@@ -391,328 +874,328 @@ 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 (s === 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 (s) {
+            let E = [s, f];
+            u === !1 && (E = [s]), o(this.prerelease[0], s) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = E) : this.prerelease = E;
           }
           break;
         }
         default:
-          throw new Error(`invalid increment argument: ${a}`);
+          throw new Error(`invalid increment argument: ${l}`);
       }
       return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
     }
   }
-  return oe = h, oe;
+  return le = h, le;
 }
-var le, ot;
-function M() {
-  if (ot) return le;
+var ce, ot;
+function j() {
+  if (ot) return ce;
   ot = 1;
-  const t = b();
-  return le = (r, n, i = !1) => {
-    if (r instanceof t)
-      return r;
+  const r = D();
+  return ce = (t, n, i = !1) => {
+    if (t instanceof r)
+      return t;
     try {
-      return new t(r, n);
+      return new r(t, n);
     } catch (c) {
       if (!i)
         return null;
       throw c;
     }
-  }, le;
+  }, ce;
 }
-var ce, lt;
-function Or() {
-  if (lt) return ce;
+var ue, lt;
+function Gr() {
+  if (lt) return ue;
   lt = 1;
-  const t = M();
-  return ce = (r, n) => {
-    const i = t(r, n);
+  const r = j();
+  return ue = (t, n) => {
+    const i = r(t, n);
     return i ? i.version : null;
-  }, ce;
+  }, ue;
 }
-var ue, ct;
-function Ar() {
-  if (ct) return ue;
+var he, ct;
+function xr() {
+  if (ct) return he;
   ct = 1;
-  const t = M();
-  return ue = (r, n) => {
-    const i = t(r.trim().replace(/^[=v]+/, ""), n);
+  const r = j();
+  return he = (t, n) => {
+    const i = r(t.trim().replace(/^[=v]+/, ""), n);
     return i ? i.version : null;
-  }, ue;
+  }, he;
 }
 var fe, ut;
-function wr() {
+function Dr() {
   if (ut) return fe;
   ut = 1;
-  const t = b();
-  return fe = (r, n, i, c, l) => {
-    typeof i == "string" && (l = c, c = i, i = void 0);
+  const r = D();
+  return fe = (t, n, i, c, o) => {
+    typeof i == "string" && (o = c, c = i, i = void 0);
     try {
-      return new t(
-        r instanceof t ? r.version : r,
+      return new r(
+        t instanceof r ? t.version : t,
         i
-      ).inc(n, c, l).version;
+      ).inc(n, c, o).version;
     } catch {
       return null;
     }
   }, fe;
 }
-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);
-    if (l === 0)
+var me, ht;
+function _r() {
+  if (ht) return me;
+  ht = 1;
+  const r = j();
+  return me = (t, n) => {
+    const i = r(t, null, !0), c = r(n, null, !0), o = i.compare(c);
+    if (o === 0)
       return null;
-    const h = l > 0, o = h ? i : c, a = h ? c : i, e = !!o.prerelease.length;
-    if (!!a.prerelease.length && !e) {
-      if (!a.patch && !a.minor)
+    const h = o > 0, a = h ? i : c, l = h ? c : i, s = !!a.prerelease.length;
+    if (!!l.prerelease.length && !s) {
+      if (!l.patch && !l.minor)
         return "major";
-      if (a.compareMain(o) === 0)
-        return a.minor && !a.patch ? "minor" : "patch";
+      if (l.compareMain(a) === 0)
+        return l.minor && !l.patch ? "minor" : "patch";
     }
-    const f = e ? "pre" : "";
+    const f = s ? "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;
+  }, me;
 }
-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 Ur() {
+  if (ft) return de;
+  ft = 1;
+  const r = D();
+  return de = (t, n) => new r(t, n).major, de;
 }
-var Ee, mt;
-function Pr() {
-  if (mt) return Ee;
+var pe, mt;
+function Fr() {
+  if (mt) return pe;
   mt = 1;
-  const t = b();
-  return Ee = (r, n) => new t(r, n).patch, Ee;
+  const r = D();
+  return pe = (t, n) => new r(t, n).minor, pe;
 }
-var pe, Et;
-function Gr() {
-  if (Et) return pe;
-  Et = 1;
-  const t = M();
-  return pe = (r, n) => {
-    const i = t(r, n);
+var Ee, dt;
+function kr() {
+  if (dt) return Ee;
+  dt = 1;
+  const r = D();
+  return Ee = (t, n) => new r(t, n).patch, Ee;
+}
+var ge, pt;
+function jr() {
+  if (pt) return ge;
+  pt = 1;
+  const r = j();
+  return ge = (t, n) => {
+    const i = r(t, n);
     return i && i.prerelease.length ? i.prerelease : null;
-  }, pe;
+  }, ge;
 }
-var Re, pt;
+var Re, Et;
 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;
+  if (Et) return Re;
+  Et = 1;
+  const r = D();
+  return Re = (t, n, i) => new r(t, i).compare(new r(n, i)), Re;
 }
-var ve, Rt;
-function xr() {
-  if (Rt) return ve;
+var ve, gt;
+function Mr() {
+  if (gt) return ve;
+  gt = 1;
+  const r = U();
+  return ve = (t, n, i) => r(n, t, i), ve;
+}
+var Ie, Rt;
+function Vr() {
+  if (Rt) return Ie;
   Rt = 1;
-  const t = U();
-  return ve = (r, n, i) => t(n, r, i), ve;
+  const r = U();
+  return Ie = (t, n) => r(t, n, !0), Ie;
 }
-var Ie, vt;
-function Dr() {
-  if (vt) return Ie;
+var $e, vt;
+function Ke() {
+  if (vt) return $e;
   vt = 1;
-  const t = U();
-  return Ie = (r, n) => t(r, n, !0), Ie;
+  const r = D();
+  return $e = (t, n, i) => {
+    const c = new r(t, i), o = new r(n, i);
+    return c.compare(o) || c.compareBuild(o);
+  }, $e;
 }
-var ge, It;
-function Je() {
-  if (It) return ge;
+var Le, It;
+function Xr() {
+  if (It) return Le;
   It = 1;
-  const t = b();
-  return ge = (r, n, i) => {
-    const c = new t(r, i), l = new t(n, i);
-    return c.compare(l) || c.compareBuild(l);
-  }, ge;
-}
-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;
+  const r = Ke();
+  return Le = (t, n) => t.sort((i, c) => r(i, c, n)), Le;
 }
-var Le, $t;
-function _r() {
-  if ($t) return Le;
+var Te, $t;
+function Br() {
+  if ($t) return Te;
   $t = 1;
-  const t = Je();
-  return Le = (r, n) => r.sort((i, c) => t(c, i, n)), Le;
+  const r = Ke();
+  return Te = (t, n) => t.sort((i, c) => r(c, i, n)), Te;
 }
-var Te, Lt;
-function J() {
-  if (Lt) return Te;
+var Ne, Lt;
+function K() {
+  if (Lt) return Ne;
   Lt = 1;
-  const t = U();
-  return Te = (r, n, i) => t(r, n, i) > 0, Te;
+  const r = U();
+  return Ne = (t, n, i) => r(t, n, i) > 0, Ne;
 }
-var Ne, Tt;
-function Ke() {
-  if (Tt) return Ne;
+var Se, Tt;
+function Ze() {
+  if (Tt) return Se;
   Tt = 1;
-  const t = U();
-  return Ne = (r, n, i) => t(r, n, i) < 0, Ne;
+  const r = U();
+  return Se = (t, n, i) => r(t, n, i) < 0, Se;
 }
-var Se, Nt;
-function nr() {
-  if (Nt) return Se;
+var Oe, Nt;
+function ur() {
+  if (Nt) return Oe;
   Nt = 1;
-  const t = U();
-  return Se = (r, n, i) => t(r, n, i) === 0, Se;
+  const r = U();
+  return Oe = (t, n, i) => r(t, n, i) === 0, Oe;
 }
-var Oe, St;
-function ir() {
-  if (St) return Oe;
+var Ae, St;
+function hr() {
+  if (St) return Ae;
   St = 1;
-  const t = U();
-  return Oe = (r, n, i) => t(r, n, i) !== 0, Oe;
+  const r = U();
+  return Ae = (t, n, i) => r(t, n, i) !== 0, Ae;
 }
-var Ae, Ot;
-function Ze() {
-  if (Ot) return Ae;
+var we, Ot;
+function Je() {
+  if (Ot) return we;
   Ot = 1;
-  const t = U();
-  return Ae = (r, n, i) => t(r, n, i) >= 0, Ae;
+  const r = U();
+  return we = (t, n, i) => r(t, n, i) >= 0, we;
 }
-var we, At;
+var ye, At;
 function Qe() {
-  if (At) return we;
+  if (At) return ye;
   At = 1;
-  const t = U();
-  return we = (r, n, i) => t(r, n, i) <= 0, we;
+  const r = U();
+  return ye = (t, n, i) => r(t, n, i) <= 0, ye;
 }
-var ye, wt;
-function ar() {
-  if (wt) return ye;
+var Ce, wt;
+function fr() {
+  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) => {
-    switch (o) {
+  const r = ur(), e = hr(), t = K(), n = Je(), i = Ze(), c = Qe();
+  return Ce = (h, a, l, s) => {
+    switch (a) {
       case "===":
-        return typeof h == "object" && (h = h.version), typeof a == "object" && (a = a.version), h === a;
+        return typeof h == "object" && (h = h.version), typeof l == "object" && (l = l.version), h === l;
       case "!==":
-        return typeof h == "object" && (h = h.version), typeof a == "object" && (a = a.version), h !== a;
+        return typeof h == "object" && (h = h.version), typeof l == "object" && (l = l.version), h !== l;
       case "":
       case "=":
       case "==":
-        return t(h, a, e);
+        return r(h, l, s);
       case "!=":
-        return s(h, a, e);
+        return e(h, l, s);
       case ">":
-        return r(h, a, e);
+        return t(h, l, s);
       case ">=":
-        return n(h, a, e);
+        return n(h, l, s);
       case "<":
-        return i(h, a, e);
+        return i(h, l, s);
       case "<=":
-        return c(h, a, e);
+        return c(h, l, s);
       default:
-        throw new TypeError(`Invalid operator: ${o}`);
+        throw new TypeError(`Invalid operator: ${a}`);
     }
-  }, ye;
+  }, Ce;
 }
-var Ce, yt;
-function Ur() {
-  if (yt) return Ce;
+var Pe, yt;
+function Wr() {
+  if (yt) return Pe;
   yt = 1;
-  const t = b(), s = M(), { safeRe: r, t: n } = B();
-  return Ce = (c, l) => {
-    if (c instanceof t)
+  const r = D(), e = j(), { safeRe: t, t: n } = B();
+  return Pe = (c, o) => {
+    if (c instanceof r)
       return c;
     if (typeof c == "number" && (c = String(c)), typeof c != "string")
       return null;
-    l = l || {};
+    o = o || {};
     let h = null;
-    if (!l.rtl)
-      h = c.match(l.includePrerelease ? r[n.COERCEFULL] : r[n.COERCE]);
+    if (!o.rtl)
+      h = c.match(o.includePrerelease ? t[n.COERCEFULL] : t[n.COERCE]);
     else {
-      const p = l.includePrerelease ? r[n.COERCERTLFULL] : r[n.COERCERTL];
+      const E = o.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 a = h[2], l = h[3] || "0", s = h[4] || "0", u = o.includePrerelease && h[5] ? `-${h[5]}` : "", f = o.includePrerelease && h[6] ? `+${h[6]}` : "";
+    return e(`${a}.${l}.${s}${u}${f}`, o);
+  }, Pe;
 }
 var qe, Ct;
-function jr() {
+function Hr() {
   if (Ct) return qe;
   Ct = 1;
-  class t {
+  class r {
     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 qe = r, qe;
 }
-var Pe, qt;
-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)
+var be, Pt;
+function F() {
+  if (Pt) return be;
+  Pt = 1;
+  const r = /\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(r, " "), 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) => !d(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 && N(I[0])) {
+              this.set = [I];
               break;
             }
         }
@@ -722,11 +1205,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,335 +1220,335 @@ 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 ? a[l.HYPHENRANGELOOSE] : a[l.HYPHENRANGE];
+      m = m.replace($, te(this.options.includePrerelease)), o("hyphen replace", m), m = m.replace(a[l.COMPARATORTRIM], s), o("comparator trim", m), m = m.replace(a[l.TILDETRIM], u), o("tilde trim", m), m = m.replace(a[l.CARETTRIM], f), o("caret trim", m);
+      let O = m.split(" ").map((P) => b(P, this.options)).join(" ").split(/\s+/).map((P) => ee(P, this.options));
+      R && (O = O.filter((P) => (o("loose invalid filter", P, this.options), !!P.match(a[l.COMPARATORLOOSE])))), o("range list", O);
+      const T = /* @__PURE__ */ new Map(), y = O.map((P) => new c(P, this.options));
+      for (const P of y) {
+        if (d(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;
+      const x = [...T.values()];
+      return n.set(g, x), x;
     }
-    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) => A(g, v) && m.set.some((I) => A(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 (re(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(), {
-    safeRe: o,
-    t: a,
-    comparatorTrimReplace: e,
+  be = e;
+  const t = Hr(), n = new t(), i = Ye(), c = Z(), o = Y(), h = D(), {
+    safeRe: a,
+    t: l,
+    comparatorTrimReplace: s,
     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);
+  } = B(), { FLAG_INCLUDE_PRERELEASE: E, FLAG_LOOSE: S } = z(), d = (p) => p.value === "<0.0.0-0", N = (p) => p.value === "", A = (p, m) => {
+    let v = !0;
+    const g = p.slice();
+    let I = g.pop();
+    for (; v && g.length; )
+      v = g.every((R) => I.intersects(R, m)), I = g.pop();
+    return v;
+  }, b = (p, m) => (p = p.replace(a[l.BUILD], ""), o("comp", p, m), p = C(p, m), o("caret", p), p = G(p, m), o("tildes", p), p = L(p, m), o("xrange", p), p = Q(p, m), o("stars", p), p), w = (p) => !p || p.toLowerCase() === "x" || p === "*", G = (p, m) => p.trim().split(/\s+/).map((v) => _(v, m)).join(" "), _ = (p, m) => {
+    const v = m.loose ? a[l.TILDELOOSE] : a[l.TILDE];
+    return p.replace(v, (g, I, R, $, O) => {
+      o("tilde", p, g, I, R, $, O);
       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 w(I) ? T = "" : w(R) ? T = `>=${I}.0.0 <${+I + 1}.0.0-0` : w($) ? T = `>=${I}.${R}.0 <${I}.${+R + 1}.0-0` : O ? (o("replaceTilde pr", O), T = `>=${I}.${R}.${$}-${O} <${I}.${+R + 1}.0-0`) : T = `>=${I}.${R}.${$} <${I}.${+R + 1}.0-0`, o("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 = (p, m) => p.trim().split(/\s+/).map((v) => q(v, m)).join(" "), q = (p, m) => {
+    o("caret", p, m);
+    const v = m.loose ? a[l.CARETLOOSE] : a[l.CARET], g = m.includePrerelease ? "-0" : "";
+    return p.replace(v, (I, R, $, O, T) => {
+      o("caret", p, I, R, $, O, 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 w(R) ? y = "" : w($) ? y = `>=${R}.0.0${g} <${+R + 1}.0.0-0` : w(O) ? R === "0" ? y = `>=${R}.${$}.0${g} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.0${g} <${+R + 1}.0.0-0` : T ? (o("replaceCaret pr", T), R === "0" ? $ === "0" ? y = `>=${R}.${$}.${O}-${T} <${R}.${$}.${+O + 1}-0` : y = `>=${R}.${$}.${O}-${T} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.${O}-${T} <${+R + 1}.0.0-0`) : (o("no pr"), R === "0" ? $ === "0" ? y = `>=${R}.${$}.${O}${g} <${R}.${$}.${+O + 1}-0` : y = `>=${R}.${$}.${O}${g} <${R}.${+$ + 1}.0-0` : y = `>=${R}.${$}.${O} <${+R + 1}.0.0-0`), o("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 = (p, m) => (o("replaceXRanges", p, m), p.split(/\s+/).map((v) => M(v, m)).join(" ")), M = (p, m) => {
+    p = p.trim();
+    const v = m.loose ? a[l.XRANGELOOSE] : a[l.XRANGE];
+    return p.replace(v, (g, I, R, $, O, T) => {
+      o("xRange", p, g, I, R, $, O, T);
+      const y = w(R), x = y || w($), P = x || w(O), V = P;
+      return I === "=" && V && (I = ""), T = m.includePrerelease ? "-0" : "", y ? I === ">" || I === "<" ? g = "<0.0.0-0" : g = "*" : I && V ? (x && ($ = 0), O = 0, I === ">" ? (I = ">=", x ? (R = +R + 1, $ = 0, O = 0) : ($ = +$ + 1, O = 0)) : I === "<=" && (I = "<", x ? R = +R + 1 : $ = +$ + 1), I === "<" && (T = "-0"), g = `${I + R}.${$}.${O}${T}`) : x ? g = `>=${R}.0.0${T} <${+R + 1}.0.0-0` : P && (g = `>=${R}.${$}.0${T} <${R}.${+$ + 1}.0-0`), o("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))
+  }, Q = (p, m) => (o("replaceStars", p, m), p.trim().replace(a[l.STAR], "")), ee = (p, m) => (o("replaceGTE0", p, m), p.trim().replace(a[m.includePrerelease ? l.GTE0PRE : l.GTE0], "")), te = (p) => (m, v, g, I, R, $, O, T, y, x, P, V) => (w(g) ? v = "" : w(I) ? v = `>=${g}.0.0${p ? "-0" : ""}` : w(R) ? v = `>=${g}.${I}.0${p ? "-0" : ""}` : $ ? v = `>=${v}` : v = `>=${v}${p ? "-0" : ""}`, w(y) ? T = "" : w(x) ? T = `<${+y + 1}.0.0-0` : w(P) ? T = `<${y}.${+x + 1}.0-0` : V ? T = `<=${y}.${x}.${P}-${V}` : p ? T = `<${y}.${x}.${+P + 1}-0` : T = `<=${T}`, `${v} ${T}`.trim()), re = (p, m, v) => {
+    for (let g = 0; g < p.length; g++)
+      if (!p[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 < p.length; g++)
+        if (o(p[g].semver), p[g].semver !== c.ANY && p[g].semver.prerelease.length > 0) {
+          const I = p[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 Ge, qt;
+function Z() {
+  if (qt) return Ge;
+  qt = 1;
+  const r = /* @__PURE__ */ Symbol("SemVer ANY");
+  class e {
     static get ANY() {
-      return t;
+      return r;
     }
-    constructor(e, u) {
-      if (u = r(u), e instanceof s) {
-        if (e.loose === !!u.loose)
-          return e;
-        e = e.value;
+    constructor(s, u) {
+      if (u = t(u), s instanceof e) {
+        if (s.loose === !!u.loose)
+          return s;
+        s = s.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);
+      s = s.trim().split(/\s+/).join(" "), o("comparator", s, u), this.options = u, this.loose = !!u.loose, this.parse(s), this.semver === r ? this.value = "" : this.value = this.operator + this.semver.version, o("comp", this);
     }
-    parse(e) {
-      const u = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], f = e.match(u);
+    parse(s) {
+      const u = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], f = s.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: ${s}`);
+      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 = r;
     }
     toString() {
       return this.value;
     }
-    test(e) {
-      if (l("Comparator.test", e, this.options.loose), this.semver === t || e === t)
+    test(s) {
+      if (o("Comparator.test", s, this.options.loose), this.semver === r || s === r)
         return !0;
-      if (typeof e == "string")
+      if (typeof s == "string")
         try {
-          e = new h(e, this.options);
+          s = new h(s, this.options);
         } catch {
           return !1;
         }
-      return c(e, this.operator, this.semver, this.options);
+      return c(s, this.operator, this.semver, this.options);
     }
-    intersects(e, u) {
-      if (!(e instanceof s))
+    intersects(s, u) {
+      if (!(s 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 a(s.value, u).test(this.value) : s.operator === "" ? s.value === "" ? !0 : new a(this.value, u).test(s.semver) : (u = t(u), u.includePrerelease && (this.value === "<0.0.0-0" || s.value === "<0.0.0-0") || !u.includePrerelease && (this.value.startsWith("<0.0.0") || s.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && s.operator.startsWith(">") || this.operator.startsWith("<") && s.operator.startsWith("<") || this.semver.version === s.semver.version && this.operator.includes("=") && s.operator.includes("=") || c(this.semver, "<", s.semver, u) && this.operator.startsWith(">") && s.operator.startsWith("<") || c(this.semver, ">", s.semver, u) && this.operator.startsWith("<") && s.operator.startsWith(">")));
     }
   }
-  Ge = s;
-  const r = ze(), { safeRe: n, t: i } = B(), c = ar(), l = z(), h = b(), o = j();
+  Ge = e;
+  const t = Ye(), { safeRe: n, t: i } = B(), c = fr(), o = Y(), h = D(), a = F();
   return Ge;
 }
-var xe, Gt;
-function Z() {
-  if (Gt) return xe;
-  Gt = 1;
-  const t = j();
-  return xe = (r, n, i) => {
+var xe, bt;
+function J() {
+  if (bt) return xe;
+  bt = 1;
+  const r = F();
+  return xe = (t, n, i) => {
     try {
-      n = new t(n, i);
+      n = new r(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 De, Gt;
+function zr() {
+  if (Gt) return De;
+  Gt = 1;
+  const r = F();
+  return De = (t, n) => new r(t, n).set.map((i) => i.map((c) => c.value).join(" ").trim().split(" ")), De;
 }
-var be, Dt;
-function Mr() {
-  if (Dt) return be;
-  Dt = 1;
-  const t = b(), s = j();
-  return be = (n, i, c) => {
-    let l = null, h = null, o = null;
+var _e, xt;
+function Yr() {
+  if (xt) return _e;
+  xt = 1;
+  const r = D(), e = F();
+  return _e = (n, i, c) => {
+    let o = null, h = null, a = null;
     try {
-      o = new s(i, c);
+      a = 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));
-    }), l;
-  }, be;
+    return n.forEach((l) => {
+      a.test(l) && (!o || h.compare(l) === -1) && (o = l, h = new r(o, c));
+    }), o;
+  }, _e;
 }
-var _e, bt;
-function Vr() {
-  if (bt) return _e;
-  bt = 1;
-  const t = b(), s = j();
-  return _e = (n, i, c) => {
-    let l = null, h = null, o = null;
+var Ue, Dt;
+function Kr() {
+  if (Dt) return Ue;
+  Dt = 1;
+  const r = D(), e = F();
+  return Ue = (n, i, c) => {
+    let o = null, h = null, a = null;
     try {
-      o = new s(i, c);
+      a = 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));
-    }), l;
-  }, _e;
+    return n.forEach((l) => {
+      a.test(l) && (!o || h.compare(l) === 1) && (o = l, h = new r(o, c));
+    }), o;
+  }, Ue;
 }
-var Ue, _t;
-function kr() {
-  if (_t) return Ue;
+var Fe, _t;
+function Zr() {
+  if (_t) return Fe;
   _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)))
-      return l;
-    l = null;
+  const r = D(), e = F(), t = K();
+  return Fe = (i, c) => {
+    i = new e(i, c);
+    let o = new r("0.0.0");
+    if (i.test(o) || (o = new r("0.0.0-0"), i.test(o)))
+      return o;
+    o = 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) {
+      const a = i.set[h];
+      let l = null;
+      a.forEach((s) => {
+        const u = new r(s.semver.version);
+        switch (s.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);
+            (!l || t(u, l)) && (l = u);
             break;
           case "<":
           case "<=":
             break;
           /* istanbul ignore next */
           default:
-            throw new Error(`Unexpected operation: ${e.operator}`);
+            throw new Error(`Unexpected operation: ${s.operator}`);
         }
-      }), a && (!l || r(l, a)) && (l = a);
+      }), l && (!o || t(o, l)) && (o = l);
     }
-    return l && i.test(l) ? l : null;
-  }, Ue;
+    return o && i.test(o) ? o : null;
+  }, Fe;
 }
-var je, Ut;
-function Xr() {
-  if (Ut) return je;
+var ke, Ut;
+function Jr() {
+  if (Ut) return ke;
   Ut = 1;
-  const t = j();
-  return je = (r, n) => {
+  const r = F();
+  return ke = (t, n) => {
     try {
-      return new t(r, n).range || "*";
+      return new r(t, n).range || "*";
     } catch {
       return null;
     }
-  }, je;
+  }, ke;
 }
-var Fe, jt;
+var je, 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 je;
+  Ft = 1;
+  const r = D(), e = Z(), { ANY: t } = e, n = F(), i = J(), c = K(), o = Ze(), h = Qe(), a = Je();
+  return je = (s, u, f, E) => {
+    s = new r(s, E), u = new n(u, E);
+    let S, d, N, A, b;
     switch (f) {
       case ">":
-        S = c, m = h, N = l, A = ">", G = ">=";
+        S = c, d = h, N = o, A = ">", b = ">=";
         break;
       case "<":
-        S = l, m = o, N = c, A = "<", G = "<=";
+        S = o, d = a, N = c, A = "<", b = "<=";
         break;
       default:
         throw new TypeError('Must provide a hilo val of "<" or ">"');
     }
-    if (i(e, u, p))
+    if (i(s, u, E))
       return !1;
     for (let w = 0; w < u.set.length; ++w) {
-      const x = u.set[w];
+      const G = 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))
+      if (G.forEach((q) => {
+        q.semver === t && (q = new e(">=0.0.0")), _ = _ || q, C = C || q, S(q.semver, _.semver, E) ? _ = q : N(q.semver, C.semver, E) && (C = q);
+      }), _.operator === A || _.operator === b || (!C.operator || C.operator === A) && d(s, C.semver))
         return !1;
-      if (C.operator === G && N(e, C.semver))
+      if (C.operator === b && N(s, C.semver))
         return !1;
     }
     return !0;
-  }, Fe;
+  }, je;
 }
-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 Me, kt;
+function Qr() {
+  if (kt) return Me;
+  kt = 1;
+  const r = et();
+  return Me = (t, n, i) => r(t, n, ">", i), Me;
 }
-var Ve, Mt;
-function Hr() {
-  if (Mt) return Ve;
+var Ve, jt;
+function es() {
+  if (jt) return Ve;
+  jt = 1;
+  const r = et();
+  return Ve = (t, n, i) => r(t, n, "<", i), Ve;
+}
+var Xe, Mt;
+function ts() {
+  if (Mt) return Xe;
   Mt = 1;
-  const t = et();
-  return Ve = (r, n, i) => t(r, n, "<", i), Ve;
+  const r = F();
+  return Xe = (t, n, i) => (t = new r(t, i), n = new r(n, i), t.intersects(n, i)), Xe;
 }
-var ke, Vt;
-function Wr() {
-  if (Vt) return ke;
+var Be, Vt;
+function rs() {
+  if (Vt) return Be;
   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 Xe, kt;
-function Yr() {
-  if (kt) return Xe;
-  kt = 1;
-  const t = Z(), s = U();
-  return Xe = (r, n, i) => {
+  const r = J(), e = U();
+  return Be = (t, n, i) => {
     const c = [];
-    let l = null, h = null;
-    const o = r.sort((f, p) => s(f, p, i));
-    for (const f of o)
-      t(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;
+    let o = null, h = null;
+    const a = t.sort((f, E) => e(f, E, i));
+    for (const f of a)
+      r(f, n, i) ? (h = f, o || (o = f)) : (h && c.push([o, h]), h = null, o = null);
+    o && c.push([o, null]);
+    const l = [];
+    for (const [f, E] of c)
+      f === E ? l.push(f) : !E && f === a[0] ? l.push("*") : E ? f === a[0] ? l.push(`<=${E}`) : l.push(`${f} - ${E}`) : l.push(`>=${f}`);
+    const s = l.join(" || "), u = typeof n.raw == "string" ? n.raw : String(n);
+    return s.length < u.length ? s : n;
+  }, Be;
+}
+var We, Xt;
+function ss() {
+  if (Xt) return We;
   Xt = 1;
-  const t = j(), s = K(), { ANY: r } = s, n = Z(), i = U(), c = (u, f, p = {}) => {
+  const r = F(), e = Z(), { ANY: t } = e, n = J(), i = U(), c = (u, f, E = {}) => {
     if (u === f)
       return !0;
-    u = new t(u, p), f = new t(f, p);
+    u = new r(u, E), f = new r(f, E);
     let S = !1;
-    e: for (const m of u.set) {
+    e: for (const d of u.set) {
       for (const N of f.set) {
-        const A = o(m, N, p);
+        const A = a(d, N, E);
         if (S = S || A !== null, A)
           continue e;
       }
@@ -1073,143 +1556,142 @@ function zr() {
         return !1;
     }
     return !0;
-  }, l = [new s(">=0.0.0-0")], h = [new s(">=0.0.0")], o = (u, f, p) => {
+  }, o = [new e(">=0.0.0-0")], h = [new e(">=0.0.0")], a = (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 = o : 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 d, N;
     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 === ">=" ? d = l(d, L, E) : L.operator === "<" || L.operator === "<=" ? N = s(N, 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)
+    if (d && N) {
+      if (A = i(d.semver, N.semver, E), A > 0)
         return null;
-      if (A === 0 && (m.operator !== ">=" || N.operator !== "<="))
+      if (A === 0 && (d.operator !== ">=" || N.operator !== "<="))
         return null;
     }
     for (const L of S) {
-      if (m && !n(L, String(m), p) || N && !n(L, String(N), p))
+      if (d && !n(L, String(d), E) || N && !n(L, String(N), E))
         return null;
-      for (const V of f)
-        if (!n(L, String(V), p))
+      for (const M of f)
+        if (!n(L, String(M), 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;
+    let b, w, G, _, C = N && !E.includePrerelease && N.semver.prerelease.length ? N.semver : !1, q = d && !E.includePrerelease && d.semver.prerelease.length ? d.semver : !1;
     C && C.prerelease.length === 1 && N.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 (_ = _ || L.operator === ">" || L.operator === ">=", G = G || L.operator === "<" || L.operator === "<=", d) {
+        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 (b = l(d, L, E), b === L && b !== d)
             return !1;
-        } else if (m.operator === ">=" && !n(m.semver, String(L), p))
+        } else if (d.operator === ">=" && !n(d.semver, String(L), E))
           return !1;
       }
       if (N) {
         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 (w = s(N, L, E), w === L && w !== N)
             return !1;
-        } else if (N.operator === "<=" && !n(N.semver, String(L), p))
+        } else if (N.operator === "<=" && !n(N.semver, String(L), E))
           return !1;
       }
-      if (!L.operator && (N || m) && A !== 0)
+      if (!L.operator && (N || d) && A !== 0)
         return !1;
     }
-    return !(m && x && !N && A !== 0 || N && _ && !m && A !== 0 || P || C);
-  }, a = (u, f, p) => {
+    return !(d && G && !N && A !== 0 || N && _ && !d && A !== 0 || q || C);
+  }, l = (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) => {
+  }, s = (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 We = c, We;
 }
 var He, Bt;
-function Jr() {
+function ns() {
   if (Bt) return He;
   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();
+  const r = B(), e = z(), t = D(), n = cr(), i = j(), c = Gr(), o = xr(), h = Dr(), a = _r(), l = Ur(), s = Fr(), u = kr(), f = jr(), E = U(), S = Mr(), d = Vr(), N = Ke(), A = Xr(), b = Br(), w = K(), G = Ze(), _ = ur(), C = hr(), q = Je(), L = Qe(), M = fr(), Q = Wr(), ee = Z(), te = F(), re = J(), p = zr(), m = Yr(), v = Kr(), g = Zr(), I = Jr(), R = et(), $ = Qr(), O = es(), T = ts(), y = rs(), x = ss();
   return He = {
     parse: i,
     valid: c,
-    clean: l,
+    clean: o,
     inc: h,
-    diff: o,
-    major: a,
-    minor: e,
+    diff: a,
+    major: l,
+    minor: s,
     patch: u,
     prerelease: f,
-    compare: p,
+    compare: E,
     rcompare: S,
-    compareLoose: m,
+    compareLoose: d,
     compareBuild: N,
     sort: A,
-    rsort: G,
+    rsort: b,
     gt: w,
-    lt: x,
+    lt: G,
     eq: _,
     neq: C,
-    gte: P,
+    gte: q,
     lte: L,
-    cmp: V,
+    cmp: M,
     coerce: Q,
     Comparator: ee,
     Range: te,
     satisfies: re,
-    toComparators: E,
-    maxSatisfying: d,
-    minSatisfying: I,
-    minVersion: R,
-    validRange: g,
-    outside: v,
+    toComparators: p,
+    maxSatisfying: m,
+    minSatisfying: v,
+    minVersion: g,
+    validRange: I,
+    outside: R,
     gtr: $,
     ltr: O,
     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,
+    subset: x,
+    SemVer: t,
+    re: r.re,
+    src: r.src,
+    tokens: r.t,
+    SEMVER_SPEC_VERSION: e.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: e.RELEASE_TYPES,
     compareIdentifiers: n.compareIdentifiers,
     rcompareIdentifiers: n.rcompareIdentifiers
   }, He;
 }
-var Kr = Jr();
-const Ht = `^${X.Version}`;
-class ts {
-  config = new lr(Wt);
-  event = new cr();
+var is = ns();
+const Wt = `^${X.Version}`;
+class ls {
+  config = new dr(Ht);
+  event = new pr();
   state;
   active;
   time;
-  offset;
   info;
-  mergedLineEnd = [];
+  merger = new Pr();
+  offset = new qr();
+  driver = new br();
   constructor() {
     this.state = {
       playing: !1,
-      frameId: null,
-      timerId: null,
       scanIndex: 0
     }, this.active = {
       lines: [],
@@ -1217,14 +1699,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());
+  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,126 +1713,91 @@ 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]);
-    const l = [], h = [];
-    for (let o = n; o <= i; o++) {
-      const a = c.get(o) ?? this.info.lines[o];
-      a && (l.push(a), h.push(o));
+    for (let a = 0; a < t.length; a++)
+      c.set(t[a], e[a]);
+    const o = [], h = [];
+    for (let a = n; a <= i; a++) {
+      const l = c.get(a) ?? this.info.lines[a];
+      l && (o.push(l), h.push(a));
     }
-    return { lines: l, index: h };
+    return { lines: o, 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) {
+      const o = this.info.lines[c];
+      if (o.time.start > e) {
         i = c;
         break;
       }
-      this.handleGetMergedLineTime(c) > s && (r.push(l), n.push(c));
+      this.merger.getMergedTime(c) > e && (t.push(o), 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));
+      const o = this.active.lines[c], h = this.active.index[c];
+      e >= this.merger.getMergedTime(h) ? t = !0 : (n.push(o), 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;
+    is.satisfies(e.version, Wt) || (console.warn(`[music-lyric-player] ignored lyric with incompatible version "${e.version}", expected "${Wt}"`), t = new X.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
@@ -1363,34 +1807,40 @@ class ts {
   }
   /**
    * 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)
+      const o = this.info.lines[c];
+      if (o.time.start > t)
         break;
-      this.handleGetMergedLineTime(c) > r && (n.push(l), i.push(c));
+      this.merger.getMergedTime(c) > t && (n.push(o), 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 +1882,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
+  ls as BaseLyricPlayer,
+  os as BaseLyricPlayerConfig
 };
 //# sourceMappingURL=index.ecma.js.map