@music-lyric-player/base 0.9.0 → 0.12.0

package/dist/index.ecma.js

@@ -1,32 +1,1207 @@
+import { freezeObjectDeep as or, ConfigManager as lr, Event as cr } from "@music-lyric-player/utils";
 import "lodash-es";
-import { ConfigManager as c, Event as d } from "@music-lyric-player/utils";
-const o = {
-  driver: "timer"
-}, m = "0.5.1";
-class r {
-  get version() {
-    return m;
-  }
-  type = "Incorrect";
+const Wt = or({
+  driver: "animation",
+  bridgeActive: !0,
+  offset: {
+    global: 0,
+    useMeta: !0,
+    resetTempOnLyricChange: !0
+  }
+}), es = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DEFAULT: Wt
+}, Symbol.toStringTag, { value: "Module" })), We = (t = 8) => {
+  const n = new Uint8Array(t);
+  if (typeof globalThis.crypto?.getRandomValues == "function")
+    crypto.getRandomValues(n);
+  else
+    for (let r = 0; r < n.length; r++)
+      n[r] = Math.floor(Math.random() * 256);
+  return Array.from(n).map((r) => r.toString(16).padStart(2, "0")).join("");
+};
+class W {
+  start = 0;
+  end = 0;
+  get duration() {
+    return this.end - this.start;
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end,
+      duration: this.duration
+    };
+  }
+}
+var Ye = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Space = "Space", t))(Ye || {});
+class Yt {
+  stress = !1;
+}
+class ur {
+  type = "Normal";
+  time = new W();
+  content = "";
+  extended = [];
+  config = new Yt();
+}
+class fr {
+  type = "Space";
+  count = 1;
+}
+var zt = /* @__PURE__ */ ((t) => (t.Unknown = "Unknown", t.Translate = "Translate", t.Roman = "Roman", t))(zt || {});
+class hr {
+  type = "Unknown";
+  content = "";
+}
+var Jt = /* @__PURE__ */ ((t) => (t.Normal = "Normal", t.Interlude = "Interlude", t))(Jt || {});
+class pr {
+  id = We(4).toUpperCase();
+  type = "Interlude";
+  time = new W();
+}
+class Kt {
+  words = [];
+  extended = [];
+  get original() {
+    return this.words.map((n) => n.type === Ye.Normal ? n.content : " ".repeat(n.count)).join("");
+  }
+  toJSON() {
+    return {
+      words: this.words,
+      extended: this.extended,
+      original: this.original
+    };
+  }
+}
+class Zt {
+  type = "Normal";
+  id = We(4).toUpperCase();
+  time = new W();
+  content = new Kt();
+  agent;
+}
+class Er extends Zt {
+}
+class mr extends Zt {
+  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 dr 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 $r extends F {
+  type = "Album";
+  content = "";
+}
+class gr extends F {
+  type = "Creator";
+  content = {
+    role: "",
+    name: []
+  };
+}
+class Lr extends F {
+  type = "Unknown";
+  content = "";
+}
+class Tr {
+  id = "";
+  name = "";
+  count = 0;
+}
+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 Or {
+  version = tr;
+  type = "Invalid";
   metas = [];
   lines = [];
   agents = [];
-  toJSON() {
-    return {
-      version: this.version,
-      type: this.type,
-      metas: this.metas,
-      lines: this.lines,
-      agents: this.agents
+}
+const M = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Agent: Tr,
+  Extended: hr,
+  ExtendedType: zt,
+  Info: Or,
+  InfoType: rr,
+  LineAgent: Nr,
+  LineAgentIndex: er,
+  LineInterlude: pr,
+  LineNormal: mr,
+  LineNormalBackground: Er,
+  LineNormalContent: Kt,
+  LineType: Jt,
+  MetaAlbum: $r,
+  MetaCreator: gr,
+  MetaDuration: Rr,
+  MetaOffset: dr,
+  MetaSinger: Ir,
+  MetaTitle: vr,
+  MetaType: Qt,
+  MetaUnknown: Lr,
+  Time: W,
+  Version: tr,
+  WordNormal: ur,
+  WordNormalConfig: Yt,
+  WordSpace: fr,
+  WordType: Ye
+}, Symbol.toStringTag, { value: "Module" }));
+var H = { exports: {} }, se, tt;
+function Y() {
+  if (tt) return se;
+  tt = 1;
+  const t = "2.0.0", n = 256, r = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, s = 16, i = n - 6;
+  return se = {
+    MAX_LENGTH: n,
+    MAX_SAFE_COMPONENT_LENGTH: s,
+    MAX_SAFE_BUILD_LENGTH: i,
+    MAX_SAFE_INTEGER: r,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: t,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, se;
+}
+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) ? (...n) => console.error("SEMVER", ...n) : () => {
+  }), ne;
+}
+var st;
+function B() {
+  return st || (st = 1, (function(t, n) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: r,
+      MAX_SAFE_BUILD_LENGTH: s,
+      MAX_LENGTH: i
+    } = Y(), u = z();
+    n = t.exports = {};
+    const l = n.re = [], h = n.safeRe = [], o = n.src = [], a = n.safeSrc = [], e = n.t = {};
+    let c = 0;
+    const f = "[a-zA-Z0-9-]", d = [
+      ["\\s", 1],
+      ["\\d", i],
+      [f, s]
+    ], O = (N) => {
+      for (const [A, G] of d)
+        N = N.split(`${A}*`).join(`${A}{0,${G}}`).split(`${A}+`).join(`${A}{1,${G}}`);
+      return N;
+    }, E = (N, A, G) => {
+      const w = O(A), x = c++;
+      u(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);
     };
+    E("NUMERICIDENTIFIER", "0|[1-9]\\d*"), E("NUMERICIDENTIFIERLOOSE", "\\d+"), E("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`), E("MAINVERSION", `(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})\\.(${o[e.NUMERICIDENTIFIER]})`), E("MAINVERSIONLOOSE", `(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})\\.(${o[e.NUMERICIDENTIFIERLOOSE]})`), E("PRERELEASEIDENTIFIER", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIER]})`), E("PRERELEASEIDENTIFIERLOOSE", `(?:${o[e.NONNUMERICIDENTIFIER]}|${o[e.NUMERICIDENTIFIERLOOSE]})`), E("PRERELEASE", `(?:-(${o[e.PRERELEASEIDENTIFIER]}(?:\\.${o[e.PRERELEASEIDENTIFIER]})*))`), E("PRERELEASELOOSE", `(?:-?(${o[e.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${o[e.PRERELEASEIDENTIFIERLOOSE]})*))`), E("BUILDIDENTIFIER", `${f}+`), E("BUILD", `(?:\\+(${o[e.BUILDIDENTIFIER]}(?:\\.${o[e.BUILDIDENTIFIER]})*))`), E("FULLPLAIN", `v?${o[e.MAINVERSION]}${o[e.PRERELEASE]}?${o[e.BUILD]}?`), E("FULL", `^${o[e.FULLPLAIN]}$`), E("LOOSEPLAIN", `[v=\\s]*${o[e.MAINVERSIONLOOSE]}${o[e.PRERELEASELOOSE]}?${o[e.BUILD]}?`), E("LOOSE", `^${o[e.LOOSEPLAIN]}$`), E("GTLT", "((?:<|>)?=?)"), E("XRANGEIDENTIFIERLOOSE", `${o[e.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), E("XRANGEIDENTIFIER", `${o[e.NUMERICIDENTIFIER]}|x|X|\\*`), E("XRANGEPLAIN", `[v=\\s]*(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:\\.(${o[e.XRANGEIDENTIFIER]})(?:${o[e.PRERELEASE]})?${o[e.BUILD]}?)?)?`), E("XRANGEPLAINLOOSE", `[v=\\s]*(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:\\.(${o[e.XRANGEIDENTIFIERLOOSE]})(?:${o[e.PRERELEASELOOSE]})?${o[e.BUILD]}?)?)?`), E("XRANGE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAIN]}$`), E("XRANGELOOSE", `^${o[e.GTLT]}\\s*${o[e.XRANGEPLAINLOOSE]}$`), E("COERCEPLAIN", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?`), E("COERCE", `${o[e.COERCEPLAIN]}(?:$|[^\\d])`), E("COERCEFULL", o[e.COERCEPLAIN] + `(?:${o[e.PRERELEASE]})?(?:${o[e.BUILD]})?(?:$|[^\\d])`), E("COERCERTL", o[e.COERCE], !0), E("COERCERTLFULL", o[e.COERCEFULL], !0), E("LONETILDE", "(?:~>?)"), E("TILDETRIM", `(\\s*)${o[e.LONETILDE]}\\s+`, !0), n.tildeTrimReplace = "$1~", E("TILDE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAIN]}$`), E("TILDELOOSE", `^${o[e.LONETILDE]}${o[e.XRANGEPLAINLOOSE]}$`), E("LONECARET", "(?:\\^)"), E("CARETTRIM", `(\\s*)${o[e.LONECARET]}\\s+`, !0), n.caretTrimReplace = "$1^", E("CARET", `^${o[e.LONECARET]}${o[e.XRANGEPLAIN]}$`), E("CARETLOOSE", `^${o[e.LONECARET]}${o[e.XRANGEPLAINLOOSE]}$`), E("COMPARATORLOOSE", `^${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]})$|^$`), E("COMPARATOR", `^${o[e.GTLT]}\\s*(${o[e.FULLPLAIN]})$|^$`), E("COMPARATORTRIM", `(\\s*)${o[e.GTLT]}\\s*(${o[e.LOOSEPLAIN]}|${o[e.XRANGEPLAIN]})`, !0), n.comparatorTrimReplace = "$1$2$3", E("HYPHENRANGE", `^\\s*(${o[e.XRANGEPLAIN]})\\s+-\\s+(${o[e.XRANGEPLAIN]})\\s*$`), E("HYPHENRANGELOOSE", `^\\s*(${o[e.XRANGEPLAINLOOSE]})\\s+-\\s+(${o[e.XRANGEPLAINLOOSE]})\\s*$`), E("STAR", "(<|>)?=?\\s*\\*"), E("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), E("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(H, H.exports)), H.exports;
+}
+var ie, nt;
+function ze() {
+  if (nt) return ie;
+  nt = 1;
+  const t = Object.freeze({ loose: !0 }), n = Object.freeze({});
+  return ie = (s) => s ? typeof s != "object" ? t : s : n, ie;
+}
+var ae, it;
+function sr() {
+  if (it) return ae;
+  it = 1;
+  const t = /^[0-9]+$/, n = (s, i) => {
+    if (typeof s == "number" && typeof i == "number")
+      return s === i ? 0 : s < i ? -1 : 1;
+    const u = t.test(s), l = t.test(i);
+    return u && l && (s = +s, i = +i), s === i ? 0 : u && !l ? -1 : l && !u ? 1 : s < i ? -1 : 1;
+  };
+  return ae = {
+    compareIdentifiers: n,
+    rcompareIdentifiers: (s, i) => n(i, s)
+  }, ae;
+}
+var oe, at;
+function b() {
+  if (at) return oe;
+  at = 1;
+  const t = z(), { MAX_LENGTH: n, MAX_SAFE_INTEGER: r } = Y(), { safeRe: s, t: i } = B(), u = ze(), { compareIdentifiers: l } = sr();
+  class h {
+    constructor(a, e) {
+      if (e = u(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 > n)
+        throw new TypeError(
+          `version is longer than ${n} characters`
+        );
+      t("SemVer", a, e), this.options = e, this.loose = !!e.loose, this.includePrerelease = !!e.includePrerelease;
+      const c = a.trim().match(e.loose ? s[i.LOOSE] : s[i.FULL]);
+      if (!c)
+        throw new TypeError(`Invalid Version: ${a}`);
+      if (this.raw = a, this.major = +c[1], this.minor = +c[2], this.patch = +c[3], this.major > r || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > r || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > r || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      c[4] ? this.prerelease = c[4].split(".").map((f) => {
+        if (/^[0-9]+$/.test(f)) {
+          const d = +f;
+          if (d >= 0 && d < r)
+            return d;
+        }
+        return f;
+      }) : this.prerelease = [], this.build = c[5] ? c[5].split(".") : [], this.format();
+    }
+    format() {
+      return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(a) {
+      if (t("SemVer.compare", this.version, this.options, a), !(a instanceof h)) {
+        if (typeof a == "string" && a === this.version)
+          return 0;
+        a = new h(a, this.options);
+      }
+      return a.version === this.version ? 0 : this.compareMain(a) || this.comparePre(a);
+    }
+    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;
+    }
+    comparePre(a) {
+      if (a instanceof h || (a = new h(a, this.options)), this.prerelease.length && !a.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && a.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !a.prerelease.length)
+        return 0;
+      let e = 0;
+      do {
+        const c = this.prerelease[e], f = a.prerelease[e];
+        if (t("prerelease compare", e, c, f), c === void 0 && f === void 0)
+          return 0;
+        if (f === void 0)
+          return 1;
+        if (c === void 0)
+          return -1;
+        if (c === f)
+          continue;
+        return l(c, f);
+      } while (++e);
+    }
+    compareBuild(a) {
+      a instanceof h || (a = new h(a, this.options));
+      let e = 0;
+      do {
+        const c = this.build[e], f = a.build[e];
+        if (t("build compare", e, c, f), c === void 0 && f === void 0)
+          return 0;
+        if (f === void 0)
+          return 1;
+        if (c === void 0)
+          return -1;
+        if (c === f)
+          continue;
+        return l(c, f);
+      } while (++e);
+    }
+    // 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, c) {
+      if (a.startsWith("pre")) {
+        if (!e && c === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (e) {
+          const f = `-${e}`.match(this.options.loose ? s[i.PRERELEASELOOSE] : s[i.PRERELEASE]);
+          if (!f || f[1] !== e)
+            throw new Error(`invalid identifier: ${e}`);
+        }
+      }
+      switch (a) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", e, c);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", e, c);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", e, c), this.inc("pre", e, c);
+          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, c), this.inc("pre", e, c);
+          break;
+        case "release":
+          if (this.prerelease.length === 0)
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+          break;
+        case "minor":
+          (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+          break;
+        case "patch":
+          this.prerelease.length === 0 && this.patch++, this.prerelease = [];
+          break;
+        // This probably shouldn't be used publicly.
+        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+        case "pre": {
+          const f = Number(c) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [f];
+          else {
+            let d = this.prerelease.length;
+            for (; --d >= 0; )
+              typeof this.prerelease[d] == "number" && (this.prerelease[d]++, d = -2);
+            if (d === -1) {
+              if (e === this.prerelease.join(".") && c === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(f);
+            }
+          }
+          if (e) {
+            let d = [e, f];
+            c === !1 && (d = [e]), l(this.prerelease[0], e) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = d) : this.prerelease = d;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${a}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
   }
+  return oe = h, oe;
+}
+var le, ot;
+function V() {
+  if (ot) return le;
+  ot = 1;
+  const t = b();
+  return le = (r, s, i = !1) => {
+    if (r instanceof t)
+      return r;
+    try {
+      return new t(r, s);
+    } catch (u) {
+      if (!i)
+        return null;
+      throw u;
+    }
+  }, le;
+}
+var ce, lt;
+function Sr() {
+  if (lt) return ce;
+  lt = 1;
+  const t = V();
+  return ce = (r, s) => {
+    const i = t(r, s);
+    return i ? i.version : null;
+  }, ce;
+}
+var ue, ct;
+function Ar() {
+  if (ct) return ue;
+  ct = 1;
+  const t = V();
+  return ue = (r, s) => {
+    const i = t(r.trim().replace(/^[=v]+/, ""), s);
+    return i ? i.version : null;
+  }, ue;
+}
+var fe, ut;
+function wr() {
+  if (ut) return fe;
+  ut = 1;
+  const t = b();
+  return fe = (r, s, i, u, l) => {
+    typeof i == "string" && (l = u, u = i, i = void 0);
+    try {
+      return new t(
+        r instanceof t ? r.version : r,
+        i
+      ).inc(s, u, l).version;
+    } catch {
+      return null;
+    }
+  }, fe;
+}
+var he, ft;
+function yr() {
+  if (ft) return he;
+  ft = 1;
+  const t = V();
+  return he = (r, s) => {
+    const i = t(r, null, !0), u = t(s, null, !0), l = i.compare(u);
+    if (l === 0)
+      return null;
+    const h = l > 0, o = h ? i : u, a = h ? u : i, e = !!o.prerelease.length;
+    if (!!a.prerelease.length && !e) {
+      if (!a.patch && !a.minor)
+        return "major";
+      if (a.compareMain(o) === 0)
+        return a.minor && !a.patch ? "minor" : "patch";
+    }
+    const f = e ? "pre" : "";
+    return i.major !== u.major ? f + "major" : i.minor !== u.minor ? f + "minor" : i.patch !== u.patch ? f + "patch" : "prerelease";
+  }, he;
+}
+var pe, ht;
+function Cr() {
+  if (ht) return pe;
+  ht = 1;
+  const t = b();
+  return pe = (r, s) => new t(r, s).major, pe;
+}
+var Ee, pt;
+function qr() {
+  if (pt) return Ee;
+  pt = 1;
+  const t = b();
+  return Ee = (r, s) => new t(r, s).minor, Ee;
+}
+var me, Et;
+function Pr() {
+  if (Et) return me;
+  Et = 1;
+  const t = b();
+  return me = (r, s) => new t(r, s).patch, me;
+}
+var de, mt;
+function Gr() {
+  if (mt) return de;
+  mt = 1;
+  const t = V();
+  return de = (r, s) => {
+    const i = t(r, s);
+    return i && i.prerelease.length ? i.prerelease : null;
+  }, de;
+}
+var Re, dt;
+function U() {
+  if (dt) return Re;
+  dt = 1;
+  const t = b();
+  return Re = (r, s, i) => new t(r, i).compare(new t(s, i)), Re;
+}
+var ve, Rt;
+function xr() {
+  if (Rt) return ve;
+  Rt = 1;
+  const t = U();
+  return ve = (r, s, i) => t(s, r, i), ve;
+}
+var Ie, vt;
+function Dr() {
+  if (vt) return Ie;
+  vt = 1;
+  const t = U();
+  return Ie = (r, s) => t(r, s, !0), Ie;
+}
+var $e, It;
+function Je() {
+  if (It) return $e;
+  It = 1;
+  const t = b();
+  return $e = (r, s, i) => {
+    const u = new t(r, i), l = new t(s, i);
+    return u.compare(l) || u.compareBuild(l);
+  }, $e;
+}
+var ge, $t;
+function br() {
+  if ($t) return ge;
+  $t = 1;
+  const t = Je();
+  return ge = (r, s) => r.sort((i, u) => t(i, u, s)), ge;
 }
-class v {
-  config = new c(o);
-  event = new d();
+var Le, gt;
+function _r() {
+  if (gt) return Le;
+  gt = 1;
+  const t = Je();
+  return Le = (r, s) => r.sort((i, u) => t(u, i, s)), Le;
+}
+var Te, Lt;
+function J() {
+  if (Lt) return Te;
+  Lt = 1;
+  const t = U();
+  return Te = (r, s, i) => t(r, s, i) > 0, Te;
+}
+var Ne, Tt;
+function Ke() {
+  if (Tt) return Ne;
+  Tt = 1;
+  const t = U();
+  return Ne = (r, s, i) => t(r, s, i) < 0, Ne;
+}
+var Oe, Nt;
+function nr() {
+  if (Nt) return Oe;
+  Nt = 1;
+  const t = U();
+  return Oe = (r, s, i) => t(r, s, i) === 0, Oe;
+}
+var Se, Ot;
+function ir() {
+  if (Ot) return Se;
+  Ot = 1;
+  const t = U();
+  return Se = (r, s, i) => t(r, s, i) !== 0, Se;
+}
+var Ae, St;
+function Ze() {
+  if (St) return Ae;
+  St = 1;
+  const t = U();
+  return Ae = (r, s, i) => t(r, s, i) >= 0, Ae;
+}
+var we, At;
+function Qe() {
+  if (At) return we;
+  At = 1;
+  const t = U();
+  return we = (r, s, i) => t(r, s, i) <= 0, we;
+}
+var ye, wt;
+function ar() {
+  if (wt) return ye;
+  wt = 1;
+  const t = nr(), n = ir(), r = J(), s = Ze(), i = Ke(), u = Qe();
+  return ye = (h, o, a, e) => {
+    switch (o) {
+      case "===":
+        return typeof h == "object" && (h = h.version), typeof a == "object" && (a = a.version), h === a;
+      case "!==":
+        return typeof h == "object" && (h = h.version), typeof a == "object" && (a = a.version), h !== a;
+      case "":
+      case "=":
+      case "==":
+        return t(h, a, e);
+      case "!=":
+        return n(h, a, e);
+      case ">":
+        return r(h, a, e);
+      case ">=":
+        return s(h, a, e);
+      case "<":
+        return i(h, a, e);
+      case "<=":
+        return u(h, a, e);
+      default:
+        throw new TypeError(`Invalid operator: ${o}`);
+    }
+  }, ye;
+}
+var Ce, yt;
+function Ur() {
+  if (yt) return Ce;
+  yt = 1;
+  const t = b(), n = V(), { safeRe: r, t: s } = B();
+  return Ce = (u, l) => {
+    if (u instanceof t)
+      return u;
+    if (typeof u == "number" && (u = String(u)), typeof u != "string")
+      return null;
+    l = l || {};
+    let h = null;
+    if (!l.rtl)
+      h = u.match(l.includePrerelease ? r[s.COERCEFULL] : r[s.COERCE]);
+    else {
+      const d = l.includePrerelease ? r[s.COERCERTLFULL] : r[s.COERCERTL];
+      let O;
+      for (; (O = d.exec(u)) && (!h || h.index + h[0].length !== u.length); )
+        (!h || O.index + O[0].length !== h.index + h[0].length) && (h = O), d.lastIndex = O.index + O[1].length + O[2].length;
+      d.lastIndex = -1;
+    }
+    if (h === null)
+      return null;
+    const o = h[2], a = h[3] || "0", e = h[4] || "0", c = l.includePrerelease && h[5] ? `-${h[5]}` : "", f = l.includePrerelease && h[6] ? `+${h[6]}` : "";
+    return n(`${o}.${a}.${e}${c}${f}`, l);
+  }, Ce;
+}
+var qe, Ct;
+function jr() {
+  if (Ct) return qe;
+  Ct = 1;
+  class t {
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(r) {
+      const s = this.map.get(r);
+      if (s !== void 0)
+        return this.map.delete(r), this.map.set(r, s), s;
+    }
+    delete(r) {
+      return this.map.delete(r);
+    }
+    set(r, s) {
+      if (!this.delete(r) && s !== void 0) {
+        if (this.map.size >= this.max) {
+          const u = this.map.keys().next().value;
+          this.delete(u);
+        }
+        this.map.set(r, s);
+      }
+      return this;
+    }
+  }
+  return qe = t, qe;
+}
+var Pe, qt;
+function j() {
+  if (qt) return Pe;
+  qt = 1;
+  const t = /\s+/g;
+  class n {
+    constructor(p, I) {
+      if (I = i(I), p instanceof n)
+        return p.loose === !!I.loose && p.includePrerelease === !!I.includePrerelease ? p : new n(p.raw, I);
+      if (p instanceof u)
+        return this.raw = p.value, this.set = [[p]], this.formatted = void 0, this;
+      if (this.options = I, this.loose = !!I.loose, this.includePrerelease = !!I.includePrerelease, this.raw = p.trim().replace(t, " "), this.set = this.raw.split("||").map((R) => this.parseRange(R.trim())).filter((R) => R.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(($) => !E($[0])), this.set.length === 0)
+          this.set = [R];
+        else if (this.set.length > 1) {
+          for (const $ of this.set)
+            if ($.length === 1 && N($[0])) {
+              this.set = [$];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let p = 0; p < this.set.length; p++) {
+          p > 0 && (this.formatted += "||");
+          const I = this.set[p];
+          for (let R = 0; R < I.length; R++)
+            R > 0 && (this.formatted += " "), this.formatted += I[R].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(p) {
+      const R = ((this.options.includePrerelease && d) | (this.options.loose && O)) + ":" + p, $ = s.get(R);
+      if ($)
+        return $;
+      const v = this.options.loose, g = v ? o[a.HYPHENRANGELOOSE] : o[a.HYPHENRANGE];
+      p = p.replace(g, te(this.options.includePrerelease)), l("hyphen replace", p), p = p.replace(o[a.COMPARATORTRIM], e), l("comparator trim", p), p = p.replace(o[a.TILDETRIM], c), l("tilde trim", p), p = p.replace(o[a.CARETTRIM], f), l("caret trim", p);
+      let S = p.split(" ").map((q) => G(q, this.options)).join(" ").split(/\s+/).map((q) => ee(q, this.options));
+      v && (S = S.filter((q) => (l("loose invalid filter", q, this.options), !!q.match(o[a.COMPARATORLOOSE])))), l("range list", S);
+      const T = /* @__PURE__ */ new Map(), y = S.map((q) => new u(q, this.options));
+      for (const q of y) {
+        if (E(q))
+          return [q];
+        T.set(q.value, q);
+      }
+      T.size > 1 && T.has("") && T.delete("");
+      const D = [...T.values()];
+      return s.set(R, D), D;
+    }
+    intersects(p, I) {
+      if (!(p instanceof n))
+        throw new TypeError("a Range is required");
+      return this.set.some((R) => A(R, I) && p.set.some(($) => A($, I) && R.every((v) => $.every((g) => v.intersects(g, I)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(p) {
+      if (!p)
+        return !1;
+      if (typeof p == "string")
+        try {
+          p = new h(p, this.options);
+        } catch {
+          return !1;
+        }
+      for (let I = 0; I < this.set.length; I++)
+        if (re(this.set[I], p, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  Pe = n;
+  const r = jr(), s = new r(), i = ze(), u = K(), l = z(), h = b(), {
+    safeRe: o,
+    t: a,
+    comparatorTrimReplace: e,
+    tildeTrimReplace: c,
+    caretTrimReplace: f
+  } = B(), { FLAG_INCLUDE_PRERELEASE: d, FLAG_LOOSE: O } = Y(), E = (m) => m.value === "<0.0.0-0", N = (m) => m.value === "", A = (m, p) => {
+    let I = !0;
+    const R = m.slice();
+    let $ = R.pop();
+    for (; I && R.length; )
+      I = R.every((v) => $.intersects(v, p)), $ = R.pop();
+    return I;
+  }, G = (m, p) => (m = m.replace(o[a.BUILD], ""), l("comp", m, p), m = C(m, p), l("caret", m), m = x(m, p), l("tildes", m), m = L(m, p), l("xrange", m), m = Q(m, p), l("stars", m), m), w = (m) => !m || m.toLowerCase() === "x" || m === "*", x = (m, p) => m.trim().split(/\s+/).map((I) => _(I, p)).join(" "), _ = (m, p) => {
+    const I = p.loose ? o[a.TILDELOOSE] : o[a.TILDE];
+    return m.replace(I, (R, $, v, g, S) => {
+      l("tilde", m, R, $, v, g, S);
+      let T;
+      return w($) ? T = "" : w(v) ? T = `>=${$}.0.0 <${+$ + 1}.0.0-0` : w(g) ? T = `>=${$}.${v}.0 <${$}.${+v + 1}.0-0` : S ? (l("replaceTilde pr", S), T = `>=${$}.${v}.${g}-${S} <${$}.${+v + 1}.0-0`) : T = `>=${$}.${v}.${g} <${$}.${+v + 1}.0-0`, l("tilde return", T), T;
+    });
+  }, C = (m, p) => m.trim().split(/\s+/).map((I) => P(I, p)).join(" "), P = (m, p) => {
+    l("caret", m, p);
+    const I = p.loose ? o[a.CARETLOOSE] : o[a.CARET], R = p.includePrerelease ? "-0" : "";
+    return m.replace(I, ($, v, g, S, T) => {
+      l("caret", m, $, v, g, S, T);
+      let y;
+      return w(v) ? y = "" : w(g) ? y = `>=${v}.0.0${R} <${+v + 1}.0.0-0` : w(S) ? v === "0" ? y = `>=${v}.${g}.0${R} <${v}.${+g + 1}.0-0` : y = `>=${v}.${g}.0${R} <${+v + 1}.0.0-0` : T ? (l("replaceCaret pr", T), v === "0" ? g === "0" ? y = `>=${v}.${g}.${S}-${T} <${v}.${g}.${+S + 1}-0` : y = `>=${v}.${g}.${S}-${T} <${v}.${+g + 1}.0-0` : y = `>=${v}.${g}.${S}-${T} <${+v + 1}.0.0-0`) : (l("no pr"), v === "0" ? g === "0" ? y = `>=${v}.${g}.${S}${R} <${v}.${g}.${+S + 1}-0` : y = `>=${v}.${g}.${S}${R} <${v}.${+g + 1}.0-0` : y = `>=${v}.${g}.${S} <${+v + 1}.0.0-0`), l("caret return", y), y;
+    });
+  }, L = (m, p) => (l("replaceXRanges", m, p), m.split(/\s+/).map((I) => k(I, p)).join(" ")), k = (m, p) => {
+    m = m.trim();
+    const I = p.loose ? o[a.XRANGELOOSE] : o[a.XRANGE];
+    return m.replace(I, (R, $, v, g, S, T) => {
+      l("xRange", m, R, $, v, g, S, T);
+      const y = w(v), D = y || w(g), q = D || w(S), X = q;
+      return $ === "=" && X && ($ = ""), T = p.includePrerelease ? "-0" : "", y ? $ === ">" || $ === "<" ? R = "<0.0.0-0" : R = "*" : $ && X ? (D && (g = 0), S = 0, $ === ">" ? ($ = ">=", D ? (v = +v + 1, g = 0, S = 0) : (g = +g + 1, S = 0)) : $ === "<=" && ($ = "<", D ? v = +v + 1 : g = +g + 1), $ === "<" && (T = "-0"), R = `${$ + v}.${g}.${S}${T}`) : D ? R = `>=${v}.0.0${T} <${+v + 1}.0.0-0` : q && (R = `>=${v}.${g}.0${T} <${v}.${+g + 1}.0-0`), l("xRange return", R), R;
+    });
+  }, Q = (m, p) => (l("replaceStars", m, p), m.trim().replace(o[a.STAR], "")), ee = (m, p) => (l("replaceGTE0", m, p), m.trim().replace(o[p.includePrerelease ? a.GTE0PRE : a.GTE0], "")), te = (m) => (p, I, R, $, v, g, S, T, y, D, q, X) => (w(R) ? I = "" : w($) ? I = `>=${R}.0.0${m ? "-0" : ""}` : w(v) ? I = `>=${R}.${$}.0${m ? "-0" : ""}` : g ? I = `>=${I}` : I = `>=${I}${m ? "-0" : ""}`, w(y) ? T = "" : w(D) ? T = `<${+y + 1}.0.0-0` : w(q) ? T = `<${y}.${+D + 1}.0-0` : X ? T = `<=${y}.${D}.${q}-${X}` : m ? T = `<${y}.${D}.${+q + 1}-0` : T = `<=${T}`, `${I} ${T}`.trim()), re = (m, p, I) => {
+    for (let R = 0; R < m.length; R++)
+      if (!m[R].test(p))
+        return !1;
+    if (p.prerelease.length && !I.includePrerelease) {
+      for (let R = 0; R < m.length; R++)
+        if (l(m[R].semver), m[R].semver !== u.ANY && m[R].semver.prerelease.length > 0) {
+          const $ = m[R].semver;
+          if ($.major === p.major && $.minor === p.minor && $.patch === p.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return Pe;
+}
+var Ge, Pt;
+function K() {
+  if (Pt) return Ge;
+  Pt = 1;
+  const t = /* @__PURE__ */ Symbol("SemVer ANY");
+  class n {
+    static get ANY() {
+      return t;
+    }
+    constructor(e, c) {
+      if (c = r(c), e instanceof n) {
+        if (e.loose === !!c.loose)
+          return e;
+        e = e.value;
+      }
+      e = e.trim().split(/\s+/).join(" "), l("comparator", e, c), this.options = c, this.loose = !!c.loose, this.parse(e), this.semver === t ? this.value = "" : this.value = this.operator + this.semver.version, l("comp", this);
+    }
+    parse(e) {
+      const c = this.options.loose ? s[i.COMPARATORLOOSE] : s[i.COMPARATOR], f = e.match(c);
+      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;
+    }
+    toString() {
+      return this.value;
+    }
+    test(e) {
+      if (l("Comparator.test", e, this.options.loose), this.semver === t || e === t)
+        return !0;
+      if (typeof e == "string")
+        try {
+          e = new h(e, this.options);
+        } catch {
+          return !1;
+        }
+      return u(e, this.operator, this.semver, this.options);
+    }
+    intersects(e, c) {
+      if (!(e instanceof n))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new o(e.value, c).test(this.value) : e.operator === "" ? e.value === "" ? !0 : new o(this.value, c).test(e.semver) : (c = r(c), c.includePrerelease && (this.value === "<0.0.0-0" || e.value === "<0.0.0-0") || !c.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("=") || u(this.semver, "<", e.semver, c) && this.operator.startsWith(">") && e.operator.startsWith("<") || u(this.semver, ">", e.semver, c) && this.operator.startsWith("<") && e.operator.startsWith(">")));
+    }
+  }
+  Ge = n;
+  const r = ze(), { safeRe: s, t: i } = B(), u = ar(), l = z(), h = b(), o = j();
+  return Ge;
+}
+var xe, Gt;
+function Z() {
+  if (Gt) return xe;
+  Gt = 1;
+  const t = j();
+  return xe = (r, s, i) => {
+    try {
+      s = new t(s, i);
+    } catch {
+      return !1;
+    }
+    return s.test(r);
+  }, xe;
+}
+var De, xt;
+function Fr() {
+  if (xt) return De;
+  xt = 1;
+  const t = j();
+  return De = (r, s) => new t(r, s).set.map((i) => i.map((u) => u.value).join(" ").trim().split(" ")), De;
+}
+var be, Dt;
+function Vr() {
+  if (Dt) return be;
+  Dt = 1;
+  const t = b(), n = j();
+  return be = (s, i, u) => {
+    let l = null, h = null, o = null;
+    try {
+      o = new n(i, u);
+    } catch {
+      return null;
+    }
+    return s.forEach((a) => {
+      o.test(a) && (!l || h.compare(a) === -1) && (l = a, h = new t(l, u));
+    }), l;
+  }, be;
+}
+var _e, bt;
+function kr() {
+  if (bt) return _e;
+  bt = 1;
+  const t = b(), n = j();
+  return _e = (s, i, u) => {
+    let l = null, h = null, o = null;
+    try {
+      o = new n(i, u);
+    } catch {
+      return null;
+    }
+    return s.forEach((a) => {
+      o.test(a) && (!l || h.compare(a) === 1) && (l = a, h = new t(l, u));
+    }), l;
+  }, _e;
+}
+var Ue, _t;
+function Xr() {
+  if (_t) return Ue;
+  _t = 1;
+  const t = b(), n = j(), r = J();
+  return Ue = (i, u) => {
+    i = new n(i, u);
+    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;
+    for (let h = 0; h < i.set.length; ++h) {
+      const o = i.set[h];
+      let a = null;
+      o.forEach((e) => {
+        const c = new t(e.semver.version);
+        switch (e.operator) {
+          case ">":
+            c.prerelease.length === 0 ? c.patch++ : c.prerelease.push(0), c.raw = c.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!a || r(c, a)) && (a = c);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${e.operator}`);
+        }
+      }), a && (!l || r(l, a)) && (l = a);
+    }
+    return l && i.test(l) ? l : null;
+  }, Ue;
+}
+var je, Ut;
+function Mr() {
+  if (Ut) return je;
+  Ut = 1;
+  const t = j();
+  return je = (r, s) => {
+    try {
+      return new t(r, s).range || "*";
+    } catch {
+      return null;
+    }
+  }, je;
+}
+var Fe, jt;
+function et() {
+  if (jt) return Fe;
+  jt = 1;
+  const t = b(), n = K(), { ANY: r } = n, s = j(), i = Z(), u = J(), l = Ke(), h = Qe(), o = Ze();
+  return Fe = (e, c, f, d) => {
+    e = new t(e, d), c = new s(c, d);
+    let O, E, N, A, G;
+    switch (f) {
+      case ">":
+        O = u, E = h, N = l, A = ">", G = ">=";
+        break;
+      case "<":
+        O = l, E = o, N = u, A = "<", G = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (i(e, c, d))
+      return !1;
+    for (let w = 0; w < c.set.length; ++w) {
+      const x = c.set[w];
+      let _ = null, C = null;
+      if (x.forEach((P) => {
+        P.semver === r && (P = new n(">=0.0.0")), _ = _ || P, C = C || P, O(P.semver, _.semver, d) ? _ = P : N(P.semver, C.semver, d) && (C = P);
+      }), _.operator === A || _.operator === G || (!C.operator || C.operator === A) && E(e, C.semver))
+        return !1;
+      if (C.operator === G && N(e, C.semver))
+        return !1;
+    }
+    return !0;
+  }, Fe;
+}
+var Ve, Ft;
+function Br() {
+  if (Ft) return Ve;
+  Ft = 1;
+  const t = et();
+  return Ve = (r, s, i) => t(r, s, ">", i), Ve;
+}
+var ke, Vt;
+function Hr() {
+  if (Vt) return ke;
+  Vt = 1;
+  const t = et();
+  return ke = (r, s, i) => t(r, s, "<", i), ke;
+}
+var Xe, kt;
+function Wr() {
+  if (kt) return Xe;
+  kt = 1;
+  const t = j();
+  return Xe = (r, s, i) => (r = new t(r, i), s = new t(s, i), r.intersects(s, i)), Xe;
+}
+var Me, Xt;
+function Yr() {
+  if (Xt) return Me;
+  Xt = 1;
+  const t = Z(), n = U();
+  return Me = (r, s, i) => {
+    const u = [];
+    let l = null, h = null;
+    const o = r.sort((f, d) => n(f, d, i));
+    for (const f of o)
+      t(f, s, i) ? (h = f, l || (l = f)) : (h && u.push([l, h]), h = null, l = null);
+    l && u.push([l, null]);
+    const a = [];
+    for (const [f, d] of u)
+      f === d ? a.push(f) : !d && f === o[0] ? a.push("*") : d ? f === o[0] ? a.push(`<=${d}`) : a.push(`${f} - ${d}`) : a.push(`>=${f}`);
+    const e = a.join(" || "), c = typeof s.raw == "string" ? s.raw : String(s);
+    return e.length < c.length ? e : s;
+  }, Me;
+}
+var Be, Mt;
+function zr() {
+  if (Mt) return Be;
+  Mt = 1;
+  const t = j(), n = K(), { ANY: r } = n, s = Z(), i = U(), u = (c, f, d = {}) => {
+    if (c === f)
+      return !0;
+    c = new t(c, d), f = new t(f, d);
+    let O = !1;
+    e: for (const E of c.set) {
+      for (const N of f.set) {
+        const A = o(E, N, d);
+        if (O = O || A !== null, A)
+          continue e;
+      }
+      if (O)
+        return !1;
+    }
+    return !0;
+  }, l = [new n(">=0.0.0-0")], h = [new n(">=0.0.0")], o = (c, f, d) => {
+    if (c === f)
+      return !0;
+    if (c.length === 1 && c[0].semver === r) {
+      if (f.length === 1 && f[0].semver === r)
+        return !0;
+      d.includePrerelease ? c = l : c = h;
+    }
+    if (f.length === 1 && f[0].semver === r) {
+      if (d.includePrerelease)
+        return !0;
+      f = h;
+    }
+    const O = /* @__PURE__ */ new Set();
+    let E, N;
+    for (const L of c)
+      L.operator === ">" || L.operator === ">=" ? E = a(E, L, d) : L.operator === "<" || L.operator === "<=" ? N = e(N, L, d) : O.add(L.semver);
+    if (O.size > 1)
+      return null;
+    let A;
+    if (E && N) {
+      if (A = i(E.semver, N.semver, d), A > 0)
+        return null;
+      if (A === 0 && (E.operator !== ">=" || N.operator !== "<="))
+        return null;
+    }
+    for (const L of O) {
+      if (E && !s(L, String(E), d) || N && !s(L, String(N), d))
+        return null;
+      for (const k of f)
+        if (!s(L, String(k), d))
+          return !1;
+      return !0;
+    }
+    let G, w, x, _, C = N && !d.includePrerelease && N.semver.prerelease.length ? N.semver : !1, P = E && !d.includePrerelease && E.semver.prerelease.length ? E.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 === "<=", E) {
+        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(E, L, d), G === L && G !== E)
+            return !1;
+        } else if (E.operator === ">=" && !s(E.semver, String(L), d))
+          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, d), w === L && w !== N)
+            return !1;
+        } else if (N.operator === "<=" && !s(N.semver, String(L), d))
+          return !1;
+      }
+      if (!L.operator && (N || E) && A !== 0)
+        return !1;
+    }
+    return !(E && x && !N && A !== 0 || N && _ && !E && A !== 0 || P || C);
+  }, a = (c, f, d) => {
+    if (!c)
+      return f;
+    const O = i(c.semver, f.semver, d);
+    return O > 0 ? c : O < 0 || f.operator === ">" && c.operator === ">=" ? f : c;
+  }, e = (c, f, d) => {
+    if (!c)
+      return f;
+    const O = i(c.semver, f.semver, d);
+    return O < 0 ? c : O > 0 || f.operator === "<" && c.operator === "<=" ? f : c;
+  };
+  return Be = u, Be;
+}
+var He, Bt;
+function Jr() {
+  if (Bt) return He;
+  Bt = 1;
+  const t = B(), n = Y(), r = b(), s = sr(), i = V(), u = Sr(), l = Ar(), h = wr(), o = yr(), a = Cr(), e = qr(), c = Pr(), f = Gr(), d = U(), O = xr(), E = Dr(), N = Je(), A = br(), G = _r(), w = J(), x = Ke(), _ = nr(), C = ir(), P = Ze(), L = Qe(), k = ar(), Q = Ur(), ee = K(), te = j(), re = Z(), m = Fr(), p = Vr(), I = kr(), R = Xr(), $ = Mr(), v = et(), g = Br(), S = Hr(), T = Wr(), y = Yr(), D = zr();
+  return He = {
+    parse: i,
+    valid: u,
+    clean: l,
+    inc: h,
+    diff: o,
+    major: a,
+    minor: e,
+    patch: c,
+    prerelease: f,
+    compare: d,
+    rcompare: O,
+    compareLoose: E,
+    compareBuild: N,
+    sort: A,
+    rsort: G,
+    gt: w,
+    lt: x,
+    eq: _,
+    neq: C,
+    gte: P,
+    lte: L,
+    cmp: k,
+    coerce: Q,
+    Comparator: ee,
+    Range: te,
+    satisfies: re,
+    toComparators: m,
+    maxSatisfying: p,
+    minSatisfying: I,
+    minVersion: R,
+    validRange: $,
+    outside: v,
+    gtr: g,
+    ltr: S,
+    intersects: T,
+    simplifyRange: y,
+    subset: D,
+    SemVer: r,
+    re: t.re,
+    src: t.src,
+    tokens: t.t,
+    SEMVER_SPEC_VERSION: n.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: n.RELEASE_TYPES,
+    compareIdentifiers: s.compareIdentifiers,
+    rcompareIdentifiers: s.rcompareIdentifiers
+  }, He;
+}
+var Kr = Jr();
+const Ht = `^${M.Version}`;
+class ts {
+  config = new lr(Wt);
+  event = new cr();
   state;
   active;
   time;
+  offset;
   info;
   constructor() {
     this.state = {
@@ -40,99 +1215,161 @@ class v {
     }, this.time = {
       start: 0,
       seek: 0
-    }, this.info = new r();
+    }, this.offset = {
+      temp: 0,
+      meta: 0
+    }, this.info = new M.Info(), this.config.event.add("update", this.onConfigUpdate);
   }
+  onConfigUpdate = (n) => {
+    const r = n.has("offset.useMeta");
+    r && this.handleRefreshOffset(), (r || n.has("offset.global")) && this.handleSyncTime();
+  };
+  // Get current playback time.
   handleGetCurrentTime() {
     return this.state.playing ? this.time.seek + (performance.now() - this.time.start) : this.time.seek;
   }
-  handleGetLineTime(e) {
-    if (e < 0 || e >= this.info.lines.length)
+  // Real playback time shifted by the combined offset; all lyric matching runs against this.
+  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 === M.MetaType.Offset)?.content, s = typeof r == "number" && Number.isFinite(r) ? r : 0;
+      this.offset.meta = s;
+    } else
+      this.offset.meta = 0;
+  }
+  handleGetLineTime(n) {
+    if (n < 0 || n >= this.info.lines.length)
       return 0;
-    if (e === this.info.lines.length - 1)
+    if (n === this.info.lines.length - 1)
       return 1 / 0;
-    const s = this.info.lines[e], n = this.info.lines[e + 1];
-    return Math.max(s.time.end, n.time.start);
+    const r = this.info.lines[n], s = this.info.lines[n + 1];
+    return Math.max(r.time.end, s.time.start);
   }
   handleGetActiveIndex() {
     return this.active.index.length > 0 ? this.active.index[0] : -1;
   }
-  handleSyncTime(e) {
-    const s = [], n = [];
+  handleBridgeActive(n, r) {
+    if (!this.config.current.bridgeActive || r.length < 2)
+      return { lines: n, index: r };
+    const s = r[0], i = r[r.length - 1];
+    if (i - s + 1 === r.length)
+      return { lines: n, index: r };
+    const u = /* @__PURE__ */ new Map();
+    for (let o = 0; o < r.length; o++)
+      u.set(r[o], n[o]);
+    const l = [], h = [];
+    for (let o = s; o <= i; o++) {
+      const a = u.get(o) ?? this.info.lines[o];
+      a && (l.push(a), h.push(o));
+    }
+    return { lines: l, index: h };
+  }
+  handleEmitLinesUpdate(n) {
+    const r = this.handleBridgeActive(this.active.lines, this.active.index);
+    this.event.emit("linesUpdate", r.lines, r.index, this.handleGetActiveIndex(), n);
+  }
+  handleSyncTime(n) {
+    if (!this.info.lines.length || (n === void 0 && (n = this.handleGetEffectiveTime()), !Number.isFinite(n)))
+      return;
+    const r = [], s = [];
     let i = this.info.lines.length;
-    for (let t = 0; t < this.info.lines.length; t++) {
-      const a = this.info.lines[t];
-      if (a.time.start > e) {
-        i = t;
+    for (let u = 0; u < this.info.lines.length; u++) {
+      const l = this.info.lines[u];
+      if (l.time.start > n) {
+        i = u;
         break;
       }
-      this.handleGetLineTime(t) > e && (s.push(a), n.push(t));
+      this.handleGetLineTime(u) > n && (r.push(l), s.push(u));
     }
-    this.state.scanIndex = i, this.active.lines = s, this.active.index = n, this.event.emit("linesUpdate", [...this.active.lines], [...this.active.index], this.handleGetActiveIndex(), !0);
+    this.state.scanIndex = i, this.active.lines = r, this.active.index = s, this.handleEmitLinesUpdate(!0);
   }
-  handleUpdateActiveLines(e) {
-    let s = !1;
-    const n = [], i = [];
-    for (let t = 0; t < this.active.lines.length; t++) {
-      const a = this.active.lines[t], h = this.active.index[t];
-      e >= this.handleGetLineTime(h) ? s = !0 : (n.push(a), i.push(h));
+  handleUpdateActiveLines(n) {
+    let r = !1;
+    const s = [], i = [];
+    for (let u = 0; u < this.active.lines.length; u++) {
+      const l = this.active.lines[u], h = this.active.index[u];
+      n >= this.handleGetLineTime(h) ? r = !0 : (s.push(l), i.push(h));
     }
     for (; this.state.scanIndex < this.info.lines.length; ) {
-      const t = this.info.lines[this.state.scanIndex];
-      if (e >= t.time.start)
-        e < this.handleGetLineTime(this.state.scanIndex) && (n.push(t), i.push(this.state.scanIndex), s = !0), this.state.scanIndex++;
+      const u = this.info.lines[this.state.scanIndex];
+      if (n >= u.time.start)
+        n < this.handleGetLineTime(this.state.scanIndex) && (s.push(u), i.push(this.state.scanIndex), r = !0), this.state.scanIndex++;
       else
         break;
     }
-    s && (this.active.lines = n, this.active.index = i, this.event.emit("linesUpdate", [...this.active.lines], [...this.active.index], this.handleGetActiveIndex(), !1));
+    r && (this.active.lines = s, this.active.index = i, this.handleEmitLinesUpdate(!1));
   }
   onTick = () => {
     if (!this.state.playing)
       return;
-    const e = this.handleGetCurrentTime();
-    switch (this.handleUpdateActiveLines(e), this.config.current.driver) {
+    const n = this.handleGetEffectiveTime();
+    switch (this.handleUpdateActiveLines(n), this.config.current.driver) {
       case "animation":
-        this.state.frameId = window.requestAnimationFrame(this.onTick);
+        this.state.frameId = globalThis.requestAnimationFrame(this.onTick);
         break;
       case "timer":
-        this.state.timerId = window.setTimeout(this.onTick, 16);
+        this.state.timerId = globalThis.setTimeout(this.onTick, 16);
         break;
     }
   };
-  updateLyric(e) {
-    e && (this.pause(), this.info = e, this.active.lines = [], this.active.index = [], this.state.scanIndex = 0, this.time.seek = 0, this.event.emit("lyricUpdate", e), this.event.emit("linesUpdate", [], [], -1, !1));
+  updateLyric(n) {
+    if (!n)
+      return;
+    let r = n;
+    Kr.satisfies(n.version, Ht) || (console.warn(`[music-lyric-player] ignored lyric with incompatible version "${n.version}", expected "${Ht}"`), r = new M.Info()), this.pause(), this.info = r, 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);
   }
   /**
    * 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(e) {
-    this.pause(), typeof e == "number" && !Number.isNaN(e) && (this.time.seek = e, this.handleSyncTime(e)), this.time.start = performance.now(), this.state.playing = !0, this.onTick(), this.event.emit("play", this.handleGetCurrentTime());
+  play(n) {
+    this.pause(), typeof n == "number" && Number.isFinite(n) && (this.time.seek = n, 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.state.frameId !== null && (cancelAnimationFrame(this.state.frameId), this.state.frameId = null), this.state.timerId !== null && (clearTimeout(this.state.timerId), this.state.timerId = null), this.event.emit("pause", this.handleGetCurrentTime());
+    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);
   }
   /**
    * Stop playback
    */
   dispose() {
-    this.pause(), this.event.clear(), this.active.lines = [], this.active.index = [], this.info = new r();
+    this.pause(), this.event.clear(), this.config.event.remove("update", this.onConfigUpdate), this.active.lines = [], this.active.index = [], this.info = new M.Info();
+  }
+  /**
+   * Update the temp offset in ms (the user's temporary adjustment).
+   * Stacked on top of the global config offset and the lyric's meta offset, then resyncs immediately.
+   * @param value temp offset in ms; non-finite values are treated as 0.
+   */
+  updateTempOffset(n) {
+    this.offset.temp = Number.isFinite(n) ? n : 0, 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(e) {
-    const s = [], n = [];
-    for (let i = 0; i < this.info.lines.length; i++) {
-      const t = this.info.lines[i];
-      if (t.time.start > e)
+  matchLinesWithTime(n) {
+    const r = n + this.currentOffset, s = [], i = [];
+    for (let u = 0; u < this.info.lines.length; u++) {
+      const l = this.info.lines[u];
+      if (l.time.start > r)
         break;
-      this.handleGetLineTime(i) > e && (s.push(t), n.push(i));
+      this.handleGetLineTime(u) > r && (s.push(l), i.push(u));
     }
-    return { lines: s, index: n };
+    return this.handleBridgeActive(s, 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(n) {
+    return n - this.currentOffset;
   }
   /**
    * Whether the player is currently playing.
@@ -144,13 +1381,13 @@ class v {
    * Current active lines.
    */
   get currentLines() {
-    return [...this.active.lines];
+    return this.handleBridgeActive(this.active.lines, this.active.index).lines;
   }
   /**
    * Indices of currently active lines.
    */
   get currentIndex() {
-    return [...this.active.index];
+    return this.handleBridgeActive(this.active.lines, this.active.index).index;
   }
   /**
    * The index of the primary active line, or -1 if none.
@@ -170,8 +1407,16 @@ class v {
   get currentTime() {
     return this.handleGetCurrentTime();
   }
+  /**
+   * The current effective lyric offset in ms (config offset + lyric meta offset + temp offset).
+   */
+  get currentOffset() {
+    const n = this.config.current.offset.global + this.offset.meta + this.offset.temp;
+    return Number.isFinite(n) ? n : 0;
+  }
 }
 export {
-  v as BaseLyricPlayer
+  ts as BaseLyricPlayer,
+  es as BaseLyricPlayerConfig
 };
 //# sourceMappingURL=index.ecma.js.map