@ztimson/momentum 0.42.2 → 0.43.0

package/dist/index.mjs

@@ -34,6 +34,100 @@ function Lt(r, t) {
 function ft(r) {
   return Array.isArray(r) ? r : [r];
 }
+class B extends Array {
+  /** Number of elements in set */
+  get size() {
+    return this.length;
+  }
+  /**
+   * Array to create set from, duplicate values will be removed
+   * @param {T[]} elements Elements which will be added to set
+   */
+  constructor(t = []) {
+    super(), t != null && t.forEach && t.forEach((e) => this.add(e));
+  }
+  /**
+   * Add elements to set if unique
+   * @param items
+   */
+  add(...t) {
+    t.filter((e) => !this.has(e)).forEach((e) => this.push(e));
+  }
+  /**
+   * Delete elements from set
+   * @param items Elements that will be deleted
+   */
+  delete(...t) {
+    t.forEach((e) => {
+      const n = this.indexOf(e);
+      n != -1 && this.slice(n, 1);
+    });
+  }
+  /**
+   * Create list of elements this set has which the comparison set does not
+   * @param {ASet<T>} set Set to compare against
+   * @return {ASet<T>} Different elements
+   */
+  difference(t) {
+    return new B(this.filter((e) => !t.has(e)));
+  }
+  /**
+   * Check if set includes element
+   * @param {T} el Element to look for
+   * @return {boolean} True if element was found, false otherwise
+   */
+  has(t) {
+    return this.indexOf(t) != -1;
+  }
+  /**
+   * Create list of elements this set has in common with the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} Set of common elements
+   */
+  intersection(t) {
+    return new B(this.filter((e) => t.has(e)));
+  }
+  /**
+   * Check if this set has no elements in common with the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if nothing in common, false otherwise
+   */
+  isDisjointFrom(t) {
+    return this.intersection(t).size == 0;
+  }
+  /**
+   * Check if all elements in this set are included in the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if all elements are included, false otherwise
+   */
+  isSubsetOf(t) {
+    return this.findIndex((e) => !t.has(e)) == -1;
+  }
+  /**
+   * Check if all elements from comparison set are included in this set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if all elements are included, false otherwise
+   */
+  isSuperset(t) {
+    return t.findIndex((e) => !this.has(e)) == -1;
+  }
+  /**
+   * Create list of elements that are only in one set but not both (XOR)
+   * @param {ASet<T>} set Set to compare against
+   * @return {ASet<T>} New set of unique elements
+   */
+  symmetricDifference(t) {
+    return new B([...this.difference(t), ...t.difference(this)]);
+  }
+  /**
+   * Create joined list of elements included in this & the comparison set
+   * @param {ASet<T>} set Set join
+   * @return {ASet<T>} New set of both previous sets combined
+   */
+  union(t) {
+    return new B([...this, ...t]);
+  }
+}
 class Dt {
   /**
    * Create new cache
@@ -190,6 +284,11 @@ function Ut(r = {}) {
     }, document.body.appendChild(e), e.click();
   });
 }
+function qt(r, t = /* @__PURE__ */ new Date()) {
+  (typeof t == "number" || typeof t == "string") && (t = new Date(t));
+  const e = `${t.getFullYear()}-${(t.getMonth() + 1).toString().padStart(2, "0")}-${t.getDate().toString().padStart(2, "0")}_${t.getHours().toString().padStart(2, "0")}-${t.getMinutes().toString().padStart(2, "0")}-${t.getSeconds().toString().padStart(2, "0")}`;
+  return e;
+}
 function Ft(r) {
   return new E((t, e, n) => {
     const s = new XMLHttpRequest(), o = new FormData();
@@ -448,7 +547,7 @@ const x = {
   BLINK: "\x1B[5m",
   REVERSE: "\x1B[7m",
   HIDDEN: "\x1B[8m"
-}, j = {
+}, $ = {
   BLACK: "\x1B[30m",
   RED: "\x1B[31m",
   GREEN: "\x1B[32m",
@@ -484,7 +583,7 @@ const g = class g2 extends _ {
   debug(...t) {
     if (g2.LOG_LEVEL < 4) return;
     const e = this.format(...t);
-    g2.emit(4, e), console.debug(j.LIGHT_GREY + e + x.CLEAR);
+    g2.emit(4, e), console.debug($.LIGHT_GREY + e + x.CLEAR);
   }
   log(...t) {
     if (g2.LOG_LEVEL < 3) return;
@@ -494,21 +593,21 @@ const g = class g2 extends _ {
   info(...t) {
     if (g2.LOG_LEVEL < 2) return;
     const e = this.format(...t);
-    g2.emit(2, e), console.info(j.BLUE + e + x.CLEAR);
+    g2.emit(2, e), console.info($.BLUE + e + x.CLEAR);
   }
   warn(...t) {
     if (g2.LOG_LEVEL < 1) return;
     const e = this.format(...t);
-    g2.emit(1, e), console.warn(j.YELLOW + e + x.CLEAR);
+    g2.emit(1, e), console.warn($.YELLOW + e + x.CLEAR);
   }
   error(...t) {
     if (g2.LOG_LEVEL < 0) return;
     const e = this.format(...t);
-    g2.emit(0, e), console.error(j.RED + e + x.CLEAR);
+    g2.emit(0, e), console.error($.RED + e + x.CLEAR);
   }
 };
 c(g, "LOG_LEVEL", 4);
-var $ = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, xt = {}, S = {};
+var j = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, xt = {}, S = {};
 Object.defineProperty(S, "__esModule", { value: true });
 S.persist = S.Persist = void 0;
 class st {
@@ -628,7 +727,7 @@ class At {
 }
 L.MemoryStorage = At;
 (function(r) {
-  var t = $ && $.__createBinding || (Object.create ? function(n, s, o, i) {
+  var t = j && j.__createBinding || (Object.create ? function(n, s, o, i) {
     i === void 0 && (i = o);
     var a = Object.getOwnPropertyDescriptor(s, o);
     (!a || ("get" in a ? !s.__esModule : a.writable || a.configurable)) && (a = { enumerable: true, get: function() {
@@ -636,22 +735,120 @@ L.MemoryStorage = At;
     } }), Object.defineProperty(n, i, a);
   } : function(n, s, o, i) {
     i === void 0 && (i = o), n[i] = s[o];
-  }), e = $ && $.__exportStar || function(n, s) {
+  }), e = j && j.__exportStar || function(n, s) {
     for (var o in n) o !== "default" && !Object.prototype.hasOwnProperty.call(s, o) && t(s, n, o);
   };
   Object.defineProperty(r, "__esModule", { value: true }), e(S, r), e(L, r);
 })(xt);
+function combinePathedEvents(...paths) {
+  let hitNone = false;
+  const combined = paths.map((p2) => typeof p2 == "string" ? parsePathedEvent(p2) : p2).toSorted((p1, p2) => {
+    const l1 = p1.fullPath.length, l2 = p2.fullPath.length;
+    return l1 < l2 ? 1 : l1 > l2 ? -1 : 0;
+  }).reduce((acc, p2) => {
+    if (p2.none) hitNone = true;
+    if (!acc) return p2;
+    if (hitNone) return acc;
+    if (p2.all) acc.all = true;
+    if (p2.all || p2.create) acc.create = true;
+    if (p2.all || p2.read) acc.read = true;
+    if (p2.all || p2.update) acc.update = true;
+    if (p2.all || p2.delete) acc.delete = true;
+    if (p2.all || p2.execute) acc.execute = true;
+    acc.methods = [...acc.methods, ...p2.methods];
+    return acc;
+  }, null);
+  if (combined.all) combined.methods = ["*"];
+  if (combined.none) combined.methods = ["n"];
+  combined.methods = new B(combined.methods);
+  combined.full = pathedEvent(combined.fullPath, ...combined.methods);
+  return combined;
+}
+function hasPath(target, ...anyPath) {
+  const parsedRequired = anyPath.map(parsePathedEvent);
+  const parsedTarget = ft(target).map(parsePathedEvent);
+  return !!parsedRequired.find((r) => {
+    if (r.all) return true;
+    const filtered = parsedTarget.filter((p2) => r.fullPath.startsWith(p2.fullPath));
+    if (!filtered.length) return false;
+    const combined = combinePathedEvents(...filtered);
+    return !combined.none && (combined.all || new B(combined.methods).intersection(new B(r.methods)).length);
+  });
+}
+function hasPathFatal(target, ...paths) {
+  if (!hasPath(target, ...paths)) throw new Error(`Missing permission: ${paths.join(", ")}`);
+}
+function pathedEvent(path, ...methods) {
+  var _a;
+  let p2 = ft(path).map((p22) => p22 == null ? void 0 : p22.toString()).filter((p22) => !!p22).map((p22) => p22 == null ? void 0 : p22.replaceAll(/(^\/|\/$)/g, "")).join("/");
+  if (methods.length) p2 += `:${methods.join("")}`;
+  return (_a = p2 == null ? void 0 : p2.replaceAll("//", "/")) == null ? void 0 : _a.trim();
+}
+function parsePathedEvent(path) {
+  var _a;
+  if (typeof path == "object") return path;
+  let [p2, scope, method] = path.split(":");
+  if (!method) method = scope || "*";
+  if (p2 == "*" || !p2 && method == "*") {
+    p2 = "";
+    method = "*";
+  }
+  let temp = p2.split("/").filter((p22) => !!p22);
+  return {
+    full: path,
+    module: ((_a = temp.splice(0, 1)[0]) == null ? void 0 : _a.toLowerCase()) || "",
+    fullPath: p2,
+    path: temp.join("/"),
+    methods: method.split(""),
+    all: method == null ? void 0 : method.includes("*"),
+    none: method == null ? void 0 : method.includes("n"),
+    create: !(method == null ? void 0 : method.includes("n")) && ((method == null ? void 0 : method.includes("*")) || (method == null ? void 0 : method.includes("w")) || (method == null ? void 0 : method.includes("c"))),
+    read: !(method == null ? void 0 : method.includes("n")) && ((method == null ? void 0 : method.includes("*")) || (method == null ? void 0 : method.includes("r"))),
+    update: !(method == null ? void 0 : method.includes("n")) && ((method == null ? void 0 : method.includes("*")) || (method == null ? void 0 : method.includes("w")) || (method == null ? void 0 : method.includes("u"))),
+    delete: !(method == null ? void 0 : method.includes("n")) && ((method == null ? void 0 : method.includes("*")) || (method == null ? void 0 : method.includes("w")) || (method == null ? void 0 : method.includes("d"))),
+    execute: !(method == null ? void 0 : method.includes("n")) && ((method == null ? void 0 : method.includes("*")) || (method == null ? void 0 : method.includes("x")))
+  };
+}
+class PathedEventEmitter {
+  constructor() {
+    __publicField(this, "listeners", []);
+  }
+  emit(event, ...args) {
+    const parsed = parsePathedEvent(event);
+    this.listeners.filter((l) => hasPath(l[0], event)).forEach((l) => l[1](parsed, ...args));
+  }
+  off(listener) {
+    this.listeners = this.listeners.filter((l) => l[1] != listener);
+  }
+  on(event, listener) {
+    ft(event).forEach((e) => this.listeners.push([parsePathedEvent(e), listener]));
+    return () => this.off(listener);
+  }
+  once(event, listener) {
+    return new Promise((res) => {
+      const unsubscribe = this.on(event, (event2, ...args) => {
+        res(args);
+        if (listener) listener(event2, ...args);
+        unsubscribe();
+      });
+    });
+  }
+  relayEvents(emitter) {
+    emitter.on("*", (event, ...args) => this.emit(event, ...args));
+  }
+}
 class Api extends F {
   constructor(url = location.origin, opts = {}) {
     opts.url = url;
     super(opts);
-    __publicField(this, "emitter", new _());
+    __publicField(this, "emitter", new PathedEventEmitter());
     __publicField(this, "pending", {});
     __publicField(this, "_token", null);
     __publicField(this, "emit", this.emitter.emit.bind(this.emitter));
     __publicField(this, "off", this.emitter.off.bind(this.emitter));
     __publicField(this, "on", this.emitter.on.bind(this.emitter));
     __publicField(this, "once", this.emitter.once.bind(this.emitter));
+    __publicField(this, "relayEvents", this.emitter.relayEvents.bind(this.emitter));
     this.url = url;
     this.opts = opts;
   }
@@ -662,26 +859,27 @@ class Api extends F {
     if (token == this._token) return;
     this._token = token;
     this.headers["Authorization"] = token ? `Bearer ${token}` : null;
-    this.emit("token", token);
+    this.emit(pathedEvent("api/token", "u"), token);
   }
   healthcheck() {
-    return this.request({ url: "/api/healthcheck" });
-  }
-  path(...children) {
-    return children.filter((p2) => !!p2).join("/").replaceAll("//", "/");
+    return this.request({ url: "/api/healthcheck" }).then((resp) => {
+      this.emit(pathedEvent("api/healthcheck", "r"), resp);
+      return resp;
+    });
   }
   request(options) {
     const key = Lt(options);
+    const method = options.method == "GET" ? "r" : options.method == "POST" ? "c" : options.method == "DELETE" ? "d" : "u";
     if (this.pending[key] != null) return this.pending[key];
     this.pending[key] = super.request(options).then((resp) => {
-      this.emit("response", resp, options);
+      this.emit(pathedEvent("api/response", method), resp, options);
       return resp.data;
     }).catch((err) => {
       const e = (err == null ? void 0 : err.data) || err;
-      this.emit("rejected", e, options);
+      this.emit(pathedEvent("api/error", method), e, options);
       throw e;
     }).finally(() => delete this.pending[key]);
-    this.emit("request", this.pending[key], options);
+    this.emit(pathedEvent("api/request", method), this.pending[key], options);
     return this.pending[key];
   }
 }
@@ -695,7 +893,7 @@ var ActionType = /* @__PURE__ */ ((ActionType2) => {
   ActionType2[ActionType2["PUT"] = 6] = "PUT";
   return ActionType2;
 })(ActionType || {});
-class Actions extends _ {
+class Actions extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
@@ -703,80 +901,86 @@ class Actions extends _ {
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   delete(id) {
-    return this.api.request({ url: `/api/actions/${id}`, method: "DELETE" }).then(() => {
+    if (!id) throw new Error("Cannot delete action, missing ID");
+    return this.api.request({ url: `/api/` + pathedEvent(["actions", id]), method: "DELETE" }).then(() => {
       this.cache.delete(id);
-      this.emit("delete", id);
+      this.emit(pathedEvent(["actions", id], "d"), id);
     });
   }
   all() {
     return this.api.request({ url: `/api/actions` }).then((resp) => {
       this.cache.addAll(resp);
-      this.emit("all", resp || []);
+      this.emit(pathedEvent("actions", "r"), resp || []);
       return resp;
     });
   }
   read(id, reload = false) {
+    if (!id) throw new Error("Cannot read action, missing ID");
     const cached = this.cache.get(id);
     if (!reload && cached) return Promise.resolve(cached);
-    return this.api.request({ url: `/api/actions/${id}` }).then((action) => {
+    return this.api.request({ url: `/api/` + pathedEvent(["actions", id]) }).then((action) => {
       if (action) this.cache.add(action);
-      this.emit("read", action);
+      this.emit(pathedEvent(["actions", id], "r"), action);
       return action;
     });
   }
   run(path, opts = {}) {
-    return this.api.request({ url: (`/api/actions/run/` + path).replaceAll("//", "/"), ...opts }).then((resp) => {
-      this.emit("execute", path, resp);
+    if (!path) throw new Error("Cannot run action, missing path");
+    return this.api.request({ url: `/api/` + pathedEvent(["actions/run", path]), ...opts }).then((resp) => {
+      this.emit(pathedEvent(["actions/run", path], "x"), resp);
       return resp;
     });
   }
   runById(action, opts = {}) {
-    const id = typeof action == "string" ? action : action._id;
-    return this.api.request({ url: "/api/actions/run-by-id/" + id, method: "POST", ...opts }).then((resp) => {
-      this.emit("execute", typeof action == "string" ? action : action._id, resp);
+    const id = typeof action == "string" ? action : action == null ? void 0 : action._id;
+    if (!id) throw new Error("Cannot run action, missing ID");
+    return this.api.request({ url: "/api/" + pathedEvent(["actions/run-by-id", id]), method: "POST", ...opts }).then((resp) => {
+      this.emit(pathedEvent(["actions/run-by-id", id], "x"), resp);
       return resp;
     });
   }
   update(action) {
     return this.api.request({
-      url: `/api/actions${action._id ? `/${action._id}` : ""}`,
+      url: `/api/` + pathedEvent(["actions", action._id]),
       method: "POST",
       body: action
     }).then((action2) => {
       if (action2) this.cache.add(action2);
-      this.emit("update", action2);
+      this.emit(pathedEvent(["actions", action2._id], "u"), action2);
       return action2;
     });
   }
 }
-class Ai extends _ {
+class Ai extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   ask(question, context) {
+    if (!question) throw new Error("Cannot ask AI, missing question");
     return this.api.request({ url: `/api/ai`, method: "POST", body: {
       question,
       context
     } }).then((resp) => {
-      this.emit("ask", question, context, resp);
+      this.emit(pathedEvent("ai", "c"), question, context, resp);
       return resp;
     });
   }
   clear() {
-    return this.api.request({ url: "/api/ai", method: "DELETE" });
+    return this.api.request({ url: "/api/ai", method: "DELETE" }).then(() => this.emit(pathedEvent("ai", "d")));
   }
 }
-class Analytics extends _ {
+class Analytics extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   ipTrace(ip) {
+    if (!ip) throw new Error("Cannot trace, missing IP");
     return this.api.request({ url: `/api/analytics/trace?ip=${ip}` }).then((resp) => {
-      this.emit("ipTrace", ip, resp);
+      this.emit(pathedEvent("analytics/trace", "r"), ip, resp);
       return resp;
     });
   }
@@ -799,7 +1003,7 @@ class Totp {
     }) });
   }
 }
-class Auth extends _ {
+class Auth extends PathedEventEmitter {
   constructor(api, opts = {}) {
     super();
     __publicField(this, "api");
@@ -822,10 +1026,10 @@ class Auth extends _ {
         "/api/auth/totp"
       ];
       if (resp.status == 401 && !blacklist.find((url) => resp.url.includes(url)))
-        this.emit("sessionExpired");
+        this.emit(pathedEvent("auth/session-expired", "d"));
       next();
     });
-    this.api.on("token", (token) => {
+    this.api.on("api/token", (event, token) => {
       var _a;
       if ((_a = this.opts) == null ? void 0 : _a.persist) {
         if (token) localStorage.setItem(this.storageKey, token);
@@ -849,15 +1053,18 @@ class Auth extends _ {
   set user(user) {
     if (!A(this.user, user)) {
       this._user = user ? user : null;
-      this.emit("user", this._user);
+      this.emit(pathedEvent("auth/user", "u"), this._user);
     }
   }
   knownHost(host = location.origin) {
     if (host.startsWith("/")) return Promise.resolve();
-    return this.api.request({ url: `/api/auth/known-host?host=${encodeURI(new URL(host).origin)}` }).then(() => {
+    return this.api.request({ url: `/api/auth/known-host?host=${encodeURI(new URL(host).origin)}` }).then(() => this.emit(pathedEvent("auth/known-host", "r"), host, true)).catch((err) => {
+      this.emit(pathedEvent("auth/known-host", "r"), host, false);
+      throw err;
     });
   }
   login(username, password, totp) {
+    if (!username || !password) throw new Error("Cannot login, missing username or password");
     return this.api.request({
       url: "/api/auth/login",
       headers: { Authorization: void 0 },
@@ -869,8 +1076,8 @@ class Auth extends _ {
       }
     }).then(async (resp) => {
       this.api.token = (resp == null ? void 0 : resp.token) || null;
-      const user = await this.once("user");
-      this.emit("login", user);
+      const user = await this.once("auth/user");
+      this.emit(pathedEvent(["auth/login", username], "x"), user);
       return user;
     });
   }
@@ -893,16 +1100,18 @@ class Auth extends _ {
   logout() {
     this.api.token = null;
     this.user = null;
-    this.emit("logout");
+    this.emit(pathedEvent("auth/logout", "d"));
   }
   async register(u) {
     var _a;
+    if (!u.username || !u.password) throw new Error("Cannot register user, missing username or password");
     const user = await this.api.request({ url: "/api/auth/register", body: { ...u } });
     if ((_a = user == null ? void 0 : user.image) == null ? void 0 : _a.startsWith("/")) user.image = `${this.api.url}${user.image}?token=${this.api.token}`;
-    this.emit("register", user);
+    this.emit(pathedEvent("auth/register", "c"), user);
     return user;
   }
   reset(emailOrPass, token) {
+    if (!emailOrPass) throw new Error("Cannot reset password, missing email or token");
     return this.api.request({
       url: "/api/auth/reset",
       headers: { "Authorization": token ? `Bearer ${token}` : void 0 },
@@ -911,8 +1120,7 @@ class Auth extends _ {
         password: token ? emailOrPass : void 0
       }
     }).then(() => {
-      if (token) this.emit("reset", token);
-      else this.emit("resetRequest", emailOrPass);
+      this.emit(pathedEvent("auth/reset", token ? "u" : "c"), token || emailOrPass);
     });
   }
   async session(token, set = false) {
@@ -921,25 +1129,29 @@ class Auth extends _ {
       url: "/api/auth/session",
       headers: token ? { "Authorization": `Bearer ${token}` } : void 0
     });
+    this.emit(pathedEvent("auth/session", "r"), session);
     if (set) {
       this.api.token = token;
       if (session == null ? void 0 : session.user) session.user.image = `${this.api.url}${session.user.image}?token=${this.api.token}`;
       this.user = (session == null ? void 0 : session.user) || null;
-      if (session) this.emit("login", session.user);
+      if (session) this.emit(pathedEvent("auth/login", "c"), session.user);
     }
     return session;
   }
   async updatePassword(username, password, oldPassword) {
+    if (!username || !password) throw new Error("Cannot update password, missing username or password");
     return this.api.request({
       url: "/api/auth/password",
       body: { username, password, oldPassword }
     }).then((resp) => {
+      this.emit(pathedEvent("auth/reset", "u"), resp == null ? void 0 : resp.token);
       if (resp == null ? void 0 : resp.token) this.api.token = resp.token;
     });
   }
 }
-class Client {
+class Client extends PathedEventEmitter {
   constructor(settings) {
+    super();
     __publicField(this, "_platform");
     __publicField(this, "_pwa");
     this.settings = settings;
@@ -966,7 +1178,7 @@ class Client {
   }
   async inject(reload = false) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const settings = await this.settings.all();
+    const settings = await this.settings.all(false, reload);
     if (!document.querySelector('meta[name="mobile-web-app-capable"]')) {
       const meta = document.createElement("meta");
       meta.name = "mobile-web-app-capable";
@@ -1038,6 +1250,7 @@ class Client {
         if (!dismissed && !this.pwa && this.mobile) this.pwaPrompt();
       }, 500);
     }
+    this.emit(pathedEvent("client/inject", "c"));
   }
   pwaPrompt(platform) {
     const url = this.settings.api.url;
@@ -1154,88 +1367,101 @@ class Client {
       setTimeout(() => {
         prompt.remove();
         backdrop.remove();
+        this.emit(pathedEvent("client/pwa", "d"), platform);
       }, 500);
     };
     prompt.append(close);
     backdrop.append(prompt);
     document.body.append(backdrop);
+    this.emit(pathedEvent("client/pwa", "c"), platform);
   }
 }
-class Data extends _ {
+class Data extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   create(collection, document2) {
+    if (!collection || !document2) throw new Error("Cannot create document, missing collection or document");
     return this.api.request({
-      url: `/api/data/${collection.replaceAll(/(^\/|\/$)/g, "")}`,
+      url: `/api/` + pathedEvent(["data", collection]),
       method: "POST",
       body: document2
     }).then((resp) => {
-      this.emit("create", collection, resp);
+      this.emit(pathedEvent(["data", collection], "c"), collection, resp);
       return resp;
     });
   }
   read(collection, id) {
-    return this.api.request({ url: `/api/data/${collection.replaceAll(/(^\/|\/$)/g, "")}/${id ?? ""}` }).then((resp) => {
-      this.emit("read", collection, resp);
+    if (!collection) throw new Error("Cannot read documents, missing collection");
+    return this.api.request({ url: `/api/` + pathedEvent(["data", collection, id]) }).then((resp) => {
+      this.emit(pathedEvent(["data", collection, id], "r"), collection, resp);
       return resp;
     });
   }
   update(collection, document2, append = true) {
+    if (!collection || !document2) throw new Error("Cannot update document, missing collection or document");
     if (!document2._id) return this.create(collection, document2);
     return this.api.request({
-      url: `/api/data/${collection.replaceAll(/(^\/|\/$)/g, "")}/${document2._id}`,
+      url: `/api/` + pathedEvent(["data", collection, document2._id]),
       method: append ? "PATCH" : "PUT",
       body: document2
     }).then((resp) => {
-      this.emit("update", collection, resp);
+      this.emit(pathedEvent(["data", collection, document2._id], "u"), collection, resp);
       return resp;
     });
   }
   delete(collection, id) {
+    if (!collection || !id) throw new Error("Cannot delete document, missing collection or ID");
     return this.api.request({
-      url: `/api/data/${collection.replaceAll(/(^\/|\/$)/g, "")}/${id}`,
+      url: `/api/` + pathedEvent(["data", collection, id]),
       method: "DELETE"
-    }).then(() => this.emit("delete", collection, id));
+    }).then(() => this.emit(pathedEvent(["data", collection, id], "d"), collection, id));
   }
   raw(collection, query) {
-    return this.api.request({ url: `/api/data/${collection.replaceAll(/(^\/|\/$)/g, "")}`, body: query }).then((resp) => {
-      this.emit("raw", collection, query, resp);
+    if (!collection || !query) throw new Error("Cannot execute raw query, missing collection or query");
+    const mode = query.operand.startsWith("find") ? "r" : query.operand == "insert" ? "c" : query.operand.startsWith("delete") ? "d" : "u";
+    return this.api.request({ url: `/api/` + pathedEvent(["data/raw", collection]) + "?raw", body: query }).then((resp) => {
+      this.emit(pathedEvent(["data", collection], mode), collection, query, resp);
       return resp;
     });
   }
-  deleteSchema(collection) {
-    return this.api.request({ url: `/api/data/schema/${collection.replaceAll(/(^\/|\/$)/g, "")}`, method: "DELETE" });
+  deleteSchema(path) {
+    if (!path) throw new Error("Cannot delete schema, missing collection path");
+    return this.api.request({ url: `/api/` + pathedEvent(["schema", path]), method: "DELETE" }).then(() => this.emit(pathedEvent(["schema", path], "d"), path));
   }
   getSchema(pathOrTree) {
-    let url = "/api/data/schema";
-    if (typeof pathOrTree == "string") url += `/${pathOrTree.replaceAll(/(^\/|\/$)/g, "")}`;
-    else if (typeof pathOrTree == "boolean") url += `?tree=${pathOrTree}`;
-    return this.api.request({ url });
+    return this.api.request({ url: "/api/" + pathedEvent(["schema", typeof pathOrTree == "string" ? pathOrTree : ""]) + (pathOrTree === true ? `?tree=${pathOrTree}` : "") }).then((resp) => {
+      this.emit(pathedEvent(["schema", typeof pathOrTree == "string" ? pathOrTree : ""], "r"), resp);
+      return resp;
+    });
   }
   setSchema(schema) {
-    if (!schema.path) throw new Error("Unable to create schema, missing path");
-    return this.api.request({ url: `/api/data/schema/${schema.path.replaceAll(/(^\/|\/$)/g, "")}`, body: schema });
+    if (!schema.path) throw new Error("Cannot update schema, missing collection path");
+    return this.api.request({ url: "/api/" + pathedEvent(["schema", schema.path]), body: schema }).then((resp) => {
+      this.emit(pathedEvent(["schema", schema.path], schema._id ? "u" : "c"), resp);
+      return resp;
+    });
   }
 }
-class Email extends _ {
+class Email extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   send(email) {
-    let url = "/api/email";
-    if (typeof email.body == "object") url += `/${email.body.template}`;
-    return this.api.request({ url, body: email }).then((resp) => {
-      this.emit("sent", email, resp);
+    var _a;
+    if (!email.to && !email.bcc || !email.body) throw new Error("Cannot send email, missing address or body");
+    return this.api.request({ url: "/api/" + pathedEvent(["email", (_a = email.body) == null ? void 0 : _a.template]), body: email }).then((resp) => {
+      var _a2;
+      this.emit(pathedEvent(["email", (_a2 = email.body) == null ? void 0 : _a2.template], "c"), email, resp);
       return resp;
     });
   }
 }
-class Groups extends _ {
+class Groups extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
@@ -1243,46 +1469,52 @@ class Groups extends _ {
   }
   all() {
     return this.api.request({ url: `/api/groups` }).then((resp) => {
-      this.emit("all", resp || []);
+      this.emit(pathedEvent("groups", "r"), resp || []);
       return resp;
     });
   }
   create(group) {
+    if (!group.name) throw new Error("Cannot create group, missing name");
     return this.api.request({
       url: `/api/groups/${group.name}`,
       method: "POST",
       body: group
     }).then((resp) => {
-      this.emit("create", resp);
+      this.emit(pathedEvent(["groups", group.name], "c"), resp);
       return resp;
     });
   }
   read(name) {
-    return this.api.request({ url: `/api/groups/${name}` }).then((resp) => {
-      this.emit("read", resp);
+    if (!name) throw new Error("Cannot read group, missing name");
+    return this.api.request({ url: `/api/` + pathedEvent(["groups", name]) }).then((resp) => {
+      this.emit(pathedEvent(["groups", name], "r"), resp);
       return resp;
     });
   }
   update(group) {
+    if (!group.name) throw new Error("Cannot update group, missing name");
     return this.api.request({
-      url: `/api/groups/${group.name}`,
+      url: `/api/` + pathedEvent(["groups", group.name]),
       method: "PATCH",
       body: group
     }).then((resp) => {
-      this.emit("update", resp);
+      this.emit(pathedEvent(["groups", group.name], "u"), resp);
       return resp;
     });
   }
   delete(name) {
+    if (!name) throw new Error("Cannot delete group, missing name");
     return this.api.request({
-      url: `/api/groups/${name}`,
+      url: `/api/` + pathedEvent(["groups", name]),
       method: "DELETE"
-    }).then(() => this.emit("delete", name));
+    }).then(() => this.emit(pathedEvent(["groups", name], "d")));
   }
 }
-class Logger {
-  constructor(api, logLevel) {
+class Logger extends PathedEventEmitter {
+  constructor(api, namespace, logLevel) {
+    super();
     __publicField(this, "api");
+    this.namespace = namespace;
     this.api = typeof api == "string" ? new Api(api) : api;
     if (logLevel != null && logLevel != "NONE") {
       window.addEventListener("error", (event) => {
@@ -1313,47 +1545,44 @@ ${log}`;
       }
     };
   }
-  clearClientLogs() {
-    return this.api.request({ url: `/api/logs/client`, method: "DELETE" });
+  createLog(log, namespace = this.namespace) {
+    return this.api.request({ url: `/api/` + pathedEvent(["logs", namespace]), body: log }).then(() => this.emit(pathedEvent(["logs", namespace], "c"), log)).catch(() => {
+    });
+  }
+  clearLogs(namespace = this.namespace) {
+    return this.api.request({ url: `/api/` + pathedEvent(["logs", namespace]), method: "DELETE" }).then(() => this.emit(pathedEvent(["logs", namespace], "d")));
   }
   clearServerLogs() {
-    return this.api.request({ url: `/api/logs/server`, method: "DELETE" });
+    return this.clearLogs("server");
   }
-  clientLogs(length, page) {
+  getLogs(length, page, namespace = this.namespace) {
+    if (!namespace) throw new Error("Cannot get logs, missing namespace");
     const query = [length ? `length=${length}` : void 0, page ? `page=${page}` : void 0].filter((v) => !!v).join("&");
-    return this.api.request({ url: `/api/logs/client${query ? `?${query}` : ""}` }).then((resp) => resp);
+    return this.api.request({ url: `/api/` + pathedEvent(["logs", namespace]) + (query ? `?${query}` : "") }).then((logs) => {
+      this.emit(pathedEvent(["logs", namespace], "r"), logs);
+      return logs;
+    });
   }
-  serverLogs(length, page) {
-    const query = [length ? `length=${length}` : void 0, page ? `page=${page}` : void 0].filter((v) => !!v).join("&");
-    return this.api.request({ url: `/api/logs/server${query ? `?${query}` : ""}` }).then((resp) => resp);
+  getServerLogs(length, page) {
+    return this.getLogs(length, page, "server");
   }
-  debug(...logs) {
-    return this.api.request({ url: `/api/logs/client`, body: this.buildLog(yt.DEBUG, logs) }).then(() => {
-    }).catch(() => {
-    });
+  debug(log, namespace = this.namespace) {
+    return this.createLog(this.buildLog(yt.DEBUG, log), namespace);
   }
-  log(...logs) {
-    return this.api.request({ url: `/api/logs/client`, body: this.buildLog(yt.LOG, logs) }).then(() => {
-    }).catch(() => {
-    });
+  log(log, namespace = this.namespace) {
+    return this.createLog(this.buildLog(yt.LOG, log), namespace);
   }
-  info(...logs) {
-    return this.api.request({ url: `/api/logs/client`, body: this.buildLog(yt.INFO, logs) }).then(() => {
-    }).catch(() => {
-    });
+  info(log, namespace = this.namespace) {
+    return this.createLog(this.buildLog(yt.INFO, log), namespace);
   }
-  warn(...logs) {
-    return this.api.request({ url: `/api/logs/client`, body: this.buildLog(yt.WARN, logs) }).then(() => {
-    }).catch(() => {
-    });
+  warn(log, namespace = this.namespace) {
+    return this.createLog(this.buildLog(yt.WARN, log), namespace);
   }
-  error(...logs) {
-    return this.api.request({ url: `/api/logs/client`, body: this.buildLog(yt.ERROR, logs) }).then(() => {
-    }).catch(() => {
-    });
+  error(log, namespace = this.namespace) {
+    return this.createLog(this.buildLog(yt.ERROR, log), namespace);
   }
 }
-class Payments extends _ {
+class Payments extends PathedEventEmitter {
   constructor(api, secret) {
     super();
     __publicField(this, "api");
@@ -1371,11 +1600,12 @@ class Payments extends _ {
     setup();
   }
   async create(amount, custom = {}) {
+    if (!amount) throw new Error("Please specify a valid amount`");
     const request = await this.api.request({ url: "/api/payments", body: {
       amount,
       custom
     } });
-    this.emit("create", amount, custom, request.data.clientSecret);
+    this.emit(pathedEvent("payments", "c"), amount, custom, request.data.clientSecret);
     return request.data.clientSecret;
   }
   async createForm(element, amount, custom) {
@@ -1389,35 +1619,42 @@ class Payments extends _ {
     });
   }
   async history(username) {
-    const history = await this.api.request({ url: `/api/payments${username ? `/${username}` : ""}` });
-    this.emit("history", username || null, history);
+    const history = await this.api.request({ url: `/api/` + pathedEvent("payments", username) });
+    this.emit(pathedEvent(["payments", username], "r"), username, history);
     return history;
   }
 }
-class Pdf extends _ {
+class Pdf extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
-  async handleResponse(resp, fileName) {
-    const blob = await resp.blob();
-    if (fileName) {
-      const url = URL.createObjectURL(blob);
-      dt(url, fileName.endsWith(".pdf") ? fileName : fileName + ".pdf");
-      URL.revokeObjectURL(url);
-    }
-    this.emit("create", blob);
-    return blob;
+  createPdf(body, options) {
+    return this.api.request({ url: `/api/pdf`, body: { ...body, options }, decode: false }).then(async (resp) => {
+      const blob = await resp.blob();
+      if (options == null ? void 0 : options.download) {
+        let filename = (options == null ? void 0 : options.filename) || qt();
+        if (!filename.endsWith(".pdf")) filename += ".pdf";
+        const url = URL.createObjectURL(blob);
+        dt(url, filename);
+        URL.revokeObjectURL(url);
+      }
+      this.emit(pathedEvent("pdf", "c"), body, options, blob);
+      return blob;
+    });
   }
-  fromHtml(content, opts = {}) {
-    return this.api.request({ url: `/api/pdf`, body: { html: content }, decode: false }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+  fromHtml(html, options = {}) {
+    if (!html) throw new Error("Cannot create PDF, missing HTML");
+    return this.createPdf({ html }, options);
   }
-  fromTemplate(template, data, opts = {}) {
-    return this.api.request({ url: `/api/pdf${template}`, body: data, decode: false }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+  fromTemplate(template, data, options = {}) {
+    if (!template) throw new Error("Cannot create PDF, missing template");
+    return this.createPdf({ template, data }, options);
   }
-  fromUrl(url, opts = {}) {
-    return this.api.request({ url: `/api/pdf`, body: { url }, decode: false }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+  fromUrl(url, options = {}) {
+    if (!url) throw new Error("Cannot create PDF, missing URL");
+    return this.createPdf({ url }, options);
   }
 }
 const _Socket = class _Socket {
@@ -1428,7 +1665,7 @@ const _Socket = class _Socket {
     __publicField(this, "open", false);
     this.api = typeof api == "string" ? new Api(api) : api;
     this.url = this.api.url.replace("http", "ws");
-    this.api.on("token", () => this.connect());
+    this.api.on("api/token", () => this.connect());
     this.connect();
   }
   close() {
@@ -1467,126 +1704,127 @@ const _Socket = class _Socket {
 };
 __publicField(_Socket, "timeout", 1e4);
 let Socket = _Socket;
-class Storage extends _ {
+class Storage extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
-  copy(path) {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    return this.api.request({ url, method: "PUT" }).then((resp) => {
-      this.emit("copy", path, resp);
+  copy(source, destination) {
+    if (!source || !destination) throw new Error("Cannot copy file or folder, missing source or destination");
+    return this.api.request({ url: "/api/" + pathedEvent(["storage", destination]), body: { from: source } }).then((resp) => {
+      this.emit(pathedEvent(["storage", destination], "c"), source, destination, resp);
       return resp;
     });
   }
   delete(path) {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    return this.api.request({ url, method: "DELETE" }).then(() => {
-      this.emit("delete", url);
+    if (!path) throw new Error("Cannot delete file or folder, missing path");
+    return this.api.request({ url: "/api/" + pathedEvent(["storage", path]), method: "DELETE" }).then(() => {
+      this.emit(pathedEvent(["storage", path], "d"), path);
     });
   }
   download(path, opts = {}) {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    return this.api.request({ ...opts, url, decode: false }).then(async (response) => {
+    if (!path) throw new Error("Cannot download file, missing path");
+    return this.api.request({ ...opts, url: "/api/" + pathedEvent(["storage", path]), decode: false }).then(async (response) => {
       const blob = await response.blob();
       const name = opts.downloadAs || path.split("/").pop();
-      this.emit("download", path, blob);
+      this.emit(pathedEvent(["storage", path], "r"), path, blob);
       Gt(blob, name);
       return response;
     });
   }
   list(path) {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    return this.api.request({ url: url + "?list" }).then((resp) => {
-      this.emit("list", path, resp);
+    if (!path) path = "/";
+    return this.api.request({ url: "/api/" + pathedEvent(["storage", path]) + "?list" }).then((resp) => {
+      this.emit(pathedEvent(["storage", path], "r"), path, resp);
       return resp;
     });
   }
   open(path, target = "_blank") {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    const link = `${this.api.url}${url}${this.api.token ? `?token=${this.api.token}` : ""}`;
+    if (!path) throw new Error("Cannot download file, missing path");
+    const link = `${this.api.url}/api/${pathedEvent(["storage", path])}${this.api.token ? `?token=${this.api.token}` : ""}`;
     if (!target) return link;
-    this.emit("open", path);
+    this.emit(pathedEvent(["storage", path], "r"), path);
     return window.open(link, target);
   }
   mkdir(path) {
-    const url = this.api.path(path.startsWith("/api/storage/") ? "" : "/api/storage/", path);
-    return this.api.request({ url: url + "?directory", method: "POST" }).then((resp) => {
-      this.emit("mkdir", path, resp);
+    if (!path) throw new Error("Cannot make directory, missing path");
+    return this.api.request({ url: "/api/" + pathedEvent(["storage", path]), body: { directory: true } }).then((resp) => {
+      this.emit(pathedEvent(["storage", path], "c"), path, resp);
       return resp;
     });
   }
-  move(from, to) {
-    if (from == to) return this.list(to);
-    const url = this.api.path(from.startsWith("/api/storage/") ? "" : "/api/storage/", from);
-    return this.api.request({ url, method: "PATCH", body: { move: to } }).then((resp) => {
-      this.emit("move", from, to, resp);
+  move(source, destination) {
+    if (!source || !destination) throw new Error("Cannot move file or folder, missing source or destination");
+    if (source == destination) return this.list(destination);
+    return this.api.request({ url: "/api/" + pathedEvent(["storage", source]), method: "PATCH", body: { move: destination } }).then((resp) => {
+      this.emit(pathedEvent(["storage", source], "u"), source, destination, resp);
       return resp;
     });
   }
-  upload(files, opts = "") {
+  upload(files, opts) {
     return new E(async (res, rej, prog) => {
       if (!files) files = await Ut(typeof opts == "object" ? opts : void 0);
       if (!files || Array.isArray(files) && !files.length) return [];
-      const path = this.api.path("/api/storage/", typeof opts == "string" ? opts : opts.path || "");
+      const path = (opts && typeof opts == "object" ? opts == null ? void 0 : opts.path : opts) || "/";
       return Ft({
-        url: `${this.api.url}${path}`,
+        url: `${this.api.url}/api/${pathedEvent(["storage", path])}`,
         files: ft(files),
         headers: this.api.headers
       }).onProgress((p2) => {
         prog(p2);
       }).then((resp) => {
-        this.emit("upload", resp);
+        this.emit(pathedEvent(["storage", path], "c"), resp);
         res(resp);
       }).catch((err) => rej(err));
     });
   }
 }
-class Users extends _ {
+class Users extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
-    __publicField(this, "listed", false);
     __publicField(this, "cache", new Dt("username"));
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   delete(username) {
+    if (!username) throw new Error("Cannot delete user, missing username");
     return this.api.request({
-      url: `/api/users/${username}`,
+      url: "/api/" + pathedEvent(["users", username]),
       method: "DELETE"
     }).then(() => {
       this.cache.delete(username);
-      this.emit("delete", username);
+      this.emit(pathedEvent(["users", username], "d"), username);
     });
   }
   async all(reload = false) {
     if (!reload && this.cache.complete) return this.cache.all();
-    return this.api.request({ url: `/api/users` }).then((resp) => {
+    return this.api.request({ url: "/api/" + pathedEvent("users") }).then((resp) => {
       resp == null ? void 0 : resp.forEach((r) => {
         r.image = this.api.url + r.image + `?token=${this.api.token}`;
         return r;
       });
       this.cache.addAll(resp);
-      this.listed = true;
-      this.emit("all", resp || []);
+      this.emit(pathedEvent("users", "r"), resp || []);
       return resp;
     });
   }
   async read(username, reload = false) {
+    if (!username) throw new Error("Cannot read user, missing username");
     if (!reload && this.cache.get(username)) return this.cache.get(username);
-    return this.api.request({ url: `/api/users/${username}` }).then((resp) => {
+    return this.api.request({ url: "/api/" + pathedEvent(["users", username]) }).then((resp) => {
       if (resp) {
         resp.image = this.api.url + resp.image + `?token=${this.api.token}`;
         this.cache.add(resp);
       }
-      this.emit("read", resp);
+      this.emit(pathedEvent(["users", username], "r"), resp);
       return resp;
     });
   }
   update(user) {
+    if (!user.username) throw new Error("Cannot update user, missing username");
     return this.api.request({
-      url: `/api/users/${user.username}`,
+      url: `/api/` + pathedEvent(["users", user.username]),
       method: "PATCH",
       body: user
     }).then((resp) => {
@@ -1594,22 +1832,23 @@ class Users extends _ {
         resp.image = this.api.url + resp.image + `?token=${this.api.token}`;
         this.cache.add(resp);
       }
-      this.emit(resp._id ? "update" : "create", resp);
+      this.emit(pathedEvent(["users", user.username], resp._id ? "u" : "c"), resp);
       return resp;
     });
   }
   uploadImage(username, file) {
+    if (!username || !file) throw new Error("Cannot update user image, missing username or file");
     return Ft({
-      url: this.api.url + `/api/users/${username}/image`,
+      url: this.api.url + `/api/` + pathedEvent(["users", username, "image"]),
       files: [file],
       headers: this.api.headers
     }).then((resp) => {
-      this.emit("image", username, file);
+      this.emit(pathedEvent(["users", username, "image"], "u"), username, file);
       return resp;
     });
   }
 }
-class Settings extends _ {
+class Settings extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
@@ -1620,59 +1859,64 @@ class Settings extends _ {
     if (!reload && !detailed && this.cache.complete) return this.cache;
     return this.api.request({ url: `/api/settings` + (detailed ? "?detailed" : "") }).then((resp) => {
       if (resp) Object.keys(resp).forEach((key) => this.cache.set(key, detailed ? resp[key].value : resp[key]));
-      this.emit("all", resp || []);
+      this.emit(pathedEvent("settings", "r"), resp || []);
       return resp;
     });
   }
   delete(key) {
-    return this.api.request({ url: `/api/settings/${key}`, method: "DELETE" }).then(() => {
+    if (!key) throw new Error("Cannot delete setting, missing key");
+    return this.api.request({ url: `/api/` + pathedEvent(["settings", key]), method: "DELETE" }).then(() => {
       this.cache.delete(key);
-      this.emit("delete", key);
+      this.emit(pathedEvent(["settings", key], "d"), key);
     });
   }
   read(key, reload = false) {
+    if (!key) throw new Error("Cannot read setting, missing key");
     if (!reload && this.cache.get(key)) return this.cache.get(key);
-    return this.api.request({ url: `/api/settings/${key}` }).then((variable) => {
+    return this.api.request({ url: `/api/` + pathedEvent(["settings", key]) }).then((variable) => {
       if (variable) this.cache.set(variable.key, variable.value);
-      this.emit("read", variable);
+      this.emit(pathedEvent(["settings", key], "r"), variable);
       return variable;
     });
   }
   update(variable) {
-    return this.api.request({ url: `/api/settings/${variable.key}`, body: variable }).then((variable2) => {
+    if (!variable.key) throw new Error("Cannot update setting, missing key");
+    return this.api.request({ url: `/api/` + pathedEvent(["settings", variable.key]), body: variable }).then((variable2) => {
       if (variable2) this.cache.set(variable2.key, variable2.value);
-      this.emit("update", variable2);
+      this.emit(`/api/` + pathedEvent(["settings", variable2.key], variable2._id ? "u" : "c"), variable2);
       return variable2;
     });
   }
 }
-class Static extends _ {
+class Static extends PathedEventEmitter {
   constructor(api) {
     super();
     __publicField(this, "api");
     this.api = typeof api == "string" ? new Api(api) : api;
   }
   delete(path) {
-    return this.api.request({ url: `/api/static/${path}`, method: "DELETE" }).then(() => {
-      this.emit("delete", path);
+    if (!path) throw new Error("Cannot delete static asset, missing path");
+    return this.api.request({ url: `/api/` + pathedEvent(["static", path]), method: "DELETE" }).then(() => {
+      this.emit(pathedEvent(["static", path], "d"), path);
     });
   }
   upload(files, path = "/") {
+    if (!files) throw new Error("Cannot upload static assets, missing file");
     return new E(async (res, rej, prog) => {
       return Ft({
-        url: this.api.url + ("/api/static/" + path).replaceAll("//", "/"),
+        url: this.api.url + "/api/" + pathedEvent(["static", path]),
         files: ft(files),
         headers: this.api.headers
       }).onProgress((p2) => {
         prog(p2);
       }).then((resp) => {
-        this.emit("upload", resp);
+        this.emit(pathedEvent(["static", path], "c"), resp);
         res(resp);
       }).catch((err) => rej(err));
     });
   }
 }
-class Momentum extends _ {
+class Momentum extends PathedEventEmitter {
   constructor(url, opts) {
     super();
     __publicField(this, "api");
@@ -1703,7 +1947,7 @@ class Momentum extends _ {
     this.data = new Data(this.api);
     this.email = new Email(this.api);
     this.groups = new Groups(this.api);
-    this.logger = new Logger(this.api, opts == null ? void 0 : opts.logLevel);
+    this.logger = new Logger(this.api, "client", opts == null ? void 0 : opts.logLevel);
     if (opts == null ? void 0 : opts.stripeSecret) this.payments = new Payments(this.api, opts.stripeSecret);
     this.pdf = new Pdf(this.api);
     this.settings = new Settings(this.api);
@@ -1712,24 +1956,25 @@ class Momentum extends _ {
     this.storage = new Storage(this.api);
     this.client = new Client(this.settings);
     this.users = new Users(this.api);
-    this.api.on("*", (event, ...args) => this.emit(`Api:${event}`, ...args));
-    this.actions.on("*", (event, ...args) => this.emit(`Actions:${event}`, ...args));
-    this.auth.on("*", (event, ...args) => this.emit(`Auth:${event}`, ...args));
-    this.data.on("*", (event, ...args) => this.emit(`Data:${event}`, ...args));
-    this.email.on("*", (event, ...args) => this.emit(`Email:${event}`, ...args));
-    this.groups.on("*", (event, ...args) => this.emit(`Groups:${event}`, ...args));
-    if (this.payments) this.payments.on("*", (event, ...args) => this.emit(`Payments:${event}`, ...args));
-    this.pdf.on("*", (event, ...args) => this.emit(`Pdf:${event}`, ...args));
-    this.settings.on("*", (event, ...args) => this.emit(`Settings:${event}`, ...args));
-    this.static.on("*", (event, ...args) => this.emit(`Static:${event}`, ...args));
-    this.storage.on("*", (event, ...args) => this.emit(`Storage:${event}`, ...args));
-    this.users.on("*", (event, ...args) => this.emit(`Users:${event}`, ...args));
-    this.users.on("*", (event, ...args) => {
-      const u = ft(args[0]).find((u2) => {
-        var _a;
-        return (u2 == null ? void 0 : u2._id) == ((_a = this.auth.user) == null ? void 0 : _a._id);
-      });
-      if (u) this.auth.user = u;
+    this.relayEvents(this.actions);
+    this.relayEvents(this.ai);
+    this.relayEvents(this.analytics);
+    this.relayEvents(this.api);
+    this.relayEvents(this.auth);
+    this.relayEvents(this.client);
+    this.relayEvents(this.data);
+    this.relayEvents(this.email);
+    this.relayEvents(this.groups);
+    this.relayEvents(this.logger);
+    if (this.payments) this.relayEvents(this.payments);
+    this.relayEvents(this.pdf);
+    this.relayEvents(this.settings);
+    this.relayEvents(this.static);
+    this.relayEvents(this.storage);
+    this.relayEvents(this.users);
+    this.users.on(`*`, () => {
+      if (!this.auth.user) return;
+      this.auth.user = this.users.cache.get(this.auth.user.username);
     });
   }
 }
@@ -1746,6 +1991,7 @@ export {
   Groups,
   Logger,
   Momentum,
+  PathedEventEmitter,
   Payments,
   Pdf,
   Settings,
@@ -1753,5 +1999,10 @@ export {
   Static,
   Storage,
   Totp,
-  Users
+  Users,
+  combinePathedEvents,
+  hasPath,
+  hasPathFatal,
+  parsePathedEvent,
+  pathedEvent
 };