@overlayed/app 0.2.1

package/dist/index.js

@@ -0,0 +1,1388 @@
+var Fe = Object.defineProperty;
+var xe = (r, t, e) => t in r ? Fe(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var l = (r, t, e) => xe(r, typeof t != "symbol" ? t + "" : t, e);
+import p, { resolve as Ke } from "node:path";
+import { PipeEventServer as Le, ProcessMonitor as Oe, Process as L }from "./native-interface/main.js";
+import { type as D } from "arktype";
+import w, { existsSync as $e, mkdirSync as He, readFileSync as ye, writeFileSync as Ne, copyFileSync as je } from "node:fs";
+import b from "node:fs/promises";
+import me from "jszip";
+import { RenderInterface as Ue }from "./render-interface/main.js";
+import { createHash as Be } from "node:crypto";
+var Ge = Object.defineProperty, Ve = (r, t, e) => t in r ? Ge(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, R = (r, t, e) => Ve(r, typeof t != "symbol" ? t + "" : t, e);
+function ze(r) {
+  return { all: r = r || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var n = r.get(t);
+    n ? n.push(e) : r.set(t, [e]);
+  }, off: function(t, e) {
+    var n = r.get(t);
+    n && (e ? n.splice(n.indexOf(e) >>> 0, 1) : r.set(t, []));
+  }, emit: function(t, e) {
+    var n = r.get(t);
+    n && n.slice().map(function(s) {
+      s(e);
+    }), (n = r.get("*")) && n.slice().map(function(s) {
+      s(t, e);
+    });
+  } };
+}
+let We = class {
+  constructor() {
+    R(this, "emitter"), this.emitter = ze();
+  }
+  on(t, e) {
+    this.emitter.on(t, e);
+  }
+  off(t, e) {
+    this.emitter.off(t, e);
+  }
+  emit(t, e) {
+    this.emitter.emit(t, e);
+  }
+  removeAllListeners() {
+    this.emitter.off("*", () => {
+    });
+  }
+};
+function qe(r, ...t) {
+  var e;
+  return e = class extends r {
+    /**
+     * Lazy get the static instance
+     */
+    static getInstance() {
+      return this._instance || (this._instance = new r(...t)), this._instance;
+    }
+    /**
+     * Release the instance (most of the time you won't need this)
+     */
+    static clearInstance() {
+      this._instance = void 0;
+    }
+  }, R(e, "_instance"), e;
+}
+const Xe = p.join(process.env.APPDATA ?? "", "overlayed");
+p.join(Xe, "logs");
+let Je = class extends We {
+  constructor(t) {
+    super(), R(this, "server", null), R(this, "_hasConnection", !1), R(this, "pipeId"), this.pipeId = t, this.init();
+  }
+  get hasConnection() {
+    return this._hasConnection;
+  }
+  destroy() {
+    var t;
+    this.server && (this._hasConnection = !1, (t = this.server) == null || t.removeAllListeners(), this.server = null);
+  }
+  init() {
+    this.server = new Le(this.pipeId, { clientCount: 1, access: 1 }), this.server.on("event", (t) => {
+      try {
+        const e = JSON.parse(t);
+        this.emit("data", e);
+      } catch (e) {
+        this.emit("error", e);
+      }
+    }), this.server.on("connected", () => {
+      this._hasConnection = !0;
+    }), this.server.on("disconnected", () => {
+      this._hasConnection = !1;
+    });
+  }
+};
+const Qe = qe(Je, "overlayed"), Ye = D({
+  game: "string",
+  type: "string",
+  creation_time: "number"
+});
+function Ze(r) {
+  return { all: r = r || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var n = r.get(t);
+    n ? n.push(e) : r.set(t, [e]);
+  }, off: function(t, e) {
+    var n = r.get(t);
+    n && (e ? n.splice(n.indexOf(e) >>> 0, 1) : r.set(t, []));
+  }, emit: function(t, e) {
+    var n = r.get(t);
+    n && n.slice().map(function(s) {
+      s(e);
+    }), (n = r.get("*")) && n.slice().map(function(s) {
+      s(t, e);
+    });
+  } };
+}
+class et {
+  constructor() {
+    l(this, "emitter");
+    this.emitter = Ze();
+  }
+  on(t, e) {
+    this.emitter.on(t, e);
+  }
+  off(t, e) {
+    this.emitter.off(t, e);
+  }
+  emit(t, e) {
+    this.emitter.emit(t, e);
+  }
+  removeAllListeners() {
+    this.emitter.off("*", () => {
+    });
+  }
+}
+function k(r, ...t) {
+  var n;
+  return n = class extends r {
+    /**
+     * Lazy get the static instance
+     */
+    static getInstance() {
+      return this._instance || (this._instance = new r(...t)), this._instance;
+    }
+    /**
+     * Release the instance (most of the time you won't need this)
+     */
+    static clearInstance() {
+      this._instance = void 0;
+    }
+  }, l(n, "_instance"), n;
+}
+function tt(r) {
+  try {
+    return [JSON.parse(r), null];
+  } catch (t) {
+    return [null, t];
+  }
+}
+function X(r, t) {
+  const e = {};
+  for (const n in t)
+    n in r ? typeof r[n] == "object" && r[n] !== null && typeof t[n] == "object" && t[n] !== null ? e[n] = X(r[n], t[n]) : e[n] = r[n] : e[n] = t[n];
+  for (const n in r)
+    n in e || (e[n] = r[n]);
+  return e;
+}
+class rt {
+  constructor(t) {
+    l(this, "options");
+    l(this, "_data");
+    this.options = t, this._data = this.load();
+  }
+  get data() {
+    return this._data;
+  }
+  set data(t) {
+    this._data = t, this.saveCurrentData();
+  }
+  onBeforeSave(t) {
+    return t;
+  }
+  onAfterLoad(t) {
+    return t;
+  }
+  saveCurrentData() {
+    try {
+      const t = this.onBeforeSave(this._data);
+      w.writeFileSync(this.options.path, JSON.stringify(t, null, 2));
+    } catch {
+    }
+  }
+  load() {
+    if (!this.fileExists(this.options.path))
+      return this.setupDefaultData();
+    if (!this.canReadWriteFile(this.options.path))
+      return this.setupDefaultData(!0);
+    const t = w.readFileSync(this.options.path, "utf8"), [e, n] = tt(t);
+    return n ? this.setupDefaultData(!0) : this.onAfterLoad(e);
+  }
+  canReadWriteFile(t) {
+    try {
+      return w.accessSync(t, w.constants.R_OK | w.constants.W_OK), !0;
+    } catch {
+      return !1;
+    }
+  }
+  fileExists(t) {
+    try {
+      return w.accessSync(t, w.constants.F_OK), !0;
+    } catch {
+      return !1;
+    }
+  }
+  setupDefaultData(t = !1) {
+    return this._data = this.options.default, t || this.saveCurrentData(), this.data;
+  }
+}
+class nt extends rt {
+  constructor(e) {
+    super(e);
+    l(this, "options");
+    this.options = e;
+  }
+  get data() {
+    const e = this.options.schema["~standard"].validate(super.data);
+    if (e instanceof Promise)
+      throw new Error("StructuredConfigFile does not support async validation");
+    return e.issues ? this.options.default : e.value;
+  }
+  set data(e) {
+    const n = this.options.schema["~standard"].validate(e);
+    if (n instanceof Promise)
+      throw new Error("StructuredConfigFile does not support async validation");
+    n.issues || (super.data = n.value);
+  }
+  onAfterLoad(e) {
+    const n = this.options.schema["~standard"].validate(e);
+    if (n instanceof Promise)
+      throw new Error("StructuredConfigFile does not support async validation");
+    return n.issues ? X(e, this.options.default) : X(n.value, this.options.default);
+  }
+}
+const ve = {
+  scope: (r) => ({
+    log: (...t) => {
+      console.log(r, ...t);
+    },
+    error: (...t) => {
+      console.error(r, ...t);
+    },
+    warn: (...t) => {
+      console.warn(r, ...t);
+    },
+    info: (...t) => {
+      console.info(r, ...t);
+    },
+    debug: (...t) => {
+      console.debug(r, ...t);
+    },
+    captureSentryException: (...t) => {
+      console.error(r, ...t);
+    },
+    sentryError: (...t) => {
+      console.error(r, ...t);
+    },
+    sentryLog: (...t) => {
+      console.log(r, ...t);
+    },
+    sentryWarn: (...t) => {
+      console.warn(r, ...t);
+    }
+  }),
+  error: (...r) => {
+    console.error(name, ...r);
+  },
+  warn: (...r) => {
+    console.warn(name, ...r);
+  },
+  info: (...r) => {
+    console.info(name, ...r);
+  },
+  debug: (...r) => {
+    console.debug(name, ...r);
+  },
+  captureSentryException: (...r) => {
+    console.error(name, ...r);
+  },
+  sentryError: (...r) => {
+    console.error(name, ...r);
+  },
+  sentryLog: (...r) => {
+    console.log(name, ...r);
+  },
+  sentryWarn: (...r) => {
+    console.warn(name, ...r);
+  },
+  sentryInfo: (...r) => {
+    console.info(name, ...r);
+  }
+}, F = p.join(process.env.APPDATA ?? "", "overlayed");
+p.join(F, "logs");
+class st {
+  constructor(t) {
+    l(this, "logger");
+    l(this, "initialized", !1);
+    this.logger = ve.scope(t);
+  }
+  init() {
+    this.logger.log("Initializing"), this.initialized = !0;
+  }
+  destroy() {
+    this.logger.log("Destroying"), this.initialized = !1;
+  }
+}
+class C extends et {
+  constructor(e) {
+    super();
+    l(this, "logger");
+    l(this, "initialized", !1);
+    this.logger = ve.scope(e);
+  }
+  init() {
+    this.logger.log("Initializing"), this.initialized = !0;
+  }
+  destroy() {
+    this.logger.log("Destroying"), this.initialized = !1, this.removeAllListeners();
+  }
+}
+class it extends C {
+  constructor() {
+    super("ErrorManager");
+  }
+  error(t, e, n) {
+    this.emit("error", {
+      code: e,
+      message: t,
+      data: n,
+      timestamp: Date.now()
+    });
+  }
+  warn(t, e, n) {
+    this.emit("warning", {
+      code: e,
+      message: t,
+      data: n,
+      timestamp: Date.now()
+    });
+  }
+}
+const be = k(it), ot = {
+  buildChannel: "dev"
+};
+function at() {
+  return p.normalize(F);
+}
+var I = "object", Ee = "function", we = "prototype", q = "text", re = "json", le = "abort", J = "paramsSerializer", ue = "addEventListener", O = "status", v = "headers", W = Object, _ = void 0, N = null, Q = W[we], j = W.keys, M = Array.isArray, he = "method", _e = "HEAD", Y = "GET", ke = "OPTIONS", ct = "POST", lt = "PUT", ut = "PATCH", ht = "DELETE";
+function dt(r, t) {
+  let e = new AbortController();
+  function n(a) {
+    e.abort(a), i();
+  }
+  let s = [];
+  for (let a of r) {
+    if ((a == null ? void 0 : a.aborted) === !0) {
+      n(a.reason);
+      break;
+    }
+    if (a != null && a[ue]) {
+      let c = () => {
+        n(a.reason);
+      };
+      s.push(() => {
+        var d;
+        (d = a.removeEventListener) == null || d.call(a, le, c);
+      }), a[ue](le, c);
+    }
+  }
+  function i() {
+    s.forEach((a) => a()), t == null || t();
+  }
+  let o = e.signal;
+  return o.clear = i, o;
+}
+var de = W.getPrototypeOf, ge = (r) => {
+  if (r !== N && typeof r === I) {
+    if (typeof de === Ee) {
+      let t = de(r);
+      return t === Q || t === N;
+    }
+    return Q.toString.call(r) === `[${I} Object]`;
+  }
+  return !1;
+}, ne = (...r) => r.reduce((t, e) => {
+  if (M(e)) throw new TypeError(`Arguments must be ${I}s, not arrays.`);
+  return j(e).forEach((n) => {
+    ["__proto__", "constructor", we].includes(n) || (M(t[n]) && M(e[n]) ? t[n] = Array.from(new Set(t[n].concat(e[n]))) : ge(t[n]) && ge(e[n]) ? t[n] = ne(t[n], e[n]) : t[n] = e[n]);
+  }), t;
+}, {});
+function se(r, t = !0, e = N, n) {
+  if (r === _ || r === N) return "";
+  let s = [], i = t ? encodeURIComponent : (g) => g, o = M(r), { arrayFormat: a, allowDots: c, serializeDate: d } = n || {}, h = (g) => {
+    if (c && !o) return `.${g}`;
+    if (o) {
+      if (a === "brackets") return "[]";
+      if (a === "repeat") return "";
+    }
+    return `[${g}]`;
+  };
+  for (let g in r) if (Q.hasOwnProperty.call(r, g)) {
+    let u = r[g];
+    if (u !== _) {
+      let y = e ? `${e}${h(g)}` : i(g);
+      if (!isNaN(u) && u instanceof Date && (u = d ? d(u) : u.toISOString()), typeof u === I) {
+        let f = se(u, t, y, n);
+        f !== "" && s.push(f);
+      } else s.push(`${i(y)}=${i(u)}`);
+    }
+  }
+  return s.join("&");
+}
+function Z(r) {
+  return M(r) ? r.map(Z) : (r && typeof r === I && j(r).forEach((t) => {
+    let e = r[t];
+    e === _ ? delete r[t] : Z(e);
+  }), r);
+}
+function gt(r) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
+}
+function ft(r, t) {
+  return r ? t ? (r.endsWith("/") ? r : r + "/") + (t[0] === "/" ? t.slice(1) : t) : r : t || "";
+}
+var pt = "XiorError", yt = "XiorTimeoutError", Pe = class extends Error {
+  constructor(r, t, e) {
+    super(r), this.name = pt, this.request = t, this.config = t, this.response = e;
+  }
+}, mt = class extends Pe {
+  constructor(t, e, n) {
+    super(t, e, n), this.name = yt;
+  }
+}, vt = Object.defineProperty, bt = Object.defineProperties, Et = Object.getOwnPropertyDescriptors, U = Object.getOwnPropertySymbols, Ie = Object.prototype.hasOwnProperty, Ce = Object.prototype.propertyIsEnumerable, fe = (r, t, e) => t in r ? vt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, A = (r, t) => {
+  for (var e in t || (t = {})) Ie.call(t, e) && fe(r, e, t[e]);
+  if (U) for (var e of U(t)) Ce.call(t, e) && fe(r, e, t[e]);
+  return r;
+}, $ = (r, t) => bt(r, Et(t)), wt = (r, t) => {
+  var e = {};
+  for (var n in r) Ie.call(r, n) && t.indexOf(n) < 0 && (e[n] = r[n]);
+  if (r != null && U) for (var n of U(r)) t.indexOf(n) < 0 && Ce.call(r, n) && (e[n] = r[n]);
+  return e;
+}, T = (r, t, e) => new Promise((n, s) => {
+  var i = (c) => {
+    try {
+      a(e.next(c));
+    } catch (d) {
+      s(d);
+    }
+  }, o = (c) => {
+    try {
+      a(e.throw(c));
+    } catch (d) {
+      s(d);
+    }
+  }, a = (c) => c.done ? n(c.value) : Promise.resolve(c.value).then(i, o);
+  a((e = e.apply(r, t)).next());
+}), ie = "application/", Se = `${ie}x-www-form-urlencoded`, Re = RegExp, _t = new Re(`^${Se}`, "i"), kt = `${ie}${re}`, Pt = new Re(`^${ie}.*${re}.*`, "i");
+function It(r = Y) {
+  return [_e, Y, ke].includes(r);
+}
+var Ct = typeof URLSearchParams != `${_}`;
+function St(r) {
+  return T(this, null, function* () {
+    let t = r[J] || se, e = r.encodeURI !== !1, n = r[he] && r[he].toUpperCase(), s = r.url, i = s, o = Ct && r.data instanceof URLSearchParams, a = o ? W.fromEntries(r.data.entries()) : r.data, c = a, d = r != null && r[v] ? A({}, r[v]) : {}, h = r.params, g = It(n);
+    if (a && typeof a.append !== Ee) {
+      let u = "", y = "content-type";
+      if (r != null && r[v]) {
+        let f = j(r[v]).find((E) => E.toLowerCase() === y);
+        f && (y = f, u = r[v][f]);
+      }
+      (!u || o) && (u = g || o ? Se : kt, d[y] = u), typeof a === I && (g && h && (h = ne(a, h)), Pt.test(u) ? c = JSON.stringify(Z(a)) : !g && _t.test(u) && (c = t(a)));
+    }
+    if (h && j(h).length > 0) {
+      let u = t(h, e);
+      s += s.includes("?") ? `&${u}` : `?${u}`;
+    }
+    return $(A({}, r), { _data: c, _url: s, data: a, url: i, method: n, [v]: d, isGet: g });
+  });
+}
+var Rt = typeof AbortController != `${_}`;
+function Mt(r, t) {
+  return T(this, null, function* () {
+    let e;
+    if (!t || !r.ok || [q, re].includes(t)) {
+      if (e = yield r[q](), e && t !== q) try {
+        e = JSON.parse(e);
+      } catch {
+      }
+    } else {
+      if (t === "blob") return r.blob();
+      if (t === "arraybuffer") return r.arrayBuffer();
+    }
+    return e;
+  });
+}
+var At = (r) => new P(r), P = class {
+  constructor(t) {
+    this.REQI = [], this.RESI = [], this.P = [], this.config = t, this.defaults = { params: {}, [v]: {} };
+  }
+  get interceptors() {
+    return { request: { use: (t, e, n) => (this.REQI.push(t), t), eject: (t) => {
+      this.REQI = this.REQI.filter((e) => e !== t);
+    }, clear: () => {
+      this.REQI = [];
+    } }, response: { use: (t, e) => (this.RESI.push({ fn: t, onRejected: e }), t), eject: (t) => {
+      this.RESI = this.RESI.filter((e) => e.fn !== t);
+    }, clear: () => {
+      this.RESI = [];
+    } } };
+  }
+  get plugins() {
+    return { use: (t) => (this.P.push(t), t), eject: (t) => {
+      this.P = this.P.filter((e) => e !== t);
+    }, clear: () => {
+      this.P = [];
+    } };
+  }
+  request(t) {
+    return T(this, null, function* () {
+      let e = ne(this.config || {}, this.defaults, typeof t == "string" ? { url: t } : t), n = "credentials";
+      e.withCredentials && !e[n] && (e[n] = "include"), e[J] || (e[J] = se);
+      for (let o of this.REQI) e = yield o(e);
+      let s = this._.bind(this);
+      this.P.forEach((o) => {
+        s = o(s, this);
+      });
+      let i = s(e);
+      if (!e._did) {
+        let o = 0, a = [];
+        for (this.RESI.forEach(function(c) {
+          a.push(c.fn, c.onRejected);
+        }); a.length > o; ) i = i.then(a[o++], a[o++]);
+      }
+      return i;
+    });
+  }
+  _(t) {
+    return T(this, null, function* () {
+      let e = yield St(t), { url: n, method: s, headers: i, timeout: o, signal: a, data: c, _data: d, _url: h, isGet: g, fetch: u } = e, y = wt(e, ["url", "method", "headers", "timeout", "signal", "data", "_data", "_url", "isGet", "fetch"]);
+      t._url = h;
+      let f, E = [], x = _;
+      if (o && Rt) {
+        let m = new AbortController();
+        x = setTimeout(() => {
+          m.abort(new mt(`timeout of ${o}ms exceeded`, t));
+        }, o), E.push(m.signal);
+      }
+      a && E.push(a), f = E[0], E.length > 1 && (f = dt(E, () => {
+        clearTimeout(x);
+      }));
+      let K = h || n, ae = "baseURL";
+      return t[ae] && !gt(K) && (K = ft(t[ae], K)), (u || fetch)(K, $(A({ body: g ? _ : d }, y), { signal: f, method: s, headers: i })).then((m) => T(this, null, function* () {
+        let { responseType: Te } = t, ce = { data: yield Mt(m, Te), response: m, config: t, request: t, [O]: m[O], statusText: m.statusText, [v]: m[v] };
+        if (!m.ok) {
+          let De = new Pe(m[O] ? `Request failed with status code ${m[O]}` : "Network error", t, ce);
+          return Promise.reject(De);
+        }
+        return ce;
+      })).finally(() => {
+        var m;
+        x && clearTimeout(x), (m = f == null ? void 0 : f.clear) == null || m.call(f);
+      });
+    });
+  }
+  cG(t) {
+    return (e, n) => this.request(n ? $(A({}, n), { method: t, url: e }) : { method: t, url: e });
+  }
+  cP(t) {
+    return (e, n, s) => this.request(s ? $(A({}, s), { method: t, url: e, data: n }) : { method: t, url: e, data: n });
+  }
+  get(t, e) {
+    return this.cG(Y)(t, e);
+  }
+  head(t, e) {
+    return this.cG(_e)(t, e);
+  }
+  post(t, e, n) {
+    return this.cP(ct)(t, e, n);
+  }
+  put(t, e, n) {
+    return this.cP(lt)(t, e, n);
+  }
+  patch(t, e, n) {
+    return this.cP(ut)(t, e, n);
+  }
+  delete(t, e) {
+    return this.cG(ht)(t, e);
+  }
+  options(t, e) {
+    return this.cG(ke)(t, e);
+  }
+};
+P.create = At, P.VERSION = "0.7.7";
+var Tt = Object.assign(P.create(), { create: P.create, VERSION: P.VERSION }), Me = Tt;
+const Ae = Me.create({
+  baseURL: "https://updater.overlayed.gg",
+  headers: {
+    Accept: "application/json",
+    "Accept-Encoding": "gzip, deflate, br"
+  }
+}), oe = Me.create({
+  baseURL: "https://api.overlayed.gg",
+  headers: {
+    Accept: "application/json",
+    "Accept-Encoding": "gzip, deflate, br"
+  }
+});
+function Dt(r, t) {
+  return Ae.get(`/v1/native/${r}/version.txt`, {
+    params: { channel: t },
+    responseType: "text"
+  });
+}
+function Ft(r, t) {
+  return Ae.get(`/v1/native/${r}/files`, {
+    params: { channel: t },
+    responseType: "arraybuffer"
+  });
+}
+function xt() {
+  return oe.get("/v1/raven/config");
+}
+function Kt(r, t) {
+  return oe.get(`/v1/raven/games/${r}/builds/${t}/check`);
+}
+function Lt(r, t) {
+  const e = new FormData();
+  return e.append("file", t), oe.post(`/v1/raven/games/${r}/builds/upload`, e, {});
+}
+function Ot(r) {
+  return r instanceof Error && (r.name === "XiorError" || r.name === "XiorTimeoutError");
+}
+function $t(r) {
+  return !!(r && "kind" in r.data && "message" in r.data);
+}
+class Ht extends C {
+  constructor() {
+    super("NativeDllManager");
+    l(this, "UPDATE_CHECK_INTERVAL_MS", 1e3 * 60 * 5);
+    // 5 minutes
+    l(this, "targetDir");
+    l(this, "updateInterval");
+    this.targetDir = p.join(F, "resources"), this.logger.log("Target directory", this.targetDir);
+  }
+  async initWithDlls(e) {
+    super.init(), await b.mkdir(this.targetDir, { recursive: !0 }), await this.checkForUpdates(e), clearInterval(this.updateInterval), this.updateInterval = setInterval(() => this.checkForUpdates(e), this.UPDATE_CHECK_INTERVAL_MS);
+  }
+  destroy() {
+    this.updateInterval && (clearInterval(this.updateInterval), this.updateInterval = void 0), super.destroy();
+  }
+  async getCurrentVersion(e) {
+    try {
+      const n = p.join(this.targetDir, e, "version.txt");
+      return await b.readFile(n, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  getTargetPath(e) {
+    return p.join(this.targetDir, e);
+  }
+  getTargetVersionPath(e, n) {
+    return p.join(this.getTargetPath(e), n);
+  }
+  async checkForUpdates(e) {
+    const n = ot.buildChannel;
+    this.logger.log("Checking for updates");
+    for (const s of e)
+      try {
+        const { data: i } = await Dt(s, n), o = await this.getCurrentVersion(s);
+        this.logger.log(`${s} > Update Check. current: ${o}, latest: ${i}`), i !== o ? (this.logger.log(`${s} > Update found: ${o} -> ${i}`), await this.downloadAndExtractDll(s, i, n), this.logger.log(`${s} > Downloaded and extracted`), await this.cleanupOldVersions(s, i), this.logger.log(`${s} > Cleaning up versions older than ${i}`), this.emit("dllUpdated", { identifier: s, version: i })) : this.logger.log(`${s} Up to date`);
+      } catch (i) {
+        this.logger.captureSentryException(`${s} > Error checking/updating`, i);
+      }
+  }
+  async downloadAndExtractDll(e, n, s) {
+    const { data: i } = await Ft(e, s), o = this.getTargetPath(e), a = this.getTargetVersionPath(e, n);
+    await b.mkdir(a, { recursive: !0 });
+    const c = new me();
+    await c.loadAsync(i);
+    const d = Object.keys(c.files).map(async (g) => {
+      const u = c.files[g];
+      if (u && !u.dir) {
+        const y = await u.async("nodebuffer"), f = p.join(a, g);
+        await b.writeFile(f, y);
+      }
+    });
+    await Promise.all(d);
+    const h = p.join(o, "version.txt");
+    this.logger.log("Saving version file", h), await b.writeFile(h, n);
+  }
+  async cleanupOldVersions(e, n) {
+    const s = p.join(this.targetDir, e), i = await b.readdir(s, { withFileTypes: !0 });
+    for (const o of i)
+      o.isDirectory() && o.name !== n && await b.rm(p.join(s, o.name), { recursive: !0, force: !0 });
+  }
+}
+const B = k(Ht);
+class Nt extends C {
+  constructor() {
+    super("RavenManager");
+    l(this, "REFETCH_INTERVAL", 1e3 * 60 * 5);
+    l(this, "FAILED_REFETCH_INTERVAL", 1e3 * 30);
+    l(this, "_ravenConfig");
+    l(this, "_executableToGameMap", /* @__PURE__ */ new Map());
+    l(this, "_executablesArray", []);
+    l(this, "_refetchIntervalHandler", null);
+    l(this, "_failedRefetchTimeoutHandler", null);
+  }
+  init() {
+    super.init(), this.fetchRavenConfig(), this._refetchIntervalHandler = setInterval(() => {
+      this._failedRefetchTimeoutHandler && (clearTimeout(this._failedRefetchTimeoutHandler), this._failedRefetchTimeoutHandler = null), this.fetchRavenConfig();
+    }, this.REFETCH_INTERVAL);
+  }
+  getExecutableData(e) {
+    return this._executableToGameMap.get(e.toLowerCase()) ?? null;
+  }
+  get executables() {
+    return this._executablesArray;
+  }
+  get executablesMap() {
+    return this._executableToGameMap;
+  }
+  destroy() {
+    this._refetchIntervalHandler && clearInterval(this._refetchIntervalHandler), this._failedRefetchTimeoutHandler && clearTimeout(this._failedRefetchTimeoutHandler), B.getInstance().destroy(), super.destroy();
+  }
+  async fetchRavenConfig() {
+    try {
+      const e = await xt();
+      this._ravenConfig = e.data, this.resetState();
+      const n = /* @__PURE__ */ new Set();
+      for (const s of this._ravenConfig.games) {
+        for (const i of s.executables) {
+          const o = i.toLowerCase();
+          this._executableToGameMap.set(o, s), this._executablesArray.push(o);
+        }
+        s.dlls_to_inject.forEach((i) => n.add(i));
+      }
+      await B.getInstance().initWithDlls(Array.from(n)), this.logger.log("Raven updated", this._ravenConfig), this.emit("executablesUpdated", { executables: this.executables, map: this._executableToGameMap });
+    } catch (e) {
+      this.logger.captureSentryException("Failed to fetch Raven config", e), this._failedRefetchTimeoutHandler = setTimeout(() => this.fetchRavenConfig(), this.FAILED_REFETCH_INTERVAL);
+    }
+  }
+  resetState() {
+    this._executableToGameMap.clear(), this._executablesArray = [];
+  }
+}
+const G = k(Nt);
+class jt extends C {
+  constructor() {
+    super("ProcessManager");
+    l(this, "_processMonitor");
+    l(this, "_processes", /* @__PURE__ */ new Map());
+    l(this, "boundOnRavenManagerExecutablesUpdated", this.onRavenManagerExecutablesUpdated.bind(this));
+    this._processMonitor = new Oe();
+  }
+  get hasAnyActiveProcesses() {
+    return this.activeProcesses.length > 0;
+  }
+  get activeProcesses() {
+    return Array.from(this._processes.values()).flat().filter((e) => !e.destroyedAt);
+  }
+  init() {
+    super.init(), G.getInstance().on("executablesUpdated", this.boundOnRavenManagerExecutablesUpdated), this._processMonitor.on("create", (e) => {
+      this.logger.log("Process created", e), this.addProcess(e), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("create", { process: e });
+    }), this._processMonitor.on("destroy", (e) => {
+      this.logger.log("Process destroyed", e), this.deleteProcess(e), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("destroy", { process: e });
+    });
+  }
+  destroy() {
+    G.getInstance().off("executablesUpdated", this.boundOnRavenManagerExecutablesUpdated), this._processes.clear(), this._processMonitor.removeAllListeners(), super.destroy();
+  }
+  isProcessRunning(e) {
+    const n = this._processes.get(e);
+    return (n == null ? void 0 : n.some((s) => !s.destroyedAt)) ?? !1;
+  }
+  onRavenManagerExecutablesUpdated(e) {
+    e.executables.forEach((n) => {
+      this.logger.log("Monitoring process", n), this._processMonitor.registerProcess(n);
+    });
+  }
+  addProcess(e) {
+    if (!e.name)
+      return;
+    const n = this._processes.get(e.name);
+    if (!n) {
+      this._processes.set(e.name, [e]);
+      return;
+    }
+    this._processes.set(e.name, n.concat(e));
+  }
+  deleteProcess(e) {
+    if (!e.name)
+      return;
+    const n = this._processes.get(e.name), s = (n == null ? void 0 : n.filter((i) => i.id !== e.id)) ?? [];
+    s.length === 0 ? this._processes.delete(e.name) : this._processes.set(e.name, s);
+  }
+}
+const S = k(jt);
+var Ut = Object.defineProperty, Bt = (r, t, e) => t in r ? Ut(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, H = (r, t, e) => Bt(r, typeof t != "symbol" ? t + "" : t, e);
+class Gt {
+  constructor(t) {
+    H(this, "_instance"), H(this, "_resolution"), H(this, "boundOnResolutionChanged", this.onResolutionChanged.bind(this)), this._instance = t, this._resolution = { width: 0, height: 0 }, this._instance.on("resolution", this.boundOnResolutionChanged);
+  }
+  destroy() {
+    this._instance.off("resolution", this.boundOnResolutionChanged);
+  }
+  get instance() {
+    return this._instance;
+  }
+  get resolution() {
+    return this._resolution;
+  }
+  onResolutionChanged(t, e) {
+    this._resolution = { width: t, height: e };
+  }
+}
+class Vt {
+  constructor() {
+    H(this, "interfaces", {});
+  }
+  createInterface(t) {
+    return this.interfaces[t] ? this.interfaces[t] : (this.interfaces[t] = new Gt(new Ue(t, { access: 1 })), this.interfaces[t]);
+  }
+  getInterface(t) {
+    return this.interfaces[t] ? this.interfaces[t] : this.createInterface(t);
+  }
+}
+const ee = k(Vt);
+class zt extends C {
+  constructor() {
+    super("GameLaunchManager");
+    l(this, "RENDER_INTERFACE_PATH", "./native-modules/render-interface/build/statscc_render_hook_x64.dll");
+    l(this, "boundOnProcessCreate", this.onProcessCreate.bind(this));
+    l(this, "boundOnProcessDestroy", this.onProcessDestroy.bind(this));
+  }
+  init() {
+    super.init(), ee.getInstance().createInterface("SCC_RAINBOW"), S.getInstance().on("create", this.boundOnProcessCreate), S.getInstance().on("destroy", this.boundOnProcessDestroy);
+  }
+  destroy() {
+    S.getInstance().off("create", this.boundOnProcessCreate), S.getInstance().off("destroy", this.boundOnProcessDestroy), super.destroy();
+  }
+  async onProcessCreate({ process: e }) {
+    const n = this.getRavenGame(e);
+    if (!n)
+      return;
+    if (this.logger.log("Game Launched", n), this.logger.log("Process is elevated: ", e.isElevated), this.logger.log("Current process is elevated: ", L.currentProcess.isElevated), e.isElevated && !L.currentProcess.isElevated) {
+      be.getInstance().error("Game is elevated but the App is not", "ELEVATION_MISMATCH", {
+        appElevated: L.currentProcess.isElevated,
+        gameElevated: e.isElevated
+      }), this.logger.sentryLog("Game elevated but App is not", {
+        appElevated: L.currentProcess.isElevated,
+        gameElevated: e.isElevated
+      });
+      return;
+    }
+    const s = this.copyDll(this.RENDER_INTERFACE_PATH);
+    if (s)
+      try {
+        await e.injectDll(s), this.logger.log("Render Interface Injection Successful", s);
+      } catch (o) {
+        this.logger.captureSentryException("Render Interface Injection Failed", o), this.logger.sentryError("Render Interface Injection Failed", {
+          renderInterfacePath: s
+        });
+      }
+    const i = n == null ? void 0 : n.dlls_to_inject.map(async (o) => {
+      const a = await B.getInstance().getCurrentVersion(o);
+      if (!a)
+        return this.logger.sentryError("No version found for DLL", { identifier: o }), Promise.resolve();
+      const c = B.getInstance().getTargetVersionPath(o, a);
+      this.logger.log("DLL Path", c);
+      const d = await this.getDllFiles(c);
+      return this.logger.log("DLL Files", d), Promise.all(
+        d.map(async (h) => {
+          const g = p.basename(h), u = p.join(c, g);
+          if (!u)
+            return Promise.resolve();
+          this.logger.log("Injecting: ", u);
+          try {
+            return e.injectDll(u).then(() => {
+              this.logger.log("Injection Successful", u);
+            }).catch((y) => {
+              this.logger.sentryError("Injection Failed [1]", { targetPath: u }, y);
+            });
+          } catch (y) {
+            return this.logger.sentryError("Injection Failed [2]", { targetPath: u }, y), Promise.reject(y);
+          }
+        })
+      );
+    });
+    await Promise.allSettled(i), this.emit("gameLaunch", { ravenGame: n, process: e });
+  }
+  copyDll(e) {
+    this.logger.log(at());
+    const n = e.split("/");
+    if (n.length < 2)
+      return this.logger.sentryError("Path is invalid", { dllPath: e }), !1;
+    const s = n.at(-1);
+    if (!s)
+      return this.logger.sentryError("Dll name is invalid", { dllPath: e }), !1;
+    const i = Ke(e), o = p.join(F, "resources"), a = p.join(o, s);
+    this.logger.debug("Copying", i, "to", a);
+    try {
+      $e(o) || He(o, { recursive: !0 });
+      const c = ye(i);
+      Ne(a, c), je(i, a);
+    } catch (c) {
+      return c.code === "EBUSY" ? a : (this.logger.captureSentryException("Failed to copy", c), this.logger.sentryError("Failed to copy", { originalPath: i, targetPath: a }), !1);
+    }
+    return a;
+  }
+  async getDllFiles(e) {
+    try {
+      return (await b.readdir(e)).filter((s) => s.endsWith(".dll")).map((s) => p.join(e, s));
+    } catch (n) {
+      return this.logger.captureSentryException("Failed to read DLL directory", n), this.logger.sentryError("Failed to read DLL directory", { dllPath: e }), [];
+    }
+  }
+  onProcessDestroy({ process: e }) {
+    const n = this.getRavenGame(e);
+    n && this.emit("gameClose", { ravenGame: n, process: e });
+  }
+  getRavenGame(e) {
+    if (!e.name)
+      return;
+    const n = G.getInstance().getExecutableData(e.name);
+    if (!n) {
+      this.logger.sentryError("No raven game found for process", { process: e });
+      return;
+    }
+    return n;
+  }
+}
+const V = k(zt);
+class Wt extends st {
+  constructor() {
+    super("GameBuildManager");
+    l(this, "boundOnGameLaunch", this.onGameLaunch.bind(this));
+  }
+  init() {
+    super.init(), V.getInstance().on("gameLaunch", this.boundOnGameLaunch);
+  }
+  destroy() {
+    V.getInstance().off("gameLaunch", this.boundOnGameLaunch), super.destroy();
+  }
+  async onGameLaunch(e) {
+    const { ravenGame: n, process: s } = e;
+    if (!s.path || !s.name) {
+      this.logger.sentryError(
+        "Process path or name not found, could not check for build hash",
+        void 0,
+        s
+      );
+      return;
+    }
+    const i = ye(s.path), o = Be("sha256").update(i).digest("hex");
+    this.logger.log("Process Path", s.path), this.logger.log("Process Name", s.name), this.logger.log("Build Hash", o);
+    let a = !1;
+    try {
+      a = (await Kt(n.identifier, o)).data.upload;
+    } catch (h) {
+      this.logger.captureSentryException("Error checking game build hash", h);
+      return;
+    }
+    if (!a) {
+      this.logger.log("Build hash already exists, skipping upload");
+      return;
+    }
+    const c = new me();
+    c.file(s.name, i);
+    const d = await c.generateAsync({ type: "blob" });
+    try {
+      this.logger.log("Uploading build (size: ", d.size, " bytes)"), await Lt(n.identifier, d), this.logger.log("Build uploaded successfully");
+    } catch (h) {
+      Ot(h) ? $t(h.response) ? this.logger.captureSentryException("Error uploading build hash, api error", h) : this.logger.captureSentryException("Error uploading build hash, request error", h) : this.logger.captureSentryException("Error uploading build hash, unknown error", h);
+    }
+  }
+}
+const qt = k(Wt), te = /* @__PURE__ */ new Map([
+  [1, "LeftButton"],
+  [2, "RightButton"],
+  [3, "Cancel"],
+  [4, "MiddleButton"],
+  [5, "ExtraButton1"],
+  [6, "ExtraButton2"],
+  [8, "Backspace"],
+  [9, "Tab"],
+  [12, "Clear"],
+  [13, "Enter"],
+  [16, "ShiftLeft"],
+  [17, "ControlLeft"],
+  [18, "AltLeft"],
+  [19, "Pause"],
+  [20, "CapsLock"],
+  [21, "KanaMode"],
+  [23, "JunjaMode"],
+  [24, "Finalize"],
+  [25, "HanjaMode"],
+  [27, "Escape"],
+  [28, "Convert"],
+  [29, "NonConvert"],
+  [30, "Accept"],
+  [31, "ModeChange"],
+  [32, "Space"],
+  [33, "PageUp"],
+  [34, "PageDown"],
+  [35, "End"],
+  [36, "Home"],
+  [37, "ArrowLeft"],
+  [38, "ArrowUp"],
+  [39, "ArrowRight"],
+  [40, "ArrowDown"],
+  [41, "Select"],
+  [42, "PrintScreen"],
+  [43, "Execute"],
+  [44, "Snapshot"],
+  [45, "Insert"],
+  [46, "Delete"],
+  [47, "Help"],
+  [48, "Digit0"],
+  [49, "Digit1"],
+  [50, "Digit2"],
+  [51, "Digit3"],
+  [52, "Digit4"],
+  [53, "Digit5"],
+  [54, "Digit6"],
+  [55, "Digit7"],
+  [56, "Digit8"],
+  [57, "Digit9"],
+  [65, "KeyA"],
+  [66, "KeyB"],
+  [67, "KeyC"],
+  [68, "KeyD"],
+  [69, "KeyE"],
+  [70, "KeyF"],
+  [71, "KeyG"],
+  [72, "KeyH"],
+  [73, "KeyI"],
+  [74, "KeyJ"],
+  [75, "KeyK"],
+  [76, "KeyL"],
+  [77, "KeyM"],
+  [78, "KeyN"],
+  [79, "KeyO"],
+  [80, "KeyP"],
+  [81, "KeyQ"],
+  [82, "KeyR"],
+  [83, "KeyS"],
+  [84, "KeyT"],
+  [85, "KeyU"],
+  [86, "KeyV"],
+  [87, "KeyW"],
+  [88, "KeyX"],
+  [89, "KeyY"],
+  [90, "KeyZ"],
+  [91, "MetaLeft"],
+  [92, "MetaRight"],
+  [93, "ContextMenu"],
+  [95, "Sleep"],
+  [96, "Numpad0"],
+  [97, "Numpad1"],
+  [98, "Numpad2"],
+  [99, "Numpad3"],
+  [100, "Numpad4"],
+  [101, "Numpad5"],
+  [102, "Numpad6"],
+  [103, "Numpad7"],
+  [104, "Numpad8"],
+  [105, "Numpad9"],
+  [106, "NumpadMultiply"],
+  [107, "NumpadAdd"],
+  [108, "NumpadSeparator"],
+  [109, "NumpadSubtract"],
+  [110, "NumpadDecimal"],
+  [111, "NumpadDivide"],
+  [112, "F1"],
+  [113, "F2"],
+  [114, "F3"],
+  [115, "F4"],
+  [116, "F5"],
+  [117, "F6"],
+  [118, "F7"],
+  [119, "F8"],
+  [120, "F9"],
+  [121, "F10"],
+  [122, "F11"],
+  [123, "F12"],
+  [124, "F13"],
+  [125, "F14"],
+  [126, "F15"],
+  [127, "F16"],
+  [128, "F17"],
+  [129, "F18"],
+  [130, "F19"],
+  [131, "F20"],
+  [132, "F21"],
+  [133, "F22"],
+  [134, "F23"],
+  [135, "F24"],
+  [144, "NumLock"],
+  [145, "ScrollLock"],
+  [146, "NEC_Equal"],
+  [147, "Fujitsu_Masshou"],
+  [148, "Fujitsu_Touroku"],
+  [149, "Fujitsu_Loya"],
+  [150, "Fujitsu_Roya"],
+  [160, "ShiftLeft"],
+  [161, "ShiftRight"],
+  [162, "ControlLeft"],
+  [163, "ControlRight"],
+  [164, "AltLeft"],
+  [165, "AltRight"],
+  [166, "BrowserBack"],
+  [167, "BrowserForward"],
+  [168, "BrowserRefresh"],
+  [169, "BrowserStop"],
+  [170, "BrowserSearch"],
+  [171, "BrowserFavorites"],
+  [172, "BrowserHome"],
+  [173, "VolumeMute"],
+  [174, "VolumeDown"],
+  [175, "VolumeUp"],
+  [176, "MediaTrackNext"],
+  [177, "MediaTrackPrevious"],
+  [178, "MediaStop"],
+  [179, "MediaPlayPause"],
+  [180, "LaunchMail"],
+  [181, "LaunchMediaSelect"],
+  [182, "LaunchApplication1"],
+  [183, "LaunchApplication2"],
+  [186, "OEM_1"],
+  [187, "Equal"],
+  [188, "Comma"],
+  [189, "Minus"],
+  [190, "Period"],
+  [191, "Slash"],
+  [192, "Backquote"],
+  [219, "BracketLeft"],
+  [220, "Backslash"],
+  [221, "BracketRight"],
+  [222, "Quote"],
+  [223, "IntlRo"],
+  [225, "OEM_AX"],
+  [226, "IntlBackslash"],
+  [227, "ICO_HELP"],
+  [228, "ICO_00"],
+  [229, "Process"],
+  [230, "ICO_CLEAR"],
+  [231, "Packet"],
+  [233, "OEM_Reset"],
+  [234, "OEM_Jump"],
+  [235, "OEM_PA1"],
+  [236, "OEM_PA2"],
+  [237, "OEM_PA3"],
+  [238, "OEM_WS_Ctrl"],
+  [239, "OEM_CU_Sel"],
+  [240, "OEM_ATTN"],
+  [241, "OEM_Finish"],
+  [242, "OEM_Copy"],
+  [243, "OEM_Auto"],
+  [244, "OEM_ENLW"],
+  [245, "BackTab"],
+  [246, "ATTN"],
+  [247, "CRSel"],
+  [248, "EXSel"],
+  [249, "EREOF"],
+  [250, "MediaPlay"],
+  [251, "Zoom"],
+  [252, "Noname"],
+  [253, "PA1"],
+  [254, "OEM_Clear"]
+]), pe = new Map(te.entries().map(([r, t]) => [t, r])), Xt = D({
+  "[string]": {
+    keys: "string[]",
+    mode: D("'toggle' | 'hold'").pipe((r) => r ?? "toggle")
+  }
+});
+class Jt extends C {
+  constructor(e) {
+    super("KeybindManager");
+    l(this, "preferencesKeybindToCallbacks", /* @__PURE__ */ new Map());
+    l(this, "pressedKeys", /* @__PURE__ */ new Set());
+    l(this, "activeKeybinds", /* @__PURE__ */ new Set());
+    l(this, "triggeredToggleKeybinds", /* @__PURE__ */ new Set());
+    l(this, "isRecording", !1);
+    l(this, "boundHandleKeyboardFocus", this.handleKeyboardFocus.bind(this));
+    l(this, "boundHandleKeyDown", this.handleKeyDown.bind(this));
+    l(this, "boundHandleKeyUp", this.handleKeyUp.bind(this));
+    l(this, "keybidnsFile");
+    this.keybidnsFile = new nt({
+      path: p.join(F, "keybinds.json"),
+      schema: Xt,
+      default: e
+    });
+  }
+  init() {
+    super.init();
+    const e = ee.getInstance().getInterface("SCC_RAINBOW");
+    e.instance.on("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.on("keyDown", this.boundHandleKeyDown), e.instance.on("keyUp", this.boundHandleKeyUp);
+  }
+  async onHotkeyToggled(e, n) {
+    const s = this.preferencesKeybindToCallbacks.get(e) || {};
+    s.toggle = n, this.preferencesKeybindToCallbacks.set(e, s);
+  }
+  async onHotkeyDown(e, n) {
+    const s = this.preferencesKeybindToCallbacks.get(e) || {};
+    s.down = n, this.preferencesKeybindToCallbacks.set(e, s);
+  }
+  async onHotkeyUp(e, n) {
+    const s = this.preferencesKeybindToCallbacks.get(e) || {};
+    s.up = n, this.preferencesKeybindToCallbacks.set(e, s);
+  }
+  destroy() {
+    const e = ee.getInstance().getInterface("SCC_RAINBOW");
+    e.instance.off("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.off("keyDown", this.boundHandleKeyDown), e.instance.off("keyUp", this.boundHandleKeyUp), super.destroy();
+  }
+  handleKeyDown(e) {
+    if (this.isRecording)
+      return;
+    const n = te.get(e.key);
+    if (!n) {
+      this.logger.error("Unknown key down", e);
+      return;
+    }
+    this.pressedKeys.add(n), this.checkKeybindings();
+  }
+  handleKeyboardFocus() {
+    this.pressedKeys.clear(), this.activeKeybinds.clear(), this.triggeredToggleKeybinds.clear();
+  }
+  async handleKeyUp(e) {
+    if (this.isRecording)
+      return;
+    const n = te.get(e.key);
+    if (!n)
+      return;
+    this.pressedKeys.delete(n);
+    const s = this.keybidnsFile.data;
+    for (const [i] of this.preferencesKeybindToCallbacks.entries())
+      s[i].keys.includes(n) && this.triggeredToggleKeybinds.delete(i);
+    this.checkHotkeyUps();
+  }
+  async checkHotkeyUps() {
+    const e = this.keybidnsFile.data;
+    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
+      if (!s.up) continue;
+      const i = e[n];
+      this.activeKeybinds.has(n) && i.keys.some((o) => !this.pressedKeys.has(o)) && (this.activeKeybinds.delete(n), s.up(), this.logger.log("Hotkey up triggered", this.getHotkeyToString(i)));
+    }
+  }
+  async checkKeybindings() {
+    const e = this.keybidnsFile.data;
+    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const i = e[n];
+      if (i.keys.length === this.pressedKeys.size && i.keys.every((a) => pe.has(a) ? this.pressedKeys.has(a) : !1)) {
+        this.triggerHotkey(i, s, n);
+        return;
+      }
+    }
+    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const i = e[n];
+      i.keys.every((a) => pe.has(a) ? this.pressedKeys.has(a) : (this.logger.error("Unknown key", a, i), !1)) && this.triggerHotkey(i, s, n);
+    }
+  }
+  triggerHotkey(e, n, s) {
+    const i = e.mode;
+    if (i === "toggle" && n.toggle && !this.triggeredToggleKeybinds.has(s)) {
+      const o = n.toggle();
+      this.triggeredToggleKeybinds.add(s), this.logger.log(
+        o ? `Hotkey pressed rejected: ${o}` : "Hotkey pressed accepted",
+        this.getHotkeyToString(e)
+      );
+    }
+    if (i === "hold" && n.down && !this.activeKeybinds.has(s)) {
+      const o = n.down();
+      o ? this.logger.log(`Hotkey down rejected: ${o}`, this.getHotkeyToString(e)) : (this.activeKeybinds.add(s), this.logger.log("Hotkey down accepted", this.getHotkeyToString(e)));
+    }
+  }
+  getHotkeyToString(e) {
+    return `(${e.keys.join("+")}${e.mode ? ` ${e.mode}` : ""})`;
+  }
+}
+function pr(r) {
+  const t = /* @__PURE__ */ new Map(), e = Yt(r.modules, t), n = Zt(), s = tr(r.keybinds);
+  return Qt(), er(r, t), {
+    ...e,
+    ...n,
+    keybinds: s
+  };
+}
+function Qt() {
+  qt.getInstance().init(), V.getInstance().init(), S.getInstance().init(), G.getInstance().init();
+}
+function Yt(r, t) {
+  return r.reduce((e, n) => {
+    const s = n.key;
+    return e[s] = {
+      // prettier-ignore
+      on(i, o) {
+        const a = z(s, i), c = t.get(a) ?? /* @__PURE__ */ new Set();
+        c.add(o), t.set(a, c);
+      },
+      // prettier-ignore
+      off(i, o) {
+        const a = z(s, i), c = t.get(a) ?? /* @__PURE__ */ new Set();
+        c.delete(o), t.set(a, c);
+      }
+    }, e;
+  }, {});
+}
+function Zt() {
+  const r = be.getInstance(), t = V.getInstance();
+  return {
+    on: (e, n) => {
+      switch (e) {
+        case "error":
+          r.on("error", n);
+          break;
+        case "warning":
+          r.on("warning", n);
+          break;
+        case "gameLaunch":
+          t.on("gameLaunch", n);
+          break;
+        case "gameClose":
+          t.on("gameClose", n);
+          break;
+        default:
+          throw new Error("Not implemented", { cause: [e, n] });
+      }
+    }
+  };
+}
+function z(r, t) {
+  return `${r}:${t}`;
+}
+function er(r, t) {
+  const e = Qe.getInstance();
+  function n(s) {
+    const i = Ye(s);
+    if (i instanceof D.errors)
+      return;
+    const o = r.modules.find((f) => f.key === i.game), a = o == null ? void 0 : o.events.event;
+    if (!a)
+      return;
+    const c = a(s);
+    if (c instanceof D.errors)
+      return;
+    const d = z(o.key, c.type), h = z(o.key, "*"), g = t.get(d), u = t.get(h), y = [...Array.from(g ?? []), ...Array.from(u ?? [])];
+    y.length !== 0 && y.forEach((f) => {
+      f(c);
+    });
+  }
+  return e.on("data", (s) => s.forEach(n)), e;
+}
+function tr(r) {
+  const t = {}, e = new Jt(r);
+  for (const n in r)
+    t[n] = {
+      on: (s, i) => {
+        switch (s) {
+          case "down":
+            e.onHotkeyDown(n, i);
+            break;
+          case "up":
+            e.onHotkeyUp(n, i);
+            break;
+          case "toggle":
+            e.onHotkeyToggled(n, i);
+            break;
+          default:
+            throw new Error("Not implemented", { cause: [s, i] });
+        }
+      }
+    };
+  return t;
+}
+function yr() {
+  return "test";
+}
+export {
+  pr as overlayed,
+  yr as test
+};