@overlayed/app 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,57 +1,57 @@
-var Fe = Object.defineProperty;
-var xe = (r, t, e) => t in r ? Fe(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var l = (r, t, e) => xe(r, typeof t != "symbol" ? t + "" : t, e);
-import p, { resolve as Ke } from "node:path";
-import { PipeEventServer as Le, ProcessMonitor as Oe, Process as L }from "./native-interface/main.js";
-import { type as D } from "arktype";
-import w, { existsSync as $e, mkdirSync as He, readFileSync as ye, writeFileSync as Ne, copyFileSync as je } from "node:fs";
-import b from "node:fs/promises";
-import me from "jszip";
-import { RenderInterface as Ue }from "./render-interface/main.js";
-import { createHash as Be } from "node:crypto";
-var Ge = Object.defineProperty, Ve = (r, t, e) => t in r ? Ge(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, R = (r, t, e) => Ve(r, typeof t != "symbol" ? t + "" : t, e);
-function ze(r) {
-  return { all: r = r || /* @__PURE__ */ new Map(), on: function(t, e) {
-    var n = r.get(t);
-    n ? n.push(e) : r.set(t, [e]);
-  }, off: function(t, e) {
-    var n = r.get(t);
-    n && (e ? n.splice(n.indexOf(e) >>> 0, 1) : r.set(t, []));
-  }, emit: function(t, e) {
-    var n = r.get(t);
-    n && n.slice().map(function(s) {
-      s(e);
-    }), (n = r.get("*")) && n.slice().map(function(s) {
-      s(t, e);
+var Ue = Object.defineProperty;
+var ze = (n, e, t) => e in n ? Ue(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 oe } 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, F = (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 We = class {
+let Ce = class {
   constructor() {
-    R(this, "emitter"), this.emitter = ze();
+    F(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 qe(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)
@@ -59,28 +59,68 @@ function qe(r, ...t) {
     static clearInstance() {
       this._instance = void 0;
     }
-  }, R(e, "_instance"), e;
+  }, F(t, "_instance"), t;
 }
-const Xe = p.join(process.env.APPDATA ?? "", "overlayed");
-p.join(Xe, "logs");
-let Je = class extends We {
-  constructor(t) {
-    super(), R(this, "server", null), R(this, "_hasConnection", !1), R(this, "pipeId"), this.pipeId = t, this.init();
+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 = oe(import.meta.url), {
+  PipeEventServer: it,
+  PipeEventClient: Fn,
+  PipeEventBase: xn,
+  ProcessMonitor: Dn,
+  Process: $n,
+  InjectionMethod: Tn,
+  AccessLevel: Bn,
+  HardwareInterface: Gn
+} = st("./build/overlayed_native_interface_x64.node");
+let at = class extends Ce {
+  constructor(e) {
+    super(), F(this, "server", null), F(this, "_hasConnection", !1), F(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 Le(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 Je = class extends We {
     });
   }
 };
-const Qe = qe(Je, "overlayed"), Ye = D({
-  game: "string",
-  type: "string",
-  creation_time: "number"
-});
-function Ze(r) {
-  return { all: r = r || /* @__PURE__ */ new Map(), on: function(t, e) {
-    var n = r.get(t);
-    n ? n.push(e) : r.set(t, [e]);
-  }, off: function(t, e) {
-    var n = r.get(t);
-    n && (e ? n.splice(n.indexOf(e) >>> 0, 1) : r.set(t, []));
-  }, emit: function(t, e) {
-    var n = r.get(t);
-    n && n.slice().map(function(s) {
-      s(e);
-    }), (n = r.get("*")) && n.slice().map(function(s) {
-      s(t, e);
+const le = 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 et {
+class Se {
   constructor() {
-    l(this, "emitter");
-    this.emitter = Ze();
+    c(this, "emitter");
+    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 k(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,209 @@ function k(r, ...t) {
     static clearInstance() {
       this._instance = void 0;
     }
-  }, l(n, "_instance"), n;
+  }, c(r, "_instance"), r;
 }
-function tt(r) {
-  try {
-    return [JSON.parse(r), null];
-  } catch (t) {
-    return [null, t];
+class lt extends Se {
+  destroy() {
+    this.removeAllListeners();
   }
-}
-function X(r, t) {
-  const e = {};
-  for (const n in t)
-    n in r ? typeof r[n] == "object" && r[n] !== null && typeof t[n] == "object" && t[n] !== null ? e[n] = X(r[n], t[n]) : e[n] = r[n] : e[n] = t[n];
-  for (const n in r)
-    n in e || (e[n] = r[n]);
-  return e;
-}
-class rt {
-  constructor(t) {
-    l(this, "options");
-    l(this, "_data");
-    this.options = t, this._data = this.load();
+  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 E = _(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);
-      w.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 = w.readFileSync(this.options.path, "utf8"), [e, n] = tt(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 w.accessSync(t, w.constants.R_OK | w.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;
+    }
+  }
+  onBeforeSave(e) {
+    return e;
+  }
+  onAfterLoad(e) {
+    return e;
+  }
+  getFilePath() {
+    return this._path;
+  }
+  parseStoredData(e) {
+    try {
+      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 this._defaultValue;
     }
   }
-  fileExists(t) {
+  canReadWriteFile(e) {
     try {
-      return w.accessSync(t, w.constants.F_OK), !0;
+      return k.accessSync(e, k.constants.R_OK | k.constants.W_OK), !0;
     } catch {
       return !1;
     }
   }
-  setupDefaultData(t = !1) {
-    return this._data = this.options.default, t || this.saveCurrentData(), this.data;
-  }
-}
-class nt extends rt {
-  constructor(e) {
-    super(e);
-    l(this, "options");
-    this.options = e;
-  }
-  get data() {
-    const e = this.options.schema["~standard"].validate(super.data);
-    if (e instanceof Promise)
-      throw new Error("StructuredConfigFile does not support async validation");
-    return e.issues ? this.options.default : e.value;
-  }
-  set data(e) {
-    const n = this.options.schema["~standard"].validate(e);
-    if (n instanceof Promise)
-      throw new Error("StructuredConfigFile does not support async validation");
-    n.issues || (super.data = n.value);
+  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 ? X(e, this.options.default) : X(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) {
+    E.getInstance().error("Invalid config file", "INVALID_CONFIG_FILE", {
+      issues: e.map((t) => t.message),
+      filePath: this._path,
+      data: this.data
+    });
   }
 }
-const ve = {
-  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);
   }
-}, F = p.join(process.env.APPDATA ?? "", "overlayed");
-p.join(F, "logs");
-class st {
-  constructor(t) {
-    l(this, "logger");
-    l(this, "initialized", !1);
-    this.logger = ve.scope(t);
+}, Y = () => m.join(process.env.APPDATA ?? "", "overlayed");
+function ut() {
+  return m.normalize(Y());
+}
+function dt(n = []) {
+  return m.normalize(m.join(Y(), global.OVERLAYED.APP_NAME, ...n));
+}
+const ht = K({
+  game: "string",
+  type: "string",
+  creation_time: "number"
+});
+class Ae {
+  constructor(e) {
+    c(this, "logger");
+    c(this, "initialized", !1);
+    this.logger = Me.scope(e);
   }
   init() {
     this.logger.log("Initializing"), this.initialized = !0;
@@ -309,12 +391,12 @@ class st {
     this.logger.log("Destroying"), this.initialized = !1;
   }
 }
-class C extends et {
-  constructor(e) {
+class G extends Se {
+  constructor(t) {
     super();
-    l(this, "logger");
-    l(this, "initialized", !1);
-    this.logger = ve.scope(e);
+    c(this, "logger");
+    c(this, "initialized", !1);
+    this.logger = Me.scope(t);
   }
   init() {
     this.logger.log("Initializing"), this.initialized = !0;
@@ -323,403 +405,388 @@ class C extends et {
     this.logger.log("Destroying"), this.initialized = !1, this.removeAllListeners();
   }
 }
-class it extends C {
-  constructor() {
-    super("ErrorManager");
-  }
-  error(t, e, n) {
-    this.emit("error", {
-      code: e,
-      message: t,
-      data: n,
-      timestamp: Date.now()
-    });
-  }
-  warn(t, e, n) {
-    this.emit("warning", {
-      code: e,
-      message: t,
-      data: n,
-      timestamp: Date.now()
-    });
-  }
-}
-const be = k(it);
-function ot() {
-  return p.normalize(F);
-}
-var I = "object", Ee = "function", we = "prototype", q = "text", re = "json", le = "abort", J = "paramsSerializer", ue = "addEventListener", O = "status", v = "headers", W = Object, _ = void 0, N = null, Q = W[we], j = W.keys, M = Array.isArray, he = "method", _e = "HEAD", Y = "GET", ke = "OPTIONS", at = "POST", ct = "PUT", lt = "PATCH", ut = "DELETE";
-function ht(r, t) {
-  let e = new AbortController();
-  function n(a) {
-    e.abort(a), i();
+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", Re = "HEAD", se = "GET", Fe = "OPTIONS", gt = "POST", ft = "PUT", pt = "PATCH", yt = "DELETE";
+function mt(n, e) {
+  let t = new AbortController();
+  function r(o) {
+    t.abort(o), i();
   }
   let s = [];
-  for (let a of r) {
-    if ((a == null ? void 0 : a.aborted) === !0) {
-      n(a.reason);
+  for (let o of n) {
+    if ((o == null ? void 0 : o.aborted) === !0) {
+      r(o.reason);
       break;
     }
-    if (a != null && a[ue]) {
-      let c = () => {
-        n(a.reason);
+    if (o != null && o[me]) {
+      let l = () => {
+        r(o.reason);
       };
       s.push(() => {
         var d;
-        (d = a.removeEventListener) == null || d.call(a, le, c);
-      }), a[ue](le, c);
+        (d = o.removeEventListener) == null || d.call(o, ye, l);
+      }), o[me](ye, l);
     }
   }
   function i() {
-    s.forEach((a) => a()), t == null || t();
+    s.forEach((o) => o()), e == null || e();
   }
-  let o = e.signal;
-  return o.clear = i, o;
+  let a = t.signal;
+  return a.clear = i, a;
 }
-var de = W.getPrototypeOf, ge = (r) => {
-  if (r !== N && typeof r === I) {
-    if (typeof de === Ee) {
-      let t = de(r);
-      return t === Q || t === N;
+var ve = Z.getPrototypeOf, Ee = (n) => {
+  if (n !== W && typeof n === L) {
+    if (typeof ve === Le) {
+      let e = ve(n);
+      return e === re || e === W;
     }
-    return Q.toString.call(r) === `[${I} Object]`;
+    return re.toString.call(n) === `[${L} Object]`;
   }
   return !1;
-}, ne = (...r) => r.reduce((t, e) => {
-  if (M(e)) throw new TypeError(`Arguments must be ${I}s, not arrays.`);
-  return j(e).forEach((n) => {
-    ["__proto__", "constructor", we].includes(n) || (M(t[n]) && M(e[n]) ? t[n] = Array.from(new Set(t[n].concat(e[n]))) : ge(t[n]) && ge(e[n]) ? t[n] = ne(t[n], e[n]) : t[n] = e[n]);
-  }), t;
+}, 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]))) : Ee(e[r]) && Ee(t[r]) ? e[r] = ue(e[r], t[r]) : e[r] = t[r]);
+  }), e;
 }, {});
-function se(r, t = !0, e = N, n) {
-  if (r === _ || r === N) return "";
-  let s = [], i = t ? encodeURIComponent : (g) => g, o = M(r), { arrayFormat: a, allowDots: c, serializeDate: d } = n || {}, h = (g) => {
-    if (c && !o) return `.${g}`;
-    if (o) {
-      if (a === "brackets") return "[]";
-      if (a === "repeat") return "";
+function de(n, e = !0, t = W, r) {
+  if (n === S || n === W) return "";
+  let s = [], i = e ? encodeURIComponent : (g) => g, a = x(n), { arrayFormat: o, allowDots: l, serializeDate: d } = r || {}, h = (g) => {
+    if (l && !a) return `.${g}`;
+    if (a) {
+      if (o === "brackets") return "[]";
+      if (o === "repeat") return "";
     }
     return `[${g}]`;
   };
-  for (let g in r) if (Q.hasOwnProperty.call(r, g)) {
-    let u = r[g];
-    if (u !== _) {
-      let y = e ? `${e}${h(g)}` : i(g);
-      if (!isNaN(u) && u instanceof Date && (u = d ? d(u) : u.toISOString()), typeof u === I) {
-        let f = se(u, t, y, n);
+  for (let g in n) if (re.hasOwnProperty.call(n, g)) {
+    let u = n[g];
+    if (u !== S) {
+      let p = t ? `${t}${h(g)}` : i(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(`${i(y)}=${i(u)}`);
+      } else s.push(`${i(p)}=${i(u)}`);
     }
   }
   return s.join("&");
 }
-function Z(r) {
-  return M(r) ? r.map(Z) : (r && typeof r === I && j(r).forEach((t) => {
-    let e = r[t];
-    e === _ ? delete r[t] : Z(e);
-  }), r);
+function 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 dt(r) {
-  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
+function bt(n) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(n);
 }
-function gt(r, t) {
-  return r ? t ? (r.endsWith("/") ? r : r + "/") + (t[0] === "/" ? t.slice(1) : t) : r : t || "";
+function vt(n, e) {
+  return n ? e ? (n.endsWith("/") ? n : n + "/") + (e[0] === "/" ? e.slice(1) : e) : n : e || "";
 }
-var ft = "XiorError", pt = "XiorTimeoutError", Pe = class extends Error {
-  constructor(r, t, e) {
-    super(r), this.name = ft, this.request = t, this.config = t, this.response = e;
-  }
-}, yt = class extends Pe {
-  constructor(t, e, n) {
-    super(t, e, n), this.name = pt;
-  }
-}, mt = Object.defineProperty, vt = Object.defineProperties, bt = Object.getOwnPropertyDescriptors, U = Object.getOwnPropertySymbols, Ie = Object.prototype.hasOwnProperty, Ce = Object.prototype.propertyIsEnumerable, fe = (r, t, e) => t in r ? mt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, A = (r, t) => {
-  for (var e in t || (t = {})) Ie.call(t, e) && fe(r, e, t[e]);
-  if (U) for (var e of U(t)) Ce.call(t, e) && fe(r, e, t[e]);
-  return r;
-}, $ = (r, t) => vt(r, bt(t)), Et = (r, t) => {
-  var e = {};
-  for (var n in r) Ie.call(r, n) && t.indexOf(n) < 0 && (e[n] = r[n]);
-  if (r != null && U) for (var n of U(r)) t.indexOf(n) < 0 && Ce.call(r, n) && (e[n] = r[n]);
-  return e;
-}, T = (r, t, e) => new Promise((n, s) => {
-  var i = (c) => {
+var Et = "XiorError", It = "XiorTimeoutError", xe = class extends Error {
+  constructor(n, e, t) {
+    super(n), this.name = Et, this.request = e, this.config = e, this.response = t;
+  }
+}, wt = class extends xe {
+  constructor(e, t, r) {
+    super(e, t, r), this.name = It;
+  }
+}, _t = Object.defineProperty, kt = Object.defineProperties, Pt = Object.getOwnPropertyDescriptors, X = Object.getOwnPropertySymbols, De = Object.prototype.hasOwnProperty, $e = Object.prototype.propertyIsEnumerable, Ie = (n, e, t) => e in n ? _t(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, D = (n, e) => {
+  for (var t in e || (e = {})) De.call(e, t) && Ie(n, t, e[t]);
+  if (X) for (var t of X(e)) $e.call(e, t) && Ie(n, t, e[t]);
+  return n;
+}, z = (n, e) => kt(n, Pt(e)), Ct = (n, e) => {
+  var t = {};
+  for (var r in n) De.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 && $e.call(n, r) && (t[r] = n[r]);
+  return t;
+}, $ = (n, e, t) => new Promise((r, s) => {
+  var i = (l) => {
     try {
-      a(e.next(c));
+      o(t.next(l));
     } catch (d) {
       s(d);
     }
-  }, o = (c) => {
+  }, a = (l) => {
     try {
-      a(e.throw(c));
+      o(t.throw(l));
     } catch (d) {
       s(d);
     }
-  }, a = (c) => c.done ? n(c.value) : Promise.resolve(c.value).then(i, o);
-  a((e = e.apply(r, t)).next());
-}), ie = "application/", Se = `${ie}x-www-form-urlencoded`, Re = RegExp, wt = new Re(`^${Se}`, "i"), _t = `${ie}${re}`, kt = new Re(`^${ie}.*${re}.*`, "i");
-function Pt(r = Y) {
-  return [_e, Y, ke].includes(r);
+  }, o = (l) => l.done ? r(l.value) : Promise.resolve(l.value).then(i, a);
+  o((t = t.apply(n, e)).next());
+}), he = "application/", Te = `${he}x-www-form-urlencoded`, Be = RegExp, Kt = new Be(`^${Te}`, "i"), St = `${he}${ce}`, Mt = new Be(`^${he}.*${ce}.*`, "i");
+function At(n = se) {
+  return [Re, se, Fe].includes(n);
 }
-var It = typeof URLSearchParams != `${_}`;
-function Ct(r) {
-  return T(this, null, function* () {
-    let t = r[J] || se, e = r.encodeURI !== !1, n = r[he] && r[he].toUpperCase(), s = r.url, i = s, o = It && r.data instanceof URLSearchParams, a = o ? W.fromEntries(r.data.entries()) : r.data, c = a, d = r != null && r[v] ? A({}, r[v]) : {}, h = r.params, g = Pt(n);
-    if (a && typeof a.append !== Ee) {
-      let u = "", y = "content-type";
-      if (r != null && r[v]) {
-        let f = j(r[v]).find((E) => E.toLowerCase() === y);
-        f && (y = f, u = r[v][f]);
+var Lt = typeof URLSearchParams != `${S}`;
+function Ot(n) {
+  return $(this, null, function* () {
+    let e = n[ne] || de, t = n.encodeURI !== !1, r = n[be] && n[be].toUpperCase(), s = n.url, i = s, a = Lt && n.data instanceof URLSearchParams, o = a ? Z.fromEntries(n.data.entries()) : n.data, l = o, d = n != null && n[w] ? D({}, n[w]) : {}, h = n.params, g = At(r);
+    if (o && typeof o.append !== Le) {
+      let u = "", p = "content-type";
+      if (n != null && n[w]) {
+        let f = Q(n[w]).find((I) => I.toLowerCase() === p);
+        f && (p = f, u = n[w][f]);
       }
-      (!u || o) && (u = g || o ? Se : _t, d[y] = u), typeof a === I && (g && h && (h = ne(a, h)), kt.test(u) ? c = JSON.stringify(Z(a)) : !g && wt.test(u) && (c = t(a)));
+      (!u || a) && (u = g || a ? Te : St, d[p] = u), typeof o === L && (g && h && (h = ue(o, h)), Mt.test(u) ? l = JSON.stringify(ie(o)) : !g && Kt.test(u) && (l = e(o)));
     }
-    if (h && j(h).length > 0) {
-      let u = t(h, e);
+    if (h && Q(h).length > 0) {
+      let u = e(h, t);
       s += s.includes("?") ? `&${u}` : `?${u}`;
     }
-    return $(A({}, r), { _data: c, _url: s, data: a, url: i, method: n, [v]: d, isGet: g });
+    return z(D({}, n), { _data: l, _url: s, data: o, url: i, method: r, [w]: d, isGet: g });
   });
 }
-var St = typeof AbortController != `${_}`;
-function Rt(r, t) {
-  return T(this, null, function* () {
-    let e;
-    if (!t || !r.ok || [q, re].includes(t)) {
-      if (e = yield r[q](), e && t !== q) try {
-        e = JSON.parse(e);
+var Rt = typeof AbortController != `${S}`;
+function Ft(n, e) {
+  return $(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 Mt = (r) => new P(r), P = class {
-  constructor(t) {
-    this.REQI = [], this.RESI = [], this.P = [], this.config = t, this.defaults = { params: {}, [v]: {} };
+var xt = (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 T(this, null, function* () {
-      let e = ne(this.config || {}, this.defaults, typeof t == "string" ? { url: t } : t), n = "credentials";
-      e.withCredentials && !e[n] && (e[n] = "include"), e[J] || (e[J] = se);
-      for (let o of this.REQI) e = yield o(e);
+  request(e) {
+    return $(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 a of this.REQI) t = yield a(t);
       let s = this._.bind(this);
-      this.P.forEach((o) => {
-        s = o(s, this);
+      this.P.forEach((a) => {
+        s = a(s, this);
       });
-      let i = s(e);
-      if (!e._did) {
-        let o = 0, a = [];
-        for (this.RESI.forEach(function(c) {
-          a.push(c.fn, c.onRejected);
-        }); a.length > o; ) i = i.then(a[o++], a[o++]);
+      let i = s(t);
+      if (!t._did) {
+        let a = 0, o = [];
+        for (this.RESI.forEach(function(l) {
+          o.push(l.fn, l.onRejected);
+        }); o.length > a; ) i = i.then(o[a++], o[a++]);
       }
       return i;
     });
   }
-  _(t) {
-    return T(this, null, function* () {
-      let e = yield Ct(t), { url: n, method: s, headers: i, timeout: o, signal: a, data: c, _data: d, _url: h, isGet: g, fetch: u } = e, y = Et(e, ["url", "method", "headers", "timeout", "signal", "data", "_data", "_url", "isGet", "fetch"]);
-      t._url = h;
-      let f, E = [], x = _;
-      if (o && St) {
-        let m = new AbortController();
-        x = setTimeout(() => {
-          m.abort(new yt(`timeout of ${o}ms exceeded`, t));
-        }, o), E.push(m.signal);
+  _(e) {
+    return $(this, null, function* () {
+      let t = yield Ot(e), { url: r, method: s, headers: i, timeout: a, signal: o, data: l, _data: d, _url: h, isGet: g, fetch: u } = t, p = Ct(t, ["url", "method", "headers", "timeout", "signal", "data", "_data", "_url", "isGet", "fetch"]);
+      e._url = h;
+      let f, I = [], j = S;
+      if (a && Rt) {
+        let b = new AbortController();
+        j = setTimeout(() => {
+          b.abort(new wt(`timeout of ${a}ms exceeded`, e));
+        }, a), I.push(b.signal);
       }
-      a && E.push(a), f = E[0], E.length > 1 && (f = ht(E, () => {
-        clearTimeout(x);
+      o && I.push(o), f = I[0], I.length > 1 && (f = mt(I, () => {
+        clearTimeout(j);
       }));
-      let K = h || n, ae = "baseURL";
-      return t[ae] && !dt(K) && (K = gt(t[ae], K)), (u || fetch)(K, $(A({ body: g ? _ : d }, y), { signal: f, method: s, headers: i })).then((m) => T(this, null, function* () {
-        let { responseType: Te } = t, ce = { data: yield Rt(m, Te), response: m, config: t, request: t, [O]: m[O], statusText: m.statusText, [v]: m[v] };
-        if (!m.ok) {
-          let De = new Pe(m[O] ? `Request failed with status code ${m[O]}` : "Network error", t, ce);
-          return Promise.reject(De);
+      let N = h || r, fe = "baseURL";
+      return e[fe] && !bt(N) && (N = vt(e[fe], N)), (u || fetch)(N, z(D({ body: g ? S : d }, p), { signal: f, method: s, headers: i })).then((b) => $(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 He = new xe(b[V] ? `Request failed with status code ${b[V]}` : "Network error", e, pe);
+          return Promise.reject(He);
         }
-        return ce;
+        return pe;
       })).finally(() => {
-        var m;
-        x && clearTimeout(x), (m = f == null ? void 0 : f.clear) == null || m.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 ? $(A({}, n), { method: t, url: e }) : { method: t, url: e });
+  cG(e) {
+    return (t, r) => this.request(r ? z(D({}, r), { method: e, url: t }) : { method: e, url: t });
   }
-  cP(t) {
-    return (e, n, s) => this.request(s ? $(A({}, s), { method: t, url: e, data: n }) : { method: t, url: e, data: n });
+  cP(e) {
+    return (t, r, s) => this.request(s ? z(D({}, s), { method: e, url: t, data: r }) : { method: e, url: t, data: r });
   }
-  get(t, e) {
-    return this.cG(Y)(t, e);
+  get(e, t) {
+    return this.cG(se)(e, t);
   }
-  head(t, e) {
-    return this.cG(_e)(t, e);
+  head(e, t) {
+    return this.cG(Re)(e, t);
   }
-  post(t, e, n) {
-    return this.cP(at)(t, e, n);
+  post(e, t, r) {
+    return this.cP(gt)(e, t, r);
   }
-  put(t, e, n) {
-    return this.cP(ct)(t, e, n);
+  put(e, t, r) {
+    return this.cP(ft)(e, t, r);
   }
-  patch(t, e, n) {
-    return this.cP(lt)(t, e, n);
+  patch(e, t, r) {
+    return this.cP(pt)(e, t, r);
   }
-  delete(t, e) {
-    return this.cG(ut)(t, e);
+  delete(e, t) {
+    return this.cG(yt)(e, t);
   }
-  options(t, e) {
-    return this.cG(ke)(t, e);
+  options(e, t) {
+    return this.cG(Fe)(e, t);
   }
 };
-P.create = Mt, P.VERSION = "0.7.7";
-var At = Object.assign(P.create(), { create: P.create, VERSION: P.VERSION }), Me = At;
-const Ae = Me.create({
+A.create = xt, A.VERSION = "0.7.7";
+var Dt = Object.assign(A.create(), { create: A.create, VERSION: A.VERSION }), Ge = Dt;
+const je = Ge.create({
   baseURL: "https://updater.stats.cc",
   headers: {
     Accept: "application/json",
     "Accept-Encoding": "gzip, deflate, br"
   }
-}), oe = Me.create({
+}), ge = Ge.create({
   baseURL: "https://api.stats.cc",
   headers: {
     Accept: "application/json",
     "Accept-Encoding": "gzip, deflate, br"
   }
 });
-function Tt(r, t) {
-  return Ae.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 Dt(r, t) {
-  return Ae.get(`/v1/native/${r}/files`, {
-    params: { channel: t },
+function Tt(n, e) {
+  return je.get(`/v1/native/${n}/files`, {
+    params: { channel: e },
     responseType: "arraybuffer"
   });
 }
-function Ft() {
-  return oe.get("/v1/raven/config");
+function Bt() {
+  return ge.get("/v1/raven/config");
 }
-function xt(r, t) {
-  return oe.get(`/v1/raven/games/${r}/builds/${t}/check`);
+function Gt(n, e) {
+  return ge.get(`/v1/raven/games/${n}/builds/${e}/check`);
 }
-function Kt(r, t) {
-  const e = new FormData();
-  return e.append("file", t), oe.post(`/v1/raven/games/${r}/builds/upload`, e, {});
+function jt(n, e) {
+  const t = new FormData();
+  return t.append("file", e), ge.post(`/v1/raven/games/${n}/builds/upload`, t, {});
 }
-function Lt(r) {
-  return r instanceof Error && (r.name === "XiorError" || r.name === "XiorTimeoutError");
+function Nt(n) {
+  return n instanceof Error && (n.name === "XiorError" || n.name === "XiorTimeoutError");
 }
-function Ot(r) {
-  return !!(r && "kind" in r.data && "message" in r.data);
+function Vt(n) {
+  return !!(n && "kind" in n.data && "message" in n.data);
 }
-const $t = {
+const Ht = {
   buildChannel: "alpha"
 };
-class Ht extends C {
+class Ut extends G {
   constructor() {
     super("NativeDllManager");
-    l(this, "UPDATE_CHECK_INTERVAL_MS", 1e3 * 60 * 5);
+    c(this, "UPDATE_CHECK_INTERVAL_MS", 1e3 * 60 * 5);
     // 5 minutes
-    l(this, "targetDir");
-    l(this, "updateInterval");
-    this.targetDir = p.join(F, "resources"), this.logger.log("Target directory", this.targetDir);
+    c(this, "targetDir");
+    c(this, "updateInterval");
+    this.targetDir = m.join(Y(), "resources"), this.logger.log("Target directory", this.targetDir);
   }
-  async initWithDlls(e) {
-    super.init(), await b.mkdir(this.targetDir, { recursive: !0 }), await this.checkForUpdates(e), clearInterval(this.updateInterval), this.updateInterval = setInterval(() => this.checkForUpdates(e), this.UPDATE_CHECK_INTERVAL_MS);
+  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 = p.join(this.targetDir, e, "version.txt");
-      return await b.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 p.join(this.targetDir, e);
+  getTargetPath(t) {
+    return m.join(this.targetDir, t);
   }
-  getTargetVersionPath(e, n) {
-    return p.join(this.getTargetPath(e), n);
+  getTargetVersionPath(t, r) {
+    return m.join(this.getTargetPath(t), r);
   }
-  async checkForUpdates(e) {
-    const n = $t.buildChannel;
+  async checkForUpdates(t) {
+    const r = Ht.buildChannel;
     this.logger.log("Checking for updates");
-    for (const s of e)
+    for (const s of t)
       try {
-        const { data: i } = await Tt(s, n), o = await this.getCurrentVersion(s);
-        this.logger.log(`${s} > Update Check. current: ${o}, latest: ${i}`), i !== o ? (this.logger.log(`${s} > Update found: ${o} -> ${i}`), await this.downloadAndExtractDll(s, i, n), this.logger.log(`${s} > Downloaded and extracted`), await this.cleanupOldVersions(s, i), this.logger.log(`${s} > Cleaning up versions older than ${i}`), this.emit("dllUpdated", { identifier: s, version: i })) : this.logger.log(`${s} Up to date`);
+        const { data: i } = await $t(s, r), a = await this.getCurrentVersion(s);
+        this.logger.log(`${s} > Update Check. current: ${a}, latest: ${i}`);
+        const o = i !== a;
+        this.logger.log(`${s} > Update found: ${a} -> ${i}`), await this.downloadAndExtractDll(s, i, r, o), this.logger.log(`${s} > Downloaded and extracted`), o && (this.logger.log(`${s} > Cleaning up versions older than ${i}`), await this.cleanupOldVersions(s, i)), this.emit("dllUpdated", { identifier: s, version: i });
       } catch (i) {
         this.logger.captureSentryException(`${s} > Error checking/updating`, i);
       }
   }
-  async downloadAndExtractDll(e, n, s) {
-    const { data: i } = await Dt(e, s), o = this.getTargetPath(e), a = this.getTargetVersionPath(e, n);
-    await b.mkdir(a, { recursive: !0 });
-    const c = new me();
-    await c.loadAsync(i);
-    const d = Object.keys(c.files).map(async (g) => {
-      const u = c.files[g];
-      if (u && !u.dir) {
-        const y = await u.async("nodebuffer"), f = p.join(a, g);
-        await b.writeFile(f, y);
+  async downloadAndExtractDll(t, r, s, i) {
+    const { data: a } = await Tt(t, s), o = this.getTargetPath(t), l = this.getTargetVersionPath(t, r);
+    await v.mkdir(l, { recursive: !0 });
+    const d = new ke();
+    await d.loadAsync(a);
+    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 (!i)
+          try {
+            await v.access(f, v.constants.F_OK);
+            return;
+          } catch {
+            this.logger.warn(`${t} > File missing, re-downloading: ${f}`);
+          }
+        const I = await p.async("nodebuffer");
+        await v.writeFile(f, I);
       }
     });
-    await Promise.all(d);
-    const h = p.join(o, "version.txt");
-    this.logger.log("Saving version file", h), await b.writeFile(h, 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 = p.join(this.targetDir, e), i = await b.readdir(s, { withFileTypes: !0 });
-    for (const o of i)
-      o.isDirectory() && o.name !== n && await b.rm(p.join(s, o.name), { recursive: !0, force: !0 });
+  async cleanupOldVersions(t, r) {
+    const s = m.join(this.targetDir, t), i = await v.readdir(s, { withFileTypes: !0 });
+    for (const a of i)
+      a.isDirectory() && a.name !== r && await v.rm(m.join(s, a.name), { recursive: !0, force: !0 });
   }
 }
-const B = k(Ht);
-class Nt extends C {
+const J = _(Ut);
+class zt extends G {
   constructor() {
     super("RavenManager");
-    l(this, "REFETCH_INTERVAL", 1e3 * 60 * 5);
-    l(this, "FAILED_REFETCH_INTERVAL", 1e3 * 30);
-    l(this, "_ravenConfig");
-    l(this, "_executableToGameMap", /* @__PURE__ */ new Map());
-    l(this, "_executablesArray", []);
-    l(this, "_refetchIntervalHandler", null);
-    l(this, "_failedRefetchTimeoutHandler", null);
+    c(this, "REFETCH_INTERVAL", 1e3 * 60 * 5);
+    c(this, "FAILED_REFETCH_INTERVAL", 1e3 * 30);
+    c(this, "_ravenConfig");
+    c(this, "_executableToGameMap", /* @__PURE__ */ new Map());
+    c(this, "_executablesArray", []);
+    c(this, "_refetchIntervalHandler", null);
+    c(this, "_failedRefetchTimeoutHandler", null);
   }
   init() {
     super.init(), this.fetchRavenConfig(), this._refetchIntervalHandler = setInterval(() => {
       this._failedRefetchTimeoutHandler && (clearTimeout(this._failedRefetchTimeoutHandler), this._failedRefetchTimeoutHandler = null), this.fetchRavenConfig();
     }, this.REFETCH_INTERVAL);
   }
-  getExecutableData(e) {
-    return this._executableToGameMap.get(e.toLowerCase()) ?? null;
+  getExecutableData(t) {
+    return this._executableToGameMap.get(t.toLowerCase()) ?? null;
   }
   get executables() {
     return this._executablesArray;
@@ -728,85 +795,94 @@ class Nt extends C {
     return this._executableToGameMap;
   }
   destroy() {
-    this._refetchIntervalHandler && clearInterval(this._refetchIntervalHandler), this._failedRefetchTimeoutHandler && clearTimeout(this._failedRefetchTimeoutHandler), B.getInstance().destroy(), super.destroy();
+    this._refetchIntervalHandler && clearInterval(this._refetchIntervalHandler), this._failedRefetchTimeoutHandler && clearTimeout(this._failedRefetchTimeoutHandler), J.getInstance().destroy(), super.destroy();
   }
   async fetchRavenConfig() {
     try {
-      const e = await Ft();
-      this._ravenConfig = e.data, this.resetState();
-      const n = /* @__PURE__ */ new Set();
+      const t = await Bt();
+      this._ravenConfig = t.data, this.resetState();
+      const r = /* @__PURE__ */ new Set();
       for (const s of this._ravenConfig.games) {
         for (const i of s.executables) {
-          const o = i.toLowerCase();
-          this._executableToGameMap.set(o, s), this._executablesArray.push(o);
+          const a = i.toLowerCase();
+          this._executableToGameMap.set(a, s), this._executablesArray.push(a);
         }
-        s.dlls_to_inject.forEach((i) => n.add(i));
+        s.dlls_to_inject.forEach((i) => r.add(i));
       }
-      await B.getInstance().initWithDlls(Array.from(n)), this.logger.log("Raven updated", this._ravenConfig), this.emit("executablesUpdated", { executables: this.executables, map: this._executableToGameMap });
-    } catch (e) {
-      this.logger.captureSentryException("Failed to fetch Raven config", e), this._failedRefetchTimeoutHandler = setTimeout(() => this.fetchRavenConfig(), this.FAILED_REFETCH_INTERVAL);
+      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 G = k(Nt);
-class jt extends C {
+const T = _(zt), qt = oe(import.meta.url), {
+  PipeEventServer: Hn,
+  PipeEventClient: Un,
+  PipeEventBase: zn,
+  ProcessMonitor: Wt,
+  Process: H,
+  InjectionMethod: qn,
+  AccessLevel: Wn,
+  HardwareInterface: Qt
+} = qt("./build/overlayed_native_interface_x64.node");
+class Xt extends G {
   constructor() {
     super("ProcessManager");
-    l(this, "_processMonitor");
-    l(this, "_processes", /* @__PURE__ */ new Map());
-    l(this, "boundOnRavenManagerExecutablesUpdated", this.onRavenManagerExecutablesUpdated.bind(this));
-    this._processMonitor = new Oe();
+    c(this, "_processMonitor");
+    c(this, "_processes", /* @__PURE__ */ new Map());
+    c(this, "boundOnRavenManagerExecutablesUpdated", this.onRavenManagerExecutablesUpdated.bind(this));
+    this._processMonitor = new Wt();
   }
   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(), G.getInstance().on("executablesUpdated", this.boundOnRavenManagerExecutablesUpdated), this._processMonitor.on("create", (e) => {
-      this.logger.log("Process created", e), this.addProcess(e), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("create", { process: e });
-    }), this._processMonitor.on("destroy", (e) => {
-      this.logger.log("Process destroyed", e), this.deleteProcess(e), this.logger.log(`Active Process Count: ${this._processes.size}`), this.emit("destroy", { process: e });
+    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() {
-    G.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((i) => i.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((i) => i.id !== t.id)) ?? [];
+    s.length === 0 ? this._processes.delete(t.name) : this._processes.set(t.name, s);
   }
 }
-const S = k(jt);
-var Ut = Object.defineProperty, Bt = (r, t, e) => t in r ? Ut(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, H = (r, t, e) => Bt(r, typeof t != "symbol" ? t + "" : t, e);
-class Gt {
-  constructor(t) {
-    H(this, "_instance"), H(this, "_resolution"), H(this, "boundOnResolutionChanged", this.onResolutionChanged.bind(this)), this._instance = t, this._resolution = { width: 0, height: 0 }, this._instance.on("resolution", this.boundOnResolutionChanged);
+const C = _(Xt), Jt = oe(import.meta.url), { RenderInterface: Yt, renderHookPath: Qn } = Jt("./build/overlayed_render_interface_x64.node");
+var Zt = Object.defineProperty, en = (n, e, t) => e in n ? Zt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, q = (n, e, t) => en(n, typeof e != "symbol" ? e + "" : e, t);
+class tn {
+  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);
@@ -817,140 +893,196 @@ class Gt {
   get resolution() {
     return this._resolution;
   }
-  onResolutionChanged(t, e) {
-    this._resolution = { width: t, height: e };
+  onResolutionChanged(e, t) {
+    this._resolution = { width: e, height: t };
   }
 }
-class Vt {
+let nn = class {
+  constructor() {
+    q(this, "interfaces", {});
+  }
+  createInterface(e) {
+    return this.interfaces[e] ? this.interfaces[e] : (this.interfaces[e] = new tn(new Yt(e, { access: 1 })), this.interfaces[e]);
+  }
+  getInterface(e) {
+    return this.interfaces[e] ? this.interfaces[e] : this.createInterface(e);
+  }
+};
+const O = _(nn);
+var rn = Object.defineProperty, sn = (n, e, t) => e in n ? rn(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, R = (n, e, t) => sn(n, typeof e != "symbol" ? e + "" : e, t);
+class an {
   constructor() {
-    H(this, "interfaces", {});
+    R(this, "data", []);
+  }
+  get size() {
+    return this.data.length;
+  }
+  add(e) {
+    this.data.push(e);
   }
-  createInterface(t) {
-    return this.interfaces[t] ? this.interfaces[t] : (this.interfaces[t] = new Gt(new Ue(t, { access: 1 })), this.interfaces[t]);
+  next() {
+    return this.data.shift();
   }
-  getInterface(t) {
-    return this.interfaces[t] ? this.interfaces[t] : this.createInterface(t);
+  clear() {
+    this.data.length = 0;
+  }
+  *flush() {
+    for (; this.size > 0; ) {
+      const e = this.next();
+      e && (yield e);
+    }
+  }
+}
+class on {
+  constructor(e) {
+    R(this, "_clientId", null), R(this, "_userId", null), R(this, "options"), R(this, "eventQueue"), this.options = this.resolveOptions(e), this.eventQueue = new an(), 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 ee = k(Vt);
-class zt extends C {
+const P = _(on);
+class ln extends G {
   constructor() {
     super("GameLaunchManager");
-    l(this, "RENDER_INTERFACE_PATH", "node_modules/@overlayed/app/dist/render-interface/build/overlayed_render_hook_x64.dll");
-    l(this, "boundOnProcessCreate", this.onProcessCreate.bind(this));
-    l(this, "boundOnProcessDestroy", this.onProcessDestroy.bind(this));
+    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(), ee.getInstance().createInterface("SCC_RAINBOW"), S.getInstance().on("create", this.boundOnProcessCreate), S.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() {
-    S.getInstance().off("create", this.boundOnProcessCreate), S.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: ", L.currentProcess.isElevated), e.isElevated && !L.currentProcess.isElevated) {
-      be.getInstance().error("Game is elevated but the App is not", "ELEVATION_MISMATCH", {
-        appElevated: L.currentProcess.isElevated,
-        gameElevated: e.isElevated
+    if (this.logger.log("Game Launched", r), this.logger.log("Process is elevated: ", t.isElevated), this.logger.log("Current process is elevated: ", H.currentProcess.isElevated), t.isElevated && !H.currentProcess.isElevated) {
+      E.getInstance().fatal("Game is elevated but the App is not", "ELEVATION_MISMATCH", {
+        appElevated: !!H.currentProcess.isElevated,
+        gameElevated: !!t.isElevated
       }), this.logger.sentryLog("Game elevated but App is not", {
-        appElevated: L.currentProcess.isElevated,
-        gameElevated: e.isElevated
+        appElevated: H.currentProcess.isElevated,
+        gameElevated: t.isElevated
       });
       return;
     }
     const s = this.copyDll(this.RENDER_INTERFACE_PATH);
     if (s)
       try {
-        await e.injectDll(s), this.logger.log("Render Interface Injection Successful", s);
-      } catch (o) {
-        this.logger.captureSentryException("Render Interface Injection Failed", o), this.logger.sentryError("Render Interface Injection Failed", {
+        await t.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", {
           renderInterfacePath: s
         });
       }
-    const i = n == null ? void 0 : n.dlls_to_inject.map(async (o) => {
-      const a = await B.getInstance().getCurrentVersion(o);
-      if (!a)
-        return this.logger.sentryError("No version found for DLL", { identifier: o }), Promise.resolve();
-      const c = B.getInstance().getTargetVersionPath(o, a);
-      this.logger.log("DLL Path", c);
-      const d = await this.getDllFiles(c);
+    const i = r == null ? void 0 : r.dlls_to_inject.map(async (a) => {
+      const o = await J.getInstance().getCurrentVersion(a);
+      if (!o)
+        return this.logger.sentryError("No version found for DLL", { identifier: a }), Promise.resolve();
+      const l = J.getInstance().getTargetVersionPath(a, o);
+      this.logger.log("DLL Path", l);
+      const d = await this.getDllFiles(l);
       return this.logger.log("DLL Files", d), Promise.all(
         d.map(async (h) => {
-          const g = p.basename(h), u = p.join(c, g);
+          const g = m.basename(h), u = m.join(l, g);
           if (!u)
             return Promise.resolve();
           this.logger.log("Injecting: ", u);
           try {
-            return e.injectDll(u).then(() => {
+            return t.injectDll(u).then(() => {
               this.logger.log("Injection Successful", u);
-            }).catch((y) => {
-              this.logger.sentryError("Injection Failed [1]", { targetPath: u }, y);
+            }).catch((p) => {
+              this.logger.sentryError("Injection Failed [1]", { targetPath: u }, p);
             });
-          } catch (y) {
-            return this.logger.sentryError("Injection Failed [2]", { targetPath: u }, y), Promise.reject(y);
+          } catch (p) {
+            return this.logger.sentryError("Injection Failed [2]", { targetPath: u }, p), Promise.reject(p);
           }
         })
       );
     });
-    await Promise.allSettled(i), this.emit("gameLaunch", { ravenGame: n, process: e });
-  }
-  copyDll(e) {
-    this.logger.log(ot());
-    const n = e.split("/");
-    if (n.length < 2)
-      return this.logger.sentryError("Path is invalid", { dllPath: e }), !1;
-    const s = n.at(-1);
+    await Promise.allSettled(i), this.emit("gameLaunchInternal", { ravenGame: r, process: t }), this.emit("gameLaunch", { game: r.identifier }), P.getInstance().track("game_launch", {
+      game: r.identifier
+    });
+  }
+  copyDll(t) {
+    this.logger.log(ut());
+    const r = t.split("/");
+    if (r.length < 2)
+      return this.logger.sentryError("Path is invalid", { dllPath: t }), !1;
+    const s = r.at(-1);
     if (!s)
-      return this.logger.sentryError("Dll name is invalid", { dllPath: e }), !1;
-    const i = Ke(e), o = p.join(F, "resources"), a = p.join(o, s);
-    this.logger.debug("Copying", i, "to", a);
+      return this.logger.sentryError("Dll name is invalid", { dllPath: t }), !1;
+    const i = Je(t), a = m.join(Y(), "resources"), o = m.join(a, s);
+    this.logger.debug("Copying", i, "to", o);
     try {
-      $e(o) || He(o, { recursive: !0 });
-      const c = ye(i);
-      Ne(a, c), je(i, a);
-    } catch (c) {
-      return c.code === "EBUSY" ? a : (this.logger.captureSentryException("Failed to copy", c), this.logger.sentryError("Failed to copy", { originalPath: i, targetPath: a }), !1);
+      qe(a) || We(a, { recursive: !0 });
+      const l = _e(i);
+      Qe(o, l), Xe(i, o);
+    } catch (l) {
+      return l.code === "EBUSY" ? o : (this.logger.captureSentryException("Failed to copy", l), this.logger.sentryError("Failed to copy", { originalPath: i, targetPath: o }), !1);
     }
-    return a;
+    return o;
   }
-  async getDllFiles(e) {
+  async getDllFiles(t) {
     try {
-      return (await b.readdir(e)).filter((s) => s.endsWith(".dll")).map((s) => p.join(e, s));
-    } catch (n) {
-      return this.logger.captureSentryException("Failed to read DLL directory", n), this.logger.sentryError("Failed to read DLL directory", { dllPath: e }), [];
+      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("gameClose", { ravenGame: n, process: e });
+  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 = G.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 V = k(zt);
-class Wt extends st {
+const B = _(ln);
+class cn extends Ae {
   constructor() {
     super("GameBuildManager");
-    l(this, "boundOnGameLaunch", this.onGameLaunch.bind(this));
+    c(this, "boundOnGameLaunch", this.onGameLaunch.bind(this));
   }
   init() {
-    super.init(), V.getInstance().on("gameLaunch", this.boundOnGameLaunch);
+    super.init(), B.getInstance().on("gameLaunchInternal", this.boundOnGameLaunch);
   }
   destroy() {
-    V.getInstance().off("gameLaunch", 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",
@@ -959,30 +1091,30 @@ class Wt extends st {
       );
       return;
     }
-    const i = ye(s.path), o = Be("sha256").update(i).digest("hex");
-    this.logger.log("Process Path", s.path), this.logger.log("Process Name", s.name), this.logger.log("Build Hash", o);
-    let a = !1;
+    const i = _e(s.path), a = Ye("sha256").update(i).digest("hex");
+    this.logger.log("Process Path", s.path), this.logger.log("Process Name", s.name), this.logger.log("Build Hash", a);
+    let o = !1;
     try {
-      a = (await xt(n.identifier, o)).data.upload;
+      o = (await Gt(r.identifier, a)).data.upload;
     } catch (h) {
       this.logger.captureSentryException("Error checking game build hash", h);
       return;
     }
-    if (!a) {
+    if (!o) {
       this.logger.log("Build hash already exists, skipping upload");
       return;
     }
-    const c = new me();
-    c.file(s.name, i);
-    const d = await c.generateAsync({ type: "blob" });
+    const l = new ke();
+    l.file(s.name, i);
+    const d = await l.generateAsync({ type: "blob" });
     try {
-      this.logger.log("Uploading build (size: ", d.size, " bytes)"), await Kt(n.identifier, d), this.logger.log("Build uploaded successfully");
+      this.logger.log("Uploading build (size: ", d.size, " bytes)"), await jt(r.identifier, d), this.logger.log("Build uploaded successfully");
     } catch (h) {
-      Lt(h) ? Ot(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);
+      Nt(h) ? Vt(h.response) ? this.logger.captureSentryException("Error uploading build hash, api error", h) : this.logger.captureSentryException("Error uploading build hash, request error", h) : this.logger.captureSentryException("Error uploading build hash, unknown error", h);
     }
   }
 }
-const qt = k(Wt), te = /* @__PURE__ */ new Map([
+const Ne = _(cn), ae = /* @__PURE__ */ new Map([
   [1, "LeftButton"],
   [2, "RightButton"],
   [3, "Cancel"],
@@ -1175,211 +1307,422 @@ const qt = k(Wt), te = /* @__PURE__ */ new Map([
   [252, "Noname"],
   [253, "PA1"],
   [254, "OEM_Clear"]
-]), pe = new Map(te.entries().map(([r, t]) => [t, r])), Xt = D({
+]), we = new Map(ae.entries().map(([n, e]) => [e, n])), un = K({
   "[string]": {
     keys: "string[]",
-    mode: D("'toggle' | 'hold'").pipe((r) => r ?? "toggle")
+    mode: K("'toggle' | 'hold'").pipe((n) => n ?? "toggle")
   }
 });
-class Jt extends C {
-  constructor(e) {
+class dn extends G {
+  constructor(t) {
     super("KeybindManager");
-    l(this, "preferencesKeybindToCallbacks", /* @__PURE__ */ new Map());
-    l(this, "pressedKeys", /* @__PURE__ */ new Set());
-    l(this, "activeKeybinds", /* @__PURE__ */ new Set());
-    l(this, "triggeredToggleKeybinds", /* @__PURE__ */ new Set());
-    l(this, "isRecording", !1);
-    l(this, "boundHandleKeyboardFocus", this.handleKeyboardFocus.bind(this));
-    l(this, "boundHandleKeyDown", this.handleKeyDown.bind(this));
-    l(this, "boundHandleKeyUp", this.handleKeyUp.bind(this));
-    l(this, "keybidnsFile");
-    this.keybidnsFile = new nt({
-      path: p.join(F, "keybinds.json"),
-      schema: Xt,
-      default: e
+    c(this, "preferencesKeybindToCallbacks", /* @__PURE__ */ new Map());
+    c(this, "pressedKeys", /* @__PURE__ */ new Set());
+    c(this, "activeKeybinds", /* @__PURE__ */ new Set());
+    c(this, "triggeredToggleKeybinds", /* @__PURE__ */ new Set());
+    c(this, "boundHandleKeyboardFocus", this.handleKeyboardFocus.bind(this));
+    c(this, "boundHandleKeyDown", this.handleKeyDown.bind(this));
+    c(this, "boundHandleKeyUp", this.handleKeyUp.bind(this));
+    c(this, "keybindsFile");
+    // TODO try to figure out a better way to handle this
+    c(this, "keybindListeningPaused", !1);
+    this.keybindsFile = new ct({
+      path: dt(["keybinds.json"]),
+      schema: un,
+      default: t
     });
   }
   init() {
     super.init();
-    const e = ee.getInstance().getInterface("SCC_RAINBOW");
-    e.instance.on("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.on("keyDown", this.boundHandleKeyDown), e.instance.on("keyUp", this.boundHandleKeyUp);
+    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 onKeybindToggled(t, r) {
+    const s = this.preferencesKeybindToCallbacks.get(t) || {};
+    s.toggle = r, this.preferencesKeybindToCallbacks.set(t, s);
+  }
+  async onKeybindDown(t, r) {
+    const s = this.preferencesKeybindToCallbacks.get(t) || {};
+    s.down = r, this.preferencesKeybindToCallbacks.set(t, s);
   }
-  async onHotkeyToggled(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.toggle = 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 onHotkeyDown(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.down = n, this.preferencesKeybindToCallbacks.set(e, s);
+  async updateKeybind(t, r) {
+    this.keybindsFile.set({
+      [t]: r
+    });
+  }
+  async updateKeybinds(t) {
+    const r = Object.fromEntries(
+      Object.entries(t).filter(([s, i]) => i !== void 0)
+    );
+    this.keybindsFile.set({
+      ...this.keybindsFile.get(),
+      ...r
+    });
   }
-  async onHotkeyUp(e, n) {
-    const s = this.preferencesKeybindToCallbacks.get(e) || {};
-    s.up = n, this.preferencesKeybindToCallbacks.set(e, s);
+  getConfig() {
+    return this.keybindsFile.get();
   }
   destroy() {
-    const e = ee.getInstance().getInterface("SCC_RAINBOW");
-    e.instance.off("keyboardFocus", this.boundHandleKeyboardFocus), e.instance.off("keyDown", this.boundHandleKeyDown), e.instance.off("keyUp", this.boundHandleKeyUp), super.destroy();
+    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 = te.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 = te.get(e.key);
-    if (!n)
+    const r = ae.get(t.key);
+    if (!r)
       return;
-    this.pressedKeys.delete(n);
-    const s = this.keybidnsFile.data;
+    this.pressedKeys.delete(r);
+    const s = this.keybindsFile.get();
     for (const [i] of this.preferencesKeybindToCallbacks.entries())
-      s[i].keys.includes(n) && this.triggeredToggleKeybinds.delete(i);
-    this.checkHotkeyUps();
+      s[i].keys.includes(r) && this.triggeredToggleKeybinds.delete(i);
+    this.checkKeybindUps();
   }
-  async checkHotkeyUps() {
-    const e = this.keybidnsFile.data;
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
+  async checkKeybindUps() {
+    const t = this.keybindsFile.get();
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
       if (!s.up) continue;
-      const i = e[n];
-      this.activeKeybinds.has(n) && i.keys.some((o) => !this.pressedKeys.has(o)) && (this.activeKeybinds.delete(n), s.up(), this.logger.log("Hotkey up triggered", this.getHotkeyToString(i)));
+      const i = t[r];
+      this.activeKeybinds.has(r) && i.keys.some((a) => !this.pressedKeys.has(a)) && (this.activeKeybinds.delete(r), s.up(), this.logger.log("Keybind up triggered", this.getKeybindToString(i)));
     }
   }
   async checkKeybindings() {
-    const e = this.keybidnsFile.data;
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
-      const i = e[n];
-      if (i.keys.length === this.pressedKeys.size && i.keys.every((a) => pe.has(a) ? this.pressedKeys.has(a) : !1)) {
-        this.triggerHotkey(i, s, n);
+    const t = this.keybindsFile.get();
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const i = t[r];
+      if (i.keys.length === this.pressedKeys.size && i.keys.every((o) => we.has(o) ? this.pressedKeys.has(o) : !1)) {
+        this.triggerKeybind(i, s, r);
         return;
       }
     }
-    for (const [n, s] of this.preferencesKeybindToCallbacks.entries()) {
-      const i = e[n];
-      i.keys.every((a) => pe.has(a) ? this.pressedKeys.has(a) : (this.logger.error("Unknown key", a, i), !1)) && this.triggerHotkey(i, s, n);
+    for (const [r, s] of this.preferencesKeybindToCallbacks.entries()) {
+      const i = t[r];
+      i.keys.every((o) => we.has(o) ? this.pressedKeys.has(o) : (this.logger.error("Unknown key", o, i), !1)) && this.triggerKeybind(i, s, r);
     }
   }
-  triggerHotkey(e, n, s) {
-    const i = e.mode;
-    if (i === "toggle" && n.toggle && !this.triggeredToggleKeybinds.has(s)) {
-      const o = n.toggle();
+  triggerKeybind(t, r, s) {
+    const i = t.mode;
+    if (i === "toggle" && r.toggle && !this.triggeredToggleKeybinds.has(s)) {
+      const a = r.toggle();
       this.triggeredToggleKeybinds.add(s), this.logger.log(
-        o ? `Hotkey pressed rejected: ${o}` : "Hotkey pressed accepted",
-        this.getHotkeyToString(e)
+        a ? `Keybind pressed rejected: ${a}` : "Keybind pressed accepted",
+        this.getKeybindToString(t)
       );
     }
-    if (i === "hold" && n.down && !this.activeKeybinds.has(s)) {
-      const o = n.down();
-      o ? this.logger.log(`Hotkey down rejected: ${o}`, this.getHotkeyToString(e)) : (this.activeKeybinds.add(s), this.logger.log("Hotkey down accepted", this.getHotkeyToString(e)));
+    if (i === "hold" && r.down && !this.activeKeybinds.has(s)) {
+      const a = r.down();
+      a ? this.logger.log(`Keybind down rejected: ${a}`, 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}` : ""})`;
   }
 }
-function pr(r) {
-  const t = /* @__PURE__ */ new Map(), e = Yt(r.modules, t), n = Zt(), s = tr(r.keybinds);
-  return Qt(), er(r, t), {
-    ...e,
-    ...n,
-    keybinds: s
+class hn 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 = O.getInstance().getInterface(t);
+  }
+  scope(t) {
+    return {
+      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(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(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(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(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 gn = _(hn, "OGG_SIEGE");
+let te = !1, U;
+function Jn(n) {
+  const { init: e = !0 } = n;
+  if (fn(n), te)
+    return U;
+  function t() {
+    _n(n);
+    const r = /* @__PURE__ */ new Map(), s = mn(n.modules, r), i = bn(), a = En(n.keybinds), o = In(), l = wn();
+    pn(), vn(n, r), te = !0, U = {
+      ...s,
+      ...i,
+      keybinds: a,
+      windows: o,
+      input: l,
+      hasAnyActiveProcesses: () => C.getInstance().hasAnyActiveProcesses,
+      init: t
+    };
+  }
+  return e ? (t(), U) : new Proxy(
+    {
+      init: t
+    },
+    {
+      get: (r, s) => {
+        if (s !== "init" && !te)
+          throw new Error("overlayed was called before initialized");
+        return s === "init" ? r[s] : U[s];
+      }
+    }
+  );
+}
+global.OVERLAYED = new Proxy({}, {
+  get: () => {
+    throw new Error("function overlayed was not called");
+  }
+});
+function fn(n) {
+  global.OVERLAYED = {
+    APP_NAME: n.appName
   };
 }
-function Qt() {
-  qt.getInstance().init(), V.getInstance().init(), S.getInstance().init(), G.getInstance().init();
+function pn() {
+  Ne.getInstance().init(), B.getInstance().init(), C.getInstance().init(), T.getInstance().init(), Pe.on("quit", () => {
+    yn();
+  });
+}
+function yn() {
+  T.getInstance().destroy(), B.getInstance().destroy(), Ne.getInstance().destroy(), C.getInstance().destroy(), O.getInstance().getInterface("OGG_SIEGE").destroy(), le.getInstance().destroy(), E.getInstance().destroy();
 }
-function Yt(r, t) {
-  return r.reduce((e, n) => {
-    const s = n.key;
-    return e[s] = {
+function mn(n, e) {
+  return n.reduce((t, r) => {
+    const s = r.key;
+    return t[s] = {
+      // prettier-ignore
+      on(i, a) {
+        const o = M(s, i), l = e.get(o) ?? /* @__PURE__ */ new Set();
+        l.add(a), e.set(o, l);
+      },
+      onAny(i) {
+        const a = M(s, "*"), o = e.get(a) ?? /* @__PURE__ */ new Set();
+        o.add(i), e.set(a, o);
+      },
       // prettier-ignore
-      on(i, o) {
-        const a = z(s, i), c = t.get(a) ?? /* @__PURE__ */ new Set();
-        c.add(o), t.set(a, c);
+      off(i, a) {
+        const o = M(s, i), l = e.get(o) ?? /* @__PURE__ */ new Set();
+        l.delete(a), e.set(o, l);
       },
       // prettier-ignore
-      off(i, o) {
-        const a = z(s, i), c = t.get(a) ?? /* @__PURE__ */ new Set();
-        c.delete(o), t.set(a, c);
+      offAny(i) {
+        const a = M(s, "*"), o = e.get(a) ?? /* @__PURE__ */ new Set();
+        o.delete(i), e.set(a, o);
       }
-    }, e;
+    }, t;
   }, {});
 }
-function Zt() {
-  const r = be.getInstance(), t = V.getInstance();
+function bn() {
+  const n = E.getInstance(), e = B.getInstance();
   return {
-    on: (e, n) => {
-      switch (e) {
+    on: (t, r) => {
+      switch (t) {
+        case "fatal":
+          n.on("fatal", r);
+          break;
+        case "error":
+          n.on("error", r);
+          break;
+        case "warning":
+          n.on("warning", r);
+          break;
+        case "gameLaunch":
+          e.on("gameLaunch", r);
+          break;
+        case "gameClose":
+          e.on("gameClose", r);
+          break;
+        default:
+          throw new Error(`Event type not implemented ${t}`, { cause: [t, r] });
+      }
+    },
+    off: (t, r) => {
+      switch (t) {
+        case "fatal":
+          n.off("fatal", r);
+          break;
         case "error":
-          r.on("error", n);
+          n.off("error", r);
           break;
         case "warning":
-          r.on("warning", n);
+          n.off("warning", r);
           break;
         case "gameLaunch":
-          t.on("gameLaunch", n);
+          e.off("gameLaunch", r);
           break;
         case "gameClose":
-          t.on("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 z(r, t) {
-  return `${r}:${t}`;
+function M(n, e) {
+  return `${n}:${e}`;
 }
-function er(r, t) {
-  const e = Qe.getInstance();
-  function n(s) {
-    const i = Ye(s);
-    if (i instanceof D.errors)
+function vn(n, e) {
+  const t = le.getInstance();
+  function r(s) {
+    const i = ht(s);
+    if (i instanceof K.errors) {
+      E.getInstance().warn("Invalid event", "INVALID_EVENT", {
+        summary: i.summary
+      });
       return;
-    const o = r.modules.find((f) => f.key === i.game), a = o == null ? void 0 : o.events.event;
-    if (!a)
+    }
+    const a = n.modules.find((f) => f.key === i.game), o = a == null ? void 0 : a.events.event;
+    if (!o)
       return;
-    const c = a(s);
-    if (c instanceof D.errors)
+    const l = o(s);
+    if (l instanceof K.errors) {
+      E.getInstance().warn("Invalid event", "INVALID_EVENT", {
+        summary: l.summary
+      });
       return;
-    const d = z(o.key, c.type), h = z(o.key, "*"), g = t.get(d), u = t.get(h), y = [...Array.from(g ?? []), ...Array.from(u ?? [])];
-    y.length !== 0 && y.forEach((f) => {
-      f(c);
+    }
+    const d = M(a.key, l.type), h = M(a.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) => {
+    E.getInstance().error("Pipe server error", "PIPE_SERVER_ERROR", {
+      error: s
+    });
+  }), t;
 }
-function tr(r) {
-  const t = {}, e = new Jt(r);
-  for (const n in r)
-    t[n] = {
-      on: (s, i) => {
-        switch (s) {
+function En(n) {
+  const e = new dn(n), t = {};
+  for (const s in n)
+    t[s] = {
+      on: (i, a) => {
+        switch (i) {
           case "down":
-            e.onHotkeyDown(n, i);
+            e.onKeybindDown(s, a);
             break;
           case "up":
-            e.onHotkeyUp(n, i);
+            e.onKeybindUp(s, a);
             break;
           case "toggle":
-            e.onHotkeyToggled(n, i);
+            e.onKeybindToggled(s, a);
             break;
           default:
-            throw new Error("Not implemented", { cause: [s, i] });
+            throw new Error(`Event type not implemented ${i}`, { cause: [i, a] });
         }
       }
     };
-  return t;
+  const r = {
+    ...t,
+    getConfig: () => e.getConfig(),
+    pauseKeybindListening: () => {
+      e.keybindListeningPaused = !0;
+    },
+    resumeKeybindListening: () => {
+      e.keybindListeningPaused = !1;
+    },
+    updateKeybind: (s, i) => {
+      e.updateKeybind(s, i);
+    },
+    updateKeybinds: (s) => {
+      e.updateKeybinds(s);
+    }
+  };
+  return e.init(), Pe.on("quit", () => {
+    e.destroy();
+  }), r;
+}
+function In() {
+  return {
+    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 n = y(), e = le.getInstance();
+      return {
+        resolution: n.resolution,
+        isConnected: e.hasConnection
+      };
+    }
+  };
+}
+function wn() {
+  return {
+    scope: (n) => gn.getInstance().scope(n),
+    raw: {
+      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 _n(n) {
+  P.getInstance().clientId = n.appName, P.getInstance().userId = Qt.generateUniqueIdentifier(), E.getInstance().on("fatal", (e) => {
+    P.getInstance().track("fatal", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  }), E.getInstance().on("error", (e) => {
+    P.getInstance().track("error", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  }), E.getInstance().on("warning", (e) => {
+    P.getInstance().track("warning", {
+      message: e.message,
+      code: e.code,
+      data: e.data
+    });
+  });
+}
+function y() {
+  return O.getInstance().getInterface("OGG_SIEGE");
 }
 export {
-  pr as overlayed
+  Jn as overlayed
 };