@overlayed/app 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,56 +1,57 @@
-var ot = Object.defineProperty;
-var it = (r, t, e) => t in r ? ot(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var c = (r, t, e) => it(r, typeof t != "symbol" ? t + "" : t, e);
-import _, { resolve as lt } from "node:path";
-import { createRequire as ue } from "node:module";
-import { type as y, scope as ct } from "arktype";
-import C, { existsSync as dt, mkdirSync as ut, readFileSync as Se, writeFileSync as ht, copyFileSync as gt } from "node:fs";
-import E from "node:fs/promises";
-import Me from "jszip";
-import { createHash as pt } from "node:crypto";
-var ft = Object.defineProperty, yt = (r, t, e) => t in r ? ft(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, T = (r, t, e) => yt(r, typeof t != "symbol" ? t + "" : t, e);
-function mt(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);
+var He = Object.defineProperty;
+var ze = (n, e, t) => e in n ? He(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var c = (n, e, t) => ze(n, typeof e != "symbol" ? e + "" : e, t);
+import { type as K } from "arktype";
+import { createRequire as Y } from "node:module";
+import k, { existsSync as qe, mkdirSync as We, readFileSync as _e, writeFileSync as Qe, copyFileSync as Xe } from "node:fs";
+import m, { resolve as Je } from "node:path";
+import v from "node:fs/promises";
+import ke from "jszip";
+import { createHash as Ye } from "node:crypto";
+import Ze, { app as Pe } from "electron";
+var et = Object.defineProperty, tt = (n, e, t) => e in n ? et(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, R = (n, e, t) => tt(n, typeof e != "symbol" ? e + "" : e, t);
+function nt(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(e, t) {
+    var r = n.get(e);
+    r ? r.push(t) : n.set(e, [t]);
+  }, off: function(e, t) {
+    var r = n.get(e);
+    r && (t ? r.splice(r.indexOf(t) >>> 0, 1) : n.set(e, []));
+  }, emit: function(e, t) {
+    var r = n.get(e);
+    r && r.slice().map(function(s) {
+      s(t);
+    }), (r = n.get("*")) && r.slice().map(function(s) {
+      s(e, t);
     });
   } };
 }
-let _t = class {
+let Ce = class {
   constructor() {
-    T(this, "emitter"), this.emitter = mt();
+    R(this, "emitter"), this.emitter = nt();
   }
-  on(t, e) {
-    this.emitter.on(t, e);
+  on(e, t) {
+    this.emitter.on(e, t);
   }
-  off(t, e) {
-    this.emitter.off(t, e);
+  off(e, t) {
+    this.emitter.off(e, t);
   }
-  emit(t, e) {
-    this.emitter.emit(t, e);
+  emit(e, t) {
+    this.emitter.emit(e, t);
   }
   removeAllListeners() {
     this.emitter.off("*", () => {
     });
   }
 };
-function bt(r, ...t) {
-  var e;
-  return e = class extends r {
+function Ke(n, ...e) {
+  var t;
+  return t = class extends n {
     /**
      * Lazy get the static instance
      */
     static getInstance() {
-      return this._instance || (this._instance = new r(...t)), this._instance;
+      return this._instance || (this._instance = new n(...e)), this._instance;
     }
     /**
      * Release the instance (most of the time you won't need this)
@@ -58,29 +59,68 @@ function bt(r, ...t) {
     static clearInstance() {
       this._instance = void 0;
     }
-  }, T(e, "_instance"), e;
+  }, R(t, "_instance"), t;
 }
-const vt = _.join(process.env.APPDATA ?? "", "overlayed");
-_.join(vt, "logs");
-const Et = ue(import.meta.url), { PipeEventServer: wt, PipeEventClient: Cr, PipeEventBase: Pr, ProcessMonitor: Sr, Process: Mr, InjectionMethod: $r, AccessLevel: Ar } = Et("./build/overlayed_native_interface_x64.node");
-let kt = class extends _t {
-  constructor(t) {
-    super(), T(this, "server", null), T(this, "_hasConnection", !1), T(this, "pipeId"), this.pipeId = t, this.init();
+class rt extends Ce {
+  destroy() {
+    this.removeAllListeners();
+  }
+  fatal(e, t, r) {
+    this.emit("fatal", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
+  }
+  error(e, t, r) {
+    this.emit("error", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
+  }
+  warn(e, t, r) {
+    this.emit("warning", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
+  }
+}
+Ke(rt);
+const st = Y(import.meta.url), {
+  PipeEventServer: it,
+  PipeEventClient: xn,
+  PipeEventBase: $n,
+  ProcessMonitor: Dn,
+  Process: Tn,
+  InjectionMethod: Bn,
+  AccessLevel: Gn,
+  HardwareInterface: jn
+} = st("./build/overlayed_native_interface_x64.node");
+let at = class extends Ce {
+  constructor(e) {
+    super(), R(this, "server", null), R(this, "_hasConnection", !1), R(this, "pipeId"), this.pipeId = e, this.init();
   }
   get hasConnection() {
     return this._hasConnection;
   }
   destroy() {
-    var t;
-    this.server && (this._hasConnection = !1, (t = this.server) == null || t.removeAllListeners(), this.server = null);
+    var e;
+    this.server && (this._hasConnection = !1, (e = this.server) == null || e.removeAllListeners(), this.server = null);
   }
+  // TODO make sure that new events and new event keys do not stop the app from working
+  // this is because we may have new events/event keys from a DLL but the types/validations might not be up to date
   init() {
-    this.server = new wt(this.pipeId, { clientCount: 1, access: 1 }), this.server.on("event", (t) => {
+    this.server = new it(this.pipeId, { clientCount: 1, access: 1 }), this.server.on("event", (e) => {
       try {
-        const e = JSON.parse(t);
-        this.emit("data", e);
-      } catch (e) {
-        this.emit("error", e);
+        const t = JSON.parse(e);
+        this.emit("data", [t]);
+      } catch (t) {
+        this.emit("error", t);
       }
     }), this.server.on("connected", () => {
       this._hasConnection = !0;
@@ -89,54 +129,50 @@ let kt = class extends _t {
     });
   }
 };
-const $e = bt(kt, "overlayed"), Ae = y({
-  game: "string",
-  type: "string",
-  creation_time: "number"
-});
-function It(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);
+const oe = Ke(at, "stats-cc");
+function ot(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(e, t) {
+    var r = n.get(e);
+    r ? r.push(t) : n.set(e, [t]);
+  }, off: function(e, t) {
+    var r = n.get(e);
+    r && (t ? r.splice(r.indexOf(t) >>> 0, 1) : n.set(e, []));
+  }, emit: function(e, t) {
+    var r = n.get(e);
+    r && r.slice().map(function(s) {
+      s(t);
+    }), (r = n.get("*")) && r.slice().map(function(s) {
+      s(e, t);
     });
   } };
 }
-class Ct {
+class Se {
   constructor() {
     c(this, "emitter");
-    this.emitter = It();
+    this.emitter = ot();
   }
-  on(t, e) {
-    this.emitter.on(t, e);
+  on(e, t) {
+    this.emitter.on(e, t);
   }
-  off(t, e) {
-    this.emitter.off(t, e);
+  off(e, t) {
+    this.emitter.off(e, t);
   }
-  emit(t, e) {
-    this.emitter.emit(t, e);
+  emit(e, t) {
+    this.emitter.emit(e, t);
   }
   removeAllListeners() {
     this.emitter.off("*", () => {
     });
   }
 }
-function I(r, ...t) {
-  var n;
-  return n = class extends r {
+function _(n, ...e) {
+  var r;
+  return r = class extends n {
     /**
      * Lazy get the static instance
      */
     static getInstance() {
-      return this._instance || (this._instance = new r(...t)), this._instance;
+      return this._instance || (this._instance = new n(...e)), this._instance;
     }
     /**
      * Release the instance (most of the time you won't need this)
@@ -144,163 +180,206 @@ function I(r, ...t) {
     static clearInstance() {
       this._instance = void 0;
     }
-  }, c(n, "_instance"), n;
+  }, c(r, "_instance"), r;
 }
-function Pt(r) {
-  try {
-    return [JSON.parse(r), null];
-  } catch (t) {
-    return [null, t];
+class lt extends Se {
+  destroy() {
+    this.removeAllListeners();
   }
-}
-function ae(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] = ae(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 St {
-  constructor(t) {
-    c(this, "options");
-    c(this, "_data");
-    this.options = t, this._data = this.load();
+  fatal(e, t, r) {
+    this.emit("fatal", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
   }
-  get data() {
-    return this._data;
+  error(e, t, r) {
+    this.emit("error", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
   }
-  set data(t) {
-    this._data = t, this.saveCurrentData();
+  warn(e, t, r) {
+    this.emit("warning", {
+      code: t,
+      message: e,
+      data: r,
+      timestamp: Date.now()
+    });
   }
-  onBeforeSave(t) {
-    return t;
+}
+const I = _(lt);
+class ct {
+  constructor(e) {
+    c(this, "data");
+    c(this, "_schema");
+    c(this, "_defaultValue");
+    c(this, "_path");
+    const { schema: t, default: r, path: s } = e;
+    this._schema = t, this._defaultValue = r, this._path = s;
+  }
+  set(e) {
+    const t = this._schema["~standard"].validate(e);
+    if (t instanceof Promise)
+      throw new Error("StructuredConfigFile does not support async validation");
+    if (t.issues) {
+      this.reportInvalidConfigFile(t.issues);
+      return;
+    }
+    this.data = this.onBeforeSave(e), this.save(e);
   }
-  onAfterLoad(t) {
-    return t;
+  get() {
+    return this.data ? this.data : this.load();
   }
-  saveCurrentData() {
+  getKey(e) {
+    return this.get()[e];
+  }
+  save(e) {
+    const t = this.onBeforeSave(e);
     try {
-      const t = this.onBeforeSave(this._data);
-      C.writeFileSync(this.options.path, JSON.stringify(t, null, 2));
+      k.writeFileSync(this.getFilePath(), JSON.stringify(t, void 0, 2));
     } catch {
+      return;
     }
+    return this.data = t;
   }
   load() {
-    if (!this.fileExists(this.options.path))
-      return this.setupDefaultData();
-    if (!this.canReadWriteFile(this.options.path))
-      return this.setupDefaultData(!0);
-    const t = C.readFileSync(this.options.path, "utf8"), [e, n] = Pt(t);
-    return n ? this.setupDefaultData(!0) : this.onAfterLoad(e);
-  }
-  canReadWriteFile(t) {
+    if (!this.fileExists(this.getFilePath()) || !this.canReadWriteFile(this.getFilePath())) {
+      this.save(this._defaultValue);
+      const e = this.onAfterLoad(this._defaultValue);
+      return this.data = e, e;
+    }
     try {
-      return C.accessSync(t, C.constants.R_OK | C.constants.W_OK), !0;
+      const e = k.readFileSync(this.getFilePath(), "utf8"), t = this.onAfterLoad(this.parseStoredData(e));
+      return this.data = t, t;
     } catch {
-      return !1;
+      return this.data = this._defaultValue;
     }
   }
-  fileExists(t) {
+  onBeforeSave(e) {
+    return e;
+  }
+  onAfterLoad(e) {
+    return e;
+  }
+  getFilePath() {
+    return this._path;
+  }
+  parseStoredData(e) {
     try {
-      return C.accessSync(t, C.constants.F_OK), !0;
+      const r = K("string.json.parse").to("object")(e);
+      if (r instanceof K.errors)
+        return this._defaultValue;
+      const s = this._schema["~standard"].validate(r);
+      if (s instanceof Promise)
+        throw new Error("StructuredConfigFile does not support async validation");
+      return s.issues ? this.migrate(r, this._defaultValue) : this.migrate(s.value, this._defaultValue);
     } catch {
-      return !1;
+      return this._defaultValue;
     }
   }
-  setupDefaultData(t = !1) {
-    return this._data = this.options.default, t || this.saveCurrentData(), this.data;
-  }
-}
-class Mt extends St {
-  constructor(e) {
-    super(e);
-    c(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;
+  canReadWriteFile(e) {
+    try {
+      return k.accessSync(e, k.constants.R_OK | k.constants.W_OK), !0;
+    } catch {
+      return !1;
+    }
   }
-  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);
+  fileExists(e) {
+    try {
+      return k.accessSync(e, k.constants.F_OK), !0;
+    } catch {
+      return !1;
+    }
   }
-  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 ? ae(e, this.options.default) : ae(n.value, this.options.default);
+  migrate(e, t) {
+    const r = { ...e };
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (s in e ? e[s] !== null && t[s] !== null && typeof e[s] == "object" && typeof t[s] == "object" && !Array.isArray(e[s]) && !Array.isArray(t[s]) ? r[s] = this.migrate(e[s], t[s]) : Array.isArray(t[s]) && (r[s] = e[s]) : r[s] = t[s]);
+    return r;
+  }
+  reportInvalidConfigFile(e) {
+    I.getInstance().error("Invalid config file", "INVALID_CONFIG_FILE", {
+      issues: e.map((t) => t.message),
+      filePath: this._path,
+      data: this.data
+    });
   }
 }
-const Re = {
-  scope: (r) => ({
-    log: (...t) => {
-      console.log(r, ...t);
+const Me = {
+  scope: (n) => ({
+    log: (...e) => {
+      console.log(n, ...e);
     },
-    error: (...t) => {
-      console.error(r, ...t);
+    error: (...e) => {
+      console.error(n, ...e);
     },
-    warn: (...t) => {
-      console.warn(r, ...t);
+    warn: (...e) => {
+      console.warn(n, ...e);
     },
-    info: (...t) => {
-      console.info(r, ...t);
+    info: (...e) => {
+      console.info(n, ...e);
     },
-    debug: (...t) => {
-      console.debug(r, ...t);
+    debug: (...e) => {
+      console.debug(n, ...e);
     },
-    captureSentryException: (...t) => {
-      console.error(r, ...t);
+    captureSentryException: (...e) => {
+      console.error(n, ...e);
     },
-    sentryError: (...t) => {
-      console.error(r, ...t);
+    sentryError: (...e) => {
+      console.error(n, ...e);
     },
-    sentryLog: (...t) => {
-      console.log(r, ...t);
+    sentryLog: (...e) => {
+      console.log(n, ...e);
     },
-    sentryWarn: (...t) => {
-      console.warn(r, ...t);
+    sentryWarn: (...e) => {
+      console.warn(n, ...e);
     }
   }),
-  error: (...r) => {
-    console.error(name, ...r);
+  error: (...n) => {
+    console.error(name, ...n);
   },
-  warn: (...r) => {
-    console.warn(name, ...r);
+  warn: (...n) => {
+    console.warn(name, ...n);
   },
-  info: (...r) => {
-    console.info(name, ...r);
+  info: (...n) => {
+    console.info(name, ...n);
   },
-  debug: (...r) => {
-    console.debug(name, ...r);
+  debug: (...n) => {
+    console.debug(name, ...n);
   },
-  captureSentryException: (...r) => {
-    console.error(name, ...r);
+  captureSentryException: (...n) => {
+    console.error(name, ...n);
   },
-  sentryError: (...r) => {
-    console.error(name, ...r);
+  sentryError: (...n) => {
+    console.error(name, ...n);
   },
-  sentryLog: (...r) => {
-    console.log(name, ...r);
+  sentryLog: (...n) => {
+    console.log(name, ...n);
   },
-  sentryWarn: (...r) => {
-    console.warn(name, ...r);
+  sentryWarn: (...n) => {
+    console.warn(name, ...n);
   },
-  sentryInfo: (...r) => {
-    console.info(name, ...r);
+  sentryInfo: (...n) => {
+    console.info(name, ...n);
   }
-}, B = _.join(process.env.APPDATA ?? "", "overlayed");
-_.join(B, "logs");
-class Ke {
-  constructor(t) {
+}, le = () => m.join(process.env.APPDATA ?? "", "overlayed");
+function ut(n = []) {
+  return m.normalize(m.join(le(), global.OVERLAYED.APP_NAME, ...n));
+}
+const dt = K({
+  game: "string",
+  type: "string",
+  creation_time: "number"
+});
+class Ae {
+  constructor(e) {
     c(this, "logger");
     c(this, "initialized", !1);
-    this.logger = Re.scope(t);
+    this.logger = Me.scope(e);
   }
   init() {
     this.logger.log("Initializing"), this.initialized = !0;
@@ -309,12 +388,12 @@ class Ke {
     this.logger.log("Destroying"), this.initialized = !1;
   }
 }
-class x extends Ct {
-  constructor(e) {
+class G extends Se {
+  constructor(t) {
     super();
     c(this, "logger");
     c(this, "initialized", !1);
-    this.logger = Re.scope(e);
+    this.logger = Me.scope(t);
   }
   init() {
     this.logger.log("Initializing"), this.initialized = !0;
@@ -323,399 +402,371 @@ class x extends Ct {
     this.logger.log("Destroying"), this.initialized = !1, this.removeAllListeners();
   }
 }
-class $t extends x {
-  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 q = I($t);
-function At() {
-  return _.normalize(B);
-}
-function Rt(r = []) {
-  return _.normalize(_.join(B, global.OVERLAYED.APP_NAME, ...r));
-}
-var R = "object", xe = "function", Te = "prototype", re = "text", he = "json", ve = "abort", oe = "paramsSerializer", Ee = "addEventListener", N = "status", k = "headers", ee = Object, P = void 0, W = null, ie = ee[Te], X = ee.keys, D = Array.isArray, we = "method", De = "HEAD", le = "GET", Oe = "OPTIONS", Kt = "POST", xt = "PUT", Tt = "PATCH", Dt = "DELETE";
-function Ot(r, t) {
-  let e = new AbortController();
-  function n(i) {
-    e.abort(i), o();
+var L = "object", Le = "function", Oe = "prototype", ee = "text", ce = "json", ye = "abort", ne = "paramsSerializer", me = "addEventListener", V = "status", w = "headers", Z = Object, S = void 0, W = null, re = Z[Oe], Q = Z.keys, x = Array.isArray, be = "method", Fe = "HEAD", se = "GET", Re = "OPTIONS", ht = "POST", gt = "PUT", ft = "PATCH", pt = "DELETE";
+function yt(n, e) {
+  let t = new AbortController();
+  function r(o) {
+    t.abort(o), a();
   }
   let s = [];
-  for (let i of r) {
-    if ((i == null ? void 0 : i.aborted) === !0) {
-      n(i.reason);
+  for (let o of n) {
+    if ((o == null ? void 0 : o.aborted) === !0) {
+      r(o.reason);
       break;
     }
-    if (i != null && i[Ee]) {
+    if (o != null && o[me]) {
       let l = () => {
-        n(i.reason);
+        r(o.reason);
       };
       s.push(() => {
-        var h;
-        (h = i.removeEventListener) == null || h.call(i, ve, l);
-      }), i[Ee](ve, l);
+        var d;
+        (d = o.removeEventListener) == null || d.call(o, ye, l);
+      }), o[me](ye, l);
     }
   }
-  function o() {
-    s.forEach((i) => i()), t == null || t();
+  function a() {
+    s.forEach((o) => o()), e == null || e();
   }
-  let a = e.signal;
-  return a.clear = o, a;
+  let i = t.signal;
+  return i.clear = a, i;
 }
-var ke = ee.getPrototypeOf, Ie = (r) => {
-  if (r !== W && typeof r === R) {
-    if (typeof ke === xe) {
-      let t = ke(r);
-      return t === ie || t === W;
+var ve = Z.getPrototypeOf, Ie = (n) => {
+  if (n !== W && typeof n === L) {
+    if (typeof ve === Le) {
+      let e = ve(n);
+      return e === re || e === W;
     }
-    return ie.toString.call(r) === `[${R} Object]`;
+    return re.toString.call(n) === `[${L} Object]`;
   }
   return !1;
-}, ge = (...r) => r.reduce((t, e) => {
-  if (D(e)) throw new TypeError(`Arguments must be ${R}s, not arrays.`);
-  return X(e).forEach((n) => {
-    ["__proto__", "constructor", Te].includes(n) || (D(t[n]) && D(e[n]) ? t[n] = Array.from(new Set(t[n].concat(e[n]))) : Ie(t[n]) && Ie(e[n]) ? t[n] = ge(t[n], e[n]) : t[n] = e[n]);
-  }), t;
+}, ue = (...n) => n.reduce((e, t) => {
+  if (x(t)) throw new TypeError(`Arguments must be ${L}s, not arrays.`);
+  return Q(t).forEach((r) => {
+    ["__proto__", "constructor", Oe].includes(r) || (x(e[r]) && x(t[r]) ? e[r] = Array.from(new Set(e[r].concat(t[r]))) : Ie(e[r]) && Ie(t[r]) ? e[r] = ue(e[r], t[r]) : e[r] = t[r]);
+  }), e;
 }, {});
-function pe(r, t = !0, e = W, n) {
-  if (r === P || r === W) return "";
-  let s = [], o = t ? encodeURIComponent : (p) => p, a = D(r), { arrayFormat: i, allowDots: l, serializeDate: h } = n || {}, g = (p) => {
-    if (l && !a) return `.${p}`;
-    if (a) {
-      if (i === "brackets") return "[]";
-      if (i === "repeat") return "";
+function de(n, e = !0, t = W, r) {
+  if (n === S || n === W) return "";
+  let s = [], a = e ? encodeURIComponent : (g) => g, i = x(n), { arrayFormat: o, allowDots: l, serializeDate: d } = r || {}, h = (g) => {
+    if (l && !i) return `.${g}`;
+    if (i) {
+      if (o === "brackets") return "[]";
+      if (o === "repeat") return "";
     }
-    return `[${p}]`;
+    return `[${g}]`;
   };
-  for (let p in r) if (ie.hasOwnProperty.call(r, p)) {
-    let d = r[p];
-    if (d !== P) {
-      let m = e ? `${e}${g(p)}` : o(p);
-      if (!isNaN(d) && d instanceof Date && (d = h ? h(d) : d.toISOString()), typeof d === R) {
-        let f = pe(d, t, m, n);
+  for (let g in n) if (re.hasOwnProperty.call(n, g)) {
+    let u = n[g];
+    if (u !== S) {
+      let p = t ? `${t}${h(g)}` : a(g);
+      if (!isNaN(u) && u instanceof Date && (u = d ? d(u) : u.toISOString()), typeof u === L) {
+        let f = de(u, e, p, r);
         f !== "" && s.push(f);
-      } else s.push(`${o(m)}=${o(d)}`);
+      } else s.push(`${a(p)}=${a(u)}`);
     }
   }
   return s.join("&");
 }
-function ce(r) {
-  return D(r) ? r.map(ce) : (r && typeof r === R && X(r).forEach((t) => {
-    let e = r[t];
-    e === P ? delete r[t] : ce(e);
-  }), r);
+function ie(n) {
+  return x(n) ? n.map(ie) : (n && typeof n === L && Q(n).forEach((e) => {
+    let t = n[e];
+    t === S ? delete n[e] : ie(t);
+  }), n);
 }
-function Lt(r) {
-  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
+function mt(n) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(n);
 }
-function Ft(r, t) {
-  return r ? t ? (r.endsWith("/") ? r : r + "/") + (t[0] === "/" ? t.slice(1) : t) : r : t || "";
+function bt(n, e) {
+  return n ? e ? (n.endsWith("/") ? n : n + "/") + (e[0] === "/" ? e.slice(1) : e) : n : e || "";
 }
-var Bt = "XiorError", Gt = "XiorTimeoutError", Le = class extends Error {
-  constructor(t, e, n) {
-    super(t), this.name = Bt, this.request = e, this.config = e, this.response = n;
-  }
-}, Ht = class extends Le {
-  constructor(t, e, n) {
-    super(t, e, n), this.name = Gt;
-  }
-}, Nt = Object.defineProperty, jt = Object.defineProperties, Ut = Object.getOwnPropertyDescriptors, Y = Object.getOwnPropertySymbols, Fe = Object.prototype.hasOwnProperty, Be = Object.prototype.propertyIsEnumerable, Ce = (r, t, e) => t in r ? Nt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, O = (r, t) => {
-  for (var e in t || (t = {})) Fe.call(t, e) && Ce(r, e, t[e]);
-  if (Y) for (var e of Y(t)) Be.call(t, e) && Ce(r, e, t[e]);
-  return r;
-}, z = (r, t) => jt(r, Ut(t)), zt = (r, t) => {
-  var e = {};
-  for (var n in r) Fe.call(r, n) && t.indexOf(n) < 0 && (e[n] = r[n]);
-  if (r != null && Y) for (var n of Y(r)) t.indexOf(n) < 0 && Be.call(r, n) && (e[n] = r[n]);
-  return e;
-}, L = (r, t, e) => new Promise((n, s) => {
-  var o = (l) => {
+var vt = "XiorError", It = "XiorTimeoutError", xe = class extends Error {
+  constructor(n, e, t) {
+    super(n), this.name = vt, this.request = e, this.config = e, this.response = t;
+  }
+}, Et = class extends xe {
+  constructor(e, t, r) {
+    super(e, t, r), this.name = It;
+  }
+}, wt = Object.defineProperty, _t = Object.defineProperties, kt = Object.getOwnPropertyDescriptors, X = Object.getOwnPropertySymbols, $e = Object.prototype.hasOwnProperty, De = Object.prototype.propertyIsEnumerable, Ee = (n, e, t) => e in n ? wt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, $ = (n, e) => {
+  for (var t in e || (e = {})) $e.call(e, t) && Ee(n, t, e[t]);
+  if (X) for (var t of X(e)) De.call(e, t) && Ee(n, t, e[t]);
+  return n;
+}, z = (n, e) => _t(n, kt(e)), Pt = (n, e) => {
+  var t = {};
+  for (var r in n) $e.call(n, r) && e.indexOf(r) < 0 && (t[r] = n[r]);
+  if (n != null && X) for (var r of X(n)) e.indexOf(r) < 0 && De.call(n, r) && (t[r] = n[r]);
+  return t;
+}, D = (n, e, t) => new Promise((r, s) => {
+  var a = (l) => {
     try {
-      i(e.next(l));
-    } catch (h) {
-      s(h);
+      o(t.next(l));
+    } catch (d) {
+      s(d);
     }
-  }, a = (l) => {
+  }, i = (l) => {
     try {
-      i(e.throw(l));
-    } catch (h) {
-      s(h);
+      o(t.throw(l));
+    } catch (d) {
+      s(d);
     }
-  }, i = (l) => l.done ? n(l.value) : Promise.resolve(l.value).then(o, a);
-  i((e = e.apply(r, t)).next());
-}), fe = "application/", Ge = `${fe}x-www-form-urlencoded`, He = RegExp, Vt = new He(`^${Ge}`, "i"), qt = `${fe}${he}`, Wt = new He(`^${fe}.*${he}.*`, "i");
-function Xt(r = le) {
-  return [De, le, Oe].includes(r);
+  }, o = (l) => l.done ? r(l.value) : Promise.resolve(l.value).then(a, i);
+  o((t = t.apply(n, e)).next());
+}), he = "application/", Te = `${he}x-www-form-urlencoded`, Be = RegExp, Ct = new Be(`^${Te}`, "i"), Kt = `${he}${ce}`, St = new Be(`^${he}.*${ce}.*`, "i");
+function Mt(n = se) {
+  return [Fe, se, Re].includes(n);
 }
-var Yt = typeof URLSearchParams != `${P}`;
-function Jt(r) {
-  return L(this, null, function* () {
-    let t = r[oe] || pe, e = r.encodeURI !== !1, n = r[we] && r[we].toUpperCase(), s = r.url, o = s, a = Yt && r.data instanceof URLSearchParams, i = a ? ee.fromEntries(r.data.entries()) : r.data, l = i, h = r != null && r[k] ? O({}, r[k]) : {}, g = r.params, p = Xt(n);
-    if (i && typeof i.append !== xe) {
-      let d = "", m = "content-type";
-      if (r != null && r[k]) {
-        let f = X(r[k]).find((w) => w.toLowerCase() === m);
-        f && (m = f, d = r[k][f]);
+var At = typeof URLSearchParams != `${S}`;
+function Lt(n) {
+  return D(this, null, function* () {
+    let e = n[ne] || de, t = n.encodeURI !== !1, r = n[be] && n[be].toUpperCase(), s = n.url, a = s, i = At && n.data instanceof URLSearchParams, o = i ? Z.fromEntries(n.data.entries()) : n.data, l = o, d = n != null && n[w] ? $({}, n[w]) : {}, h = n.params, g = Mt(r);
+    if (o && typeof o.append !== Le) {
+      let u = "", p = "content-type";
+      if (n != null && n[w]) {
+        let f = Q(n[w]).find((E) => E.toLowerCase() === p);
+        f && (p = f, u = n[w][f]);
       }
-      (!d || a) && (d = p || a ? Ge : qt, h[m] = d), typeof i === R && (p && g && (g = ge(i, g)), Wt.test(d) ? l = JSON.stringify(ce(i)) : !p && Vt.test(d) && (l = t(i)));
+      (!u || i) && (u = g || i ? Te : Kt, d[p] = u), typeof o === L && (g && h && (h = ue(o, h)), St.test(u) ? l = JSON.stringify(ie(o)) : !g && Ct.test(u) && (l = e(o)));
     }
-    if (g && X(g).length > 0) {
-      let d = t(g, e);
-      s += s.includes("?") ? `&${d}` : `?${d}`;
+    if (h && Q(h).length > 0) {
+      let u = e(h, t);
+      s += s.includes("?") ? `&${u}` : `?${u}`;
     }
-    return z(O({}, r), { _data: l, _url: s, data: i, url: o, method: n, [k]: h, isGet: p });
+    return z($({}, n), { _data: l, _url: s, data: o, url: a, method: r, [w]: d, isGet: g });
   });
 }
-var Qt = typeof AbortController != `${P}`;
-function Zt(r, t) {
-  return L(this, null, function* () {
-    let e;
-    if (!t || !r.ok || [re, he].includes(t)) {
-      if (e = yield r[re](), e && t !== re) try {
-        e = JSON.parse(e);
+var Ot = typeof AbortController != `${S}`;
+function Ft(n, e) {
+  return D(this, null, function* () {
+    let t;
+    if (!e || !n.ok || [ee, ce].includes(e)) {
+      if (t = yield n[ee](), t && e !== ee) try {
+        t = JSON.parse(t);
       } catch {
       }
     } else {
-      if (t === "blob") return r.blob();
-      if (t === "arraybuffer") return r.arrayBuffer();
+      if (e === "blob") return n.blob();
+      if (e === "arraybuffer") return n.arrayBuffer();
     }
-    return e;
+    return t;
   });
 }
-var en = (r) => new A(r), A = class {
-  constructor(t) {
-    this.REQI = [], this.RESI = [], this.P = [], this.config = t, this.defaults = { params: {}, [k]: {} };
+var Rt = (n) => new A(n), A = class {
+  constructor(e) {
+    this.REQI = [], this.RESI = [], this.P = [], this.config = e, this.defaults = { params: {}, [w]: {} };
   }
   get interceptors() {
-    return { request: { use: (t, e, n) => (this.REQI.push(t), t), eject: (t) => {
-      this.REQI = this.REQI.filter((e) => e !== t);
+    return { request: { use: (e, t, r) => (this.REQI.push(e), e), eject: (e) => {
+      this.REQI = this.REQI.filter((t) => t !== e);
     }, 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);
+    } }, response: { use: (e, t) => (this.RESI.push({ fn: e, onRejected: t }), e), eject: (e) => {
+      this.RESI = this.RESI.filter((t) => t.fn !== e);
     }, clear: () => {
       this.RESI = [];
     } } };
   }
   get plugins() {
-    return { use: (t) => (this.P.push(t), t), eject: (t) => {
-      this.P = this.P.filter((e) => e !== t);
+    return { use: (e) => (this.P.push(e), e), eject: (e) => {
+      this.P = this.P.filter((t) => t !== e);
     }, clear: () => {
       this.P = [];
     } };
   }
-  request(t) {
-    return L(this, null, function* () {
-      let e = ge(this.config || {}, this.defaults, typeof t == "string" ? { url: t } : t), n = "credentials";
-      e.withCredentials && !e[n] && (e[n] = "include"), e[oe] || (e[oe] = pe);
-      for (let a of this.REQI) e = yield a(e);
+  request(e) {
+    return D(this, null, function* () {
+      let t = ue(this.config || {}, this.defaults, typeof e == "string" ? { url: e } : e), r = "credentials";
+      t.withCredentials && !t[r] && (t[r] = "include"), t[ne] || (t[ne] = de);
+      for (let i of this.REQI) t = yield i(t);
       let s = this._.bind(this);
-      this.P.forEach((a) => {
-        s = a(s, this);
+      this.P.forEach((i) => {
+        s = i(s, this);
       });
-      let o = s(e);
-      if (!e._did) {
-        let a = 0, i = [];
+      let a = s(t);
+      if (!t._did) {
+        let i = 0, o = [];
         for (this.RESI.forEach(function(l) {
-          i.push(l.fn, l.onRejected);
-        }); i.length > a; ) o = o.then(i[a++], i[a++]);
+          o.push(l.fn, l.onRejected);
+        }); o.length > i; ) a = a.then(o[i++], o[i++]);
       }
-      return o;
+      return a;
     });
   }
-  _(t) {
-    return L(this, null, function* () {
-      let e = yield Jt(t), { url: n, method: s, headers: o, timeout: a, signal: i, data: l, _data: h, _url: g, isGet: p, fetch: d } = e, m = zt(e, ["url", "method", "headers", "timeout", "signal", "data", "_data", "_url", "isGet", "fetch"]);
-      t._url = g;
-      let f, w = [], G = P;
-      if (a && Qt) {
-        let v = new AbortController();
-        G = setTimeout(() => {
-          v.abort(new Ht(`timeout of ${a}ms exceeded`, t));
-        }, a), w.push(v.signal);
+  _(e) {
+    return D(this, null, function* () {
+      let t = yield Lt(e), { url: r, method: s, headers: a, timeout: i, signal: o, data: l, _data: d, _url: h, isGet: g, fetch: u } = t, p = Pt(t, ["url", "method", "headers", "timeout", "signal", "data", "_data", "_url", "isGet", "fetch"]);
+      e._url = h;
+      let f, E = [], j = S;
+      if (i && Ot) {
+        let b = new AbortController();
+        j = setTimeout(() => {
+          b.abort(new Et(`timeout of ${i}ms exceeded`, e));
+        }, i), E.push(b.signal);
       }
-      i && w.push(i), f = w[0], w.length > 1 && (f = Ot(w, () => {
-        clearTimeout(G);
+      o && E.push(o), f = E[0], E.length > 1 && (f = yt(E, () => {
+        clearTimeout(j);
       }));
-      let H = g || n, _e = "baseURL";
-      return t[_e] && !Lt(H) && (H = Ft(t[_e], H)), (d || fetch)(H, z(O({ body: p ? P : h }, m), { signal: f, method: s, headers: o })).then((v) => L(this, null, function* () {
-        let { responseType: st } = t, be = { data: yield Zt(v, st), response: v, config: t, request: t, [N]: v[N], statusText: v.statusText, [k]: v[k] };
-        if (!v.ok) {
-          let at = new Le(v[N] ? `Request failed with status code ${v[N]}` : "Network error", t, be);
-          return Promise.reject(at);
+      let N = h || r, fe = "baseURL";
+      return e[fe] && !mt(N) && (N = bt(e[fe], N)), (u || fetch)(N, z($({ body: g ? S : d }, p), { signal: f, method: s, headers: a })).then((b) => D(this, null, function* () {
+        let { responseType: Ve } = e, pe = { data: yield Ft(b, Ve), response: b, config: e, request: e, [V]: b[V], statusText: b.statusText, [w]: b[w] };
+        if (!b.ok) {
+          let Ue = new xe(b[V] ? `Request failed with status code ${b[V]}` : "Network error", e, pe);
+          return Promise.reject(Ue);
         }
-        return be;
+        return pe;
       })).finally(() => {
-        var v;
-        G && clearTimeout(G), (v = f == null ? void 0 : f.clear) == null || v.call(f);
+        var b;
+        j && clearTimeout(j), (b = f == null ? void 0 : f.clear) == null || b.call(f);
       });
     });
   }
-  cG(t) {
-    return (e, n) => this.request(n ? z(O({}, n), { method: t, url: e }) : { method: t, url: e });
+  cG(e) {
+    return (t, r) => this.request(r ? z($({}, r), { method: e, url: t }) : { method: e, url: t });
   }
-  cP(t) {
-    return (e, n, s) => this.request(s ? z(O({}, s), { method: t, url: e, data: n }) : { method: t, url: e, data: n });
+  cP(e) {
+    return (t, r, s) => this.request(s ? z($({}, s), { method: e, url: t, data: r }) : { method: e, url: t, data: r });
   }
-  get(t, e) {
-    return this.cG(le)(t, e);
+  get(e, t) {
+    return this.cG(se)(e, t);
   }
-  head(t, e) {
-    return this.cG(De)(t, e);
+  head(e, t) {
+    return this.cG(Fe)(e, t);
   }
-  post(t, e, n) {
-    return this.cP(Kt)(t, e, n);
+  post(e, t, r) {
+    return this.cP(ht)(e, t, r);
   }
-  put(t, e, n) {
-    return this.cP(xt)(t, e, n);
+  put(e, t, r) {
+    return this.cP(gt)(e, t, r);
   }
-  patch(t, e, n) {
-    return this.cP(Tt)(t, e, n);
+  patch(e, t, r) {
+    return this.cP(ft)(e, t, r);
   }
-  delete(t, e) {
-    return this.cG(Dt)(t, e);
+  delete(e, t) {
+    return this.cG(pt)(e, t);
   }
-  options(t, e) {
-    return this.cG(Oe)(t, e);
+  options(e, t) {
+    return this.cG(Re)(e, t);
   }
 };
-A.create = en, A.VERSION = "0.7.7";
-var tn = Object.assign(A.create(), { create: A.create, VERSION: A.VERSION }), Ne = tn;
-const je = Ne.create({
+A.create = Rt, A.VERSION = "0.7.7";
+var xt = Object.assign(A.create(), { create: A.create, VERSION: A.VERSION }), Ge = xt;
+const je = Ge.create({
   baseURL: "https://updater.stats.cc",
   headers: {
     Accept: "application/json",
     "Accept-Encoding": "gzip, deflate, br"
   }
-}), ye = Ne.create({
+}), ge = Ge.create({
   baseURL: "https://api.stats.cc",
   headers: {
     Accept: "application/json",
     "Accept-Encoding": "gzip, deflate, br"
   }
 });
-function nn(r, t) {
-  return je.get(`/v1/native/${r}/version.txt`, {
-    params: { channel: t },
+function $t(n, e) {
+  return je.get(`/v1/native/${n}/version.txt`, {
+    params: { channel: e },
     responseType: "text"
   });
 }
-function rn(r, t) {
-  return je.get(`/v1/native/${r}/files`, {
-    params: { channel: t },
+function Dt(n, e) {
+  return je.get(`/v1/native/${n}/files`, {
+    params: { channel: e },
     responseType: "arraybuffer"
   });
 }
-function sn() {
-  return ye.get("/v1/raven/config");
+function Tt() {
+  return ge.get("/v1/raven/config");
 }
-function an(r, t) {
-  return ye.get(`/v1/raven/games/${r}/builds/${t}/check`);
+function Bt(n, e) {
+  return ge.get(`/v1/raven/games/${n}/builds/${e}/check`);
 }
-function on(r, t) {
-  const e = new FormData();
-  return e.append("file", t), ye.post(`/v1/raven/games/${r}/builds/upload`, e, {});
+function Gt(n, e) {
+  const t = new FormData();
+  return t.append("file", e), ge.post(`/v1/raven/games/${n}/builds/upload`, t, {});
 }
-function ln(r) {
-  return r instanceof Error && (r.name === "XiorError" || r.name === "XiorTimeoutError");
+function jt(n) {
+  return n instanceof Error && (n.name === "XiorError" || n.name === "XiorTimeoutError");
 }
-function cn(r) {
-  return !!(r && "kind" in r.data && "message" in r.data);
+function Nt(n) {
+  return !!(n && "kind" in n.data && "message" in n.data);
 }
-const dn = {
+const Vt = {
   buildChannel: "alpha"
 };
-class un extends x {
+class Ut extends G {
   constructor() {
     super("NativeDllManager");
     c(this, "UPDATE_CHECK_INTERVAL_MS", 1e3 * 60 * 5);
     // 5 minutes
     c(this, "targetDir");
     c(this, "updateInterval");
-    this.targetDir = _.join(B, "resources"), this.logger.log("Target directory", this.targetDir);
+    this.targetDir = m.join(le(), "resources"), this.logger.log("Target directory", this.targetDir);
   }
-  async initWithDlls(e) {
-    super.init(), await E.mkdir(this.targetDir, { recursive: !0 }), await this.checkForUpdates(e), clearInterval(this.updateInterval), this.updateInterval = setInterval(() => this.checkForUpdates(e), this.UPDATE_CHECK_INTERVAL_MS);
+  async initWithDlls(t) {
+    super.init(), await v.mkdir(this.targetDir, { recursive: !0 }), await this.checkForUpdates(t), clearInterval(this.updateInterval), this.updateInterval = setInterval(() => this.checkForUpdates(t), this.UPDATE_CHECK_INTERVAL_MS);
   }
   destroy() {
     this.updateInterval && (clearInterval(this.updateInterval), this.updateInterval = void 0), super.destroy();
   }
-  async getCurrentVersion(e) {
+  async getCurrentVersion(t) {
     try {
-      const n = _.join(this.targetDir, e, "version.txt");
-      return await E.readFile(n, "utf-8");
+      const r = m.join(this.targetDir, t, "version.txt");
+      return await v.readFile(r, "utf-8");
     } catch {
       return null;
     }
   }
-  getTargetPath(e) {
-    return _.join(this.targetDir, e);
+  getTargetPath(t) {
+    return m.join(this.targetDir, t);
   }
-  getTargetVersionPath(e, n) {
-    return _.join(this.getTargetPath(e), n);
+  getTargetVersionPath(t, r) {
+    return m.join(this.getTargetPath(t), r);
   }
-  async checkForUpdates(e) {
-    const n = dn.buildChannel;
+  async checkForUpdates(t) {
+    const r = Vt.buildChannel;
     this.logger.log("Checking for updates");
-    for (const s of e)
+    for (const s of t)
       try {
-        const { data: o } = await nn(s, n), a = await this.getCurrentVersion(s);
-        this.logger.log(`${s} > Update Check. current: ${a}, latest: ${o}`);
-        const i = o !== a;
-        this.logger.log(`${s} > Update found: ${a} -> ${o}`), await this.downloadAndExtractDll(s, o, n, i), this.logger.log(`${s} > Downloaded and extracted`), i && (this.logger.log(`${s} > Cleaning up versions older than ${o}`), await this.cleanupOldVersions(s, o)), this.emit("dllUpdated", { identifier: s, version: o });
-      } catch (o) {
-        this.logger.captureSentryException(`${s} > Error checking/updating`, o);
+        const { data: a } = await $t(s, r), i = await this.getCurrentVersion(s);
+        this.logger.log(`${s} > Update Check. current: ${i}, latest: ${a}`);
+        const o = a !== i;
+        this.logger.log(`${s} > Update found: ${i} -> ${a}`), await this.downloadAndExtractDll(s, a, r, o), this.logger.log(`${s} > Downloaded and extracted`), o && (this.logger.log(`${s} > Cleaning up versions older than ${a}`), await this.cleanupOldVersions(s, a)), this.emit("dllUpdated", { identifier: s, version: a });
+      } catch (a) {
+        this.logger.captureSentryException(`${s} > Error checking/updating`, a);
       }
   }
-  async downloadAndExtractDll(e, n, s, o) {
-    const { data: a } = await rn(e, s), i = this.getTargetPath(e), l = this.getTargetVersionPath(e, n);
-    await E.mkdir(l, { recursive: !0 });
-    const h = new Me();
-    await h.loadAsync(a);
-    const g = Object.keys(h.files).map(async (d) => {
-      const m = h.files[d];
-      if (m && !m.dir) {
-        const f = _.join(l, d);
-        if (!o)
+  async downloadAndExtractDll(t, r, s, a) {
+    const { data: i } = await Dt(t, s), o = this.getTargetPath(t), l = this.getTargetVersionPath(t, r);
+    await v.mkdir(l, { recursive: !0 });
+    const d = new ke();
+    await d.loadAsync(i);
+    const h = Object.keys(d.files).map(async (u) => {
+      const p = d.files[u];
+      if (p && !p.dir) {
+        const f = m.join(l, u);
+        if (!a)
           try {
-            await E.access(f, E.constants.F_OK);
+            await v.access(f, v.constants.F_OK);
             return;
           } catch {
-            this.logger.warn(`${e} > File missing, re-downloading: ${f}`);
+            this.logger.warn(`${t} > File missing, re-downloading: ${f}`);
           }
-        const w = await m.async("nodebuffer");
-        await E.writeFile(f, w);
+        const E = await p.async("nodebuffer");
+        await v.writeFile(f, E);
       }
     });
-    await Promise.all(g);
-    const p = _.join(i, "version.txt");
-    this.logger.log("Saving version file", p), await E.writeFile(p, n);
+    await Promise.all(h);
+    const g = m.join(o, "version.txt");
+    this.logger.log("Saving version file", g), await v.writeFile(g, r);
   }
-  async cleanupOldVersions(e, n) {
-    const s = _.join(this.targetDir, e), o = await E.readdir(s, { withFileTypes: !0 });
-    for (const a of o)
-      a.isDirectory() && a.name !== n && await E.rm(_.join(s, a.name), { recursive: !0, force: !0 });
+  async cleanupOldVersions(t, r) {
+    const s = m.join(this.targetDir, t), a = await v.readdir(s, { withFileTypes: !0 });
+    for (const i of a)
+      i.isDirectory() && i.name !== r && await v.rm(m.join(s, i.name), { recursive: !0, force: !0 });
   }
 }
-const J = I(un);
-class hn extends x {
+const J = _(Ut);
+class Ht extends G {
   constructor() {
     super("RavenManager");
     c(this, "REFETCH_INTERVAL", 1e3 * 60 * 5);
@@ -731,8 +782,8 @@ class hn extends x {
       this._failedRefetchTimeoutHandler && (clearTimeout(this._failedRefetchTimeoutHandler), this._failedRefetchTimeoutHandler = null), this.fetchRavenConfig();
     }, this.REFETCH_INTERVAL);
   }
-  getExecutableData(e) {
-    return this._executableToGameMap.get(e.toLowerCase()) ?? null;
+  getExecutableData(t) {
+    return this._executableToGameMap.get(t.toLowerCase()) ?? null;
   }
   get executables() {
     return this._executablesArray;
@@ -745,81 +796,90 @@ class hn extends x {
   }
   async fetchRavenConfig() {
     try {
-      const e = await sn();
-      this._ravenConfig = e.data, this.resetState();
-      const n = /* @__PURE__ */ new Set();
+      const t = await Tt();
+      this._ravenConfig = t.data, this.resetState();
+      const r = /* @__PURE__ */ new Set();
       for (const s of this._ravenConfig.games) {
-        for (const o of s.executables) {
-          const a = o.toLowerCase();
-          this._executableToGameMap.set(a, s), this._executablesArray.push(a);
+        for (const a of s.executables) {
+          const i = a.toLowerCase();
+          this._executableToGameMap.set(i, s), this._executablesArray.push(i);
         }
-        s.dlls_to_inject.forEach((o) => n.add(o));
+        s.dlls_to_inject.forEach((a) => r.add(a));
       }
-      await J.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);
+      await J.getInstance().initWithDlls(Array.from(r)), this.logger.log("Raven updated", this._ravenConfig), this.emit("executablesUpdated", { executables: this.executables, map: this._executableToGameMap });
+    } catch (t) {
+      this.logger.captureSentryException("Failed to fetch Raven config", t), this._failedRefetchTimeoutHandler = setTimeout(() => this.fetchRavenConfig(), this.FAILED_REFETCH_INTERVAL);
     }
   }
   resetState() {
     this._executableToGameMap.clear(), this._executablesArray = [];
   }
 }
-const Q = I(hn), gn = ue(import.meta.url), { PipeEventServer: Dr, PipeEventClient: Or, PipeEventBase: Lr, ProcessMonitor: pn, Process: j, InjectionMethod: Fr, AccessLevel: Br } = gn("./build/overlayed_native_interface_x64.node");
-class fn extends x {
+const T = _(Ht), zt = Y(import.meta.url), {
+  PipeEventServer: Hn,
+  PipeEventClient: zn,
+  PipeEventBase: qn,
+  ProcessMonitor: qt,
+  Process: U,
+  InjectionMethod: Wn,
+  AccessLevel: Qn,
+  HardwareInterface: Wt
+} = zt("./build/overlayed_native_interface_x64.node");
+class Qt extends G {
   constructor() {
     super("ProcessManager");
     c(this, "_processMonitor");
     c(this, "_processes", /* @__PURE__ */ new Map());
     c(this, "boundOnRavenManagerExecutablesUpdated", this.onRavenManagerExecutablesUpdated.bind(this));
-    this._processMonitor = new pn();
+    this._processMonitor = new qt();
   }
   get hasAnyActiveProcesses() {
     return this.activeProcesses.length > 0;
   }
   get activeProcesses() {
-    return Array.from(this._processes.values()).flat().filter((e) => !e.destroyedAt);
+    return Array.from(this._processes.values()).flat().filter((t) => !t.destroyedAt);
   }
   init() {
-    super.init(), Q.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 });
+    super.init(), T.getInstance().on("executablesUpdated", this.boundOnRavenManagerExecutablesUpdated), this._processMonitor.on("create", (t) => {
+      this.logger.log("Process created", t), this.addProcess(t), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("create", { process: t });
+    }), this._processMonitor.on("destroy", (t) => {
+      this.logger.log("Process destroyed", t), this.deleteProcess(t), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("destroy", { process: t });
     });
   }
   destroy() {
-    Q.getInstance().off("executablesUpdated", this.boundOnRavenManagerExecutablesUpdated), this._processes.clear(), this._processMonitor.removeAllListeners(), super.destroy();
+    T.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;
+  isProcessRunning(t) {
+    const r = this._processes.get(t);
+    return (r == null ? void 0 : r.some((s) => !s.destroyedAt)) ?? !1;
   }
-  onRavenManagerExecutablesUpdated(e) {
-    e.executables.forEach((n) => {
-      this.logger.log("Monitoring process", n), this._processMonitor.registerProcess(n);
+  onRavenManagerExecutablesUpdated(t) {
+    t.executables.forEach((r) => {
+      this.logger.log("Monitoring process", r), this._processMonitor.registerProcess(r);
     });
   }
-  addProcess(e) {
-    if (!e.name)
+  addProcess(t) {
+    if (!t.name)
       return;
-    const n = this._processes.get(e.name);
-    if (!n) {
-      this._processes.set(e.name, [e]);
+    const r = this._processes.get(t.name);
+    if (!r) {
+      this._processes.set(t.name, [t]);
       return;
     }
-    this._processes.set(e.name, n.concat(e));
+    this._processes.set(t.name, r.concat(t));
   }
-  deleteProcess(e) {
-    if (!e.name)
+  deleteProcess(t) {
+    if (!t.name)
       return;
-    const n = this._processes.get(e.name), s = (n == null ? void 0 : n.filter((o) => o.id !== e.id)) ?? [];
-    s.length === 0 ? this._processes.delete(e.name) : this._processes.set(e.name, s);
+    const r = this._processes.get(t.name), s = (r == null ? void 0 : r.filter((a) => a.id !== t.id)) ?? [];
+    s.length === 0 ? this._processes.delete(t.name) : this._processes.set(t.name, s);
   }
 }
-const M = I(fn), yn = ue(import.meta.url), { RenderInterface: mn, renderHookPath: Gr } = yn("./build/overlayed_render_interface_x64.node");
-var _n = Object.defineProperty, bn = (r, t, e) => t in r ? _n(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, V = (r, t, e) => bn(r, typeof t != "symbol" ? t + "" : t, e);
-let vn = class {
-  constructor(t) {
-    V(this, "_instance"), V(this, "_resolution"), V(this, "boundOnResolutionChanged", this.onResolutionChanged.bind(this)), this._instance = t, this._resolution = { width: 0, height: 0 }, this._instance.on("resolution", this.boundOnResolutionChanged);
+const C = _(Qt), Xt = Y(import.meta.url), { RenderInterface: Jt, renderHookPath: Xn } = Xt("./build/overlayed_render_interface_x64.node");
+var Yt = Object.defineProperty, Zt = (n, e, t) => e in n ? Yt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, q = (n, e, t) => Zt(n, typeof e != "symbol" ? e + "" : e, t);
+class en {
+  constructor(e) {
+    q(this, "_instance"), q(this, "_resolution"), q(this, "boundOnResolutionChanged", this.onResolutionChanged.bind(this)), this._instance = e, this._resolution = { width: 0, height: 0 }, this._instance.on("resolution", this.boundOnResolutionChanged);
   }
   destroy() {
     this._instance.off("resolution", this.boundOnResolutionChanged);
@@ -830,139 +890,188 @@ let vn = class {
   get resolution() {
     return this._resolution;
   }
-  onResolutionChanged(t, e) {
-    this._resolution = { width: t, height: e };
+  onResolutionChanged(e, t) {
+    this._resolution = { width: e, height: t };
   }
-}, En = class {
+}
+let tn = class {
   constructor() {
-    V(this, "interfaces", {});
+    q(this, "interfaces", {});
   }
-  createInterface(t) {
-    return this.interfaces[t] ? this.interfaces[t] : (this.interfaces[t] = new vn(new mn(t, { access: 1 })), this.interfaces[t]);
+  createInterface(e) {
+    return this.interfaces[e] ? this.interfaces[e] : (this.interfaces[e] = new en(new Jt(e, { access: 1 })), this.interfaces[e]);
   }
-  getInterface(t) {
-    return this.interfaces[t] ? this.interfaces[t] : this.createInterface(t);
+  getInterface(e) {
+    return this.interfaces[e] ? this.interfaces[e] : this.createInterface(e);
   }
 };
-const F = I(En);
-class wn extends x {
+const O = _(tn);
+var nn = Object.defineProperty, rn = (n, e, t) => e in n ? nn(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, F = (n, e, t) => rn(n, typeof e != "symbol" ? e + "" : e, t);
+class sn {
+  constructor() {
+    F(this, "data", []);
+  }
+  get size() {
+    return this.data.length;
+  }
+  add(e) {
+    this.data.push(e);
+  }
+  next() {
+    return this.data.shift();
+  }
+  clear() {
+    this.data.length = 0;
+  }
+  *flush() {
+    for (; this.size > 0; ) {
+      const e = this.next();
+      e && (yield e);
+    }
+  }
+}
+class an {
+  constructor(e) {
+    F(this, "_clientId", null), F(this, "_userId", null), F(this, "options"), F(this, "eventQueue"), this.options = this.resolveOptions(e), this.eventQueue = new sn(), this.setupFlushInterval();
+  }
+  set clientId(e) {
+    this._clientId = e;
+  }
+  set userId(e) {
+    this._userId = e;
+  }
+  track(e, t) {
+    this.eventQueue.add({ name: e, data: t, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  flush() {
+    return Array.from(this.eventQueue.flush());
+  }
+  setupFlushInterval() {
+    setInterval(() => {
+      this.flush();
+    }, this.options.batchIntervalSeconds * 1e3);
+  }
+  resolveOptions(e) {
+    return {
+      batchIntervalSeconds: (e == null ? void 0 : e.batchIntervalSeconds) ?? 15
+    };
+  }
+}
+const P = _(an), on = Y(import.meta.url), ln = on.resolve("@overlayed/app/dist/render-interface/build/overlayed_render_hook_x64.dll");
+class cn extends G {
   constructor() {
     super("GameLaunchManager");
-    c(this, "RENDER_INTERFACE_PATH", "node_modules/@overlayed/app/dist/render-interface/build/overlayed_render_hook_x64.dll");
     c(this, "boundOnProcessCreate", this.onProcessCreate.bind(this));
     c(this, "boundOnProcessDestroy", this.onProcessDestroy.bind(this));
   }
   init() {
-    super.init(), F.getInstance().createInterface("SCC_RAINBOW"), M.getInstance().on("create", this.boundOnProcessCreate), M.getInstance().on("destroy", this.boundOnProcessDestroy);
+    super.init(), O.getInstance().createInterface("OGG_SIEGE"), C.getInstance().on("create", this.boundOnProcessCreate), C.getInstance().on("destroy", this.boundOnProcessDestroy);
   }
   destroy() {
-    M.getInstance().off("create", this.boundOnProcessCreate), M.getInstance().off("destroy", this.boundOnProcessDestroy), super.destroy();
+    C.getInstance().off("create", this.boundOnProcessCreate), C.getInstance().off("destroy", this.boundOnProcessDestroy), super.destroy();
   }
-  async onProcessCreate({ process: e }) {
-    const n = this.getRavenGame(e);
-    if (!n)
+  async onProcessCreate({ process: t }) {
+    const r = this.getRavenGame(t);
+    if (!r)
       return;
-    if (this.logger.log("Game Launched", n), this.logger.log("Process is elevated: ", e.isElevated), this.logger.log("Current process is elevated: ", j.currentProcess.isElevated), e.isElevated && !j.currentProcess.isElevated) {
-      q.getInstance().error("Game is elevated but the App is not", "ELEVATION_MISMATCH", {
-        appElevated: j.currentProcess.isElevated,
-        gameElevated: e.isElevated
+    if (this.logger.log("Game Launched", r), this.logger.log("Process is elevated: ", t.isElevated), this.logger.log("Current process is elevated: ", U.currentProcess.isElevated), t.isElevated && !U.currentProcess.isElevated) {
+      I.getInstance().fatal("Game is elevated but the App is not", "ELEVATION_MISMATCH", {
+        appElevated: !!U.currentProcess.isElevated,
+        gameElevated: !!t.isElevated
       }), this.logger.sentryLog("Game elevated but App is not", {
-        appElevated: j.currentProcess.isElevated,
-        gameElevated: e.isElevated
+        appElevated: U.currentProcess.isElevated,
+        gameElevated: t.isElevated
       });
       return;
     }
-    const s = this.copyDll(this.RENDER_INTERFACE_PATH);
+    const s = this.copyDll(ln);
     if (s)
       try {
-        await e.injectDll(s), this.logger.log("Render Interface Injection Successful", s);
-      } catch (a) {
-        this.logger.captureSentryException("Render Interface Injection Failed", a), this.logger.sentryError("Render Interface Injection Failed", {
+        await t.injectDll(s), this.logger.log("Render Interface Injection Successful", s);
+      } catch (i) {
+        this.logger.captureSentryException("Render Interface Injection Failed", i), this.logger.sentryError("Render Interface Injection Failed", {
           renderInterfacePath: s
         });
       }
-    const o = n == null ? void 0 : n.dlls_to_inject.map(async (a) => {
-      const i = await J.getInstance().getCurrentVersion(a);
-      if (!i)
-        return this.logger.sentryError("No version found for DLL", { identifier: a }), Promise.resolve();
-      const l = J.getInstance().getTargetVersionPath(a, i);
+    const a = r == null ? void 0 : r.dlls_to_inject.map(async (i) => {
+      const o = await J.getInstance().getCurrentVersion(i);
+      if (!o)
+        return this.logger.sentryError("No version found for DLL", { identifier: i }), Promise.resolve();
+      const l = J.getInstance().getTargetVersionPath(i, o);
       this.logger.log("DLL Path", l);
-      const h = await this.getDllFiles(l);
-      return this.logger.log("DLL Files", h), Promise.all(
-        h.map(async (g) => {
-          const p = _.basename(g), d = _.join(l, p);
-          if (!d)
+      const d = await this.getDllFiles(l);
+      return this.logger.log("DLL Files", d), Promise.all(
+        d.map(async (h) => {
+          const g = m.basename(h), u = m.join(l, g);
+          if (!u)
             return Promise.resolve();
-          this.logger.log("Injecting: ", d);
+          this.logger.log("Injecting: ", u);
           try {
-            return e.injectDll(d).then(() => {
-              this.logger.log("Injection Successful", d);
-            }).catch((m) => {
-              this.logger.sentryError("Injection Failed [1]", { targetPath: d }, m);
+            return t.injectDll(u).then(() => {
+              this.logger.log("Injection Successful", u);
+            }).catch((p) => {
+              this.logger.sentryError("Injection Failed [1]", { targetPath: u }, p);
             });
-          } catch (m) {
-            return this.logger.sentryError("Injection Failed [2]", { targetPath: d }, m), Promise.reject(m);
+          } catch (p) {
+            return this.logger.sentryError("Injection Failed [2]", { targetPath: u }, p), Promise.reject(p);
           }
         })
       );
     });
-    await Promise.allSettled(o), this.emit("gameLaunchInternal", { ravenGame: n, process: e }), this.emit("gameLaunch", { game: n.identifier });
-  }
-  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 o = lt(e), a = _.join(B, "resources"), i = _.join(a, s);
-    this.logger.debug("Copying", o, "to", i);
+    await Promise.allSettled(a), this.emit("gameLaunchInternal", { ravenGame: r, process: t }), this.emit("gameLaunch", { game: r.identifier }), P.getInstance().track("game_launch", {
+      game: r.identifier
+    });
+  }
+  copyDll(t) {
+    const r = m.basename(t), s = Je(t), a = m.join(le(), "resources"), i = m.join(a, r);
+    this.logger.debug("Copying", s, "to", i);
     try {
-      dt(a) || ut(a, { recursive: !0 });
-      const l = Se(o);
-      ht(i, l), gt(o, i);
-    } catch (l) {
-      return l.code === "EBUSY" ? i : (this.logger.captureSentryException("Failed to copy", l), this.logger.sentryError("Failed to copy", { originalPath: o, targetPath: i }), !1);
+      qe(a) || We(a, { recursive: !0 });
+      const o = _e(s);
+      Qe(i, o), Xe(s, i);
+    } catch (o) {
+      return o.code === "EBUSY" ? i : (this.logger.captureSentryException("Failed to copy", o), this.logger.sentryError("Failed to copy", { originalPath: s, targetPath: i }), !1);
     }
     return i;
   }
-  async getDllFiles(e) {
+  async getDllFiles(t) {
     try {
-      return (await E.readdir(e)).filter((s) => s.endsWith(".dll")).map((s) => _.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 }), [];
+      return (await v.readdir(t)).filter((s) => s.endsWith(".dll")).map((s) => m.join(t, s));
+    } catch (r) {
+      return this.logger.captureSentryException("Failed to read DLL directory", r), this.logger.sentryError("Failed to read DLL directory", { dllPath: t }), [];
     }
   }
-  onProcessDestroy({ process: e }) {
-    const n = this.getRavenGame(e);
-    n && (this.emit("gameCloseInternal", { ravenGame: n, process: e }), this.emit("gameClose", { game: n.identifier }));
+  onProcessDestroy({ process: t }) {
+    const r = this.getRavenGame(t);
+    r && (this.emit("gameCloseInternal", { ravenGame: r, process: t }), this.emit("gameClose", { game: r.identifier }), P.getInstance().track("game_close", {
+      game: r.identifier
+    }));
   }
-  getRavenGame(e) {
-    if (!e.name)
+  getRavenGame(t) {
+    if (!t.name)
       return;
-    const n = Q.getInstance().getExecutableData(e.name);
-    if (!n) {
-      this.logger.sentryError("No raven game found for process", { process: e });
+    const r = T.getInstance().getExecutableData(t.name);
+    if (!r) {
+      this.logger.sentryError("No raven game found for process", { process: t });
       return;
     }
-    return n;
+    return r;
   }
 }
-const Z = I(wn);
-class kn extends Ke {
+const B = _(cn);
+class un extends Ae {
   constructor() {
     super("GameBuildManager");
     c(this, "boundOnGameLaunch", this.onGameLaunch.bind(this));
   }
   init() {
-    super.init(), Z.getInstance().on("gameLaunchInternal", this.boundOnGameLaunch);
+    super.init(), B.getInstance().on("gameLaunchInternal", this.boundOnGameLaunch);
   }
   destroy() {
-    Z.getInstance().off("gameLaunchInternal", this.boundOnGameLaunch), super.destroy();
+    B.getInstance().off("gameLaunchInternal", this.boundOnGameLaunch), super.destroy();
   }
-  async onGameLaunch(e) {
-    const { ravenGame: n, process: s } = e;
+  async onGameLaunch(t) {
+    const { ravenGame: r, process: s } = t;
     if (!s.path || !s.name) {
       this.logger.sentryError(
         "Process path or name not found, could not check for build hash",
@@ -971,30 +1080,30 @@ class kn extends Ke {
       );
       return;
     }
-    const o = Se(s.path), a = pt("sha256").update(o).digest("hex");
-    this.logger.log("Process Path", s.path), this.logger.log("Process Name", s.name), this.logger.log("Build Hash", a);
-    let i = !1;
+    const a = _e(s.path), i = Ye("sha256").update(a).digest("hex");
+    this.logger.log("Process Path", s.path), this.logger.log("Process Name", s.name), this.logger.log("Build Hash", i);
+    let o = !1;
     try {
-      i = (await an(n.identifier, a)).data.upload;
-    } catch (g) {
-      this.logger.captureSentryException("Error checking game build hash", g);
+      o = (await Bt(r.identifier, i)).data.upload;
+    } catch (h) {
+      this.logger.captureSentryException("Error checking game build hash", h);
       return;
     }
-    if (!i) {
+    if (!o) {
       this.logger.log("Build hash already exists, skipping upload");
       return;
     }
-    const l = new Me();
-    l.file(s.name, o);
-    const h = await l.generateAsync({ type: "blob" });
+    const l = new ke();
+    l.file(s.name, a);
+    const d = await l.generateAsync({ type: "blob" });
     try {
-      this.logger.log("Uploading build (size: ", h.size, " bytes)"), await on(n.identifier, h), this.logger.log("Build uploaded successfully");
-    } catch (g) {
-      ln(g) ? cn(g.response) ? this.logger.captureSentryException("Error uploading build hash, api error", g) : this.logger.captureSentryException("Error uploading build hash, request error", g) : this.logger.captureSentryException("Error uploading build hash, unknown error", g);
+      this.logger.log("Uploading build (size: ", d.size, " bytes)"), await Gt(r.identifier, d), this.logger.log("Build uploaded successfully");
+    } catch (h) {
+      jt(h) ? Nt(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 In = I(kn), de = /* @__PURE__ */ new Map([
+const Ne = _(un), ae = /* @__PURE__ */ new Map([
   [1, "LeftButton"],
   [2, "RightButton"],
   [3, "Cancel"],
@@ -1187,14 +1296,14 @@ const In = I(kn), de = /* @__PURE__ */ new Map([
   [252, "Noname"],
   [253, "PA1"],
   [254, "OEM_Clear"]
-]), Pe = new Map(de.entries().map(([r, t]) => [t, r])), Cn = y({
+]), we = new Map(ae.entries().map(([n, e]) => [e, n])), dn = K({
   "[string]": {
     keys: "string[]",
-    mode: y("'toggle' | 'hold'").pipe((r) => r ?? "toggle")
+    mode: K("'toggle' | 'hold'").pipe((n) => n ?? "toggle")
   }
 });
-class Pn extends x {
-  constructor(e) {
+class hn extends G {
+  constructor(t) {
     super("KeybindManager");
     c(this, "preferencesKeybindToCallbacks", /* @__PURE__ */ new Map());
     c(this, "pressedKeys", /* @__PURE__ */ new Set());
@@ -1205,159 +1314,176 @@ class Pn extends x {
     c(this, "boundHandleKeyUp", this.handleKeyUp.bind(this));
     c(this, "keybindsFile");
     // TODO try to figure out a better way to handle this
-    c(this, "isRecording", !1);
-    this.keybindsFile = new Mt({
-      path: Rt(["keybinds.json"]),
-      schema: Cn,
-      default: e
+    c(this, "keybindListeningPaused", !1);
+    this.keybindsFile = new ct({
+      path: ut(["keybinds.json"]),
+      schema: dn,
+      default: t
     });
   }
   init() {
     super.init();
-    const e = F.getInstance().getInterface("SCC_RAINBOW");
-    e.instance.on("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.on("keyDown", this.boundHandleKeyDown), e.instance.on("keyUp", this.boundHandleKeyUp);
+    const t = O.getInstance().getInterface("OGG_SIEGE");
+    t.instance.on("keyboardFocus", this.boundHandleKeyboardFocus), t.instance.on("keyDown", this.boundHandleKeyDown), t.instance.on("keyUp", this.boundHandleKeyUp);
   }
   // TODO support multiple callbacks
-  async onHotkeyToggled(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.toggle = n, this.preferencesKeybindToCallbacks.set(e, s);
+  async onKeybindToggled(t, r) {
+    const s = this.preferencesKeybindToCallbacks.get(t) || {};
+    s.toggle = r, this.preferencesKeybindToCallbacks.set(t, s);
   }
-  async onHotkeyDown(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.down = n, this.preferencesKeybindToCallbacks.set(e, s);
+  async onKeybindDown(t, r) {
+    const s = this.preferencesKeybindToCallbacks.get(t) || {};
+    s.down = r, this.preferencesKeybindToCallbacks.set(t, s);
   }
-  async onHotkeyUp(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.up = n, this.preferencesKeybindToCallbacks.set(e, s);
+  async onKeybindUp(t, r) {
+    const s = this.preferencesKeybindToCallbacks.get(t) || {};
+    s.up = r, this.preferencesKeybindToCallbacks.set(t, s);
+  }
+  async updateKeybind(t, r) {
+    this.keybindsFile.set({
+      [t]: r
+    });
+  }
+  async updateKeybinds(t) {
+    const r = Object.fromEntries(
+      Object.entries(t).filter(([s, a]) => a !== void 0)
+    );
+    this.keybindsFile.set({
+      ...this.keybindsFile.get(),
+      ...r
+    });
+  }
+  getConfig() {
+    return this.keybindsFile.get();
   }
   destroy() {
-    const e = F.getInstance().getInterface("SCC_RAINBOW");
-    e.instance.off("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.off("keyDown", this.boundHandleKeyDown), e.instance.off("keyUp", this.boundHandleKeyUp), super.destroy();
+    const t = O.getInstance().getInterface("OGG_SIEGE");
+    t.instance.off("keyboardFocus", this.boundHandleKeyboardFocus), t.instance.off("keyDown", this.boundHandleKeyDown), t.instance.off("keyUp", this.boundHandleKeyUp), super.destroy();
   }
-  handleKeyDown(e) {
-    if (this.isRecording)
+  handleKeyDown(t) {
+    if (this.keybindListeningPaused)
       return;
-    const n = de.get(e.key);
-    if (!n) {
-      this.logger.error("Unknown key down", e);
+    const r = ae.get(t.key);
+    if (!r) {
+      this.logger.error("Unknown key down", t);
       return;
     }
-    this.pressedKeys.add(n), this.checkKeybindings();
+    this.pressedKeys.add(r), this.checkKeybindings();
   }
   handleKeyboardFocus() {
     this.pressedKeys.clear(), this.activeKeybinds.clear(), this.triggeredToggleKeybinds.clear();
   }
-  async handleKeyUp(e) {
-    if (this.isRecording)
+  async handleKeyUp(t) {
+    if (this.keybindListeningPaused)
       return;
-    const n = de.get(e.key);
-    if (!n)
+    const r = ae.get(t.key);
+    if (!r)
       return;
-    this.pressedKeys.delete(n);
-    const s = this.keybindsFile.data;
-    for (const [o] of this.preferencesKeybindToCallbacks.entries())
-      s[o].keys.includes(n) && this.triggeredToggleKeybinds.delete(o);
-    this.checkHotkeyUps();
-  }
-  async checkHotkeyUps() {
-    const e = this.keybindsFile.data;
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
+    this.pressedKeys.delete(r);
+    const s = this.keybindsFile.get();
+    for (const [a] of this.preferencesKeybindToCallbacks.entries())
+      s[a].keys.includes(r) && this.triggeredToggleKeybinds.delete(a);
+    this.checkKeybindUps();
+  }
+  async checkKeybindUps() {
+    const t = this.keybindsFile.get();
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
       if (!s.up) continue;
-      const o = e[n];
-      this.activeKeybinds.has(n) && o.keys.some((a) => !this.pressedKeys.has(a)) && (this.activeKeybinds.delete(n), s.up(), this.logger.log("Hotkey up triggered", this.getHotkeyToString(o)));
+      const a = t[r];
+      this.activeKeybinds.has(r) && a.keys.some((i) => !this.pressedKeys.has(i)) && (this.activeKeybinds.delete(r), s.up(), this.logger.log("Keybind up triggered", this.getKeybindToString(a)));
     }
   }
   async checkKeybindings() {
-    const e = this.keybindsFile.data;
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
-      const o = e[n];
-      if (o.keys.length === this.pressedKeys.size && o.keys.every((i) => Pe.has(i) ? this.pressedKeys.has(i) : !1)) {
-        this.triggerHotkey(o, s, n);
+    const t = this.keybindsFile.get();
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const a = t[r];
+      if (a.keys.length === this.pressedKeys.size && a.keys.every((o) => we.has(o) ? this.pressedKeys.has(o) : !1)) {
+        this.triggerKeybind(a, s, r);
         return;
       }
     }
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
-      const o = e[n];
-      o.keys.every((i) => Pe.has(i) ? this.pressedKeys.has(i) : (this.logger.error("Unknown key", i, o), !1)) && this.triggerHotkey(o, s, n);
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const a = t[r];
+      a.keys.every((o) => we.has(o) ? this.pressedKeys.has(o) : (this.logger.error("Unknown key", o, a), !1)) && this.triggerKeybind(a, s, r);
     }
   }
-  triggerHotkey(e, n, s) {
-    const o = e.mode;
-    if (o === "toggle" && n.toggle && !this.triggeredToggleKeybinds.has(s)) {
-      const a = n.toggle();
+  triggerKeybind(t, r, s) {
+    const a = t.mode;
+    if (a === "toggle" && r.toggle && !this.triggeredToggleKeybinds.has(s)) {
+      const i = r.toggle();
       this.triggeredToggleKeybinds.add(s), this.logger.log(
-        a ? `Hotkey pressed rejected: ${a}` : "Hotkey pressed accepted",
-        this.getHotkeyToString(e)
+        i ? `Keybind pressed rejected: ${i}` : "Keybind pressed accepted",
+        this.getKeybindToString(t)
       );
     }
-    if (o === "hold" && n.down && !this.activeKeybinds.has(s)) {
-      const a = n.down();
-      a ? this.logger.log(`Hotkey down rejected: ${a}`, this.getHotkeyToString(e)) : (this.activeKeybinds.add(s), this.logger.log("Hotkey down accepted", this.getHotkeyToString(e)));
+    if (a === "hold" && r.down && !this.activeKeybinds.has(s)) {
+      const i = r.down();
+      i ? this.logger.log(`Keybind down rejected: ${i}`, this.getKeybindToString(t)) : (this.activeKeybinds.add(s), this.logger.log("Keybind down accepted", this.getKeybindToString(t)));
     }
   }
-  getHotkeyToString(e) {
-    return `(${e.keys.join("+")}${e.mode ? ` ${e.mode}` : ""})`;
+  getKeybindToString(t) {
+    return `(${t.keys.join("+")}${t.mode ? ` ${t.mode}` : ""})`;
   }
 }
-class Sn extends Ke {
-  constructor(e) {
+class gn extends Ae {
+  constructor(t) {
     super("OverridesManager");
     c(this, "renderInterface");
     c(this, "globalCursorOverrideCount", /* @__PURE__ */ new Set());
     c(this, "globalMouseBlockCount", /* @__PURE__ */ new Set());
     c(this, "globalKeyboardBlockCount", /* @__PURE__ */ new Set());
     c(this, "keyInputBlocks", {});
-    this.renderInterface = F.getInstance().getInterface(e);
+    this.renderInterface = O.getInstance().getInterface(t);
   }
-  scope(e) {
+  scope(t) {
     return {
-      setGlobalCursorOverride: (n) => this.setGlobalCursorOverride(e, n),
-      setGlobalMouseBlock: (n) => this.setGlobalMouseBlock(e, n),
-      setGlobalKeyboardBlock: (n) => this.setGlobalKeyboardBlock(e, n),
-      setKeyInputBlock: (n, s) => this.setKeyInputBlock(e, n, s)
+      setGlobalCursorOverride: (r) => this.setGlobalCursorOverride(t, r),
+      setGlobalMouseBlock: (r) => this.setGlobalMouseBlock(t, r),
+      setGlobalKeyboardBlock: (r) => this.setGlobalKeyboardBlock(t, r),
+      setKeyInputBlock: (r, s) => this.setKeyInputBlock(t, r, s)
     };
   }
-  setGlobalCursorOverride(e, n) {
-    n ? this.globalCursorOverrideCount.add(e) : this.globalCursorOverrideCount.delete(e), n && this.globalCursorOverrideCount.size === 1 ? this.renderInterface.instance.setGlobalCursorOverride(!0) : !n && this.globalCursorOverrideCount.size === 0 && this.renderInterface.instance.setGlobalCursorOverride(!1);
+  setGlobalCursorOverride(t, r) {
+    r ? this.globalCursorOverrideCount.add(t) : this.globalCursorOverrideCount.delete(t), r && this.globalCursorOverrideCount.size === 1 ? this.renderInterface.instance.setGlobalCursorOverride(!0) : !r && this.globalCursorOverrideCount.size === 0 && this.renderInterface.instance.setGlobalCursorOverride(!1);
   }
-  setGlobalMouseBlock(e, n) {
-    n ? this.globalMouseBlockCount.add(e) : this.globalMouseBlockCount.delete(e), n && this.globalMouseBlockCount.size === 1 ? this.renderInterface.instance.setGlobalMouseBlock(!0) : !n && this.globalMouseBlockCount.size === 0 && this.renderInterface.instance.setGlobalMouseBlock(!1);
+  setGlobalMouseBlock(t, r) {
+    r ? this.globalMouseBlockCount.add(t) : this.globalMouseBlockCount.delete(t), r && this.globalMouseBlockCount.size === 1 ? this.renderInterface.instance.setGlobalMouseBlock(!0) : !r && this.globalMouseBlockCount.size === 0 && this.renderInterface.instance.setGlobalMouseBlock(!1);
   }
-  setGlobalKeyboardBlock(e, n) {
-    n ? this.globalKeyboardBlockCount.add(e) : this.globalKeyboardBlockCount.delete(e), n && this.globalKeyboardBlockCount.size === 1 ? this.renderInterface.instance.setGlobalKeyboardBlock(!0) : !n && this.globalKeyboardBlockCount.size === 0 && this.renderInterface.instance.setGlobalKeyboardBlock(!1);
+  setGlobalKeyboardBlock(t, r) {
+    r ? this.globalKeyboardBlockCount.add(t) : this.globalKeyboardBlockCount.delete(t), r && this.globalKeyboardBlockCount.size === 1 ? this.renderInterface.instance.setGlobalKeyboardBlock(!0) : !r && this.globalKeyboardBlockCount.size === 0 && this.renderInterface.instance.setGlobalKeyboardBlock(!1);
   }
-  setKeyInputBlock(e, n, s) {
-    this.keyInputBlocks[n] || (this.keyInputBlocks[n] = /* @__PURE__ */ new Set()), s ? this.keyInputBlocks[n].add(e) : this.keyInputBlocks[n].delete(e), s && this.keyInputBlocks[n].size === 1 ? this.renderInterface.instance.setKeyInputBlock(n, !0) : !s && this.keyInputBlocks[n].size === 0 && this.renderInterface.instance.setKeyInputBlock(n, !1);
+  setKeyInputBlock(t, r, s) {
+    this.keyInputBlocks[r] || (this.keyInputBlocks[r] = /* @__PURE__ */ new Set()), s ? this.keyInputBlocks[r].add(t) : this.keyInputBlocks[r].delete(t), s && this.keyInputBlocks[r].size === 1 ? this.renderInterface.instance.setKeyInputBlock(r, !0) : !s && this.keyInputBlocks[r].size === 0 && this.renderInterface.instance.setKeyInputBlock(r, !1);
   }
 }
-const Mn = I(Sn, "SCC_RAINBOW");
-let se = !1, U = {};
-function jr(r) {
-  const { init: t = !0 } = r;
-  if ($n(r), se)
-    return U;
-  function e() {
-    const n = /* @__PURE__ */ new Map(), s = Rn(r.modules, n), o = Kn(), a = Tn(r.keybinds), i = Dn(), l = On();
-    An(), xn(r, n), se = !0, U = {
+const fn = _(gn, "OGG_SIEGE");
+let te = !1, H;
+function Yn(n) {
+  const { init: e = !0 } = n;
+  if (pn(n), te)
+    return H;
+  function t() {
+    kn(n);
+    const r = /* @__PURE__ */ new Map(), s = bn(n.modules, r), a = vn(), i = En(n.keybinds), o = wn(), l = _n();
+    yn(), In(n, r), te = !0, H = {
       ...s,
-      ...o,
-      // TODO add a way for developer to save keybinds that the user settings
-      keybinds: a,
-      windows: i,
+      ...a,
+      keybinds: i,
+      windows: o,
       input: l,
-      hasAnyActiveProcesses: () => M.getInstance().hasAnyActiveProcesses,
-      init: e
+      hasAnyActiveProcesses: () => C.getInstance().hasAnyActiveProcesses,
+      init: t
     };
   }
-  return t ? (e(), U) : new Proxy(
+  return e ? (t(), H) : new Proxy(
     {
-      init: e
+      init: t
     },
     {
-      get: (n, s) => {
-        if (s !== "init" && !se)
+      get: (r, s) => {
+        if (s !== "init" && !te)
           throw new Error("overlayed was called before initialized");
-        return s === "init" ? n[s] : U[s];
+        return s === "init" ? r[s] : H[s];
       }
     }
   );
@@ -1367,501 +1493,225 @@ global.OVERLAYED = new Proxy({}, {
     throw new Error("function overlayed was not called");
   }
 });
-function $n(r) {
+function pn(n) {
   global.OVERLAYED = {
-    APP_NAME: r.appName
+    APP_NAME: n.appName
   };
 }
-function An() {
-  In.getInstance().init(), Z.getInstance().init(), M.getInstance().init(), Q.getInstance().init();
+function yn() {
+  Ne.getInstance().init(), B.getInstance().init(), C.getInstance().init(), T.getInstance().init(), Pe.on("quit", () => {
+    mn();
+  });
+}
+function mn() {
+  T.getInstance().destroy(), B.getInstance().destroy(), Ne.getInstance().destroy(), C.getInstance().destroy(), O.getInstance().getInterface("OGG_SIEGE").destroy(), oe.getInstance().destroy(), I.getInstance().destroy();
 }
-function Rn(r, t) {
-  return r.reduce((e, n) => {
-    const s = n.key;
-    return e[s] = {
+function bn(n, e) {
+  return n.reduce((t, r) => {
+    const s = r.key;
+    return t[s] = {
       // prettier-ignore
-      on(o, a) {
-        const i = $(s, o), l = t.get(i) ?? /* @__PURE__ */ new Set();
-        l.add(a), t.set(i, l);
+      on(a, i) {
+        const o = M(s, a), l = e.get(o) ?? /* @__PURE__ */ new Set();
+        l.add(i), e.set(o, l);
       },
-      onAny(o) {
-        const a = $(s, "*"), i = t.get(a) ?? /* @__PURE__ */ new Set();
-        i.add(o), t.set(a, i);
+      onAny(a) {
+        const i = M(s, "*"), o = e.get(i) ?? /* @__PURE__ */ new Set();
+        o.add(a), e.set(i, o);
       },
       // prettier-ignore
-      off(o, a) {
-        const i = $(s, o), l = t.get(i) ?? /* @__PURE__ */ new Set();
-        l.delete(a), t.set(i, l);
+      off(a, i) {
+        const o = M(s, a), l = e.get(o) ?? /* @__PURE__ */ new Set();
+        l.delete(i), e.set(o, l);
       },
       // prettier-ignore
-      offAny(o) {
-        const a = $(s, "*"), i = t.get(a) ?? /* @__PURE__ */ new Set();
-        i.delete(o), t.set(a, i);
+      offAny(a) {
+        const i = M(s, "*"), o = e.get(i) ?? /* @__PURE__ */ new Set();
+        o.delete(a), e.set(i, o);
       }
-    }, e;
+    }, t;
   }, {});
 }
-function Kn() {
-  const r = q.getInstance(), t = Z.getInstance();
+function vn() {
+  const n = I.getInstance(), e = B.getInstance();
   return {
-    on: (e, n) => {
-      switch (e) {
+    on: (t, r) => {
+      switch (t) {
+        case "fatal":
+          n.on("fatal", r);
+          break;
         case "error":
-          r.on("error", n);
+          n.on("error", r);
           break;
         case "warning":
-          r.on("warning", n);
+          n.on("warning", r);
           break;
         case "gameLaunch":
-          t.on("gameLaunch", n);
+          e.on("gameLaunch", r);
           break;
         case "gameClose":
-          t.on("gameClose", n);
+          e.on("gameClose", r);
           break;
         default:
-          throw new Error("Not implemented", { cause: [e, n] });
+          throw new Error(`Event type not implemented ${t}`, { cause: [t, r] });
       }
     },
-    off: (e, n) => {
-      switch (e) {
+    off: (t, r) => {
+      switch (t) {
+        case "fatal":
+          n.off("fatal", r);
+          break;
         case "error":
-          r.off("error", n);
+          n.off("error", r);
           break;
         case "warning":
-          r.off("warning", n);
+          n.off("warning", r);
           break;
         case "gameLaunch":
-          t.off("gameLaunch", n);
+          e.off("gameLaunch", r);
           break;
         case "gameClose":
-          t.off("gameClose", n);
+          e.off("gameClose", r);
           break;
         default:
-          throw new Error("Not implemented", { cause: [e, n] });
+          throw new Error(`Event type not implemented ${t}`, { cause: [t, r] });
       }
     }
   };
 }
-function $(r, t) {
-  return `${r}:${t}`;
+function M(n, e) {
+  return `${n}:${e}`;
 }
-function xn(r, t) {
-  const e = $e.getInstance();
-  function n(s) {
-    const o = Ae(s);
-    if (o instanceof y.errors) {
-      q.getInstance().warn("Invalid event", "INVALID_EVENT", {
-        cause: o.summary
+function In(n, e) {
+  const t = oe.getInstance();
+  function r(s) {
+    const a = dt(s);
+    if (a instanceof K.errors) {
+      I.getInstance().warn("Invalid event", "INVALID_EVENT", {
+        summary: a.summary
       });
       return;
     }
-    const a = r.modules.find((f) => f.key === o.game), i = a == null ? void 0 : a.events.event;
-    if (!i)
+    const i = n.modules.find((f) => f.key === a.game), o = i == null ? void 0 : i.events.event;
+    if (!o)
       return;
-    const l = i(s);
-    if (l instanceof y.errors) {
-      q.getInstance().warn("Invalid event", "INVALID_EVENT", {
-        cause: l
+    const l = o(s);
+    if (l instanceof K.errors) {
+      I.getInstance().warn("Invalid event", "INVALID_EVENT", {
+        summary: l.summary
       });
       return;
     }
-    const h = $(a.key, l.type), g = $(a.key, "*"), p = t.get(h), d = t.get(g), m = [...Array.from(p ?? []), ...Array.from(d ?? [])];
-    m.length !== 0 && m.forEach((f) => {
+    const d = M(i.key, l.type), h = M(i.key, "*"), g = e.get(d), u = e.get(h), p = [...Array.from(g ?? []), ...Array.from(u ?? [])];
+    p.length !== 0 && p.forEach((f) => {
       f(l);
     });
   }
-  return e.on("data", (s) => s.forEach(n)), e;
+  return t.on("data", (s) => s.forEach(r)), t.on("error", (s) => {
+    I.getInstance().error("Pipe server error", "PIPE_SERVER_ERROR", {
+      error: s
+    });
+  }), t;
 }
-function Tn(r) {
-  const t = new Pn(r), e = {};
-  for (const s in r)
-    e[s] = {
-      on: (o, a) => {
-        switch (o) {
+function En(n) {
+  const e = new hn(n), t = {};
+  for (const s in n)
+    t[s] = {
+      on: (a, i) => {
+        switch (a) {
           case "down":
-            t.onHotkeyDown(s, a);
+            e.onKeybindDown(s, i);
             break;
           case "up":
-            t.onHotkeyUp(s, a);
+            e.onKeybindUp(s, i);
             break;
           case "toggle":
-            t.onHotkeyToggled(s, a);
+            e.onKeybindToggled(s, i);
             break;
           default:
-            throw new Error("Not implemented", { cause: [o, a] });
+            throw new Error(`Event type not implemented ${a}`, { cause: [a, i] });
         }
       }
     };
-  return {
-    ...e,
-    toggleRecording: (s) => {
-      s === void 0 ? t.isRecording = !t.isRecording : t.isRecording = s;
+  const r = {
+    ...t,
+    getConfig: () => e.getConfig(),
+    pauseKeybindListening: () => {
+      e.keybindListeningPaused = !0;
+    },
+    resumeKeybindListening: () => {
+      e.keybindListeningPaused = !1;
+    },
+    updateKeybind: (s, a) => {
+      e.updateKeybind(s, a);
+    },
+    updateKeybinds: (s) => {
+      e.updateKeybinds(s);
     }
   };
+  return e.init(), Pe.on("quit", () => {
+    e.destroy();
+  }), r;
 }
-function Dn() {
+function wn() {
   return {
-    createWindow: b("newWindow"),
-    on: b("on"),
-    off: b("off"),
-    once: b("once"),
-    addListener: b("addListener"),
-    prependListener: b("prependListener"),
-    prependOnceListener: b("prependOnceListener"),
-    removeListener: b("removeListener"),
-    removeAllListeners: b("removeAllListeners"),
+    createWindow: (n) => y().instance.newWindowInternal(Ze.BrowserWindow, n),
+    on: (n, e) => y().instance.on(n, e),
+    off: (n, e) => y().instance.off(n, e),
+    once: (n, e) => y().instance.once(n, e),
+    addListener: (n, e) => y().instance.addListener(n, e),
+    removeListener: (n, e) => y().instance.removeListener(n, e),
+    removeAllListeners: () => y().instance.removeAllListeners(),
+    prependListener: (n, e) => y().instance.prependListener(n, e),
+    prependOnceListener: (n, e) => y().instance.prependOnceListener(n, e),
     getActiveGameInfo: () => {
-      const r = Ue(), t = $e.getInstance();
+      const n = y(), e = oe.getInstance();
       return {
-        resolution: r.resolution,
-        isConnected: t.hasConnection
+        resolution: n.resolution,
+        isConnected: e.hasConnection
       };
     }
   };
 }
-function On() {
+function _n() {
   return {
-    scope: (r) => Mn.getInstance().scope(r),
+    scope: (n) => fn.getInstance().scope(n),
     raw: {
-      setGlobalMouseBlock: b("setGlobalMouseBlock"),
-      setGlobalKeyboardBlock: b("setGlobalKeyboardBlock"),
-      setGlobalCursorOverride: b("setGlobalCursorOverride"),
-      setKeyInputBlock: b("setKeyInputBlock"),
-      getGlobalMouseBlock: b("getGlobalMouseBlock"),
-      getGlobalKeyboardBlock: b("getGlobalKeyboardBlock"),
-      getGlobalCursorOverride: b("getGlobalCursorOverride"),
-      getKeyInputBlock: b("getKeyInputBlock")
+      setGlobalMouseBlock: (n) => y().instance.setGlobalMouseBlock(n),
+      setGlobalKeyboardBlock: (n) => y().instance.setGlobalKeyboardBlock(n),
+      setGlobalCursorOverride: (n) => y().instance.setGlobalCursorOverride(n),
+      setKeyInputBlock: (n, e) => y().instance.setKeyInputBlock(n, e),
+      getGlobalMouseBlock: () => y().instance.getGlobalMouseBlock(),
+      getGlobalKeyboardBlock: () => y().instance.getGlobalKeyboardBlock(),
+      getGlobalCursorOverride: () => y().instance.getGlobalCursorOverride(),
+      getKeyInputBlock: (n) => y().instance.getKeyInputBlock(n)
     }
   };
 }
-function Ue() {
-  return F.getInstance().getInterface("SCC_RAINBOW");
-}
-function b(r) {
-  return (...t) => {
-    const n = Ue().instance[r];
-    return n(...t);
-  };
+function kn(n) {
+  P.getInstance().clientId = n.appName, P.getInstance().userId = Wt.generateUniqueIdentifier(), I.getInstance().on("fatal", (e) => {
+    P.getInstance().track("fatal", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  }), I.getInstance().on("error", (e) => {
+    P.getInstance().track("error", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  }), I.getInstance().on("warning", (e) => {
+    P.getInstance().track("warning", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  });
 }
-const ze = "00000000-0000-0000-0000-000000000000", me = y(`string.uuid | '${ze}'`), Ve = ["intro", "planning", "prep", "action", "results", "invalid"], qe = y("===", ...Ve), We = [0, 1], te = y("===", ...We), Xe = ["attacker", "defender", "both", "invalid"], K = y("===", ...Xe), Ye = ["normal", "overhealed", "low_health", "downed", "dead", "respawning"], ne = y("===", ...Ye), Je = [
-  "bullet",
-  "melee",
-  "explosive",
-  "falling",
-  "regeneration",
-  "unknown",
-  "debris",
-  "projectile",
-  "downed",
-  "gas",
-  "thermal_explosion",
-  "melee_gadget",
-  "barbed_wire",
-  "electric",
-  "reinforcement",
-  "frag",
-  "paralyzed",
-  "emp",
-  "break",
-  "cleanup",
-  "interrogation",
-  "melee-finisher",
-  "toxic",
-  "toxic-explosion",
-  "pneumatic",
-  "body-contact",
-  "contact-explosion",
-  "flash",
-  "parasite-spike",
-  "laser",
-  "concussion",
-  "blowtorch",
-  "taser-shield",
-  "reverse-friendly-fire",
-  "self-destroyed",
-  "area-control",
-  "fire",
-  "breach-kick",
-  "break-wall",
-  "blade-mine",
-  "invalid"
-], Qe = y("===", ...Je), Ze = ["unknown", "enemy", "friendly", "invalid"], et = y("===", ...Ze), u = Ae.and({
-  game: "'siege'"
-}), Ln = u.and({
-  type: "'local_player'",
-  content: {
-    profile_id: me
-  }
-}), S = y({
-  id: "number",
-  value: "string"
-}), tt = y({
-  kills: "number",
-  deaths: "number",
-  assists: "number",
-  plants: "number",
-  score: "number"
-}), Fn = y({
-  instigator_player_id: "number",
-  receiver_player_id: "number",
-  damage_amount: "number",
-  remaining_health: "number",
-  pre_damage_health: "number",
-  max_health: "number",
-  damage_type: Qe,
-  damage_team_type: et,
-  damage_item_id: "number | null",
-  damage_time: "number"
-}), nt = y({
-  index: "number",
-  rounds_until_next_segment: "number",
-  segment_size: "number",
-  segment_index: "number",
-  team_0: {
-    role: K,
-    state: "number"
-  },
-  team_1: {
-    role: K,
-    state: "number"
-  }
-}), rt = y({
-  id: "number",
-  name: S,
-  time_of_day: S
-}), Bn = y({
-  player_id: "number",
-  final_health: "number",
-  final_life_state: ne,
-  operator_name: S.or(y.null)
-}), Gn = y({
-  round_data: nt,
-  damage_events: Fn.array(),
-  players: Bn.array()
-}), Hn = u.and({
-  type: "'match_started'",
-  content: {
-    game_mode: "string",
-    game_type: S,
-    match_type: "string",
-    match_id: "string",
-    map: rt,
-    is_round_based: "boolean",
-    current_round_index: "number",
-    rounds: nt.array()
-  }
-}), Nn = u.and({
-  type: "'module_loaded'"
-}), jn = u.and({
-  type: "'module_unloaded'"
-}), Un = u.and({
-  type: "'started_queuing'",
-  content: {
-    game_mode: "string",
-    game_type: S,
-    match_type: "string"
-  }
-}), zn = u.and({
-  type: "'stopped_queuing'"
-}), Vn = u.and({
-  type: "'unsupported_game_version'",
-  content: {
-    hash: "string | null",
-    version: "string | null"
-  }
-}), qn = u.and({
-  type: "'match_ended'"
-}), Wn = u.and({
-  type: "'map_changed'",
-  content: {
-    map: rt
-  }
-}), Xn = u.and({
-  type: "'operator_banned'",
-  content: {
-    index: "number",
-    team: te,
-    side: K,
-    operator_name: S.or("null")
-  }
-}), Yn = u.and({
-  type: "'round_ended'",
-  content: Gn
-}), Jn = u.and({
-  type: "'phase_changed'",
-  content: {
-    phase: qe
-  }
-}), Qn = u.and({
-  type: "'player_joined'",
-  content: {
-    player_id: "number",
-    profile_id: me,
-    is_bot: "boolean",
-    is_enemy: "boolean",
-    is_squad_member: "boolean",
-    is_local_player: "boolean",
-    username: "string",
-    side: K,
-    team: te,
-    is_privacy_username: "boolean",
-    has_avatar_hidden: "boolean",
-    has_commend_streak: "boolean",
-    ping_id: "number",
-    match_stats: tt,
-    life_state: ne,
-    ping: "number"
-  }
-}).pipe((r) => ({
-  ...r,
-  content: {
-    ...r.content,
-    starting_side: r.content.side
-  }
-})), Zn = u.and({
-  type: "'player_left'",
-  content: {
-    player_id: "number"
-  }
-}), er = u.and({
-  type: "'player_operator_changed'",
-  content: {
-    player_id: "number",
-    operator_name: S.or(y.null)
-  }
-}), tr = u.and({
-  type: "'player_location_changed'",
-  content: {
-    player_id: "number",
-    location_name: "string"
-  }
-}), nr = u.and({
-  type: "'player_side_changed'",
-  content: {
-    player_id: "number",
-    side: K
-  }
-}), rr = u.and({
-  type: "'player_stats_changed'",
-  content: {
-    player_id: "number",
-    match_stats: tt
-  }
-}), sr = u.and({
-  type: "'player_ping_updated'",
-  content: {
-    player_id: "number",
-    ping: "number"
-  }
-}), ar = u.and({
-  type: "'defuser_planted'",
-  content: {
-    player_id: "number"
-  }
-}), or = u.and({
-  type: "'defuser_sabotaged'",
-  content: {
-    player_id: "number"
-  }
-}), ir = u.and({
-  type: "'defuser_picked_up'",
-  content: {
-    player_id: "number",
-    initial: "boolean"
-  }
-}), lr = u.and({
-  type: "'defuser_dropped'",
-  content: {
-    player_id: "number"
-  }
-}), cr = u.and({
-  type: "'player_life_state_changed'",
-  content: {
-    player_id: "number",
-    life_state: ne
-  }
-}), dr = u.and({
-  type: "'player_died'",
-  content: {
-    player_id: "number",
-    instigator_player_id: "number"
-  }
-}), ur = u.and({
-  type: "'player_downed'",
-  content: {
-    player_id: "number",
-    instigator_player_id: "number"
-  }
-}), hr = u.and({
-  type: "'player_ping_id_changed'",
-  content: {
-    player_id: "number",
-    ping_id: "number"
-  }
-}), gr = u.and({
-  type: "'player_team_changed'",
-  content: {
-    player_id: "number",
-    team: te
-  }
-}), pr = ct({
-  "#event1": "module_loaded | module_unloaded | unsupported_game_version | local_player | started_queuing | stopped_queuing | match_started | match_ended | map_changed | operator_banned | round_ended | phase_changed | player_joined | player_left | player_operator_changed | player_location_changed | player_side_changed | player_stats_changed",
-  "#event2": "player_life_state_changed | player_died | player_downed | player_ping_id_changed | player_team_changed | defuser_planted | defuser_sabotaged | defuser_picked_up | defuser_dropped | player_ping_updated",
-  event: "event1 | event2",
-  module_loaded: Nn,
-  module_unloaded: jn,
-  unsupported_game_version: Vn,
-  local_player: Ln,
-  started_queuing: Un,
-  stopped_queuing: zn,
-  match_started: Hn,
-  match_ended: qn,
-  map_changed: Wn,
-  operator_banned: Xn,
-  round_ended: Yn,
-  phase_changed: Jn,
-  player_joined: Qn,
-  player_left: Zn,
-  player_operator_changed: er,
-  player_location_changed: tr,
-  player_side_changed: nr,
-  player_stats_changed: rr,
-  defuser_planted: ar,
-  defuser_sabotaged: or,
-  defuser_picked_up: ir,
-  defuser_dropped: lr,
-  player_ping_updated: sr,
-  player_life_state_changed: cr,
-  player_died: dr,
-  player_downed: ur,
-  player_ping_id_changed: hr,
-  player_team_changed: gr
-}).export();
-function fr() {
-  return {
-    key: "siege",
-    events: pr
-  };
+function y() {
+  return O.getInstance().getInterface("OGG_SIEGE");
 }
-const Ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  BOT_ID: ze,
-  DAMAGE_TEAM_TYPES: Ze,
-  DAMAGE_TYPES: Je,
-  DamageTeamTypeSchema: et,
-  DamageTypeSchema: Qe,
-  GAME_MODE_PHASES: Ve,
-  GameModePhaseSchema: qe,
-  PLAYER_LIFE_STATES: Ye,
-  PlayerLifeStateSchema: ne,
-  ProfileId: me,
-  SIDES: Xe,
-  SideSchema: K,
-  TEAMS: We,
-  TeamSchema: te,
-  module: fr
-}, Symbol.toStringTag, { value: "Module" }));
 export {
-  Ur as Siege,
-  jr as overlayed
+  Yn as overlayed
 };