@ztimson/momentum 0.27.4 → 0.28.2

package/dist/index.cjs

@@ -0,0 +1,1901 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.utils = {}));
+})(this, function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  var Y = Object.defineProperty;
+  var v = (n, e, t) => e in n ? Y(n, e, { enumerable: true, configurable: true, writable: true, value: t }) : n[e] = t;
+  var a = (n, e, t) => (v(n, typeof e != "symbol" ? e + "" : e, t), t);
+  function F(n, e = false) {
+    if (n == null)
+      throw new Error("Cannot clean a NULL value");
+    return Array.isArray(n) ? n = n.filter((t) => t != null) : Object.entries(n).forEach(([t, r]) => {
+      (e && r === void 0 || !e && r == null) && delete n[t];
+    }), n;
+  }
+  function b(n, e) {
+    const t = typeof n, r = typeof e;
+    return t != "object" || n == null || r != "object" || e == null ? t == "function" && r == "function" ? n.toString() == e.toString() : n === e : Object.keys(n).length != Object.keys(e).length ? false : Object.keys(n).every((s) => b(n[s], e[s]));
+  }
+  class E extends Promise {
+    constructor(t) {
+      super((r, o) => t(
+        (s) => r(s),
+        (s) => o(s),
+        (s) => this.progress = s
+      ));
+      a(this, "listeners", []);
+      a(this, "_progress", 0);
+    }
+    get progress() {
+      return this._progress;
+    }
+    set progress(t) {
+      t != this._progress && (this._progress = t, this.listeners.forEach((r) => r(t)));
+    }
+    static from(t) {
+      return t instanceof E ? t : new E((r, o) => t.then((...s) => r(...s)).catch((...s) => o(...s)));
+    }
+    from(t) {
+      const r = E.from(t);
+      return this.onProgress((o) => r.progress = o), r;
+    }
+    onProgress(t) {
+      return this.listeners.push(t), this;
+    }
+    then(t, r) {
+      const o = super.then(t, r);
+      return this.from(o);
+    }
+    catch(t) {
+      return this.from(super.catch(t));
+    }
+    finally(t) {
+      return this.from(super.finally(t));
+    }
+  }
+  function V(n, e) {
+    const t = document.createElement("a");
+    t.href = n, t.download = e, document.body.appendChild(t), t.click(), document.body.removeChild(t);
+  }
+  function wt(n, e) {
+    const t = URL.createObjectURL(n);
+    V(t, e), URL.revokeObjectURL(t);
+  }
+  function xt(n = {}) {
+    return new Promise((e) => {
+      const t = document.createElement("input");
+      t.type = "file", t.accept = n.accept || "*", t.style.display = "none", t.multiple = !!n.multiple, t.onblur = t.onchange = async () => {
+        e(Array.from(t.files)), t.remove();
+      }, document.body.appendChild(t), t.click();
+    });
+  }
+  function At(n) {
+    return new E((e, t, r) => {
+      const o = new XMLHttpRequest(), s = new FormData();
+      n.files.forEach((i) => s.append("file", i)), o.withCredentials = !!n.withCredentials, o.upload.addEventListener("progress", (i) => i.lengthComputable ? r(i.loaded / i.total) : null), o.upload.addEventListener("load", (i) => e(i)), o.upload.addEventListener("error", (i) => t(i)), o.open("POST", n.url), Object.entries(n.headers || {}).forEach(([i, y]) => o.setRequestHeader(i, y)), o.send(s);
+    });
+  }
+  class P {
+    constructor() {
+      a(this, "listeners", {});
+    }
+    static emit(e, ...t) {
+      (this.listeners["*"] || []).forEach((r) => r(e, ...t)), (this.listeners[e.toString()] || []).forEach((r) => r(...t));
+    }
+    static off(e, t) {
+      const r = e.toString();
+      this.listeners[r] = (this.listeners[r] || []).filter((o) => o === t);
+    }
+    static on(e, t) {
+      var o;
+      const r = e.toString();
+      return this.listeners[r] || (this.listeners[r] = []), (o = this.listeners[r]) == null || o.push(t), () => this.off(e, t);
+    }
+    static once(e, t) {
+      return new Promise((r) => {
+        const o = this.on(e, (...s) => {
+          r(s.length == 1 ? s[0] : s), t && t(...s), o();
+        });
+      });
+    }
+    emit(e, ...t) {
+      (this.listeners["*"] || []).forEach((r) => r(e, ...t)), (this.listeners[e] || []).forEach((r) => r(...t));
+    }
+    off(e, t) {
+      this.listeners[e] = (this.listeners[e] || []).filter((r) => r === t);
+    }
+    on(e, t) {
+      var r;
+      return this.listeners[e] || (this.listeners[e] = []), (r = this.listeners[e]) == null || r.push(t), () => this.off(e, t);
+    }
+    once(e, t) {
+      return new Promise((r) => {
+        const o = this.on(e, (...s) => {
+          r(s.length == 1 ? s[0] : s), t && t(...s), o();
+        });
+      });
+    }
+  }
+  a(P, "listeners", {});
+  class w extends Error {
+    constructor(t, r) {
+      super(t);
+      a(this, "_code");
+      r != null && (this._code = r);
+    }
+    get code() {
+      return this._code || this.constructor.code;
+    }
+    set code(t) {
+      this._code = t;
+    }
+    static from(t) {
+      const r = Number(t.statusCode) ?? Number(t.code), o = new this(t.message || t.toString());
+      return Object.assign(o, {
+        stack: t.stack,
+        ...t,
+        code: r ?? void 0
+      });
+    }
+    static instanceof(t) {
+      return t.constructor.code != null;
+    }
+    toString() {
+      return this.message || super.toString();
+    }
+  }
+  a(w, "code", 500);
+  class Z extends w {
+    constructor(e = "Bad Request") {
+      super(e);
+    }
+    static instanceof(e) {
+      return e.constructor.code == this.code;
+    }
+  }
+  a(Z, "code", 400);
+  class X extends w {
+    constructor(e = "Unauthorized") {
+      super(e);
+    }
+    static instanceof(e) {
+      return e.constructor.code == this.code;
+    }
+  }
+  a(X, "code", 401);
+  class Q extends w {
+    constructor(e = "Forbidden") {
+      super(e);
+    }
+    static instanceof(e) {
+      return e.constructor.code == this.code;
+    }
+  }
+  a(Q, "code", 403);
+  class _ extends w {
+    constructor(e = "Not Found") {
+      super(e);
+    }
+    static instanceof(e) {
+      return e.constructor.code == this.code;
+    }
+  }
+  a(_, "code", 404);
+  class tt extends w {
+    constructor(e = "Internal Server Error") {
+      super(e);
+    }
+    static instanceof(e) {
+      return e.constructor.code == this.code;
+    }
+  }
+  a(tt, "code", 500);
+  const g = class g2 {
+    constructor(e = {}) {
+      a(this, "interceptors", {});
+      a(this, "headers", {});
+      a(this, "url");
+      this.url = e.url ?? null, this.headers = e.headers || {}, e.interceptors && e.interceptors.forEach((t) => g2.addInterceptor(t));
+    }
+    static addInterceptor(e) {
+      const t = Object.keys(g2.interceptors).length.toString();
+      return g2.interceptors[t] = e, () => {
+        g2.interceptors[t] = null;
+      };
+    }
+    addInterceptor(e) {
+      const t = Object.keys(this.interceptors).length.toString();
+      return this.interceptors[t] = e, () => {
+        this.interceptors[t] = null;
+      };
+    }
+    request(e = {}) {
+      var o;
+      if (!this.url && !e.url)
+        throw new Error("URL needs to be set");
+      let t = ((o = e.url) != null && o.startsWith("http") ? e.url : (this.url || "") + (e.url || "")).replace(/([^:]\/)\/+/g, "$1");
+      if (e.fragment && (t.includes("#") ? t.replace(/#.*(\?|\n)/g, (s, i) => `#${e.fragment}${i}`) : t += "#" + e.fragment), e.query) {
+        const s = Array.isArray(e.query) ? e.query : Object.keys(e.query).map((i) => ({ key: i, value: e.query[i] }));
+        t += (t.includes("?") ? "&" : "?") + s.map((i) => `${i.key}=${i.value}`).join("&");
+      }
+      const r = F({
+        "Content-Type": e.body ? e.body instanceof FormData ? "multipart/form-data" : "application/json" : void 0,
+        ...g2.headers,
+        ...this.headers,
+        ...e.headers
+      });
+      return typeof e.body == "object" && e.body != null && r["Content-Type"] == "application/json" && (e.body = JSON.stringify(e.body)), new E((s, i, y) => {
+        fetch(t, {
+          headers: r,
+          method: e.method || (e.body ? "POST" : "GET"),
+          body: e.body
+        }).then(async (c) => {
+          var k, G;
+          for (let u of [...Object.values(g2.interceptors), ...Object.values(this.interceptors)])
+            await new Promise((L) => u(c, () => L()));
+          const R = c.headers.get("Content-Length"), N = R ? parseInt(R, 10) : 0;
+          let j = 0;
+          const I = (k = c.body) == null ? void 0 : k.getReader(), H = new ReadableStream({
+            start(u) {
+              function L() {
+                I == null || I.read().then((x) => {
+                  if (x.done)
+                    return u.close();
+                  j += x.value.byteLength, y(j / N), u.enqueue(x.value), L();
+                }).catch((x) => u.error(x));
+              }
+              L();
+            }
+          });
+          if (c.data = new Response(H), e.decode == null || e.decode) {
+            const u = (G = c.headers.get("Content-Type")) == null ? void 0 : G.toLowerCase();
+            u != null && u.includes("form") ? c.data = await c.data.formData() : u != null && u.includes("json") ? c.data = await c.data.json() : u != null && u.includes("text") ? c.data = await c.data.text() : u != null && u.includes("application") && (c.data = await c.data.blob());
+          }
+          c.ok ? s(c) : i(c);
+        });
+      });
+    }
+  };
+  a(g, "interceptors", {}), a(g, "headers", {});
+  let M = g;
+  const A = {
+    CLEAR: "\x1B[0m",
+    BRIGHT: "\x1B[1m",
+    DIM: "\x1B[2m",
+    UNDERSCORE: "\x1B[4m",
+    BLINK: "\x1B[5m",
+    REVERSE: "\x1B[7m",
+    HIDDEN: "\x1B[8m"
+  }, O = {
+    BLACK: "\x1B[30m",
+    RED: "\x1B[31m",
+    GREEN: "\x1B[32m",
+    YELLOW: "\x1B[33m",
+    BLUE: "\x1B[34m",
+    MAGENTA: "\x1B[35m",
+    CYAN: "\x1B[36m",
+    LIGHT_GREY: "\x1B[37m",
+    GREY: "\x1B[90m",
+    LIGHT_RED: "\x1B[91m",
+    LIGHT_GREEN: "\x1B[92m",
+    LIGHT_YELLOW: "\x1B[93m",
+    LIGHT_BLUE: "\x1B[94m",
+    LIGHT_MAGENTA: "\x1B[95m",
+    LIGHT_CYAN: "\x1B[96m",
+    WHITE: "\x1B[97m"
+  };
+  var et = /* @__PURE__ */ ((n) => (n[n.ERROR = 0] = "ERROR", n[n.WARN = 1] = "WARN", n[n.INFO = 2] = "INFO", n[n.LOG = 3] = "LOG", n[n.DEBUG = 4] = "DEBUG", n))(et || {});
+  const p = class p2 extends P {
+    constructor(e) {
+      super(), this.namespace = e;
+    }
+    pad(e, t, r, o = false) {
+      const s = e.toString(), i = t - s.length;
+      if (i <= 0)
+        return s;
+      const y = Array(~~(i / r.length)).fill(r).join("");
+      return o ? s + y : y + s;
+    }
+    format(...e) {
+      const t = /* @__PURE__ */ new Date();
+      return `${`${t.getFullYear()}-${t.getMonth() + 1}-${t.getDate()} ${this.pad(t.getHours().toString(), 2, "0")}:${this.pad(t.getMinutes().toString(), 2, "0")}:${this.pad(t.getSeconds().toString(), 2, "0")}.${this.pad(t.getMilliseconds().toString(), 3, "0", true)}`}${this.namespace ? ` [${this.namespace}]` : ""} ${e.join(" ")}`;
+    }
+    debug(...e) {
+      if (p2.LOG_LEVEL < 4)
+        return;
+      const t = this.format(...e);
+      p2.emit(4, t), console.debug(O.LIGHT_GREY + t + A.CLEAR);
+    }
+    log(...e) {
+      if (p2.LOG_LEVEL < 3)
+        return;
+      const t = this.format(...e);
+      p2.emit(3, t), console.log(A.CLEAR + t);
+    }
+    info(...e) {
+      if (p2.LOG_LEVEL < 2)
+        return;
+      const t = this.format(...e);
+      p2.emit(2, t), console.info(O.BLUE + t + A.CLEAR);
+    }
+    warn(...e) {
+      if (p2.LOG_LEVEL < 1)
+        return;
+      const t = this.format(...e);
+      p2.emit(1, t), console.warn(O.YELLOW + t + A.CLEAR);
+    }
+    error(...e) {
+      if (p2.LOG_LEVEL < 0)
+        return;
+      const t = this.format(...e);
+      p2.emit(0, t), console.error(O.RED + t + A.CLEAR);
+    }
+  };
+  a(p, "LOG_LEVEL", 4);
+  class Api extends M {
+    constructor(url = location.origin, opts = {}) {
+      opts.url = url;
+      super(opts);
+      __publicField(this, "emitter", new P());
+      __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));
+      this.url = url;
+      this.opts = opts;
+    }
+    get token() {
+      return this._token;
+    }
+    set token(token) {
+      if (token == this._token) return;
+      this._token = token;
+      this.headers["Authorization"] = token ? `Bearer ${token}` : void 0;
+      this.emit("TOKEN", token);
+    }
+    healthcheck() {
+      return this.request({ url: "/api/healthcheck" });
+    }
+    request(options) {
+      const req = super.request(options).then((resp) => {
+        this.emit("RESPONSE", resp, options);
+        return resp.data;
+      }).catch((err) => {
+        const e = (err == null ? void 0 : err.data) || err;
+        this.emit("REJECTED", e, options);
+        throw e;
+      });
+      this.emit("REQUEST", req, options);
+      return req;
+    }
+  }
+  var extendStatics = function(d, b2) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b3) {
+      d2.__proto__ = b3;
+    } || function(d2, b3) {
+      for (var p2 in b3) if (Object.prototype.hasOwnProperty.call(b3, p2)) d2[p2] = b3[p2];
+    };
+    return extendStatics(d, b2);
+  };
+  function __extends(d, b2) {
+    if (typeof b2 !== "function" && b2 !== null)
+      throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+    extendStatics(d, b2);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
+  }
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+      next: function() {
+        if (o && i >= o.length) o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    } catch (error) {
+      e = { error };
+    } finally {
+      try {
+        if (r && !r.done && (m = i["return"])) m.call(i);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return ar;
+  }
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  }
+  typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  function isFunction(value) {
+    return typeof value === "function";
+  }
+  function createErrorClass(createImpl) {
+    var _super = function(instance) {
+      Error.call(instance);
+      instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+  }
+  var UnsubscriptionError = createErrorClass(function(_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+      _super(this);
+      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+        return i + 1 + ") " + err.toString();
+      }).join("\n  ") : "";
+      this.name = "UnsubscriptionError";
+      this.errors = errors;
+    };
+  });
+  function arrRemove(arr, item) {
+    if (arr) {
+      var index = arr.indexOf(item);
+      0 <= index && arr.splice(index, 1);
+    }
+  }
+  var Subscription = function() {
+    function Subscription2(initialTeardown) {
+      this.initialTeardown = initialTeardown;
+      this.closed = false;
+      this._parentage = null;
+      this._finalizers = null;
+    }
+    Subscription2.prototype.unsubscribe = function() {
+      var e_1, _a, e_2, _b;
+      var errors;
+      if (!this.closed) {
+        this.closed = true;
+        var _parentage = this._parentage;
+        if (_parentage) {
+          this._parentage = null;
+          if (Array.isArray(_parentage)) {
+            try {
+              for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                var parent_1 = _parentage_1_1.value;
+                parent_1.remove(this);
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          } else {
+            _parentage.remove(this);
+          }
+        }
+        var initialFinalizer = this.initialTeardown;
+        if (isFunction(initialFinalizer)) {
+          try {
+            initialFinalizer();
+          } catch (e) {
+            errors = e instanceof UnsubscriptionError ? e.errors : [e];
+          }
+        }
+        var _finalizers = this._finalizers;
+        if (_finalizers) {
+          this._finalizers = null;
+          try {
+            for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+              var finalizer = _finalizers_1_1.value;
+              try {
+                execFinalizer(finalizer);
+              } catch (err) {
+                errors = errors !== null && errors !== void 0 ? errors : [];
+                if (err instanceof UnsubscriptionError) {
+                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                } else {
+                  errors.push(err);
+                }
+              }
+            }
+          } catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+          } finally {
+            try {
+              if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+            } finally {
+              if (e_2) throw e_2.error;
+            }
+          }
+        }
+        if (errors) {
+          throw new UnsubscriptionError(errors);
+        }
+      }
+    };
+    Subscription2.prototype.add = function(teardown) {
+      var _a;
+      if (teardown && teardown !== this) {
+        if (this.closed) {
+          execFinalizer(teardown);
+        } else {
+          if (teardown instanceof Subscription2) {
+            if (teardown.closed || teardown._hasParent(this)) {
+              return;
+            }
+            teardown._addParent(this);
+          }
+          (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+        }
+      }
+    };
+    Subscription2.prototype._hasParent = function(parent) {
+      var _parentage = this._parentage;
+      return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+    };
+    Subscription2.prototype._addParent = function(parent) {
+      var _parentage = this._parentage;
+      this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    };
+    Subscription2.prototype._removeParent = function(parent) {
+      var _parentage = this._parentage;
+      if (_parentage === parent) {
+        this._parentage = null;
+      } else if (Array.isArray(_parentage)) {
+        arrRemove(_parentage, parent);
+      }
+    };
+    Subscription2.prototype.remove = function(teardown) {
+      var _finalizers = this._finalizers;
+      _finalizers && arrRemove(_finalizers, teardown);
+      if (teardown instanceof Subscription2) {
+        teardown._removeParent(this);
+      }
+    };
+    Subscription2.EMPTY = function() {
+      var empty = new Subscription2();
+      empty.closed = true;
+      return empty;
+    }();
+    return Subscription2;
+  }();
+  var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+  function isSubscription(value) {
+    return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+  }
+  function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+      finalizer();
+    } else {
+      finalizer.unsubscribe();
+    }
+  }
+  var config = {
+    onUnhandledError: null,
+    onStoppedNotification: null,
+    Promise: void 0,
+    useDeprecatedSynchronousErrorHandling: false,
+    useDeprecatedNextContext: false
+  };
+  var timeoutProvider = {
+    setTimeout: function(handler, timeout) {
+      var args = [];
+      for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+      }
+      return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function(handle) {
+      var delegate = timeoutProvider.delegate;
+      return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+    },
+    delegate: void 0
+  };
+  function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function() {
+      {
+        throw err;
+      }
+    });
+  }
+  function noop() {
+  }
+  function errorContext(cb) {
+    {
+      cb();
+    }
+  }
+  var Subscriber = function(_super) {
+    __extends(Subscriber2, _super);
+    function Subscriber2(destination) {
+      var _this = _super.call(this) || this;
+      _this.isStopped = false;
+      if (destination) {
+        _this.destination = destination;
+        if (isSubscription(destination)) {
+          destination.add(_this);
+        }
+      } else {
+        _this.destination = EMPTY_OBSERVER;
+      }
+      return _this;
+    }
+    Subscriber2.create = function(next, error, complete) {
+      return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber2.prototype.next = function(value) {
+      if (this.isStopped) ;
+      else {
+        this._next(value);
+      }
+    };
+    Subscriber2.prototype.error = function(err) {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._error(err);
+      }
+    };
+    Subscriber2.prototype.complete = function() {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._complete();
+      }
+    };
+    Subscriber2.prototype.unsubscribe = function() {
+      if (!this.closed) {
+        this.isStopped = true;
+        _super.prototype.unsubscribe.call(this);
+        this.destination = null;
+      }
+    };
+    Subscriber2.prototype._next = function(value) {
+      this.destination.next(value);
+    };
+    Subscriber2.prototype._error = function(err) {
+      try {
+        this.destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    Subscriber2.prototype._complete = function() {
+      try {
+        this.destination.complete();
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    return Subscriber2;
+  }(Subscription);
+  var _bind = Function.prototype.bind;
+  function bind(fn, thisArg) {
+    return _bind.call(fn, thisArg);
+  }
+  var ConsumerObserver = function() {
+    function ConsumerObserver2(partialObserver) {
+      this.partialObserver = partialObserver;
+    }
+    ConsumerObserver2.prototype.next = function(value) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.next) {
+        try {
+          partialObserver.next(value);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    ConsumerObserver2.prototype.error = function(err) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.error) {
+        try {
+          partialObserver.error(err);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      } else {
+        handleUnhandledError(err);
+      }
+    };
+    ConsumerObserver2.prototype.complete = function() {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.complete) {
+        try {
+          partialObserver.complete();
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    return ConsumerObserver2;
+  }();
+  var SafeSubscriber = function(_super) {
+    __extends(SafeSubscriber2, _super);
+    function SafeSubscriber2(observerOrNext, error, complete) {
+      var _this = _super.call(this) || this;
+      var partialObserver;
+      if (isFunction(observerOrNext) || !observerOrNext) {
+        partialObserver = {
+          next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+          error: error !== null && error !== void 0 ? error : void 0,
+          complete: complete !== null && complete !== void 0 ? complete : void 0
+        };
+      } else {
+        var context_1;
+        if (_this && config.useDeprecatedNextContext) {
+          context_1 = Object.create(observerOrNext);
+          context_1.unsubscribe = function() {
+            return _this.unsubscribe();
+          };
+          partialObserver = {
+            next: observerOrNext.next && bind(observerOrNext.next, context_1),
+            error: observerOrNext.error && bind(observerOrNext.error, context_1),
+            complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+          };
+        } else {
+          partialObserver = observerOrNext;
+        }
+      }
+      _this.destination = new ConsumerObserver(partialObserver);
+      return _this;
+    }
+    return SafeSubscriber2;
+  }(Subscriber);
+  function handleUnhandledError(error) {
+    {
+      reportUnhandledError(error);
+    }
+  }
+  function defaultErrorHandler(err) {
+    throw err;
+  }
+  var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop
+  };
+  var observable = function() {
+    return typeof Symbol === "function" && Symbol.observable || "@@observable";
+  }();
+  function identity(x) {
+    return x;
+  }
+  function pipeFromArray(fns) {
+    if (fns.length === 0) {
+      return identity;
+    }
+    if (fns.length === 1) {
+      return fns[0];
+    }
+    return function piped(input) {
+      return fns.reduce(function(prev, fn) {
+        return fn(prev);
+      }, input);
+    };
+  }
+  var Observable = function() {
+    function Observable2(subscribe) {
+      if (subscribe) {
+        this._subscribe = subscribe;
+      }
+    }
+    Observable2.prototype.lift = function(operator) {
+      var observable2 = new Observable2();
+      observable2.source = this;
+      observable2.operator = operator;
+      return observable2;
+    };
+    Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+      var _this = this;
+      var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+      errorContext(function() {
+        var _a = _this, operator = _a.operator, source = _a.source;
+        subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+      });
+      return subscriber;
+    };
+    Observable2.prototype._trySubscribe = function(sink) {
+      try {
+        return this._subscribe(sink);
+      } catch (err) {
+        sink.error(err);
+      }
+    };
+    Observable2.prototype.forEach = function(next, promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var subscriber = new SafeSubscriber({
+          next: function(value) {
+            try {
+              next(value);
+            } catch (err) {
+              reject(err);
+              subscriber.unsubscribe();
+            }
+          },
+          error: reject,
+          complete: resolve
+        });
+        _this.subscribe(subscriber);
+      });
+    };
+    Observable2.prototype._subscribe = function(subscriber) {
+      var _a;
+      return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable2.prototype[observable] = function() {
+      return this;
+    };
+    Observable2.prototype.pipe = function() {
+      var operations = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        operations[_i] = arguments[_i];
+      }
+      return pipeFromArray(operations)(this);
+    };
+    Observable2.prototype.toPromise = function(promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var value;
+        _this.subscribe(function(x) {
+          return value = x;
+        }, function(err) {
+          return reject(err);
+        }, function() {
+          return resolve(value);
+        });
+      });
+    };
+    Observable2.create = function(subscribe) {
+      return new Observable2(subscribe);
+    };
+    return Observable2;
+  }();
+  function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+  }
+  function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+  }
+  function isSubscriber(value) {
+    return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+  }
+  var ObjectUnsubscribedError = createErrorClass(function(_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+      _super(this);
+      this.name = "ObjectUnsubscribedError";
+      this.message = "object unsubscribed";
+    };
+  });
+  var Subject = function(_super) {
+    __extends(Subject2, _super);
+    function Subject2() {
+      var _this = _super.call(this) || this;
+      _this.closed = false;
+      _this.currentObservers = null;
+      _this.observers = [];
+      _this.isStopped = false;
+      _this.hasError = false;
+      _this.thrownError = null;
+      return _this;
+    }
+    Subject2.prototype.lift = function(operator) {
+      var subject = new AnonymousSubject(this, this);
+      subject.operator = operator;
+      return subject;
+    };
+    Subject2.prototype._throwIfClosed = function() {
+      if (this.closed) {
+        throw new ObjectUnsubscribedError();
+      }
+    };
+    Subject2.prototype.next = function(value) {
+      var _this = this;
+      errorContext(function() {
+        var e_1, _a;
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          if (!_this.currentObservers) {
+            _this.currentObservers = Array.from(_this.observers);
+          }
+          try {
+            for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var observer = _c.value;
+              observer.next(value);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        }
+      });
+    };
+    Subject2.prototype.error = function(err) {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.hasError = _this.isStopped = true;
+          _this.thrownError = err;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().error(err);
+          }
+        }
+      });
+    };
+    Subject2.prototype.complete = function() {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.isStopped = true;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().complete();
+          }
+        }
+      });
+    };
+    Subject2.prototype.unsubscribe = function() {
+      this.isStopped = this.closed = true;
+      this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject2.prototype, "observed", {
+      get: function() {
+        var _a;
+        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Subject2.prototype._trySubscribe = function(subscriber) {
+      this._throwIfClosed();
+      return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject2.prototype._subscribe = function(subscriber) {
+      this._throwIfClosed();
+      this._checkFinalizedStatuses(subscriber);
+      return this._innerSubscribe(subscriber);
+    };
+    Subject2.prototype._innerSubscribe = function(subscriber) {
+      var _this = this;
+      var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+      if (hasError || isStopped) {
+        return EMPTY_SUBSCRIPTION;
+      }
+      this.currentObservers = null;
+      observers.push(subscriber);
+      return new Subscription(function() {
+        _this.currentObservers = null;
+        arrRemove(observers, subscriber);
+      });
+    };
+    Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+      if (hasError) {
+        subscriber.error(thrownError);
+      } else if (isStopped) {
+        subscriber.complete();
+      }
+    };
+    Subject2.prototype.asObservable = function() {
+      var observable2 = new Observable();
+      observable2.source = this;
+      return observable2;
+    };
+    Subject2.create = function(destination, source) {
+      return new AnonymousSubject(destination, source);
+    };
+    return Subject2;
+  }(Observable);
+  var AnonymousSubject = function(_super) {
+    __extends(AnonymousSubject2, _super);
+    function AnonymousSubject2(destination, source) {
+      var _this = _super.call(this) || this;
+      _this.destination = destination;
+      _this.source = source;
+      return _this;
+    }
+    AnonymousSubject2.prototype.next = function(value) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject2.prototype.error = function(err) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject2.prototype.complete = function() {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject2.prototype._subscribe = function(subscriber) {
+      var _a, _b;
+      return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject2;
+  }(Subject);
+  var BehaviorSubject = function(_super) {
+    __extends(BehaviorSubject2, _super);
+    function BehaviorSubject2(_value) {
+      var _this = _super.call(this) || this;
+      _this._value = _value;
+      return _this;
+    }
+    Object.defineProperty(BehaviorSubject2.prototype, "value", {
+      get: function() {
+        return this.getValue();
+      },
+      enumerable: false,
+      configurable: true
+    });
+    BehaviorSubject2.prototype._subscribe = function(subscriber) {
+      var subscription = _super.prototype._subscribe.call(this, subscriber);
+      !subscription.closed && subscriber.next(this._value);
+      return subscription;
+    };
+    BehaviorSubject2.prototype.getValue = function() {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+      if (hasError) {
+        throw thrownError;
+      }
+      this._throwIfClosed();
+      return _value;
+    };
+    BehaviorSubject2.prototype.next = function(value) {
+      _super.prototype.next.call(this, this._value = value);
+    };
+    return BehaviorSubject2;
+  }(Subject);
+  var ActionType = /* @__PURE__ */ ((ActionType2) => {
+    ActionType2[ActionType2["CRON"] = 0] = "CRON";
+    ActionType2[ActionType2["EVENT"] = 1] = "EVENT";
+    ActionType2[ActionType2["DELETE"] = 2] = "DELETE";
+    ActionType2[ActionType2["GET"] = 3] = "GET";
+    ActionType2[ActionType2["PATCH"] = 4] = "PATCH";
+    ActionType2[ActionType2["POST"] = 5] = "POST";
+    ActionType2[ActionType2["PUT"] = 6] = "PUT";
+    return ActionType2;
+  })(ActionType || {});
+  class Actions extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      __publicField(this, "$cache", new BehaviorSubject([]));
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    get cache() {
+      return this.$cache.value;
+    }
+    set cache(val) {
+      this.$cache.next(val);
+    }
+    delete(id) {
+      return this.api.request({ url: `/api/actions/${id}`, method: "DELETE" }).then(() => {
+        this.cache = this.cache.filter((a2) => a2._id != id);
+        this.emit("DELETE", id);
+      });
+    }
+    list() {
+      return this.api.request({ url: `/api/actions` }).then((resp) => {
+        if (resp) this.cache = resp;
+        this.emit("LIST", resp || []);
+        return resp;
+      });
+    }
+    read(id, reload = false) {
+      const cached = this.cache.find((a2) => a2._id == id);
+      if (!reload && cached) return Promise.resolve(cached);
+      return this.api.request({ url: `/api/actions/${id}` }).then((action) => {
+        if (action) this.cache = this.cache.filter((a2) => a2._id != id).concat([action]);
+        this.emit("READ", action);
+        return action;
+      });
+    }
+    run(path, opts = {}) {
+      return this.api.request({ url: (`/api/actions/run/` + path).replaceAll("//", "/"), ...opts });
+    }
+    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 });
+    }
+    update(action) {
+      return this.api.request({
+        url: `/api/actions${action._id ? `/${action._id}` : ""}`,
+        method: "POST",
+        body: action
+      }).then((action2) => {
+        if (action2) this.cache = this.cache.filter((a2) => a2._id != (action2 == null ? void 0 : action2._id)).concat([action2]);
+        this.emit("UPDATE", action2);
+        return action2;
+      });
+    }
+  }
+  class Totp {
+    constructor(api) {
+      __publicField(this, "enable", this.reset);
+      this.api = api;
+    }
+    disable(username) {
+      return this.api.request({ url: `/api/auth/totp/${username}`, method: "DELETE" });
+    }
+    reset(username) {
+      return this.api.request({ url: `/api/auth/totp/${username}`, method: "POST" });
+    }
+    setup(username, method = "app", totp) {
+      return this.api.request({ url: `/api/auth/totp/${username}`, body: F({
+        method,
+        totp
+      }) });
+    }
+  }
+  class Auth extends P {
+    constructor(api, opts) {
+      var _a;
+      super();
+      __publicField(this, "api");
+      __publicField(this, "storageKey");
+      __publicField(this, "totp");
+      __publicField(this, "$user", new BehaviorSubject(void 0));
+      this.opts = opts;
+      this.api = typeof api == "string" ? new Api(api) : api;
+      this.totp = new Totp(this.api);
+      if (!((_a = this.opts) == null ? void 0 : _a.loginUi)) this.opts = { ...this.opts, loginUi: this.api.url + "/ui/login" };
+      this.storageKey = `momentum:${new URL(this.api.url).host}`;
+      this.api.addInterceptor((resp, next) => {
+        const blacklist = [
+          "/api/auth/login",
+          "/api/auth/password",
+          "/api/auth/totp"
+        ];
+        if (resp.status == 401 && !blacklist.find((url) => resp.url.includes(url)))
+          this.emit("SESSION_EXPIRED");
+        next();
+      });
+      this.api.on("TOKEN", (token) => {
+        var _a2;
+        if ((_a2 = this.opts) == null ? void 0 : _a2.persist) {
+          if (token) localStorage.setItem(this.storageKey, token);
+          else localStorage.removeItem(this.storageKey);
+        }
+        if (token) this.session(token, true).catch(() => {
+        });
+        else this.user = null;
+      });
+      if (opts == null ? void 0 : opts.persist) {
+        const token = localStorage.getItem(this.storageKey);
+        if (token) this.api.token = token;
+        else this.user = null;
+      } else {
+        this.user = null;
+      }
+    }
+    get user() {
+      return this.$user.value;
+    }
+    set user(user) {
+      if (!b(this.user, user)) {
+        const u = user ? user : null;
+        this.$user.next(u);
+        this.emit("USER", u);
+      }
+    }
+    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(() => {
+      });
+    }
+    login(username, password, totp) {
+      return this.api.request({
+        url: "/api/auth/login",
+        headers: { Authorization: void 0 },
+        method: "POST",
+        body: {
+          username: username.trim(),
+          password: password.trim(),
+          totp
+        }
+      }).then(async (resp) => {
+        this.api.token = (resp == null ? void 0 : resp.token) || null;
+        return await this.once("USER");
+      });
+    }
+    loginRedirect(host = location.origin) {
+      return new Promise((res, rej) => {
+        var _a;
+        const win = window.open(encodeURI(`${(_a = this.opts) == null ? void 0 : _a.loginUi}?redirect=postmessage&host=${host}`), "_blank");
+        if (!win) return rej("Unable to open login");
+        win.addEventListener("message", (event) => {
+          var _a2;
+          if (!((_a2 = event == null ? void 0 : event.data) == null ? void 0 : _a2.token)) return rej("Unknown response from login");
+          this.api.token = event.data.token;
+          res(event.data.token);
+          win.close();
+        });
+      });
+    }
+    logout() {
+      this.api.token = null;
+      this.user = null;
+      this.emit("LOGOUT");
+    }
+    async register(u) {
+      var _a;
+      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);
+      return user;
+    }
+    reset(emailOrPass, token) {
+      return this.api.request({
+        url: "/api/auth/reset",
+        headers: { "Authorization": token ? `Bearer ${token}` : void 0 },
+        body: {
+          email: token ? void 0 : emailOrPass,
+          password: token ? emailOrPass : void 0
+        }
+      }).then(() => {
+      });
+    }
+    async session(token, set = false) {
+      if (!token) token = this.api.token;
+      const session = await this.api.request({
+        url: "/api/auth/session",
+        headers: token ? { "Authorization": `Bearer ${token}` } : void 0
+      });
+      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);
+      }
+      return session;
+    }
+    async updatePassword(username, password, oldPassword) {
+      return this.api.request({
+        url: "/api/auth/password",
+        body: { username, password, oldPassword }
+      }).then((resp) => {
+        if (resp == null ? void 0 : resp.token) this.api.token = resp.token;
+      });
+    }
+  }
+  class Data extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    delete(collection, document2) {
+      return this.api.request({
+        url: `/api/data/${collection}/${document2}`,
+        method: "DELETE"
+      }).then(() => this.emit("DELETE", collection, document2));
+    }
+    get(collection, document2) {
+      return this.api.request({ url: `/api/data/${collection}${document2 ? `/${document2}` : ""}` }).then((resp) => {
+        this.emit("GET", collection, resp);
+        return resp;
+      });
+    }
+    raw(collection, operand, query, options) {
+      return this.api.request({
+        url: `/api/data/${collection}`,
+        body: {
+          operand,
+          query,
+          options
+        }
+      }).then((resp) => {
+        this.emit("RAW", collection, resp);
+        return resp;
+      });
+    }
+    set(collection, document2, append = false) {
+      return this.api.request({
+        url: `/api/data/${collection}/${document2._id || ""}`,
+        method: append ? "PATCH" : "POST",
+        body: document2
+      }).then((resp) => {
+        this.emit("SET", collection, resp);
+        return resp;
+      });
+    }
+  }
+  class Email extends P {
+    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);
+        return resp;
+      });
+    }
+  }
+  class Groups extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    create(group) {
+      return this.api.request({
+        url: `/api/groups/${group.name}`,
+        method: "POST",
+        body: group
+      }).then((resp) => {
+        this.emit("CREATE", resp);
+        return resp;
+      });
+    }
+    list() {
+      return this.api.request({ url: `/api/groups` }).then((resp) => {
+        this.emit("LIST", resp || []);
+        return resp;
+      });
+    }
+    read(name) {
+      return this.api.request({ url: `/api/groups/${name}` }).then((resp) => {
+        this.emit("READ", resp);
+        return resp;
+      });
+    }
+    update(group) {
+      return this.api.request({
+        url: `/api/groups/${group.name}`,
+        method: "PATCH",
+        body: group
+      }).then((resp) => {
+        this.emit("UPDATE", resp);
+        return resp;
+      });
+    }
+    delete(name) {
+      return this.api.request({
+        url: `/api/groups/${name}`,
+        method: "DELETE"
+      }).then(() => this.emit("DELETE", name));
+    }
+  }
+  class Logger {
+    constructor(api, logLevel) {
+      __publicField(this, "api");
+      this.api = typeof api == "string" ? new Api(api) : api;
+      if (logLevel != null && logLevel != "NONE") {
+        window.addEventListener("error", (event) => this.error(event.error.stack));
+        window.addEventListener("unhandledrejection", async (event) => this.error(event.reason.stack));
+      }
+    }
+    buildLog(level, log) {
+      return {
+        time: (/* @__PURE__ */ new Date()).getTime(),
+        level,
+        log,
+        ctx: {
+          cores: navigator.hardwareConcurrency,
+          mem: navigator == null ? void 0 : navigator.deviceMemory,
+          res: [window.innerWidth, window.innerHeight],
+          url: location.href
+        }
+      };
+    }
+    clearClientLogs() {
+      return this.api.request({ url: `/api/logs/client`, method: "DELETE" });
+    }
+    clearServerLogs() {
+      return this.api.request({ url: `/api/logs/server`, method: "DELETE" });
+    }
+    clientLogs(length, page) {
+      const query = [length ? `length=${length}` : void 0, page ? `page=${page}` : void 0].filter((v2) => !!v2).join("&");
+      return this.api.request({ url: `/api/logs/client${query ? `?${query}` : ""}` }).then((resp) => resp);
+    }
+    serverLogs(length, page) {
+      const query = [length ? `length=${length}` : void 0, page ? `page=${page}` : void 0].filter((v2) => !!v2).join("&");
+      return this.api.request({ url: `/api/logs/server${query ? `?${query}` : ""}` }).then((resp) => resp);
+    }
+    debug(...logs) {
+      return this.api.request({ url: `/api/logs/client`, body: this.buildLog(et.DEBUG, logs) }).then(() => {
+      }).catch(() => {
+      });
+    }
+    log(...logs) {
+      return this.api.request({ url: `/api/logs/client`, body: this.buildLog(et.LOG, logs) }).then(() => {
+      }).catch(() => {
+      });
+    }
+    info(...logs) {
+      return this.api.request({ url: `/api/logs/client`, body: this.buildLog(et.INFO, logs) }).then(() => {
+      }).catch(() => {
+      });
+    }
+    warn(...logs) {
+      return this.api.request({ url: `/api/logs/client`, body: this.buildLog(et.WARN, logs) }).then(() => {
+      }).catch(() => {
+      });
+    }
+    error(...logs) {
+      return this.api.request({ url: `/api/logs/client`, body: this.buildLog(et.ERROR, logs) }).then(() => {
+      }).catch(() => {
+      });
+    }
+  }
+  class Payments extends P {
+    constructor(api, secret) {
+      super();
+      __publicField(this, "api");
+      __publicField(this, "stripe");
+      this.api = typeof api == "string" ? new Api(api) : api;
+      const setup = (retry = 1) => {
+        try {
+          if (!Stripe) throw new Error("Stripe not added");
+          this.stripe = Stripe(secret);
+        } catch (err) {
+          if (retry > 0) setTimeout(() => setup(retry--), 250);
+          else console.warn("Stripe failed, did you add the library & setup your API key?", err);
+        }
+      };
+      setup();
+    }
+    async charge(amount, custom = {}) {
+      this.emit("CHECKOUT", amount, custom);
+      const request = await this.api.request({ url: "/api/payments", body: {
+        amount,
+        custom
+      } });
+      return request.data.clientSecret;
+    }
+    async createForm(element, amount, custom) {
+      const token = await this.charge(amount, custom);
+      const form = this.stripe.elements({ clientSecret: token });
+      form.create("payment").mount(element);
+      return () => this.stripe.confirmPayment({
+        elements: form,
+        redirect: "if_required",
+        confirmParams: { return_url: location.origin }
+      });
+    }
+    async history(username) {
+      const history = await this.api.request({ url: `/api/payments${username ? `/${username}` : ""}` });
+      this.emit("LIST", username || null, history);
+      return history;
+    }
+  }
+  class Pdf extends P {
+    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);
+        V(url, fileName.endsWith(".pdf") ? fileName : fileName + ".pdf");
+        URL.revokeObjectURL(url);
+      }
+      this.emit("CREATE", blob);
+      return blob;
+    }
+    fromHtml(content, opts = {}) {
+      return this.api.request({ url: `/api/pdf`, body: { html: content } }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+    }
+    fromTemplate(template, data, opts = {}) {
+      return this.api.request({ url: `/api/pdf${template}`, body: data }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+    }
+    fromUrl(url, opts = {}) {
+      return this.api.request({ url: `/api/pdf?url=${url}` }).then((resp) => this.handleResponse(resp, opts.download ? opts.fileName || (/* @__PURE__ */ new Date()).toISOString() : void 0));
+    }
+  }
+  const _Socket = class _Socket {
+    constructor(api) {
+      __publicField(this, "api");
+      __publicField(this, "url");
+      __publicField(this, "connection");
+      __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.connect();
+    }
+    close() {
+      console.debug("Disconnected from Momentum");
+      this.open = false;
+      this.connection.close();
+    }
+    connect(retry = 3) {
+      var _a;
+      if (((_a = this.connection) == null ? void 0 : _a.readyState) < 2) this.connection.close();
+      this.connection = new WebSocket(this.url + (this.api.token ? `?token=${this.api.token}` : ""));
+      const timeout = setTimeout(() => {
+        if (this.open) return;
+        this.connection.close();
+        console.error(`Momentum connection timeout`);
+        if (retry > 0) this.connect(retry - 1);
+      }, _Socket.timeout);
+      this.connection.onclose = () => this.open = false;
+      this.connection.onmessage = this.handle;
+      this.connection.onopen = () => {
+        this.open = true;
+        clearTimeout(timeout);
+        console.debug("Connected to Momentum");
+      };
+    }
+    handle(...args) {
+      console.log(args);
+    }
+    send(channel, payload) {
+      this.connection.send(JSON.stringify({
+        token: this.api.token,
+        channel,
+        payload
+      }));
+    }
+  };
+  __publicField(_Socket, "timeout", 1e4);
+  let Socket = _Socket;
+  class Storage extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    delete(path) {
+      const url = (path.startsWith("/api/storage/") ? path : "/api/storage/" + path).replaceAll("//", "/");
+      return this.api.request({ url, method: "DELETE" }).then(() => {
+        this.emit("DELETE", url);
+      });
+    }
+    list(path) {
+      const url = (path.startsWith("/api/storage/") ? path : "/api/storage/" + path).replaceAll("//", "/");
+      return this.api.request({ url: url + "?list" }).then((resp) => {
+        this.emit("LIST", path, resp);
+        return resp;
+      });
+    }
+    open(path, target = "_blank") {
+      const p2 = (path.startsWith("/api/storage/") ? path : "/api/storage/" + path).replaceAll(/\/{2,}/g, "/");
+      const link = `${this.api.url}${p2}${this.api.token ? `?token=${this.api.token}` : ""}`;
+      if (!target) return link;
+      this.emit("OPEN", path);
+      return window.open(link, target);
+    }
+    mkdir(path) {
+      const p2 = (path.startsWith("/api/storage/") ? path : "/api/storage/" + path).replaceAll(/\/{2,}/g, "/");
+      return this.api.request({ url: p2 + "?directory", method: "POST" });
+    }
+    download(path, opts = {}) {
+      const p2 = ("/api/storage/" + path).replaceAll("//", "/");
+      return this.api.request({ ...opts, url: p2, decode: false }).then(async (response) => {
+        const blob = await response.blob();
+        const name = opts.downloadAs || new URL(path).pathname.split("/").pop();
+        this.emit("DOWNLOAD", path, blob);
+        wt(blob, name);
+        return response;
+      });
+    }
+    upload(files, opts = "") {
+      return new E(async (res, rej, prog) => {
+        if (!files) files = await xt();
+        if (!files || Array.isArray(files) && !files.length) return [];
+        const url = this.api.url + ("/api/storage/" + (typeof opts == "string" ? opts : opts == null ? void 0 : opts.path)).replaceAll("//", "/");
+        return At({
+          url,
+          files: Array.isArray(files) ? files : [files],
+          headers: this.api.headers
+        }).onProgress((p2) => {
+          prog(p2);
+        }).then((resp) => {
+          this.emit("UPLOAD", resp);
+          res(resp);
+        }).catch((err) => rej(err));
+      });
+    }
+  }
+  class UI {
+    constructor(settings) {
+      this.settings = settings;
+    }
+    async inject(reload = false) {
+      if (!Object.keys(this.settings.cache).length || reload) await this.settings.list();
+      window.document.body.classList.add(this.settings.cache.theme.darkMode ? "theme-dark" : "theme-light");
+      window.document.body.classList.remove(this.settings.cache.theme.darkMode ? "theme-light" : "theme-dark");
+      if (this.settings.cache.title)
+        window.document.querySelectorAll(".momentum-title").forEach((el) => el.innerText = this.settings.cache.title);
+      if (this.settings.cache.description)
+        window.document.querySelectorAll(".momentum-description").forEach((el) => el.innerText = this.settings.cache.description);
+      if (this.settings.cache.version)
+        window.document.querySelectorAll(".momentum-version").forEach((el) => el.innerText = this.settings.cache.version);
+      if (this.settings.cache.logo) {
+        window.document.querySelectorAll(".momentum-logo").forEach((el) => {
+          el.src = this.settings.cache.logo;
+          el.href = this.settings.cache.logo;
+        });
+      }
+      if (this.settings.cache.theme) {
+        let style = window.document.querySelector("#momentum-theme");
+        if (!style) {
+          style = window.document.createElement("style");
+          style.id = "momentum-theme";
+          window.document.head.append(style);
+        }
+        style.innerHTML = `
+			:root {
+				--theme-bg-primary: ${this.settings.cache.theme.background};
+				--theme-bg-secondary: ${this.settings.cache.theme.darkMode ? "#2e2e2e" : "#ffffff"};
+				--theme-primary: ${this.settings.cache.theme.primary};
+				--theme-secondary: ${this.settings.cache.theme.secondary};
+				--theme-text: ${this.settings.cache.theme.darkMode ? "#ffffff" : "#000000"};
+				--theme-muted: ${this.settings.cache.theme.darkMode ? "#cccccc" : "#6c757d"};
+			}`;
+      }
+      if (this.settings.cache.pwa) {
+        const link = window.document.createElement("link");
+        link.setAttribute("rel", "manifest");
+        link.setAttribute("href", this.settings.api.url + "/manifest.json");
+        window.document.head.append(link);
+      }
+    }
+  }
+  class Users extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      __publicField(this, "listed", false);
+      __publicField(this, "$cache", new BehaviorSubject([]));
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    get cache() {
+      return this.$cache.value;
+    }
+    set cache(val) {
+      this.$cache.next(val);
+    }
+    delete(username) {
+      return this.api.request({
+        url: `/api/users/${username}`,
+        method: "DELETE"
+      }).then(() => {
+        this.cache = this.cache.filter((u) => u.username != username);
+        this.emit("DELETE", username);
+      });
+    }
+    list(reload = false) {
+      if (!reload && this.listed) return Promise.resolve(this.cache);
+      return this.api.request({ url: `/api/users` }).then((resp) => {
+        resp == null ? void 0 : resp.map((r) => {
+          r.image = this.api.url + r.image + `?token=${this.api.token}`;
+          return r;
+        });
+        this.cache = resp || [];
+        this.listed = true;
+        this.emit("LIST", resp || []);
+        return resp;
+      });
+    }
+    read(username, reload = false) {
+      if (!reload) {
+        const cached = this.cache.find((u) => u.username == username);
+        if (cached) return Promise.resolve(cached);
+      }
+      return this.api.request({ url: `/api/users/${username}` }).then((resp) => {
+        if (resp) {
+          resp.image = this.api.url + resp.image + `?token=${this.api.token}`;
+          this.cache = [...this.cache.filter((u) => u.username != username), resp];
+        }
+        this.emit("READ", resp);
+        return resp;
+      });
+    }
+    update(user) {
+      return this.api.request({
+        url: `/api/users/${user.username}`,
+        method: "PATCH",
+        body: user
+      }).then((resp) => {
+        if (resp) {
+          resp.image = this.api.url + resp.image + `?token=${this.api.token}`;
+          this.cache = this.cache.filter((u) => u.username != user.username).concat([resp]);
+        }
+        this.emit(user._id ? "UPDATE" : "CREATE", resp);
+        return resp;
+      });
+    }
+    uploadImage(username, file) {
+      return At({
+        url: this.api.url + `/api/users/${username}/image`,
+        files: [file],
+        headers: this.api.headers
+      }).then((resp) => {
+        this.emit("UPLOAD_IMAGE", username, file);
+        return resp;
+      });
+    }
+  }
+  class Settings extends P {
+    constructor(api) {
+      super();
+      __publicField(this, "api");
+      __publicField(this, "$cache", new BehaviorSubject({}));
+      this.api = typeof api == "string" ? new Api(api) : api;
+    }
+    get cache() {
+      return this.$cache.value;
+    }
+    set cache(val) {
+      this.$cache.next(val);
+    }
+    list(detailed = false) {
+      return this.api.request({ url: `/api/settings` + (detailed ? "?detailed" : "") }).then((resp) => {
+        this.cache = !detailed ? resp : Object.values(resp).reduce((acc, v2) => ({ ...acc, [v2.key]: v2.value }), {});
+        this.emit("LIST", resp || []);
+        return resp;
+      });
+    }
+    delete(key) {
+      return this.api.request({ url: `/api/settings/${key}`, method: "DELETE" }).then(() => {
+        this.cache = { ...this.cache, [key]: void 0 };
+        this.emit("DELETE", key);
+      });
+    }
+    read(key, reload = false) {
+      if (!reload && this.cache[key]) return Promise.resolve(this.cache[key]);
+      return this.api.request({ url: `/api/settings/${key}` }).then((variable) => {
+        if (variable) this.cache = { ...this.cache, [variable.key]: variable };
+        this.emit("READ", variable);
+        return variable;
+      });
+    }
+    update(variable) {
+      return this.api.request({ url: `/api/settings/${variable.key}`, body: variable }).then((variable2) => {
+        if (variable2) this.cache = { ...this.cache, [variable2.key]: variable2.value };
+        this.emit("UPDATE", variable2);
+        return variable2;
+      });
+    }
+  }
+  class Static extends P {
+    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);
+      });
+    }
+    list(path) {
+      const url = ("/api/static/" + path).replaceAll("//", "/");
+      return this.api.request({ url }).then((resp) => {
+        this.emit("LIST", path, resp || []);
+        return resp;
+      });
+    }
+    upload(files, path = "/") {
+      const data = new FormData();
+      (Array.isArray(files) ? files : [files]).forEach((f) => data.append("file", f));
+      return this.api.request({ url: "/api/static" + path, body: data }).then((resp) => {
+        this.emit("UPLOAD", resp || []);
+        return resp;
+      });
+    }
+  }
+  class Momentum extends P {
+    constructor(url, opts) {
+      super();
+      __publicField(this, "api");
+      __publicField(this, "actions");
+      __publicField(this, "auth");
+      __publicField(this, "data");
+      __publicField(this, "email");
+      __publicField(this, "groups");
+      __publicField(this, "logger");
+      __publicField(this, "payments");
+      __publicField(this, "pdf");
+      __publicField(this, "settings");
+      __publicField(this, "socket");
+      __publicField(this, "static");
+      __publicField(this, "storage");
+      __publicField(this, "ui");
+      __publicField(this, "users");
+      this.api = new Api(url, opts == null ? void 0 : opts.api);
+      this.actions = new Actions(this.api);
+      this.auth = new Auth(this.api, {
+        persist: (opts == null ? void 0 : opts.persist) ?? true,
+        loginUi: opts == null ? void 0 : opts.loginUi
+      });
+      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);
+      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);
+      if (opts == null ? void 0 : opts.socket) this.socket = new Socket(this.api);
+      this.static = new Static(this.api);
+      this.storage = new Storage(this.api);
+      this.ui = new UI(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(`PAYMENT::${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) => {
+        var _a;
+        if (Array.isArray(args[0])) {
+          const u = args[0].find((u2) => {
+            var _a2;
+            return u2._id == ((_a2 = this.auth.user) == null ? void 0 : _a2._id);
+          });
+          if (u) this.auth.user = u;
+        } else if (args[0]._id == ((_a = this.auth.user) == null ? void 0 : _a._id)) {
+          this.auth.user = args[0];
+        }
+      });
+    }
+  }
+  exports2.ActionType = ActionType;
+  exports2.Actions = Actions;
+  exports2.Api = Api;
+  exports2.Auth = Auth;
+  exports2.Data = Data;
+  exports2.Email = Email;
+  exports2.Groups = Groups;
+  exports2.Logger = Logger;
+  exports2.Momentum = Momentum;
+  exports2.Payments = Payments;
+  exports2.Pdf = Pdf;
+  exports2.Settings = Settings;
+  exports2.Socket = Socket;
+  exports2.Static = Static;
+  exports2.Storage = Storage;
+  exports2.Totp = Totp;
+  exports2.UI = UI;
+  exports2.Users = Users;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});