@ztimson/momentum 0.53.2 → 1.0.0

package/dist/index.js

@@ -0,0 +1,4473 @@
+(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.momentum = {}));
+})(this, (function(exports2) {
+  "use strict";
+  function JSONAttemptParse(json, fallback) {
+    try {
+      return JSON.parse(json);
+    } catch {
+      return fallback ?? json;
+    }
+  }
+  function JSONSanitize(obj, space) {
+    const cache = [];
+    return JSON.stringify(obj, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (cache.includes(value)) return "[Circular]";
+        cache.push(value);
+      }
+      return value;
+    }, space);
+  }
+  function clean(obj, undefinedOnly = false) {
+    if (obj == null) throw new Error("Cannot clean a NULL value");
+    if (Array.isArray(obj)) {
+      obj = obj.filter((o) => undefinedOnly ? o !== void 0 : o != null);
+    } else {
+      Object.entries(obj).forEach(([key, value]) => {
+        if (undefinedOnly && value === void 0 || !undefinedOnly && value == null) delete obj[key];
+      });
+    }
+    return obj;
+  }
+  function deepCopy(value) {
+    if (value == null) return value;
+    const t = typeof value;
+    if (t === "string" || t === "number" || t === "boolean" || t === "function") return value;
+    try {
+      return structuredClone(value);
+    } catch {
+      return JSON.parse(JSONSanitize(value));
+    }
+  }
+  function dotNotation(obj, prop, set) {
+    if (obj == null || !prop) return void 0;
+    return prop.split(/[.[\]]/g).filter((prop2) => prop2.length).reduce((obj2, prop2, i, arr) => {
+      if (prop2[0] == '"' || prop2[0] == "'") prop2 = prop2.slice(1, -1);
+      if (!obj2?.hasOwnProperty(prop2)) {
+        return void 0;
+      }
+      return obj2[prop2];
+    }, obj);
+  }
+  function includes(target, values, allowMissing = false) {
+    if (target == void 0) return allowMissing;
+    if (Array.isArray(values)) return values.findIndex((e, i) => !includes(target[i], values[i], allowMissing)) == -1;
+    const type = typeof values;
+    if (type != typeof target) return false;
+    if (type == "object") {
+      return Object.keys(values).find((key) => !includes(target[key], values[key], allowMissing)) == null;
+    }
+    if (type == "function") return target.toString() == values.toString();
+    return target == values;
+  }
+  function isEqual(a, b, seen = /* @__PURE__ */ new WeakMap()) {
+    if (a === b) return true;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+    if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+      if (Number.isNaN(a) && Number.isNaN(b)) return true;
+      if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+      return false;
+    }
+    if (seen.has(a)) return seen.get(a) === b;
+    seen.set(a, b);
+    const isArrayA = Array.isArray(a);
+    const isArrayB = Array.isArray(b);
+    if (isArrayA && isArrayB) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i], seen)) return false;
+      }
+      return true;
+    }
+    if (isArrayA !== isArrayB) return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key], seen)) return false;
+    }
+    return true;
+  }
+  class ASet 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(elements = []) {
+      super();
+      if (!!elements?.["forEach"])
+        elements.forEach((el) => this.add(el));
+    }
+    /**
+     * Add elements to set if unique
+     * @param items
+     */
+    add(...items) {
+      items.filter((el) => !this.has(el)).forEach((el) => this.push(el));
+      return this;
+    }
+    /**
+     * Remove all elements
+     */
+    clear() {
+      this.splice(0, this.length);
+      return this;
+    }
+    /**
+     * Delete elements from set
+     * @param items Elements that will be deleted
+     */
+    delete(...items) {
+      items.forEach((el) => {
+        const index = this.indexOf(el);
+        if (index != -1) this.splice(index, 1);
+      });
+      return this;
+    }
+    /**
+     * 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(set) {
+      return new ASet(this.filter((el) => !set.has(el)));
+    }
+    /**
+     * Check if set includes element
+     * @param {T} el Element to look for
+     * @return {boolean} True if element was found, false otherwise
+     */
+    has(el) {
+      return this.indexOf(el) != -1;
+    }
+    /**
+     * Find index number of element, or -1 if it doesn't exist. Matches by equality not reference
+     *
+     * @param {T} search Element to find
+     * @param {number} fromIndex Starting index position
+     * @return {number} Element index number or -1 if missing
+     */
+    indexOf(search2, fromIndex) {
+      return super.findIndex((el) => isEqual(el, search2), fromIndex);
+    }
+    /**
+     * 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(set) {
+      return new ASet(this.filter((el) => set.has(el)));
+    }
+    /**
+     * 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(set) {
+      return this.intersection(set).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(set) {
+      return this.findIndex((el) => !set.has(el)) == -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(set) {
+      return set.findIndex((el) => !this.has(el)) == -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(set) {
+      return new ASet([...this.difference(set), ...set.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(set) {
+      return new ASet([...this, ...set]);
+    }
+  }
+  function findByProp(prop, value) {
+    return (v) => isEqual(dotNotation(v, prop), value);
+  }
+  function makeArray(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  class Cache {
+    /**
+     * Create new cache
+     * @param {keyof T} key Default property to use as primary key
+     * @param options
+     */
+    constructor(key, options = {}) {
+      this.key = key;
+      this.options = options;
+      if (this.options.persistentStorage != null) {
+        if (typeof this.options.persistentStorage == "string")
+          this.options.persistentStorage = { storage: localStorage, key: this.options.persistentStorage };
+        if (this.options.persistentStorage?.storage?.database != void 0) {
+          (async () => {
+            const persists = this.options.persistentStorage;
+            const table = await persists.storage.createTable({ name: persists.key, key: this.key });
+            const rows = await table.getAll();
+            for (const row of rows) this.store.set(this.getKey(row), row);
+            this._loading();
+          })();
+        } else if (this.options.persistentStorage?.storage?.getItem != void 0) {
+          const { storage, key: key2 } = this.options.persistentStorage;
+          const stored = storage.getItem(key2);
+          if (stored != null) {
+            try {
+              const obj = JSON.parse(stored);
+              for (const k of Object.keys(obj)) this.store.set(k, obj[k]);
+            } catch {
+            }
+          }
+          this._loading();
+        }
+      } else {
+        this._loading();
+      }
+      return new Proxy(this, {
+        get: (target, prop) => {
+          if (prop in target) return target[prop];
+          return this.get(prop, true);
+        },
+        set: (target, prop, value) => {
+          if (prop in target) target[prop] = value;
+          else this.set(prop, value);
+          return true;
+        }
+      });
+    }
+    _loading;
+    store = /* @__PURE__ */ new Map();
+    timers = /* @__PURE__ */ new Map();
+    lruOrder = [];
+    /** Whether cache is complete */
+    complete = false;
+    /** Await initial loading */
+    loading = new Promise((r) => this._loading = r);
+    getKey(value) {
+      if (!this.key) throw new Error("No key defined");
+      if (value[this.key] === void 0) throw new Error(`${this.key.toString()} Doesn't exist on ${JSON.stringify(value, null, 2)}`);
+      return value[this.key];
+    }
+    /** Save item to storage */
+    save(key) {
+      const persists = this.options.persistentStorage;
+      if (!!persists?.storage) {
+        if (persists.storage?.database != void 0) {
+          persists.storage.createTable({ name: persists.key, key: this.key }).then((table) => {
+            if (key !== void 0) {
+              const value = this.get(key, true);
+              if (value != null) table.set(value, key);
+              else table.delete(key);
+            } else {
+              table.clear();
+              this.all(true).forEach((row) => table.add(row));
+            }
+          });
+        } else if (persists.storage?.setItem != void 0) {
+          const obj = {};
+          for (const [k, v] of this.store.entries()) obj[k] = v;
+          persists.storage.setItem(persists.key, JSONSanitize(obj));
+        }
+      }
+    }
+    clearTimer(key) {
+      const t = this.timers.get(key);
+      if (t) {
+        clearTimeout(t);
+        this.timers.delete(key);
+      }
+    }
+    touchLRU(key) {
+      if (!this.options.sizeLimit || this.options.sizeLimit <= 0) return;
+      const idx = this.lruOrder.indexOf(key);
+      if (idx >= 0) this.lruOrder.splice(idx, 1);
+      this.lruOrder.push(key);
+      while (this.lruOrder.length > (this.options.sizeLimit || 0)) {
+        const lru = this.lruOrder.shift();
+        if (lru !== void 0) this.delete(lru);
+      }
+    }
+    /**
+     * Get all cached items
+     * @return {T[]} Array of items
+     */
+    all(expired) {
+      const out = [];
+      for (const v of this.store.values()) {
+        const val = v;
+        if (expired || !val?._expired) out.push(deepCopy(val));
+      }
+      return out;
+    }
+    /**
+     * Add a new item to the cache. Like set, but finds key automatically
+     */
+    add(value, ttl = this.ttl) {
+      const key = this.getKey(value);
+      this.set(key, value, ttl);
+      return this;
+    }
+    /**
+     * Add several rows to the cache
+     */
+    addAll(rows, complete = true) {
+      this.clear();
+      rows.forEach((r) => this.add(r));
+      this.complete = complete;
+      return this;
+    }
+    /** Remove all keys */
+    clear() {
+      this.complete = false;
+      for (const [k, t] of this.timers) clearTimeout(t);
+      this.timers.clear();
+      this.lruOrder = [];
+      this.store.clear();
+      this.save();
+      return this;
+    }
+    /** Delete a cached item */
+    delete(key) {
+      this.clearTimer(key);
+      const idx = this.lruOrder.indexOf(key);
+      if (idx >= 0) this.lruOrder.splice(idx, 1);
+      this.store.delete(key);
+      this.save(key);
+      return this;
+    }
+    /** Return entries as array */
+    entries(expired) {
+      const out = [];
+      for (const [k, v] of this.store.entries()) {
+        const val = v;
+        if (expired || !val?._expired) out.push([k, deepCopy(val)]);
+      }
+      return out;
+    }
+    /** Manually expire a cached item */
+    expire(key) {
+      this.complete = false;
+      if (this.options.expiryPolicy == "keep") {
+        const v = this.store.get(key);
+        if (v) {
+          v._expired = true;
+          this.store.set(key, v);
+          this.save(key);
+        }
+      } else this.delete(key);
+      return this;
+    }
+    /** Find first matching item */
+    find(filter, expired) {
+      for (const v of this.store.values()) {
+        const row = v;
+        if ((expired || !row._expired) && includes(row, filter)) return deepCopy(row);
+      }
+      return void 0;
+    }
+    /** Get cached item by key */
+    get(key, expired) {
+      const raw = this.store.get(key);
+      if (raw == null) return null;
+      this.touchLRU(key);
+      const isExpired = raw?._expired;
+      if (expired || !isExpired) return deepCopy(raw);
+      return null;
+    }
+    /** Return list of keys */
+    keys(expired) {
+      const out = [];
+      for (const [k, v] of this.store.entries()) {
+        const val = v;
+        if (expired || !val?._expired) out.push(k);
+      }
+      return out;
+    }
+    /** Return map of key → item */
+    map(expired) {
+      const copy = {};
+      for (const [k, v] of this.store.entries()) {
+        const val = v;
+        if (expired || !val?._expired) copy[k] = deepCopy(val);
+      }
+      return copy;
+    }
+    /** Add item manually specifying the key */
+    set(key, value, ttl = this.options.ttl) {
+      if (this.options.expiryPolicy == "keep") delete value._expired;
+      this.clearTimer(key);
+      this.store.set(key, value);
+      this.touchLRU(key);
+      this.save(key);
+      if (ttl) {
+        const t = setTimeout(() => {
+          this.expire(key);
+          this.save(key);
+        }, ttl * 1e3);
+        this.timers.set(key, t);
+      }
+      return this;
+    }
+    /** Get all cached items */
+    values = this.all;
+  }
+  function contrast(background) {
+    const exploded = background?.match(background.length >= 6 ? /[0-9a-fA-F]{2}/g : /[0-9a-fA-F]/g);
+    if (!exploded || exploded?.length < 3) return "black";
+    const [r, g, b] = exploded.map((hex) => parseInt(hex.length == 1 ? `${hex}${hex}` : hex, 16));
+    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    return luminance > 0.5 ? "black" : "white";
+  }
+  const LETTER_LIST = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const NUMBER_LIST = "0123456789";
+  const SYMBOL_LIST = "~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/";
+  function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + " " + sizes[i];
+  }
+  function randomStringBuilder(length, letters = false, numbers = false, symbols = false) {
+    if (!letters && !numbers && !symbols) throw new Error("Must enable at least one: letters, numbers, symbols");
+    return Array(length).fill(null).map(() => {
+      let c;
+      do {
+        const type = ~~(Math.random() * 3);
+        if (letters && type == 0) {
+          c = LETTER_LIST[~~(Math.random() * LETTER_LIST.length)];
+        } else if (numbers && type == 1) {
+          c = NUMBER_LIST[~~(Math.random() * NUMBER_LIST.length)];
+        } else if (symbols && type == 2) {
+          c = SYMBOL_LIST[~~(Math.random() * SYMBOL_LIST.length)];
+        }
+      } while (!c);
+      return c;
+    }).join("");
+  }
+  function dayOfWeek(d) {
+    return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][d];
+  }
+  function dayOfYear(date) {
+    const start = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    return Math.ceil((date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24));
+  }
+  function formatDate(format = "YYYY-MM-DD H:mm", date = /* @__PURE__ */ new Date(), tz = "local") {
+    if (typeof date === "number" || typeof date === "string") date = new Date(date);
+    if (isNaN(date.getTime())) throw new Error("Invalid date input");
+    const numericTz = typeof tz === "number";
+    const localTz = tz === "local" || !numericTz && tz.toLowerCase?.() === "local";
+    const tzName = localTz ? Intl.DateTimeFormat().resolvedOptions().timeZone : numericTz ? "UTC" : tz;
+    if (!numericTz && tzName !== "UTC") {
+      try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tzName }).format();
+      } catch {
+        throw new Error(`Invalid timezone: ${tzName}`);
+      }
+    }
+    let zonedDate = new Date(date);
+    let get;
+    const partsMap = {};
+    if (!numericTz && tzName !== "UTC") {
+      const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: tzName,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        weekday: "long",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+      }).formatToParts(date);
+      parts.forEach((p) => {
+        partsMap[p.type] = p.value;
+      });
+      const monthValue = parseInt(partsMap.month) - 1;
+      const dayOfWeekValue = (/* @__PURE__ */ new Date(`${partsMap.year}-${partsMap.month}-${partsMap.day}`)).getDay();
+      const hourValue = parseInt(partsMap.hour);
+      get = (fn2) => {
+        switch (fn2) {
+          case "FullYear":
+            return parseInt(partsMap.year);
+          case "Month":
+            return monthValue;
+          case "Date":
+            return parseInt(partsMap.day);
+          case "Day":
+            return dayOfWeekValue;
+          case "Hours":
+            return hourValue;
+          case "Minutes":
+            return parseInt(partsMap.minute);
+          case "Seconds":
+            return parseInt(partsMap.second);
+          default:
+            return 0;
+        }
+      };
+    } else {
+      const offset = numericTz ? tz : 0;
+      zonedDate = new Date(date.getTime() + offset * 60 * 60 * 1e3);
+      get = (fn2) => zonedDate[`getUTC${fn2}`]();
+    }
+    function numSuffix2(n) {
+      const s = ["th", "st", "nd", "rd"];
+      const v = n % 100;
+      return n + (s[(v - 20) % 10] || s[v] || s[0]);
+    }
+    function getTZOffset() {
+      if (numericTz) {
+        const total = tz * 60;
+        const hours = Math.floor(Math.abs(total) / 60);
+        const mins = Math.abs(total) % 60;
+        return `${tz >= 0 ? "+" : "-"}${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
+      }
+      try {
+        const offset = new Intl.DateTimeFormat("en-US", { timeZone: tzName, timeZoneName: "longOffset", hour: "2-digit", minute: "2-digit" }).formatToParts(date).find((p) => p.type === "timeZoneName")?.value.match(/([+-]\d{2}:\d{2})/)?.[1];
+        if (offset) return offset;
+      } catch {
+      }
+      return "+00:00";
+    }
+    function getTZAbbr() {
+      if (numericTz && tz === 0) return "UTC";
+      try {
+        return new Intl.DateTimeFormat("en-US", { timeZone: tzName, timeZoneName: "short" }).formatToParts(date).find((p) => p.type === "timeZoneName")?.value || "";
+      } catch {
+        return tzName;
+      }
+    }
+    const tokens = {
+      YYYY: get("FullYear").toString(),
+      YY: get("FullYear").toString().slice(2),
+      MMMM: month(get("Month")),
+      MMM: month(get("Month")).slice(0, 3),
+      MM: (get("Month") + 1).toString().padStart(2, "0"),
+      M: (get("Month") + 1).toString(),
+      DDD: dayOfYear(zonedDate).toString(),
+      DD: get("Date").toString().padStart(2, "0"),
+      Do: numSuffix2(get("Date")),
+      D: get("Date").toString(),
+      dddd: dayOfWeek(get("Day")),
+      ddd: dayOfWeek(get("Day")).slice(0, 3),
+      HH: get("Hours").toString().padStart(2, "0"),
+      H: get("Hours").toString(),
+      hh: (get("Hours") % 12 || 12).toString().padStart(2, "0"),
+      h: (get("Hours") % 12 || 12).toString(),
+      mm: get("Minutes").toString().padStart(2, "0"),
+      m: get("Minutes").toString(),
+      ss: get("Seconds").toString().padStart(2, "0"),
+      s: get("Seconds").toString(),
+      SSS: zonedDate[`getUTC${"Milliseconds"}`]().toString().padStart(3, "0"),
+      A: get("Hours") >= 12 ? "PM" : "AM",
+      a: get("Hours") >= 12 ? "pm" : "am",
+      ZZ: getTZOffset().replace(":", ""),
+      Z: getTZOffset(),
+      z: getTZAbbr()
+    };
+    return format.replace(/YYYY|YY|MMMM|MMM|MM|M|DDD|DD|Do|D|dddd|ddd|HH|H|hh|h|mm|m|ss|s|SSS|A|a|ZZ|Z|z/g, (token) => tokens[token]);
+  }
+  function month(m) {
+    return ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"][m];
+  }
+  function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async function sleepWhile(fn2, checkInterval = 100) {
+    while (await fn2()) await sleep(checkInterval);
+  }
+  class AsyncLock {
+    p = Promise.resolve();
+    run(fn2) {
+      const res = this.p.then(fn2, fn2);
+      this.p = res.then(() => {
+      }, () => {
+      });
+      return res;
+    }
+  }
+  class Database {
+    constructor(database, tables, version2) {
+      this.database = database;
+      this.version = version2;
+      this.connection = new Promise((resolve, reject) => {
+        let req;
+        try {
+          req = indexedDB.open(this.database, this.version);
+        } catch (err) {
+          return reject(err);
+        }
+        this.tables = !tables ? [] : tables.map((t) => {
+          t = typeof t == "object" ? t : { name: t };
+          return { ...t, name: t.name.toString() };
+        });
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => {
+          let db;
+          try {
+            db = req.result;
+          } catch (err) {
+            return reject(err);
+          }
+          const existing = Array.from(db.objectStoreNames);
+          if (!tables) {
+            this.tables = existing.map((t) => {
+              try {
+                const tx = db.transaction(t, "readonly");
+                const store = tx.objectStore(t);
+                return { name: t, key: store.keyPath };
+              } catch {
+                return { name: t };
+              }
+            });
+          }
+          const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+          if (tables && desired.symmetricDifference(new ASet(existing)).length) {
+            db.close();
+            Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+            this.connection.then(resolve);
+          } else {
+            this.version = db.version;
+            resolve(db);
+          }
+          this.upgrading = false;
+        };
+        req.onupgradeneeded = () => {
+          this.upgrading = true;
+          let db;
+          try {
+            db = req.result;
+          } catch {
+            return;
+          }
+          try {
+            const existingTables = new ASet(Array.from(db.objectStoreNames));
+            if (tables) {
+              const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+              existingTables.difference(desired).forEach((name) => db.deleteObjectStore(name));
+              desired.difference(existingTables).forEach((name) => {
+                const t = this.tables.find(findByProp("name", name));
+                db.createObjectStore(name, {
+                  keyPath: t?.key,
+                  autoIncrement: t?.autoIncrement || !t?.key
+                });
+              });
+            }
+          } catch {
+          }
+        };
+      });
+    }
+    schemaLock = new AsyncLock();
+    upgrading = false;
+    connection;
+    tables;
+    get ready() {
+      return !this.upgrading;
+    }
+    waitForUpgrade = () => sleepWhile(() => this.upgrading);
+    async createTable(table) {
+      return this.schemaLock.run(async () => {
+        if (typeof table == "string") table = { name: table };
+        const conn = await this.connection;
+        if (!this.includes(table.name)) {
+          const newDb = new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1);
+          conn.close();
+          this.connection = newDb.connection;
+          await this.connection;
+          Object.assign(this, newDb);
+        }
+        return this.table(table.name);
+      });
+    }
+    async deleteTable(table) {
+      return this.schemaLock.run(async () => {
+        if (typeof table == "string") table = { name: table };
+        if (!this.includes(table.name)) return;
+        const conn = await this.connection;
+        const newDb = new Database(this.database, this.tables.filter((t) => t.name != table.name), (this.version ?? 0) + 1);
+        conn.close();
+        this.connection = newDb.connection;
+        await this.connection;
+        Object.assign(this, newDb);
+      });
+    }
+    includes(name) {
+      return !!this.tables.find((t) => t.name == (typeof name == "object" ? name.name : name.toString()));
+    }
+    table(name) {
+      return new Table(this, name.toString());
+    }
+  }
+  class Table {
+    constructor(database, name, key = "id") {
+      this.database = database;
+      this.name = name;
+      this.key = key;
+      this.database.connection.then(() => {
+        const exists = !!this.database.tables.find(findByProp("name", this.name));
+        if (!exists) this.database.createTable(this.name);
+      });
+    }
+    async tx(table, fn2, readonly = false) {
+      await this.database.waitForUpgrade();
+      const db = await this.database.connection;
+      const tx = db.transaction(table, readonly ? "readonly" : "readwrite");
+      return new Promise((resolve, reject) => {
+        const request = fn2(tx.objectStore(table));
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+    }
+    add(value, key) {
+      return this.tx(this.name, (store) => store.add(value, key));
+    }
+    all = this.getAll;
+    clear() {
+      return this.tx(this.name, (store) => store.clear());
+    }
+    count() {
+      return this.tx(this.name, (store) => store.count(), true);
+    }
+    create = this.add;
+    delete(key) {
+      return this.tx(this.name, (store) => store.delete(key));
+    }
+    get(key) {
+      return this.tx(this.name, (store) => store.get(key), true);
+    }
+    getAll() {
+      return this.tx(this.name, (store) => store.getAll(), true);
+    }
+    getAllKeys() {
+      return this.tx(this.name, (store) => store.getAllKeys(), true);
+    }
+    put(value, key) {
+      return this.tx(this.name, (store) => {
+        if (store.keyPath) return store.put(value);
+        return store.put(value, key);
+      });
+    }
+    read(key) {
+      return key ? this.get(key) : this.getAll();
+    }
+    set(value, key) {
+      if (key) value[this.key] = key;
+      if (!value[this.key]) return this.add(value);
+      return this.put(value);
+    }
+    update = this.set;
+  }
+  class PromiseProgress extends Promise {
+    listeners = [];
+    _progress = 0;
+    get progress() {
+      return this._progress;
+    }
+    set progress(p) {
+      if (p == this._progress) return;
+      this._progress = p;
+      this.listeners.forEach((l) => l(p));
+    }
+    constructor(executor) {
+      super((resolve, reject) => executor(
+        (value) => resolve(value),
+        (reason) => reject(reason),
+        (progress) => this.progress = progress
+      ));
+    }
+    static from(promise) {
+      if (promise instanceof PromiseProgress) return promise;
+      return new PromiseProgress((res, rej) => promise.then((...args) => res(...args)).catch((...args) => rej(...args)));
+    }
+    from(promise) {
+      const newPromise = PromiseProgress.from(promise);
+      this.onProgress((p) => newPromise.progress = p);
+      return newPromise;
+    }
+    onProgress(callback) {
+      this.listeners.push(callback);
+      return this;
+    }
+    then(res, rej) {
+      const resp = super.then(res, rej);
+      return this.from(resp);
+    }
+    catch(rej) {
+      return this.from(super.catch(rej));
+    }
+    finally(res) {
+      return this.from(super.finally(res));
+    }
+  }
+  function downloadFile(blob, name) {
+    if (!(blob instanceof Blob)) blob = new Blob(makeArray(blob));
+    const url = URL.createObjectURL(blob);
+    downloadUrl(url, name);
+    URL.revokeObjectURL(url);
+  }
+  function downloadUrl(href, name) {
+    const a = document.createElement("a");
+    a.href = href;
+    a.download = name || href.split("/").pop();
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+  }
+  function fileBrowser(options = {}) {
+    return new Promise((res) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = options.accept || "*";
+      input.style.display = "none";
+      input.multiple = !!options.multiple;
+      input.onblur = input.onchange = async () => {
+        res(Array.from(input.files));
+        input.remove();
+      };
+      document.body.appendChild(input);
+      input.click();
+    });
+  }
+  function timestampFilename(name, date = /* @__PURE__ */ new Date()) {
+    if (typeof date == "number" || typeof date == "string") date = new Date(date);
+    const timestamp = formatDate("YYYY-MM-DD_HH-mm", date);
+    return timestamp;
+  }
+  function uploadWithProgress(options) {
+    return new PromiseProgress((res, rej, prog) => {
+      const xhr = new XMLHttpRequest();
+      const formData2 = new FormData();
+      options.files.forEach((f) => formData2.append("file", f));
+      xhr.withCredentials = !!options.withCredentials;
+      xhr.upload.addEventListener("progress", (event) => event.lengthComputable ? prog(event.loaded / event.total) : null);
+      xhr.addEventListener("loadend", () => res(JSONAttemptParse(xhr.responseText)));
+      xhr.addEventListener("error", () => rej(JSONAttemptParse(xhr.responseText)));
+      xhr.addEventListener("timeout", () => rej({ error: "Request timed out" }));
+      xhr.open("POST", options.url);
+      Object.entries(options.headers || {}).forEach(([key, value]) => xhr.setRequestHeader(key, value));
+      xhr.send(formData2);
+    });
+  }
+  class HttpResponse extends Response {
+    data;
+    ok;
+    redirected;
+    type;
+    url;
+    constructor(resp, stream) {
+      const body = [204, 205, 304].includes(resp.status) ? null : stream;
+      super(body, {
+        headers: resp.headers,
+        status: resp.status,
+        statusText: resp.statusText
+      });
+      this.ok = resp.ok;
+      this.redirected = resp.redirected;
+      this.type = resp.type;
+      this.url = resp.url;
+    }
+  }
+  class Http {
+    static interceptors = {};
+    static headers = {};
+    interceptors = {};
+    headers = {};
+    url;
+    constructor(defaults = {}) {
+      this.url = defaults.url ?? null;
+      this.headers = defaults.headers || {};
+      if (defaults.interceptors) {
+        defaults.interceptors.forEach((i) => Http.addInterceptor(i));
+      }
+    }
+    static addInterceptor(fn2) {
+      const key = Object.keys(Http.interceptors).length.toString();
+      Http.interceptors[key] = fn2;
+      return () => {
+        Http.interceptors[key] = null;
+      };
+    }
+    addInterceptor(fn2) {
+      const key = Object.keys(this.interceptors).length.toString();
+      this.interceptors[key] = fn2;
+      return () => {
+        this.interceptors[key] = null;
+      };
+    }
+    request(opts = {}) {
+      if (!this.url && !opts.url) throw new Error("URL needs to be set");
+      let url = opts.url?.startsWith("http") ? opts.url : (this.url || "") + (opts.url || "");
+      url = url.replaceAll(/([^:]\/)\/+/g, "$1");
+      if (opts.fragment) url.includes("#") ? url.replace(/#.*([?\n])/g, (match, arg1) => `#${opts.fragment}${arg1}`) : `${url}#${opts.fragment}`;
+      if (opts.query) {
+        const q = Array.isArray(opts.query) ? opts.query : Object.keys(opts.query).map((k) => ({ key: k, value: opts.query[k] }));
+        url += (url.includes("?") ? "&" : "?") + q.map((q2) => `${q2.key}=${q2.value}`).join("&");
+      }
+      const headers = clean({
+        "Content-Type": !opts.body ? void 0 : opts.body instanceof FormData ? "multipart/form-data" : "application/json",
+        ...Http.headers,
+        ...this.headers,
+        ...opts.headers
+      });
+      if (typeof opts.body == "object" && opts.body != null && headers["Content-Type"] == "application/json")
+        opts.body = JSON.stringify(opts.body);
+      return new PromiseProgress((res, rej, prog) => {
+        try {
+          fetch(url, {
+            headers,
+            method: opts.method || (opts.body ? "POST" : "GET"),
+            body: opts.body
+          }).then(async (resp) => {
+            for (let fn2 of [...Object.values(Http.interceptors), ...Object.values(this.interceptors)]) {
+              await new Promise((res2) => fn2(resp, () => res2()));
+            }
+            const contentLength = resp.headers.get("Content-Length");
+            const total = contentLength ? parseInt(contentLength, 10) : 0;
+            let loaded = 0;
+            const reader = resp.body?.getReader();
+            const stream = new ReadableStream({
+              start(controller) {
+                function push() {
+                  reader?.read().then((event) => {
+                    if (event.done) return controller.close();
+                    loaded += event.value.byteLength;
+                    prog(loaded / total);
+                    controller.enqueue(event.value);
+                    push();
+                  }).catch((error) => controller.error(error));
+                }
+                push();
+              }
+            });
+            resp = new HttpResponse(resp, stream);
+            if (opts.decode !== false) {
+              const content = resp.headers.get("Content-Type")?.toLowerCase();
+              if (content?.includes("form")) resp.data = await resp.formData();
+              else if (content?.includes("json")) resp.data = await resp.json();
+              else if (content?.includes("text")) resp.data = await resp.text();
+              else if (content?.includes("application")) resp.data = await resp.blob();
+            }
+            if (resp.ok) res(resp);
+            else rej(resp);
+          }).catch((err) => rej(err));
+        } catch (err) {
+          rej(err);
+        }
+      });
+    }
+  }
+  var LOG_LEVEL = /* @__PURE__ */ ((LOG_LEVEL2) => {
+    LOG_LEVEL2[LOG_LEVEL2["ERROR"] = 0] = "ERROR";
+    LOG_LEVEL2[LOG_LEVEL2["WARN"] = 1] = "WARN";
+    LOG_LEVEL2[LOG_LEVEL2["INFO"] = 2] = "INFO";
+    LOG_LEVEL2[LOG_LEVEL2["LOG"] = 3] = "LOG";
+    LOG_LEVEL2[LOG_LEVEL2["DEBUG"] = 4] = "DEBUG";
+    return LOG_LEVEL2;
+  })(LOG_LEVEL || {});
+  function PE(str, ...args) {
+    const combined = [];
+    for (let i = 0; i < str.length || i < args.length; i++) {
+      if (str[i]) combined.push(str[i]);
+      if (args[i]) combined.push(args[i]);
+    }
+    return new PathEvent(combined.join("/"));
+  }
+  function PES(str, ...args) {
+    let combined = [];
+    for (let i = 0; i < str.length || i < args.length; i++) {
+      if (str[i]) combined.push(str[i]);
+      if (args[i]) combined.push(args[i]);
+    }
+    const [paths, methods] = combined.join("/").split(":");
+    return PathEvent.toString(paths, methods?.split(""));
+  }
+  class PathError extends Error {
+  }
+  class PathEvent {
+    /** First directory in path */
+    module;
+    /** Entire path, including the module & name */
+    fullPath;
+    /** Parent directory, excludes module & name */
+    dir;
+    /** Path including the name, excluding the module */
+    path;
+    /** Last segment of path */
+    name;
+    /** List of methods */
+    methods;
+    /** Whether this path contains glob patterns */
+    hasGlob;
+    /** Internal cache for PathEvent instances to avoid redundant parsing */
+    static pathEventCache = /* @__PURE__ */ new Map();
+    /** Cache for compiled permissions (path + required permissions → result) */
+    static permissionCache = /* @__PURE__ */ new Map();
+    /** Max size for permission cache before LRU eviction */
+    static MAX_PERMISSION_CACHE_SIZE = 1e3;
+    /** All/Wildcard specified */
+    get all() {
+      return this.methods.has("*");
+    }
+    set all(v) {
+      v ? this.methods = new ASet(["*"]) : this.methods.delete("*");
+    }
+    /** None specified */
+    get none() {
+      return this.methods.has("n");
+    }
+    set none(v) {
+      v ? this.methods = new ASet(["n"]) : this.methods.delete("n");
+    }
+    /** Create method specified */
+    get create() {
+      return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("c"));
+    }
+    set create(v) {
+      v ? this.methods.delete("n").delete("*").add("c") : this.methods.delete("c");
+    }
+    /** Execute method specified */
+    get execute() {
+      return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("x"));
+    }
+    set execute(v) {
+      v ? this.methods.delete("n").delete("*").add("x") : this.methods.delete("x");
+    }
+    /** Read method specified */
+    get read() {
+      return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("r"));
+    }
+    set read(v) {
+      v ? this.methods.delete("n").delete("*").add("r") : this.methods.delete("r");
+    }
+    /** Update method specified */
+    get update() {
+      return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("u"));
+    }
+    set update(v) {
+      v ? this.methods.delete("n").delete("*").add("u") : this.methods.delete("u");
+    }
+    /** Delete method specified */
+    get delete() {
+      return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("d"));
+    }
+    set delete(v) {
+      v ? this.methods.delete("n").delete("*").add("d") : this.methods.delete("d");
+    }
+    constructor(e) {
+      if (typeof e == "object") {
+        Object.assign(this, e);
+        return;
+      }
+      if (PathEvent.pathEventCache.has(e)) {
+        Object.assign(this, PathEvent.pathEventCache.get(e));
+        return;
+      }
+      let [p, method] = e.replaceAll(/(^|\/)\*+\/?$/g, "").split(":");
+      if (!method) method = "*";
+      if (p === "" || p === void 0 || p === "*") {
+        this.module = "";
+        this.path = "";
+        this.dir = "";
+        this.fullPath = "**";
+        this.name = "";
+        this.methods = new ASet(p === "*" ? ["*"] : method.split(""));
+        this.hasGlob = true;
+        PathEvent.pathEventCache.set(e, this);
+        return;
+      }
+      let temp = p.split("/").filter((p2) => !!p2);
+      this.module = temp.splice(0, 1)[0] || "";
+      this.path = temp.join("/");
+      this.dir = temp.length > 2 ? temp.slice(0, -1).join("/") : "";
+      this.fullPath = `${this.module}${this.module && this.path ? "/" : ""}${this.path}`;
+      this.name = temp.pop() || "";
+      this.hasGlob = this.fullPath.includes("*");
+      this.methods = new ASet(method.split(""));
+      PathEvent.pathEventCache.set(e, this);
+    }
+    /**
+     * Check if a filter pattern matches a target path
+     * @private
+     */
+    static matches(pattern, target) {
+      const methodsMatch = pattern.all || target.all || pattern.methods.intersection(target.methods).length > 0;
+      if (!methodsMatch) return false;
+      if (!pattern.hasGlob && !target.hasGlob) {
+        const last = pattern.fullPath[target.fullPath.length];
+        return pattern.fullPath.startsWith(target.fullPath) && (last == null || last == "/");
+      }
+      if (pattern.hasGlob) return this.pathMatchesGlob(target.fullPath, pattern.fullPath);
+      return this.pathMatchesGlob(pattern.fullPath, target.fullPath);
+    }
+    /**
+     * Check if a path matches a glob pattern
+     * @private
+     */
+    static pathMatchesGlob(path, pattern) {
+      if (pattern === path) return true;
+      const pathParts = path.split("/").filter((p) => !!p);
+      const patternParts = pattern.split("/").filter((p) => !!p);
+      let pathIdx = 0;
+      let patternIdx = 0;
+      while (patternIdx < patternParts.length && pathIdx < pathParts.length) {
+        const patternPart = patternParts[patternIdx];
+        if (patternPart === "**") {
+          if (patternIdx === patternParts.length - 1) return true;
+          while (pathIdx < pathParts.length) {
+            if (PathEvent.pathMatchesGlob(pathParts.slice(pathIdx).join("/"), patternParts.slice(patternIdx + 1).join("/"))) return true;
+            pathIdx++;
+          }
+          return false;
+        } else if (patternPart === "*") {
+          pathIdx++;
+          patternIdx++;
+        } else {
+          if (patternPart !== pathParts[pathIdx]) return false;
+          pathIdx++;
+          patternIdx++;
+        }
+      }
+      if (patternIdx < patternParts.length) return patternParts.slice(patternIdx).every((p) => p === "**");
+      return pathIdx === pathParts.length;
+    }
+    /**
+     * Score a path for specificity ranking (lower = more specific = higher priority)
+     * @private
+     */
+    static scoreSpecificity(path) {
+      if (path === "**" || path === "") return Number.MAX_SAFE_INTEGER;
+      const segments = path.split("/").filter((p) => !!p);
+      let score = -segments.length;
+      segments.forEach((seg) => {
+        if (seg === "**") score += 0.5;
+        else if (seg === "*") score += 0.25;
+      });
+      return score;
+    }
+    /** Clear the cache of all PathEvents */
+    static clearCache() {
+      PathEvent.pathEventCache.clear();
+    }
+    /** Clear the permission cache */
+    static clearPermissionCache() {
+      PathEvent.permissionCache.clear();
+    }
+    /**
+     * Combine multiple events into one parsed object. Longest path takes precedent, but all subsequent methods are
+     * combined until a "none" is reached
+     *
+     * @param {string | PathEvent} paths Events as strings or pre-parsed
+     * @return {PathEvent} Final combined permission
+     */
+    static combine(...paths) {
+      const parsed = paths.map((p) => p instanceof PathEvent ? p : new PathEvent(p));
+      const sorted = parsed.toSorted((p1, p2) => {
+        const score1 = PathEvent.scoreSpecificity(p1.fullPath);
+        const score2 = PathEvent.scoreSpecificity(p2.fullPath);
+        return score1 - score2;
+      });
+      let result = null;
+      for (const p of sorted) {
+        if (!result) {
+          result = p;
+        } else {
+          if (result.fullPath.startsWith(p.fullPath)) {
+            if (p.none) break;
+            result.methods = new ASet([...result.methods, ...p.methods]);
+          }
+        }
+      }
+      return result || new PathEvent("");
+    }
+    /**
+     * Filter a set of paths based on the target
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of events that will filtered
+     * @param filter {...PathEvent} Must contain one of
+     * @return {PathEvent[]} Filtered results
+     */
+    static filter(target, ...filter) {
+      const parsedTarget = makeArray(target).map((pe) => pe instanceof PathEvent ? pe : new PathEvent(pe));
+      const parsedFilter = makeArray(filter).map((pe) => pe instanceof PathEvent ? pe : new PathEvent(pe));
+      return parsedTarget.filter((t) => !!parsedFilter.find((r) => PathEvent.matches(r, t)));
+    }
+    /**
+     * Squash 2 sets of paths & return true if any overlap is found
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
+     * @param has Target must have at least one of these path
+     * @return {boolean} Whether there is any overlap
+     */
+    static has(target, ...has) {
+      const parsedTarget = makeArray(target).map((pe) => pe instanceof PathEvent ? pe : new PathEvent(pe));
+      const parsedRequired = makeArray(has).map((pe) => pe instanceof PathEvent ? pe : new PathEvent(pe));
+      return !!parsedRequired.find((r) => !!parsedTarget.find((t) => PathEvent.matches(r, t)));
+    }
+    /**
+     * Squash 2 sets of paths & return true if the target has all paths
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
+     * @param has Target must have all these paths
+     * @return {boolean} Whether all are present
+     */
+    static hasAll(target, ...has) {
+      return has.filter((h) => PathEvent.has(target, h)).length == has.length;
+    }
+    /**
+     * Same as `has` but raises an error if there is no overlap
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
+     * @param has Target must have at least one of these path
+     */
+    static hasFatal(target, ...has) {
+      if (!PathEvent.has(target, ...has)) throw new PathError(`Requires one of: ${makeArray(has).join(", ")}`);
+    }
+    /**
+     * Same as `hasAll` but raises an error if the target is missing any paths
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
+     * @param has Target must have all these paths
+     */
+    static hasAllFatal(target, ...has) {
+      if (!PathEvent.hasAll(target, ...has)) throw new PathError(`Requires all: ${makeArray(has).join(", ")}`);
+    }
+    /**
+     * Create event string from its components
+     *
+     * @param {string | string[]} path Event path
+     * @param {Method} methods Event method
+     * @return {string} String representation of Event
+     */
+    static toString(path, methods) {
+      let p = makeArray(path).filter((p2) => !!p2).join("/");
+      p = p?.trim().replaceAll(/\/{2,}/g, "/").replaceAll(/(^\/|\/$)/g, "");
+      if (methods?.length) p += `:${makeArray(methods).map((m) => m.toLowerCase()).join("")}`;
+      return p;
+    }
+    /**
+     * Squash 2 sets of paths & return true if any overlap is found
+     *
+     * @param has Target must have at least one of these path
+     * @return {boolean} Whether there is any overlap
+     */
+    has(...has) {
+      return PathEvent.has(this, ...has);
+    }
+    /**
+     * Squash 2 sets of paths & return true if the target has all paths
+     *
+     * @param has Target must have all these paths
+     * @return {boolean} Whether all are present
+     */
+    hasAll(...has) {
+      return PathEvent.hasAll(this, ...has);
+    }
+    /**
+     * Same as `has` but raises an error if there is no overlap
+     *
+     * @param has Target must have at least one of these path
+     */
+    hasFatal(...has) {
+      return PathEvent.hasFatal(this, ...has);
+    }
+    /**
+     * Same as `hasAll` but raises an error if the target is missing any paths
+     *
+     * @param has Target must have all these paths
+     */
+    hasAllFatal(...has) {
+      return PathEvent.hasAllFatal(this, ...has);
+    }
+    /**
+     * Filter a set of paths based on this event
+     *
+     * @param {string | PathEvent | (string | PathEvent)[]} target Array of events that will filtered
+     * @return {PathEvent[]} Filtered results
+     */
+    filter(target) {
+      return PathEvent.filter(target, this);
+    }
+    /**
+     * Create event string from its components
+     *
+     * @return {string} String representation of Event
+     */
+    toString() {
+      return PathEvent.toString(this.fullPath, this.methods);
+    }
+  }
+  class PathEventEmitter {
+    constructor(prefix = "") {
+      this.prefix = prefix;
+    }
+    listeners = [];
+    emit(event, ...args) {
+      const parsed = event instanceof PathEvent ? event : new PathEvent(`${this.prefix}/${event}`);
+      this.listeners.filter((l) => PathEvent.has(l[0], parsed)).forEach((l) => l[1](parsed, ...args));
+    }
+    off(listener) {
+      this.listeners = this.listeners.filter((l) => l[1] != listener);
+    }
+    on(event, listener) {
+      makeArray(event).forEach((e) => {
+        let fullEvent;
+        if (typeof e === "string") {
+          if (e[0] === ":" && this.prefix) {
+            fullEvent = `${this.prefix}${e}`;
+          } else if (this.prefix) {
+            fullEvent = `${this.prefix}/${e}`;
+          } else {
+            fullEvent = e;
+          }
+        } else {
+          fullEvent = e instanceof PathEvent ? PathEvent.toString(e.fullPath, e.methods) : e;
+        }
+        this.listeners.push([
+          new PathEvent(fullEvent),
+          listener
+        ]);
+      });
+      return () => this.off(listener);
+    }
+    once(event, listener) {
+      return new Promise((res) => {
+        const unsubscribe = this.on(event, (event2, ...args) => {
+          res(args.length < 2 ? args[0] : args);
+          if (listener) listener(event2, ...args);
+          unsubscribe();
+        });
+      });
+    }
+    relayEvents(emitter) {
+      emitter.on("**", (event, ...args) => this.emit(event, ...args));
+    }
+  }
+  var dist = {};
+  var persist = {};
+  var hasRequiredPersist;
+  function requirePersist() {
+    if (hasRequiredPersist) return persist;
+    hasRequiredPersist = 1;
+    Object.defineProperty(persist, "__esModule", { value: true });
+    persist.persist = persist.Persist = void 0;
+    class Persist {
+      key;
+      options;
+      /** Backend service to store data, must implement `Storage` interface */
+      storage;
+      /** Listeners which should be notified on changes */
+      watches = {};
+      /** Private value field */
+      _value;
+      /** Current value or default if undefined */
+      get value() {
+        return this._value !== void 0 ? this._value : this.options?.default;
+      }
+      /** Set value with proxy object wrapper to sync future changes */
+      set value(v) {
+        if (v == null || typeof v != "object")
+          this._value = v;
+        else
+          this._value = new Proxy(v, {
+            get: (target, p) => {
+              const f = typeof target[p] == "function";
+              if (!f)
+                return target[p];
+              return (...args) => {
+                const value = target[p](...args);
+                this.save();
+                return value;
+              };
+            },
+            set: (target, p, newValue) => {
+              target[p] = newValue;
+              this.save();
+              return true;
+            }
+          });
+        this.save();
+      }
+      /**
+       * @param {string} key Primary key value will be stored under
+       * @param {PersistOptions<T>} options Configure using {@link PersistOptions}
+       */
+      constructor(key, options = {}) {
+        this.key = key;
+        this.options = options;
+        this.storage = options.storage || localStorage;
+        this.load();
+      }
+      /** Notify listeners of change */
+      notify(value) {
+        Object.values(this.watches).forEach((watch) => watch(value));
+      }
+      /** Delete value from storage */
+      clear() {
+        this.storage.removeItem(this.key);
+      }
+      /** Save current value to storage */
+      save() {
+        if (this._value === void 0)
+          this.clear();
+        else
+          this.storage.setItem(this.key, JSON.stringify(this._value));
+        this.notify(this.value);
+      }
+      /** Load value from storage */
+      load() {
+        if (this.storage[this.key] != void 0) {
+          let value = JSON.parse(this.storage.getItem(this.key));
+          if (value != null && typeof value == "object" && this.options.type)
+            value.__proto__ = this.options.type.prototype;
+          this.value = value;
+        } else
+          this.value = this.options.default || void 0;
+      }
+      /**
+       * Callback function which is run when there are changes
+       *
+       * @param {(value: T) => any} fn Callback will run on each change; it's passed the next value & it's return is ignored
+       * @returns {() => void} Function which will unsubscribe the watch/callback when called
+       */
+      watch(fn2) {
+        const index = Object.keys(this.watches).length;
+        this.watches[index] = fn2;
+        return () => {
+          delete this.watches[index];
+        };
+      }
+      /**
+       * Return value as JSON string
+       *
+       * @returns {string} Stringified object as JSON
+       */
+      toString() {
+        return JSON.stringify(this.value);
+      }
+      /**
+       * Return current value
+       *
+       * @returns {T} Current value
+       */
+      valueOf() {
+        return this.value;
+      }
+    }
+    persist.Persist = Persist;
+    function persist$1(options) {
+      return (target, prop) => {
+        const key = options?.key || `${target.constructor.name}.${prop.toString()}`;
+        const wrapper = new Persist(key, options);
+        Object.defineProperty(target, prop, {
+          get: function() {
+            return wrapper.value;
+          },
+          set: function(v) {
+            wrapper.value = v;
+          }
+        });
+      };
+    }
+    persist.persist = persist$1;
+    return persist;
+  }
+  var memoryStorage = {};
+  var hasRequiredMemoryStorage;
+  function requireMemoryStorage() {
+    if (hasRequiredMemoryStorage) return memoryStorage;
+    hasRequiredMemoryStorage = 1;
+    Object.defineProperty(memoryStorage, "__esModule", { value: true });
+    memoryStorage.MemoryStorage = void 0;
+    class MemoryStorage {
+      get length() {
+        return Object.keys(this).length;
+      }
+      clear() {
+        Object.keys(this).forEach((k) => this.removeItem(k));
+      }
+      getItem(key) {
+        return this[key];
+      }
+      key(index) {
+        return Object.keys(this)[index];
+      }
+      removeItem(key) {
+        delete this[key];
+      }
+      setItem(key, value) {
+        this[key] = value;
+      }
+    }
+    memoryStorage.MemoryStorage = MemoryStorage;
+    return memoryStorage;
+  }
+  var hasRequiredDist;
+  function requireDist() {
+    if (hasRequiredDist) return dist;
+    hasRequiredDist = 1;
+    (function(exports$1) {
+      var __createBinding = dist && dist.__createBinding || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === void 0) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = { enumerable: true, get: function() {
+            return m[k];
+          } };
+        }
+        Object.defineProperty(o, k2, desc);
+      }) : (function(o, m, k, k2) {
+        if (k2 === void 0) k2 = k;
+        o[k2] = m[k];
+      }));
+      var __exportStar = dist && dist.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
+      };
+      Object.defineProperty(exports$1, "__esModule", { value: true });
+      __exportStar(requirePersist(), exports$1);
+      __exportStar(requireMemoryStorage(), exports$1);
+    })(dist);
+    return dist;
+  }
+  requireDist();
+  function treeBuilder(schemas) {
+    const tree = [];
+    function findOrCreateNode(tree2, segment, fullPath) {
+      let node = tree2.find((n) => n.name === segment);
+      if (!node) {
+        node = {
+          name: segment,
+          path: fullPath,
+          description: null,
+          children: []
+        };
+        tree2.push(node);
+      }
+      return node;
+    }
+    for (const s of schemas) {
+      const segments = s.path.split("/");
+      let currentLevel = tree;
+      let currentPath = "";
+      segments.forEach((segment, index) => {
+        const isLast = index === segments.length - 1;
+        currentPath += currentPath ? `/${segment}` : segment;
+        let node = findOrCreateNode(currentLevel, segment, currentPath);
+        if (isLast) Object.assign(node, s, { autoIncrement: void 0, exists: true });
+        currentLevel = node.children;
+      });
+    }
+    function sortTree(tree2) {
+      tree2.sort((a, b) => a.name.localeCompare(b.name));
+      for (const node of tree2) {
+        if (node.children && node.children.length > 0) {
+          sortTree(node.children);
+        }
+      }
+    }
+    sortTree(tree);
+    return tree;
+  }
+  function validEvent(event) {
+    return !![
+      "*",
+      "actions",
+      "ai",
+      "analytics",
+      "auth",
+      "call",
+      "data",
+      "discounts",
+      "email",
+      "forms",
+      "groups",
+      "payments",
+      "pdf",
+      "schema",
+      "settings",
+      "sms",
+      "static",
+      "storage",
+      "token",
+      "tools",
+      "users"
+    ].find((e) => event.startsWith(e));
+  }
+  class AssetController extends PathEventEmitter {
+    constructor(momentum, opts) {
+      super();
+      this.momentum = momentum;
+      this.opts = { storage: null, key: "_id", ...opts };
+      if (!this.opts.storage && this.momentum.opts?.offline)
+        this.opts.storage = { storage: momentum.database, key: "_" + this.opts.module };
+      this.cache = new Cache("_id", { persistentStorage: this.opts.storage });
+      this.momentum.auth.on("login:d", (e) => this.cache.clear());
+      this.on(this.opts.module, (event, payload) => {
+        if (Array.isArray(payload)) {
+          this.cache.addAll(payload);
+        } else if ((event.create || event.update || event.read) && payload != null) {
+          this.cache.add(payload);
+        } else if (event.delete || payload == null) {
+          if (!event.path) return this.cache.clear();
+          const id = this.opts.key == "_id" ? event.name : this.cache.find({ [this.opts.key]: event.path })?._id;
+          if (id != null) this.cache.delete(id);
+        }
+      });
+    }
+    subscribers = {};
+    cache;
+    opts;
+    /**
+     * Process raw data before caching & returning
+     * @hidden
+     */
+    afterRead(value) {
+      return value;
+    }
+    /**
+     * Process raw data before sending
+     * @hidden
+     */
+    beforeWrite(value) {
+      return value;
+    }
+    /**
+     * Fetch all assets as array
+     * @param {boolean} reload Force reload instead of using cache
+     * @return {Promise<T[]>} All assets as array
+     */
+    async all(reload) {
+      await this.cache.loading;
+      if (!reload && this.cache.complete) return this.cache.all();
+      let resp = await this.momentum.api.request({ url: `api/${this.opts.path || this.opts.module}` });
+      resp = resp.map((v) => this.afterRead(v));
+      this.emit(PES`${this.opts.module}:r`, resp);
+      return resp;
+    }
+    /**
+     * Create new asset
+     * @param {T} value Asset that will be created
+     * @return {Promise<T>} Saved result
+     */
+    async create(value) {
+      await this.cache.loading;
+      let resp = await this.momentum.api.request({
+        url: `api/${this.opts.path || this.opts.module}`,
+        method: "POST",
+        body: this.beforeWrite(value)
+      });
+      resp = this.afterRead(resp);
+      this.emit(PES`${this.opts.module}/${resp[this.opts.key]}:c`, resp);
+      return resp;
+    }
+    /**
+     * Delete asset
+     * @param {string} key Asset primary key
+     * @return {Promise<number>} Returns on success
+     */
+    async delete(key) {
+      await this.cache.loading;
+      const count = await this.momentum.api.request({ url: `api/${this.opts.path || this.opts.module}/${key || ""}`, method: "DELETE" });
+      if (count) this.emit(PES`${this.opts.module}/${key}:d`, key);
+      return count;
+    }
+    /**
+     * Read single asset
+     * @param {string} key Asset primary key
+     * @param {boolean} reload Force reload instead of using cache
+     * @return {Promise<T>} Discovered asset
+     */
+    async read(key, reload) {
+      await this.cache.loading;
+      const cached = !reload ? this.cache.find({ [this.opts.key]: key }) : null;
+      let resp = cached || await this.momentum.api.request({ url: `api/${this.opts.path || this.opts.module}/${key || ""}` });
+      resp = this.afterRead(resp);
+      this.emit(PES`${this.opts.module}/${key}:r`, resp);
+      return resp;
+    }
+    /**
+     * Update exiting asset
+     * @param {T} value Asset that will be updated
+     * @return {Promise<T>} Saved result
+     */
+    async update(value) {
+      await this.cache.loading;
+      let resp = await this.momentum.api.request({
+        url: `api/${this.opts.path || this.opts.module}/${value[this.opts.key] || ""}`,
+        method: "PATCH",
+        body: this.beforeWrite(value)
+      });
+      resp = this.afterRead(resp);
+      this.emit(PES`${this.opts.module}/${value[this.opts.key]}:u`, resp);
+      return resp;
+    }
+    /**
+     * Subscribe to live updates with callback
+     * @param {(value: T[]) => any | null} callback Received changes
+     * @param opts Additional options: path - scope to events within path, reload - Re-fetch even if cached
+     * @return {() => void} Function to unsubscribe
+     */
+    sync(callback, opts = {}) {
+      const e = PE`${this.opts.module}/${opts.path || ""}`;
+      const unsubscribe = callback ? this.on(e.toString(), (event) => callback(event, this.cache.all())) : null;
+      if (callback) callback(e, this.cache.all());
+      if (opts.reload !== false || !this.cache.complete) this.all(true);
+      if (!this.subscribers.length) this.momentum.socket?.subscribe(e.toString());
+      const key = Object.keys(this.subscribers).length.toString();
+      this.subscribers[key] = () => {
+        if (unsubscribe) unsubscribe();
+        delete this.subscribers[key];
+        if (!this.subscribers.length) this.momentum.socket?.unsubscribe(e.toString());
+      };
+      return this.subscribers[key];
+    }
+  }
+  class TreeAssetController extends AssetController {
+    /**
+     * Get all schemas organized into a map
+     * @param {boolean} reload Reload instead of using cache
+     * @return {Promise<TreeNode<Schema>[]>} Schemas as a map
+     */
+    async map(reload) {
+      const rows = await this.all(reload);
+      return treeBuilder(rows);
+    }
+    /**
+     * Subscribe to live updates with optional callback
+     * @param {(schema: Schema[]) => any} callback Receives latest data
+     * @param opts path - scope events, tree - return as a map or array
+     * @return {() => void}
+     */
+    sync(callback, opts = {}) {
+      return super.sync(
+        callback ? (event, value) => callback(event, opts.map ? treeBuilder(value) : value) : void 0,
+        { reload: true, ...opts }
+      );
+    }
+  }
+  var ActionType = /* @__PURE__ */ ((ActionType2) => {
+    ActionType2[ActionType2["DELETE"] = 0] = "DELETE";
+    ActionType2[ActionType2["POST"] = 1] = "POST";
+    ActionType2[ActionType2["PATCH"] = 2] = "PATCH";
+    ActionType2[ActionType2["PUT"] = 3] = "PUT";
+    ActionType2[ActionType2["GET"] = 4] = "GET";
+    ActionType2[ActionType2["EVENT"] = 6] = "EVENT";
+    ActionType2[ActionType2["CRON"] = 5] = "CRON";
+    ActionType2[ActionType2["AI"] = 7] = "AI";
+    return ActionType2;
+  })(ActionType || {});
+  class Actions extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "actions", key: "_id" });
+      this.momentum = momentum;
+    }
+    /**
+     * Manually trigger an actions execution
+     * @param {string} id Action ID
+     * @param {HttpRequestOptions} opts Additional arguments
+     * @return {Promise<ActionResult>} All action output including console logs & return
+     */
+    debug(id, opts = {}) {
+      return this.momentum.api.request({ url: `api/actions/debug/${id}`, method: "POST", ...opts });
+    }
+    /**
+     * Run an HTTP action
+     * @param {string} path HTTP path excluding `/api/actions/run`
+     * @param {HttpRequestOptions} opts HTTP options
+     * @return {Promise<T>} HTTP response
+     */
+    run(path, opts = {}) {
+      return this.momentum.api.request({ ...opts, url: `api/actions/run/${path}` });
+    }
+  }
+  class Ai extends PathEventEmitter {
+    constructor(momentum) {
+      super("ai");
+      this.momentum = momentum;
+    }
+    /** Cancel current AI requests */
+    abort() {
+      return this.momentum.api.request({ url: "/api/ai/abort", method: "POST" });
+    }
+    /**
+     * Ask the AI assistant a question
+     * @param {string} question Users question
+     * @param {context: string, stream: Function} options context - Any hidden context information. stream - Receive response in chunks
+     * @return {Promise<string>} AI's response
+     */
+    async ask(question, options = {}) {
+      if (!question) throw new Error("Cannot ask AI, missing question");
+      const files = (await Promise.all((options?.files || []).map((f) => new Promise((res) => {
+        const reader = new FileReader();
+        reader.onload = () => res([f.name, reader.result]);
+        reader.readAsDataURL(f);
+      })))).reduce((acc, f) => ({ ...acc, [f[0]]: f[1] }), {});
+      const q = { question: question.trim(), context: options.context, files };
+      if (options.stream && this.momentum.socket?.connected) {
+        let unsub = () => {
+        };
+        return new Promise((res) => {
+          let buffer = "";
+          unsub = this.momentum.socket?.on("llm", (event, chunk) => {
+            options.stream?.(chunk);
+            if (chunk.text) buffer += chunk.text;
+            if (chunk.done) res(buffer);
+          });
+          this.momentum.socket?.send("llm", q);
+        }).finally(() => unsub());
+      } else {
+        return this.momentum.api.request({ url: `api/ai`, method: "POST", body: q }).then((resp) => {
+          this.emit(PES`:c`, resp);
+          return resp;
+        });
+      }
+    }
+    /**
+     * Clear AI assistant memory & context
+     * @return {Promise<void>} Resolves once complete
+     */
+    clear() {
+      return this.momentum.api.request({ url: "api/ai", method: "DELETE" }).then(() => this.emit(PES`:d`, this.momentum.api.token));
+    }
+    /**
+     * Current chat history
+     * @return {Promise<AiMessage[]>}
+     */
+    history() {
+      return this.momentum.api.request({ url: "api/ai" }).then((resp) => {
+        this.emit(PES`:r`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Get model info
+     * @return {AiInfo>} Model Info
+     */
+    info() {
+      return this.momentum.api.request({ url: "api/ai/info" });
+    }
+  }
+  let dialogCount = 0;
+  function createDialog(html, opts = {}) {
+    opts = {
+      backdrop: true,
+      css: void 0,
+      closeBtn: true,
+      position: "center",
+      ...opts
+    };
+    const counter = dialogCount++;
+    if (!document.querySelector("style.momentum-prompt")) {
+      const style2 = document.createElement("style");
+      style2.className = "momentum-prompt";
+      style2.innerHTML = `
+.momentum-backdrop {
+    position: fixed;
+    inset: 0;
+    backdrop-filter: blur(10px);
+    background: rgba(0, 0, 0, 0.5);
+    animation: fadeIn 0.5s ease-out forwards;
+    z-index: 9998;
+    &.closing { animation: fadeOut 0.5s ease-out forwards; }
+}
+
+.momentum-prompt {
+    box-sizing: border-box;
+    font-family: sans-serif;
+    position: fixed;
+    padding: 1rem;
+    width: 100%;
+    max-width: 350px;
+    background: #fff;
+    color: #4a5568;
+    border: 1px solid #fff3;
+    border-radius: 24px;
+    box-shadow: 0 20px 40px #0003;
+    overflow: hidden;
+    z-index: 9999;
+
+	&.center {
+		translate(-50%, -50%);
+		left: 50%;
+		top: 50%;
+		animation: slideInCenter 0.5s ease-out forwards;
+		&.closing { animation: slideOutCenter 0.5s ease-out forwards; }
+	}
+
+	&.corner {
+		right: 1rem;
+		bottom: 1rem;
+		animation: slideIn 0.5s ease-out forwards;
+		&.closing { animation: slideOut 0.5s ease-out forwards; }
+	}
+
+    .close {
+        position: absolute;
+        top: 8px;
+        right: 8px;
+        width: 32px;
+        height: 32px;
+        padding: 0;
+        padding-top: 4px;
+        border: none;
+        background: transparent;
+        border-radius: 50%;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.5s ease;
+        z-index: 1;
+        &:hover {
+            background: #71809633;
+            transform: scale(1.1);
+        }
+    }
+
+    .btn {
+        flex: 1;
+        padding: 14px 20px;
+        border: 1px solid #71809633;
+        border-radius: 12px;
+        background: #7180961a;
+        color: #718096;
+        font: 600 16px sans-serif;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        position: relative;
+        overflow: hidden;
+        &:hover {transform: translateY(-1px);}
+        &.btn-primary {
+            background: var(--theme-primary);
+            color: var(--theme-primary-contrast);
+            box-shadow: 0 4px 15px #667eea66;
+        }
+    }
+
+    .expand-toggle {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 6px;
+        width: 100%;
+        padding: 12px;
+        margin-top: 16px;
+        font-size: 13px;
+        background: none;
+        border: none;
+        border-radius: 8px;
+        color: #718096;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        &:hover { background-color: #7180961a; }
+    }
+
+    .expand-area {transition: all 0.4s ease;}
+
+    .hide {
+        margin: 0;
+        padding: 0;
+        border: 0;
+        height: 0;
+        overflow: hidden;
+    }
+}
+@keyframes slideInCenter {
+	from { transform: translate(-50%, calc(100vh + 2rem)) }
+	to { transform: translate(-50%, -50%) }
+}
+@keyframes slideOutCenter {
+	from { transform: translate(-50%, -50%) }
+	to { transform: translate(-50%, calc(100vh + 2rem)) }
+}
+@keyframes slideIn {
+	from { transform: translateY(calc(100% + 2rem)) }
+	to { transform: translateY(0) }
+}
+@keyframes slideOut {
+	from { transform: translateY(0) }
+	to { transform: translateY(calc(100% + 2rem)) }
+}
+@keyframes fadeIn {
+    from { opacity: 0 }
+    to { opacity: 1 }
+}
+@keyframes fadeOut {
+    from { opacity: 1 }
+    to { opacity: 0 }
+}`;
+      document.head.append(style2);
+    }
+    let style;
+    if (opts.css) {
+      style = document.createElement("style");
+      style.className = `momentum-prompt-${counter}`;
+      style.innerHTML = opts.css;
+      document.head.append(style);
+    }
+    let backdrop;
+    if (opts.backdrop) {
+      backdrop = document.createElement("div");
+      backdrop.className = `momentum-backdrop`;
+      document.body.append(backdrop);
+    }
+    const dialog = document.createElement("div");
+    dialog.className = "momentum-prompt";
+    dialog.classList.add(opts.position);
+    dialog.innerHTML = html;
+    document.body.append(dialog);
+    let htmlOverflow, bodyOverflow;
+    if (opts.backdrop && document.documentElement.style.overflow != "hidden") {
+      htmlOverflow = document.documentElement.style.overflow;
+      document.documentElement.style.overflow = "hidden";
+      bodyOverflow = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+    }
+    let resolve;
+    const done = new Promise((r) => resolve = r);
+    const close = (result) => {
+      resolve(result);
+      dialog.classList.add("closing");
+      if (backdrop) backdrop.classList.add("closing");
+      setTimeout(() => {
+        if (htmlOverflow) document.documentElement.style.overflow = htmlOverflow;
+        if (bodyOverflow) document.body.style.overflow = bodyOverflow;
+        dialog.remove();
+        if (backdrop) backdrop.remove();
+        if (style) style.remove();
+      }, 1e3);
+    };
+    if (opts.closeBtn) {
+      const btn = document.createElement("button");
+      btn.className = "close";
+      btn.innerHTML = '<div><svg height="18" viewBox="0 0 24 24"><path stroke="#718096" stroke-width="2" d="M5 5 L19 19 M19 5 L5 19" stroke-linecap="round" /></svg></div>';
+      btn.onclick = close;
+      dialog.prepend(btn);
+    }
+    return { close, dialog, result: done };
+  }
+  class Analytics extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "analytics", key: "_id" });
+      this.momentum = momentum;
+      if (this.momentum.client.isHeadless) {
+        this.performance = Promise.resolve(this._performance);
+      } else {
+        this.performance = Promise.all([
+          this.collectNavigationMetrics(),
+          this.collectLCPMetrics()
+        ]).then(() => this._performance);
+      }
+      if (!["anonymous", "force", "prompt", "manual", "false"].includes(this.momentum.opts.analytics.toString())) {
+        if (typeof this.opts.analytics === "string") this.id = this.opts.analytics;
+        if (this._ready) {
+          this._ready();
+          this._ready = null;
+        }
+        return;
+      }
+      if (this.momentum.opts.analytics !== false) {
+        if (this.momentum.client.storage) {
+          this.id = JSONAttemptParse(sessionStorage.getItem(`${this.momentum.url.host}:analytics`) || "null");
+          if (this.id) this.new = false;
+        }
+        this.momentum.auth.on("login:d", () => {
+          if (this.momentum.client.storage) sessionStorage.removeItem(`${this.momentum.url.host}:analytics`);
+          this._id = "";
+          this._consent = void 0;
+          this._new = true;
+        });
+        this.momentum.auth.on("login:c", async () => {
+          if (this.consent) await this.init();
+        });
+        if (this.momentum.opts.analytics == "force") this.consent = true;
+        else if (this.momentum.opts.analytics == "anonymous") {
+          this.consent = false;
+          this.init();
+        } else if (this.momentum.client.storage) {
+          const stored = localStorage.getItem(`${this.momentum.url.host}:consent`);
+          if (stored == "true") this.consent = true;
+          else if (stored && !this.canPromptAgain(stored)) {
+            this.consent = false;
+            this.init();
+          } else {
+            if (stored) localStorage.removeItem(`${this.momentum.url.host}:consent`);
+            this.init();
+          }
+        } else {
+          this.init();
+        }
+        if (this.consent == null && !this.momentum.client.isHeadless && this.momentum.opts.analytics == "prompt")
+          setTimeout(() => this.consentPrompt(), 1e3);
+      }
+    }
+    lastPage;
+    _ready;
+    ready = new Promise((res) => this._ready = res);
+    _performance = { fcp: 0, lcp: 0, ttfb: 0, dom: 0, total: 0 };
+    performance;
+    _consented;
+    consented = new Promise((res) => this._consented = res);
+    _consent;
+    get consent() {
+      return this._consent;
+    }
+    set consent(value) {
+      if (this._consent === value || value == null) return;
+      this._consent = value;
+      if (this.momentum.client.storage) {
+        if (value) localStorage.setItem(`${this.momentum.url.host}:consent`, "true");
+        else if (this.canPromptAgain()) localStorage.setItem(`${this.momentum.url.host}:consent`, (/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (this._consented) {
+        this._consented(this._consent);
+        this._consented = null;
+      }
+      this.emit(`${this.id}:x`, value);
+      if (value) this.init();
+    }
+    _id;
+    get id() {
+      return this._id;
+    }
+    set id(id) {
+      this._id = id;
+      if (this.momentum.client.storage) sessionStorage.setItem(`${this.momentum.url.host}:analytics`, id);
+      if (this.momentum.opts.credentialsStrategy == "auto" && !this.momentum.api.sameOrigin || this.momentum.opts.credentialsStrategy == "header")
+        this.momentum.api.headers["X-Analytics"] = id;
+    }
+    _new = true;
+    set new(val) {
+      this._new = val;
+    }
+    get new() {
+      return this._new;
+    }
+    canPromptAgain(date = localStorage.getItem(`${this.momentum.url.host}:consent`)) {
+      if (!date) return true;
+      if (date == "true") return false;
+      if (typeof date != "object") date = new Date(date);
+      return Date.now() - date.getTime() >= 6e4 * 60 * 24 * 30;
+    }
+    collectNavigationMetrics() {
+      return new Promise((res) => {
+        window.addEventListener("load", () => {
+          const nav = performance.getEntriesByType("navigation")[0];
+          if (nav) {
+            this._performance.ttfb = Math.round(nav.responseStart - nav.requestStart);
+            this._performance.dom = Math.round(nav.domContentLoadedEventEnd - nav.startTime);
+            this._performance.total = Math.round(nav.loadEventEnd - nav.startTime);
+          } else {
+            this._performance.dom = Date.now() - performance.timeOrigin;
+          }
+          try {
+            const paints = performance.getEntriesByType("paint");
+            const fcp = paints.find((e) => e.name === "first-contentful-paint");
+            if (fcp) this._performance.fcp = Math.round(fcp.startTime);
+          } catch {
+          }
+          res();
+        });
+      });
+    }
+    collectLCPMetrics() {
+      return new Promise((res) => {
+        let resolved = false;
+        try {
+          const lcpObserver = new PerformanceObserver((entryList) => {
+            const lcp = entryList.getEntries().pop();
+            if (lcp) this._performance.lcp = Math.round(lcp.startTime);
+            lcpObserver.disconnect();
+            if (!resolved) {
+              resolved = true;
+              res();
+            }
+          });
+          lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+          setTimeout(() => {
+            if (!resolved) {
+              lcpObserver.disconnect();
+              res();
+            }
+          }, 3e3);
+        } catch (_) {
+          res();
+        }
+      });
+    }
+    async init() {
+      if (!this.momentum.opts.analytics) return;
+      const performance2 = await this.performance;
+      this.id = await this.momentum.api.request({
+        url: `api/analytics`,
+        body: [
+          navigator?.language,
+          (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+          this.consent ? 1 : 0,
+          navigator?.hardwareConcurrency ?? null,
+          navigator?.deviceMemory ?? null,
+          this.momentum.client.isHeadless ? null : window.innerWidth,
+          this.momentum.client.isHeadless ? null : window.innerHeight,
+          await this.momentum.client.networkSpeed(),
+          performance2.fcp,
+          performance2.lcp,
+          performance2.ttfb,
+          performance2.dom,
+          performance2.total
+        ]
+      });
+      if (this._ready) {
+        this._ready();
+        this._ready = null;
+      }
+      if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
+        navigator.serviceWorker.controller.postMessage({ analyticsId: this.id });
+      this.page();
+      window.addEventListener("beforeunload", () => this.page("CLOSED"));
+      return this.id;
+    }
+    async consentPrompt(content) {
+      const settings = await this.momentum.settings.map();
+      const { close, dialog, result } = createDialog(`
+<div style="margin: 1rem; text-align: center">${content || `<p style="margin: 0;">This website uses cookies to improve your experience. ${settings.privacy_policy_url ? `For more information, please read our <a href="${this.momentum.url}${settings.privacy_policy_url}" target="_blank">Privacy Policy</a>.` : ""}</p>`}</div>
+<div style="display: flex; gap: 10px">
+    <button class="agree btn btn-primary" >Agree</button>
+    <button class="decline btn">Essential Only</button>
+</div>`, { backdrop: false, position: "corner" });
+      dialog.addEventListener("click", (e) => {
+        let t = e.target, depth = 0;
+        while (!!t && t.tagName != "BUTTON" && ++depth < 5) t = t.parentElement;
+        if (!t || t.tagName != "BUTTON") return;
+        if (t.matches(".agree")) close(true);
+        else if (t.matches(".decline")) close(false);
+      });
+      return result.then((consent) => {
+        this.consent = !!consent;
+        return this.consent;
+      });
+    }
+    async speedTest(format = false, bytes) {
+      let bps = 0;
+      if (!bytes) {
+        bps = await this.speedTest(false, 1024 * 1024);
+        if (bps > 1024 * 1024 * 10) bps = await this.speedTest(false, 1024 * 1024 * 20);
+      } else {
+        const start = performance.now();
+        await this.momentum.api.request({ url: `api/tools/dummy-file?size=${bytes}` });
+        const duration = (performance.now() - start) / 1e3;
+        bps = Math.ceil(bytes / duration);
+      }
+      return format ? formatBytes(bps, 2) : bps;
+    }
+    ipTrace(ip) {
+      return this.momentum.api.request({ url: `api/analytics/trace/${ip}` });
+    }
+    async metric(name, value, strategy = "add") {
+      if (!this.momentum.opts.analytics) return;
+      await this.ready;
+      return this.momentum.api.request({
+        url: "api/analytics/metric",
+        body: {
+          name: Array.isArray(name) ? name[0] : name,
+          category: Array.isArray(name) ? name[1] : null,
+          value,
+          strategy
+        }
+      }).then(() => this.emit(`${this.id}:u`));
+    }
+    async page(page = location.href, meta = {}) {
+      if (!this.momentum.opts.analytics || this.lastPage == page) return;
+      await this.ready;
+      return this.momentum.api.request({
+        url: "api/analytics/page",
+        body: { page, timestamp: /* @__PURE__ */ new Date(), meta }
+      }).then(() => {
+        this.lastPage = page;
+        this.emit(`${this.id}:u`);
+      });
+    }
+  }
+  class Api extends Http {
+    constructor(momentum) {
+      super({ ...momentum.opts.http, url: momentum.url.toString() });
+      this.momentum = momentum;
+      this.storageKey = `${this.momentum.url.host}:token`;
+      if (this.momentum.opts.persist && typeof localStorage != "undefined") {
+        const token = localStorage.getItem(this.storageKey);
+        if (token) this.token = token;
+      }
+    }
+    emitter = new PathEventEmitter("api");
+    pending = {};
+    storageKey;
+    get sameOrigin() {
+      if (typeof window == "undefined" || !window?.location) return false;
+      return window.location.host == this.momentum.url.host;
+    }
+    _token = null;
+    /** Current API token */
+    get token() {
+      return this._token;
+    }
+    set token(token) {
+      if (token == this._token) return;
+      this._token = token;
+      if (this.momentum.opts.credentialsStrategy == "auto" && !this.sameOrigin || this.momentum.opts.credentialsStrategy == "header") {
+        this.headers["Authorization"] = this._token ? `Bearer ${this._token}` : null;
+        if (this.momentum.opts.persist && typeof localStorage != "undefined") {
+          if (this._token) localStorage.setItem(this.storageKey, this._token);
+          else localStorage.removeItem(this.storageKey);
+        }
+      }
+      this.emit(`token:${token ? "c" : "d"}`, this._token);
+    }
+    // Path emitter functions
+    emit = this.emitter.emit.bind(this.emitter);
+    off = this.emitter.off.bind(this.emitter);
+    on = this.emitter.on.bind(this.emitter);
+    once = this.emitter.once.bind(this.emitter);
+    relayEvents = this.emitter.relayEvents.bind(this.emitter);
+    /**
+     * Fetch current Momentum status
+     * @return {Promise<Health>}
+     */
+    healthcheck() {
+      return this.request({ url: "api/tools/healthcheck" });
+    }
+    /**
+     * Create API request
+     * @param {HttpRequestOptions} options Request options
+     * @return {Promise} Response
+     */
+    request(options) {
+      const method = options.method == "GET" ? "r" : options.method == "POST" ? "c" : options.method == "DELETE" ? "d" : "u";
+      if (options.url) options.url = encodeURI(options.url.replaceAll("#", "%23"));
+      const key = options.url + method + (options.headers ? JSONSanitize(options.headers) : "") + (options.body ? JSONSanitize(options.body) : "");
+      if (this.pending[key] != null) return this.pending[key];
+      if (this.momentum.client?.captchaScore != null) {
+        if (!options.headers) options.headers = {};
+        options.headers["X-Captcha"] = (+this.momentum.client.captchaScore.toFixed(2)).toString();
+      }
+      this.pending[key] = super.request({ ...options, credentials: "include" }).then((response) => {
+        this.emit(`response:${method}`, { request: options, response });
+        return options.decode === false ? response : response.data;
+      }).catch((err) => {
+        const e = err?.data || err;
+        this.emit(`error:${method}`, { request: options, error: e });
+        throw e;
+      }).finally(() => delete this.pending[key]);
+      this.emit(PES`request:${method}`, { request: options, response: this.pending[key] });
+      return this.pending[key];
+    }
+  }
+  class Audit extends PathEventEmitter {
+    constructor(momentum) {
+      super("audit");
+      this.momentum = momentum;
+    }
+    async available(module2) {
+      return this.momentum.api.request({ url: `api/audit/${module2 || ""}` });
+    }
+    async history(module2, pk) {
+      if (!module2 || !pk) throw new Error("Module and primary key required to fetch audit history");
+      return this.momentum.api.request({ url: `api/audit/${module2}/${pk || ""}` });
+    }
+    async rollback(id) {
+      if (!id) throw new Error("Audit ID required to rollback");
+      return this.momentum.api.request({ url: `api/audit/${id}`, method: "PATCH" });
+    }
+  }
+  class Totp {
+    constructor(momentum) {
+      this.momentum = momentum;
+    }
+    /**
+     * Set default 2FA method
+     * @param {string} username User to set 2FA method on
+     * @param {string} method Default method, must be either: app, call, email, sms
+     * @returns {Promise<void>} Returns once complete
+     */
+    default(username, method) {
+      return this.momentum.api.request({ url: `/api/auth/totp/${username}`, method: "PUT", body: { method } });
+    }
+    /**
+     * Disable 2FA for user
+     * @param {string} username User to disable 2FA for
+     * @param password Confirm user password (Not required as admin)
+     * @return {Promise<void>} Resolves once complete
+     */
+    disable(username, password) {
+      return this.momentum.api.request({ url: `/api/auth/totp/${username}`, method: `DELETE`, body: { password } });
+    }
+    /**
+     * Enable 2FA for user
+     * @param {string} username User to reset
+     * @return {Promise<void>} Resolves once complete
+     */
+    enable = this.reset;
+    /**
+     * Reset users 2FA
+     * @param {string} username User to reset
+     * @param password Confirm user password (Not required as admin)
+     * @return {Promise<void>} Resolves once complete
+     */
+    reset(username, password) {
+      return this.momentum.api.request({ url: `/api/auth/totp/${username}`, method: "PATCH", body: { password } });
+    }
+    /**
+     * Fetch TOTP secret to set up authenticator
+     * @param {string} username
+     * @param password Confirm user password (Not required as admin)
+     * @returns {Promise<{secret: string, qr: string}>}
+     */
+    secret(username, password) {
+      return this.momentum.api.request({ url: `/api/auth/totp/${username}`, method: "POST", body: { password } });
+    }
+  }
+  class Auth extends PathEventEmitter {
+    constructor(momentum) {
+      super("auth");
+      this.momentum = momentum;
+      this.totp = new Totp(momentum);
+      this.momentum.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(PES`login:x`, this.momentum.api.token);
+        next();
+      });
+      this.on("login:x", async () => {
+        if (this.momentum.opts.expiredStrategy != "ignore") await this.momentum.auth.logout();
+        if (this.momentum.opts.expiredStrategy == "reload") window.location.reload();
+      });
+    }
+    /** Manage user 2FA */
+    totp;
+    session;
+    _user;
+    /** Get current user, undefined if not yet initialized */
+    get user() {
+      return this._user;
+    }
+    /** Update user info without changing the session */
+    set user(user) {
+      if (!isEqual(this.user, user)) {
+        this._user = user ? user : null;
+        this.emit(PES`login:${user ? "c" : "d"}`, this._user);
+      }
+    }
+    async handleLogin(reload = false) {
+      const urlParams = new URLSearchParams(window.location.search);
+      const token = urlParams.get("token");
+      let s;
+      if (!token) {
+        s = await this.readSession();
+      } else {
+        urlParams.delete("token");
+        history.replaceState(null, "", `${window.location.pathname}?${urlParams.toString()}`);
+        s = await this.readSession(token, true);
+      }
+      if (!s?.user) await this.loginRedirect();
+      if (reload && this.user) location.reload();
+      return this.session;
+    }
+    /**
+     * Check if origin is recognized & whitelisted
+     * @param {string} host Origin to check
+     * @return {Promise<void>} Resolves in known, 401 code otherwise
+     */
+    knownHost(host = location.origin) {
+      if (host.startsWith("/")) return Promise.resolve();
+      return this.momentum.api.request({ url: `api/auth/known-host?host=${encodeURI(new URL(host).origin)}` });
+    }
+    /**
+     * Login a user & return the account
+     * @param {string} id username
+     * @param {string} password user's password
+     * @param {{totp: string, totpMethod: TotpMethods, expire: null | number | Date}} opts 2FA code, 2FA code push method, and expiry options (null to never expire)
+     * @return {Promise<{reset?: string, token?: string} | null>} User account on success
+     */
+    login(id, password, opts) {
+      if (!id) throw new Error("Cannot login, missing ID or password");
+      if (opts?.totpMethod && !["call", "email", "sms"].includes(opts.totpMethod))
+        throw new Error(`Invalid 2FA method: ${opts.totpMethod}
+Must be either: call, email or sms`);
+      return this.momentum.api.request({
+        url: "api/auth/login",
+        headers: password ? { Authorization: void 0 } : void 0,
+        method: "POST",
+        body: clean({
+          username: id.trim(),
+          password: password?.trim(),
+          totp: opts?.totp ? opts.totp.toString() : void 0,
+          totpMethod: opts?.totpMethod,
+          expire: opts?.expire
+        }, true)
+      }).then(async (resp) => {
+        if (resp?.token) await this.readSession(resp.token, true);
+        return resp;
+      });
+    }
+    /**
+     * Login via Momentum single sign on
+     * @param {string} host Host origin attempting to login
+     * @return {Promise<string>} Token on success
+     */
+    loginRedirect(host = location.origin) {
+      return new Promise((res, rej) => {
+        let listener, win;
+        window.addEventListener("message", listener = async (event) => {
+          const data = event?.data || {};
+          if (event.origin != origin || data.sender != origin) return;
+          if (!data.token) return rej("Unknown response from login");
+          window.removeEventListener("message", listener);
+          await this.readSession(data.token, true);
+          win.close();
+          res(data.token);
+        });
+        win = window.open(`${this.momentum.opts.loginUrl}?redirect=postmessage&host=${encodeURI(host)}`, "_blank");
+        if (!win) {
+          window.removeEventListener("message", listener);
+          return rej("Unable to open login");
+        }
+      });
+    }
+    /**
+     * Logout current user
+     */
+    async logout() {
+      await this.momentum.api.request({ url: "api/auth/logout", method: "DELETE" });
+      this.momentum.api.token = this.session = this.user = null;
+      await this.readSession();
+    }
+    /**
+     * Create a new user with login
+     * @param {Partial<User> & {password: string}} user User data with password
+     * @return {Promise<User>} Registered user data
+     */
+    async register(user) {
+      if (!user._id || !user.password) throw new Error("Cannot register user, missing username or password");
+      const u = await this.momentum.api.request({ url: "api/auth/register", body: { ...user } });
+      this.momentum.users.emit(PES`:c`, u);
+      return u;
+    }
+    reset(emailOrPass, token) {
+      if (!emailOrPass) throw new Error("Cannot reset password, missing email or token");
+      return this.momentum.api.request({
+        url: "api/auth/reset",
+        headers: { "Authorization": token ? `Bearer ${token}` : void 0 },
+        method: "PATCH",
+        body: {
+          email: token ? void 0 : emailOrPass,
+          password: token ? emailOrPass : void 0
+        }
+      }).then(() => this.emit(PES`:u`, token ? { token } : { email: emailOrPass }));
+    }
+    /**
+     * Get session information
+     * @param {string} token Token to fetch session info for
+     * @param {boolean} set Set as current active session
+     * @return {Promise<{token: string, user: User, permissions: string[], custom: any} | null>} Session information
+     */
+    async readSession(token, set = false) {
+      const t = token || this.momentum.api.token;
+      const session = await this.momentum.api.request({
+        url: "api/auth/session",
+        headers: { "Authorization": t ? `Bearer ${t}` : void 0 }
+      });
+      if (!token || set) {
+        this.momentum.api.token = session?.token || null;
+        if (session?.user) session.user.image = `${this.momentum.url.toString().slice(0, -1)}${session.user.image}${!this.momentum.api.sameOrigin && this.momentum.api.token ? `?token=${this.momentum.api.token}` : ""}`;
+        this.session = session;
+        this.user = session?.user || null;
+      }
+      this.emit(PES`:r`, session);
+      return session;
+    }
+    /** Unlock an account that has been locked from too many login attempts */
+    async unlock(username) {
+      return this.momentum.api.request({ url: "api/auth/unlock", method: "PATCH", body: { username } }).then(() => this.emit(PES`:x`, username));
+    }
+    /**
+     * Update password for user
+     * @param {string} username User to reset
+     * @param {string} password New user password
+     * @param {string} oldPassword Old password for validation
+     * @return {Promise<void>} Resolves once complete
+     */
+    async updatePassword(username, password, oldPassword) {
+      if (!username || !password) throw new Error("Cannot update password, missing username or password");
+      return this.momentum.api.request({
+        url: "api/auth/password",
+        method: "PATCH",
+        body: oldPassword ? { username, password, oldPassword } : { username, password }
+      }).then((resp) => {
+        this.emit(PES`:u`, resp?.token);
+        if (resp?.token) this.momentum.api.token = resp.token;
+      });
+    }
+  }
+  class Call extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+    }
+    /**
+     * Place a call to number
+     * @param {Call} message Text that will be converted to speech
+     * @return {Promise<any>} Twilio call instance
+     */
+    create(message) {
+      return this.momentum.api.request({ url: "api/call", body: message }).then((resp) => this.emit(PES`call/${message.to}`, message));
+    }
+    /**
+     * Get available numbers and voice
+     */
+    info() {
+      return this.momentum.api.request({ url: "api/call" });
+    }
+  }
+  class Captcha {
+    start = Date.now();
+    events = { mouse: [], keys: [], clicks: [] };
+    lastMouse = null;
+    velocities = [];
+    _score = 0.5;
+    set score(v) {
+      this._score = v;
+    }
+    get score() {
+      return this._score;
+    }
+    get verdict() {
+      if (this.score == 0.5) return "unknown";
+      if (this.score > 0.5) return "human";
+      return "bot";
+    }
+    constructor() {
+      if (typeof window === "undefined" || !window.innerWidth || !this.validUserAgent()) {
+        this.score = 0;
+        return;
+      }
+      document.addEventListener("mousemove", (e) => {
+        const now = Date.now();
+        const curr = { x: e.clientX, y: e.clientY, t: now };
+        this.events.mouse.push(curr);
+        if (this.lastMouse) {
+          const dt = now - this.lastMouse.t;
+          const dx = curr.x - this.lastMouse.x;
+          const dy = curr.y - this.lastMouse.y;
+          const dist2 = Math.sqrt(dx * dx + dy * dy);
+          if (dt > 0) this.velocities.push(dist2 / dt);
+        }
+        this.lastMouse = curr;
+        if (this.events.mouse.length > 50) this.events.mouse.shift();
+        if (this.velocities.length > 30) this.velocities.shift();
+      });
+      document.addEventListener("keydown", (e) => {
+        this.events.keys.push(Date.now());
+        if (this.events.keys.length > 20) this.events.keys.shift();
+      });
+      document.addEventListener("click", (e) => {
+        this.events.clicks.push({ x: e.clientX, y: e.clientY, t: Date.now() });
+        if (this.events.clicks.length > 15) this.events.clicks.shift();
+      });
+      setInterval(() => this.update(), 1e3);
+    }
+    validUserAgent() {
+      if (!navigator?.userAgent) return false;
+      const ua = navigator.userAgent.toLowerCase();
+      if (["bot", "crawler", "spider", "scraper", "headless", "phantom", "selenium", "webdriver", "puppeteer", "playwright", "cypress", "automation"].some((pattern) => ua.includes(pattern))) return false;
+      if (!["chrome", "firefox", "safari", "edge", "opera"].some((browser) => ua.includes(browser))) return false;
+      if (!["windows", "mac", "linux", "android", "ios"].some((os) => ua.includes(os))) return false;
+      return ua.length > 20 && ua.length < 1e3;
+    }
+    update() {
+      const totalEvents = this.events.mouse.length + this.events.keys.length + this.events.clicks.length;
+      const timeBonus = Math.min((Date.now() - this.start) / 2e4, 0.15);
+      const activityBonus = totalEvents > 10 ? 0.15 : totalEvents > 3 ? 0.1 : 0;
+      let mouseScore = 0.6;
+      if (this.events.mouse.length > 5) {
+        const recent = this.events.mouse.slice(-15);
+        let changes = 0;
+        for (let i = 2; i < recent.length; i++) {
+          const a1 = Math.atan2(recent[i - 1].y - recent[i - 2].y, recent[i - 1].x - recent[i - 2].x);
+          const a2 = Math.atan2(recent[i].y - recent[i - 1].y, recent[i].x - recent[i - 1].x);
+          if (Math.abs(a1 - a2) > 0.5) changes++;
+        }
+        mouseScore = 0.6 + Math.min(changes / recent.length, 0.3);
+      }
+      let velocityScore = 0.7;
+      if (this.velocities.length > 5) {
+        const avg = this.velocities.reduce((a, b) => a + b, 0) / this.velocities.length;
+        if (avg > 0.01) velocityScore = 0.8;
+      }
+      let typingScore = 0.7;
+      if (this.events.keys.length > 2) {
+        const intervals = [];
+        for (let i = 1; i < this.events.keys.length; i++) {
+          intervals.push(this.events.keys[i] - this.events.keys[i - 1]);
+        }
+        const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+        if (avgInterval > 50 && avgInterval < 1e3) typingScore = 0.85;
+      }
+      const newScore = 0.6 + mouseScore * 0.25 + velocityScore * 0.2 + typingScore * 0.15 + timeBonus + activityBonus;
+      this.score = this.score * 0.8 + newScore * 0.2;
+      this.score = Math.max(0.3, Math.min(0.95, this.score));
+    }
+  }
+  class Client extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.momentum.on("analytics/speed", (event, bps) => {
+        if (this.storage) sessionStorage.setItem(`${this.momentum.url.host}:speed`, bps.toString());
+        this.momentum.client.speed = bps;
+      });
+      if (!this.isHeadless) {
+        window.addEventListener("beforeinstallprompt", (event) => {
+          event.preventDefault();
+          this.nativePwaPrompt = event;
+          this.emit("install:r");
+        });
+        if (this.storage && sessionStorage.getItem(`${this.momentum.url.host}:speed`)) {
+          this.speed = Promise.resolve(+sessionStorage.getItem(`${this.momentum.url.host}:speed`));
+        } else {
+          this.speed = new Promise((res) => {
+            window.addEventListener("load", async () => res(await this.momentum.analytics.speedTest()));
+          });
+        }
+      }
+    }
+    captcha = new Captcha();
+    installTimeout;
+    nativePwaPrompt;
+    pendingInstall = null;
+    speed;
+    updating = false;
+    get actorType() {
+      return this.captcha.verdict;
+    }
+    get captchaScore() {
+      return this.captcha.score;
+    }
+    /** Check for updates */
+    updateReady = new Promise((res) => {
+      if (!navigator.serviceWorker) return res(false);
+      navigator.serviceWorker.getRegistration().then((sw) => {
+        if (!sw) return res(false);
+        if (sw.waiting) return res(true);
+        const t = setTimeout(() => res(false), 1e4);
+        sw.addEventListener("updatefound", () => {
+          clearTimeout(t);
+          res(true);
+        });
+        sw.update();
+      }).catch(() => res(false));
+    });
+    /** Check if PWA can be installed */
+    get canInstall() {
+      return !!this.nativePwaPrompt;
+    }
+    /** Running inside a container */
+    get isApp() {
+      return this.isElectron || this.isIframe || this.isPwa;
+    }
+    /** Running inside an electron app */
+    get isElectron() {
+      return !!window.electronEnvironment;
+    }
+    /** Headless client without access to DOM */
+    get isHeadless() {
+      return typeof window == "undefined";
+    }
+    /** Running inside an iframe */
+    get isIframe() {
+      return parent?.location != location;
+    }
+    /** Running on a mobile device */
+    get isMobile() {
+      return ["android", "ios"].includes(this.platform);
+    }
+    _isPwa;
+    /** Running as a PWA */
+    get isPwa() {
+      if (this._isPwa == null)
+        this._isPwa = matchMedia("(display-mode: standalone)").matches || navigator?.standalone || document.referrer.includes("android-app://");
+      return this._isPwa;
+    }
+    _platform;
+    /** Get the current platform type */
+    get platform() {
+      if (!this._platform) {
+        const userAgent = navigator.userAgent || navigator.vendor;
+        if (/windows/i.test(userAgent)) this._platform = "windows";
+        else if (/android/i.test(userAgent)) this._platform = "android";
+        else if (/iPad|iPhone|iPod/.test(userAgent)) this._platform = "ios";
+        else if (/macintosh|mac os x/i.test(userAgent)) this._platform = "mac";
+        else if (/linux/i.test(userAgent)) this._platform = "linux";
+        else this._platform = "unknown";
+      }
+      return this._platform;
+    }
+    get storage() {
+      return typeof localStorage != "undefined";
+    }
+    /**
+     * Inject the client theme settings, meta tags & PWA prompt
+     * @param opts Injection options: reload - use cached settings or reload; pwa - disabled auto pwa prompt
+     * @return {Promise<void>} Resolves on completion
+     */
+    async inject(opts = {}) {
+      opts = { install: true, reload: void 0, ...opts };
+      let settings;
+      if (opts.reload == null) {
+        this.inject({ ...opts, reload: true });
+        await this.momentum.settings.cache.loading;
+        settings = this.momentum.settings.cache.entries().reduce((acc, [k, v]) => ({ ...acc, [k]: v.value }), {});
+      } else settings = await this.momentum.settings.map(opts.reload);
+      const meta = (key, name, value) => {
+        const exists = document.querySelector(`meta[${key}="${name}"]`);
+        if (value === void 0 || exists) return exists;
+        const meta2 = document.createElement("meta");
+        meta2.setAttribute(key, name);
+        meta2.content = value;
+        document.head.append(meta2);
+      };
+      document.querySelectorAll(".momentum-logo").forEach((el) => {
+        const size = el.src ? /[?&]size="?(.+)(?:"|&|$)/.exec(el.src) : null;
+        el.src = `${this.momentum.url.toString()}favicon.png${size ? `?size=${size[1]}` : ""}`;
+      });
+      document.querySelectorAll(`[class^="momentum-setting_"]`).forEach((el) => {
+        const keys = [...el.classList].find((c) => c.startsWith("momentum-setting_"))?.match(/momentum-setting_(.*)(?:\:(.+))?/);
+        if (el.tagName == "TITLE") return el.innerText = el.innerText.includes("|") ? `${el.innerText.split("|")[0].trim()} | ${settings["title"]}` : settings["title"];
+        else if (keys[1] == "contact" && el.tagName == "A") el.href = `mailto:${settings.contact}?subject=${settings.title} - ${document.title.split("|")[0]}`;
+        el.innerText = keys[2] ? dotNotation(settings[keys[1]], keys[2]) : settings[keys[1]];
+      });
+      meta("name", "description", settings["description"]);
+      meta("property", "og:title", settings["title"]);
+      meta("property", "og:description", settings["description"]);
+      meta("property", "og:image", `${settings["public_url"]}/banner.png?size=1200x630`);
+      meta("property", "og:logo", `${settings["public_url"]}/favicon.png?size=180`);
+      meta("property", "og:url", settings["public_url"]);
+      meta("property", "og:site_name", "Momentum");
+      meta("property", "og:type", "website");
+      meta("name", "twitter:card", "summary_large_image");
+      if (settings.modules?.["pwa"]) {
+        meta("name", "mobile-web-app-capable", "yes");
+        meta("name", "apple-mobile-web-app-status-bar-style", "default");
+        meta("name", "apple-mobile-web-app-title", settings["title"]);
+        meta("name", "apple-touch-icon", `${settings["public_url"]}/favicon.png`);
+        meta("name", "apple-touch-startup-image", `${settings["public_url"]}/favicon.png`);
+        if (!document.querySelector('link[rel="manifest"]')) {
+          const link = document.createElement("link");
+          link.setAttribute("rel", "manifest");
+          link.setAttribute("href", this.momentum.url.toString() + "manifest.json");
+          document.head.append(link);
+        }
+        if (opts.install !== false && !this.installTimeout && !this.isApp && !this.isHeadless) {
+          this.installTimeout = setTimeout(async () => {
+            this.installTimeout = null;
+            const dismissed = localStorage.getItem(`momentum:install`);
+            if (!dismissed || dismissed != "true" && Date.now() - new Date(dismissed).getTime() > 6e4 * 60 * 24 * this.momentum.opts.installPrompt.retry)
+              this.install();
+          }, 6e4 * this.momentum.opts.installPrompt.delay);
+        }
+      }
+      meta("name", "theme-color", settings["theme"]?.background);
+      if (!document.body.classList.contains("theme-manual")) {
+        document.body.classList.add(settings["theme"]?.darkMode ? "theme-dark" : "theme-light");
+        document.body.classList.remove(!settings["theme"]?.darkMode ? "theme-dark" : "theme-light");
+      }
+      const style = document.querySelector("style.momentum-theme") || document.createElement("style");
+      style.classList.add("momentum-theme");
+      style.innerHTML = `
+	:root {
+		--theme-backdrop: ${settings["theme"]?.background} !important;
+		--theme-backdrop-alt: ${settings["theme"]?.darkMode ? "rgba(0, 0, 0, 0.1)" : "rgba(0, 0, 0, 0.05)"} !important;
+		--theme-primary: ${settings["theme"]?.primary} !important;
+		--theme-accent: ${settings["theme"]?.accent} !important;
+		--theme-backdrop-contrast: ${contrast(settings["theme"]?.background)} !important;
+		--theme-primary-contrast: ${contrast(settings["theme"]?.primary)} !important;
+		--theme-accent-contrast: ${contrast(settings["theme"]?.accent)} !important;
+		--theme-font: ${settings["theme"]?.font} !important;
+	}
+		`;
+      if (!style.parentElement) document.head.append(style);
+      this.emit(PES`client/inject:c`, this.platform);
+      return settings;
+    }
+    async networkSpeed(format) {
+      if (typeof navigator != "undefined" && !navigator.onLine) return 0;
+      const speed = await this.speed;
+      return speed == -1 ? -1 : !format ? speed : formatBytes(speed, 2);
+    }
+    /**
+     * Create an installation prompt popup
+     * @param platform Platform specific prompt, leave blank to auto-detect
+     */
+    async install(platform = this.platform) {
+      if (this.pendingInstall) this.pendingInstall();
+      const settings = await this.momentum.settings.map();
+      if (!settings.pwa) throw new Error("Universal application isn't enabled");
+      this.emit("install:u");
+      const nativePrompt = platform == this.platform && this.nativePwaPrompt;
+      const features = [
+        { label: "Works Offline", icon: '<path d="M13 9h-2V7h2m0 10h-2v-6h2m-1-9A10 10 0 0 0 2 12a10 10 0 0 0 10 10 10 10 0 0 0 10-10A10 10 0 0 0 12 2"/>' },
+        { label: "Fast & Responsive", icon: '<path d="M12 15.5A3.5 3.5 0 0 1 8.5 12 3.5 3.5 0 0 1 12 8.5a3.5 3.5 0 0 1 3.5 3.5 3.5 3.5 0 0 1-3.5 3.5m7.43-2.53c.04-.32.07-.64.07-.97s-.03-.66-.07-1l2.11-1.63c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.31-.61-.22l-2.49 1c-.52-.39-1.06-.73-1.69-.98l-.37-2.65A.506.506 0 0 0 14 2h-4c-.25 0-.46.18-.5.42l-.37 2.65c-.63.25-1.17.59-1.69.98l-2.49-1c-.22-.09-.49 0-.61.22l-2 3.46c-.12.22-.07.49.12.64L4.57 11c-.04.34-.07.67-.07 1s.03.65.07.97l-2.11 1.66c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1.01c.52.4 1.06.74 1.69.99l.37 2.65c.04.24.25.42.5.42h4c.25 0 .46-.18.5-.42l.37-2.65c.63-.25 1.17-.59 1.69-.99l2.49 1.01c.22.08.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64z"/>' },
+        { label: "Private & Secure", icon: '<path d="M12 1 3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5zm0 6c1.4 0 2.8 1.6 2.8 3v1.5c.6 0 1.2.9 1.2 1.5v3c0 1.4-.6 2-1.2 2H9.2c-.6 0-1.2-.6-1.2-2v-3c0-.6.6-1.5 1.2-1.5V10c0-1.4 1.4-3 2.8-3m0 1.2c-.8 0-1.5.5-1.5 1.8v1.5h3V10c0-1.3-.7-1.8-1.5-1.8"/>' }
+      ].map((f) => `<div class="feature"><svg viewBox="0 0 24 24">${f.icon}</svg><span>${f.label}</span></div>`).join("\n");
+      const aInstructions = [
+        { label: "1) Open the dropdown menu", icon: '<circle cx="12" cy="5" r="2"/><circle cx="12" cy="12" r="2"/><circle cx="12" cy="19" r="2"/>' },
+        { label: '2) Press "Add to Home Screen"', icon: '<rect x="6" y="2" width="12" height="20" rx="2" ry="2"/><path fill="#fff" d="M7.5 5h9v14h-9z"/><path d="M6.5 8v8" stroke="#fff" stroke-linecap="square" stroke-width="3"/><path d="M6.5 8.5h5v5M11 9l-6 6" stroke-linecap="square" stroke-width="2" fill="transparent" stroke="#000"/>' }
+      ].map((i) => `<div class="instruction"><svg width="40" viewBox="0 0 24 24">${i.icon}</svg><span style="margin-left: 0.7rem">${i.label}</span></div>`).join("\n");
+      const iInstructions = [
+        { label: '1) Press the "Share" button', icon: '<rect x="2" y="10" width="20" height="18" rx="4" ry="4"/><path d="M9 10h6" stroke="#fff" stroke-linecap="square" stroke-width="3"/><path d="M12 19V1M7 6l5-5 5 5" stroke-linecap="round" stroke-linejoin="round"/>' },
+        { label: '2) Press "Add to Home Screen"', icon: '<rect x="2" y="2" width="20" height="20" rx="4" ry="4"/><path d="M12 7v10m-5-5h10" stroke-linecap="round"/>' }
+      ].map((i) => `<div class="instruction"><svg width="35" viewBox="0 0 24 30" fill="transparent" stroke="#0B76FC" stroke-width="2">${i.icon}</svg><span style="margin-left: 1rem">${i.label}</span></div>`).join("\n");
+      const downloads = [
+        { label: "Windows", icon: '<svg height="30" viewBox="0 0 24 24"><path d="M3 12V6.75l6-1.32v6.48zm17-9v8.75l-10 .15V5.21zM3 13l6 .09v6.81l-6-1.15zm17 .25V22l-10-1.91V13.1z"/></svg>' },
+        { label: "macOS", icon: '<svg height="30" viewBox="0 0 100 100"><path d="M86 35c-7-10-21-10-28-7s-10 2-17-1c-13-5-27 6-29 18-4 20 5 37 12 44s10 9 19 6c6-2 10-5 17-1 5 3 11 4 18-4s9-11 11-18c-19-8-14-32-3-37m-37-8c0-11 9-21 19-22 0 14-11 22-19 22"/></svg>' },
+        { label: "Linux", icon: '<svg height="30" viewBox="0 0 640 640"><path d="M316.9 187.3c1 .5 1.8 1.7 3 1.7 1.1 0 2.8-.4 2.9-1.5.2-1.4-1.9-2.3-3.2-2.9-1.7-.7-3.9-1-5.5-.1-.4.2-.8.7-.6 1.1.3 1.3 2.3 1.1 3.4 1.7M295 189c1.2 0 2-1.2 3-1.7 1.1-.6 3.1-.4 3.5-1.6.2-.4-.2-.9-.6-1.1-1.6-.9-3.8-.6-5.5.1-1.3.6-3.4 1.5-3.2 2.9.1 1 1.8 1.5 2.8 1.4m221 278.8c-3.6-4-5.3-11.6-7.2-19.7-1.8-8.1-3.9-16.8-10.5-22.4-1.3-1.1-2.6-2.1-4-2.9-1.3-.8-2.7-1.5-4.1-2 9.2-27.3 5.6-54.5-3.7-79.1-11.4-30.1-31.3-56.4-46.5-74.4-17.1-21.5-33.7-41.9-33.4-72 .5-45.9 5.1-131.2-75.8-131.3-102.4-.2-76.8 103.4-77.9 135.2-1.7 23.4-6.4 41.8-22.5 64.7-18.9 22.5-45.5 58.8-58.1 96.7-6 17.9-8.8 36.1-6.2 53.3-6.5 5.8-11.4 14.7-16.6 20.2-4.2 4.3-10.3 5.9-17 8.3s-14 6-18.5 14.5c-2.1 3.9-2.8 8.1-2.8 12.4 0 3.9.6 7.9 1.2 11.8 1.2 8.1 2.5 15.7.8 20.8-5.2 14.4-5.9 24.4-2.2 31.7 3.8 7.3 11.4 10.5 20.1 12.3 17.3 3.6 40.8 2.7 59.3 12.5 19.8 10.4 39.9 14.1 55.9 10.4 11.6-2.6 21.1-9.6 25.9-20.2 12.5-.1 26.3-5.4 48.3-6.6 14.9-1.2 33.6 5.3 55.1 4.1.6 2.3 1.4 4.6 2.5 6.7v.1c8.3 16.7 23.8 24.3 40.3 23 16.6-1.3 34.1-11 48.3-27.9 13.6-16.4 36-23.2 50.9-32.2 7.4-4.5 13.4-10.1 13.9-18.3.4-8.2-4.4-17.3-15.5-29.7M319.8 151.3c9.8-22.2 34.2-21.8 44-.4 6.5 14.2 3.6 30.9-4.3 40.4-1.6-.8-5.9-2.6-12.6-4.9 1.1-1.2 3.1-2.7 3.9-4.6 4.8-11.8-.2-27-9.1-27.3-7.3-.5-13.9 10.8-11.8 23-4.1-2-9.4-3.5-13-4.4-1-6.9-.3-14.6 2.9-21.8m-40.7-11.5c10.1 0 20.8 14.2 19.1 33.5-3.5 1-7.1 2.5-10.2 4.6 1.2-8.9-3.3-20.1-9.6-19.6-8.4.7-9.8 21.2-1.8 28.1 1 .8 1.9-.2-5.9 5.5-15.6-14.6-10.5-52.1 8.4-52.1m-13.6 60.7c6.2-4.6 13.6-10 14.1-10.5 4.7-4.4 13.5-14.2 27.9-14.2 7.1 0 15.6 2.3 25.9 8.9 6.3 4.1 11.3 4.4 22.6 9.3 8.4 3.5 13.7 9.7 10.5 18.2-2.6 7.1-11 14.4-22.7 18.1-11.1 3.6-19.8 16-38.2 14.9-3.9-.2-7-1-9.6-2.1-8-3.5-12.2-10.4-20-15-8.6-4.8-13.2-10.4-14.7-15.3q-2.1-7.35 4.2-12.3m3.3 334c-2.7 35.1-43.9 34.4-75.3 18-29.9-15.8-68.6-6.5-76.5-21.9-2.4-4.7-2.4-12.7 2.6-26.4v-.2c2.4-7.6.6-16-.6-23.9-1.2-7.8-1.8-15 .9-20 3.5-6.7 8.5-9.1 14.8-11.3 10.3-3.7 11.8-3.4 19.6-9.9 5.5-5.7 9.5-12.9 14.3-18 5.1-5.5 10-8.1 17.7-6.9 8.1 1.2 15.1 6.8 21.9 16l19.6 35.6c9.5 19.9 43.1 48.4 41 68.9m-1.4-25.9c-4.1-6.6-9.6-13.6-14.4-19.6 7.1 0 14.2-2.2 16.7-8.9 2.3-6.2 0-14.9-7.4-24.9-13.5-18.2-38.3-32.5-38.3-32.5-13.5-8.4-21.1-18.7-24.6-29.9s-3-23.3-.3-35.2c5.2-22.9 18.6-45.2 27.2-59.2 2.3-1.7.8 3.2-8.7 20.8-8.5 16.1-24.4 53.3-2.6 82.4.6-20.7 5.5-41.8 13.8-61.5 12-27.4 37.3-74.9 39.3-112.7 1.1.8 4.6 3.2 6.2 4.1 4.6 2.7 8.1 6.7 12.6 10.3 12.4 10 28.5 9.2 42.4 1.2 6.2-3.5 11.2-7.5 15.9-9 9.9-3.1 17.8-8.6 22.3-15 7.7 30.4 25.7 74.3 37.2 95.7 6.1 11.4 18.3 35.5 23.6 64.6 3.3-.1 7 .4 10.9 1.4 13.8-35.7-11.7-74.2-23.3-84.9-4.7-4.6-4.9-6.6-2.6-6.5 12.6 11.2 29.2 33.7 35.2 59 2.8 11.6 3.3 23.7.4 35.7 16.4 6.8 35.9 17.9 30.7 34.8-2.2-.1-3.2 0-4.2 0 3.2-10.1-3.9-17.6-22.8-26.1-19.6-8.6-36-8.6-38.3 12.5-12.1 4.2-18.3 14.7-21.4 27.3-2.8 11.2-3.6 24.7-4.4 39.9-.5 7.7-3.6 18-6.8 29-32.1 22.9-76.7 32.9-114.3 7.2m257.4-11.5c-.9 16.8-41.2 19.9-63.2 46.5-13.2 15.7-29.4 24.4-43.6 25.5s-26.5-4.8-33.7-19.3c-4.7-11.1-2.4-23.1 1.1-36.3 3.7-14.2 9.2-28.8 9.9-40.6.8-15.2 1.7-28.5 4.2-38.7 2.6-10.3 6.6-17.2 13.7-21.1.3-.2.7-.3 1-.5.8 13.2 7.3 26.6 18.8 29.5 12.6 3.3 30.7-7.5 38.4-16.3 9-.3 15.7-.9 22.6 5.1 9.9 8.5 7.1 30.3 17.1 41.6 10.6 11.6 14 19.5 13.7 24.6M269.4 212.7c2 1.9 4.7 4.5 8 7.1 6.6 5.2 15.8 10.6 27.3 10.6 11.6 0 22.5-5.9 31.8-10.8 4.9-2.6 10.9-7 14.8-10.4s5.9-6.3 3.1-6.6-2.6 2.6-6 5.1c-4.4 3.2-9.7 7.4-13.9 9.8-7.4 4.2-19.5 10.2-29.9 10.2s-18.7-4.8-24.9-9.7c-3.1-2.5-5.7-5-7.7-6.9-1.5-1.4-1.9-4.6-4.3-4.9-1.4-.1-1.8 3.7 1.7 6.5"/></svg>' }
+      ].map((d) => `<button class="${d.label.toLowerCase()} download-btn btn">${d.icon}<div>${d.label}</div></button>`).join("\n");
+      const { close, dialog, result } = createDialog(`
+<div style="margin: 1.5rem 0; text-align: center"><img src="${this.momentum.url}favicon.png?size=75" alt="logo" style="display: inline-block" /><h2 style="margin: 0.5rem 0; font-weight: 500; font-size: 2rem;">Install ${settings.title}</h2><p style="margin: 0; color: #4a5568">Get the full experience with our app!</p></div>
+<div style="margin: 2rem 1rem">
+	${nativePrompt || platform != "android" && platform != "ios" ? `<div class="features">${features}</div>` : ""}
+	${!nativePrompt && platform == "android" ? `<div class="android">${aInstructions}</div>` : ""}
+	${!nativePrompt && platform == "ios" ? `<div class="ios">${iInstructions}</div>` : ""}
+</div>
+<div style="margin-top: 1.5rem; display: flex; gap: 10px">
+	${nativePrompt ? `<button class="install btn btn-primary">Install</button>` : ""}
+	${!nativePrompt && platform != "android" && platform != "ios" ? `<button class="download btn btn-primary">Download</button>` : ""}
+	<button class="dismiss btn btn-secondary">Not Now</button>
+</div>
+<button class="expand-toggle">Download Options ▼</button>
+<div class="downloads expand-area hide">${downloads}</div>
+`, { css: `
+.downloads {
+    display: flex;
+    height: 95px;
+    margin-top: 0.75rem;
+    gap: 10px;
+}
+
+.download-btn {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: space-between;
+    height: 85px
+}
+
+.feature, .instruction {
+    display: flex;
+    align-items: center;
+    font-size: 14px;
+    margin-bottom: 0.5rem
+}
+
+.instruction {
+    margin-bottom: 1rem
+}
+
+.feature svg {
+    width: 20px;
+    height: 20px;
+    margin-right: 12px;
+    fill: var(--theme-primary)
+}` });
+      this.pendingInstall = close;
+      let downloaded = false;
+      const download = (platform2) => {
+        downloaded = true;
+        open(`${this.momentum.url}api/download/${platform2}?analytics=${this.momentum.analytics.id}`, "_blank");
+      };
+      dialog.addEventListener("click", (e) => {
+        let t = e.target, depth = 0;
+        while (!!t && t.tagName != "BUTTON" && ++depth < 5) t = t.parentElement;
+        if (!t || t.tagName != "BUTTON") return;
+        else if (t.matches(".dismiss")) close("dismiss");
+        else if (t.matches(".expand-toggle")) dialog.querySelector(".downloads").classList.toggle("hide");
+        else if (t.matches(".install")) {
+          this.nativePwaPrompt.prompt();
+          close(true);
+        } else if (t.matches(".download")) {
+          download(platform);
+          close(true);
+        } else if (t.matches(".windows")) download("windows");
+        else if (t.matches(".macos")) download("mac");
+        else if (t.matches(".linux")) download("linux");
+      });
+      return result.then((resp) => {
+        this.pendingInstall = null;
+        const success = downloaded || resp && resp != "dismiss";
+        if (resp == "dismiss") localStorage.setItem("momentum:install", (/* @__PURE__ */ new Date()).toISOString());
+        else if (resp) localStorage.setItem("momentum:install", "true");
+        else localStorage.removeItem("momentum:install");
+        this.emit(`install:${success ? "c" : "d"}`);
+        return success;
+      });
+    }
+    /** Update service worker & other tabs */
+    update() {
+      if (this.updating) return;
+      this.updating = true;
+      if (navigator.serviceWorker.controller) {
+        navigator.serviceWorker.addEventListener("message", (event) => {
+          if (event.data?.update) location.reload();
+        });
+        navigator.serviceWorker.controller.postMessage({ update: true });
+      }
+    }
+  }
+  class Data extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+    }
+    subscribers = {};
+    /**
+     * Create new document in collection
+     * @param {string} collection Target collection
+     * @param {Document<T>} document New document
+     * @return {Promise<Document<T>>} New saved document
+     */
+    create(collection, document2) {
+      if (!collection || !document2) throw new Error("Cannot create document, missing collection or document");
+      return this.momentum.api.request({
+        url: `api/` + PES`data/${collection}`,
+        method: "POST",
+        body: document2
+      }).then((resp) => {
+        this.emit(PES`data/${collection}:c`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Delete document from collection
+     * @param {string} collection Target collection
+     * @param {number} id Document ID
+     * @return {Promise<void>} Returns once complete
+     */
+    async delete(collection, id) {
+      if (!collection || !id) throw new Error("Cannot delete document, missing collection or ID");
+      const count = await this.momentum.api.request({
+        url: `api/` + PES`data/${collection}/${id}`,
+        method: "DELETE"
+      });
+      if (count) this.emit(PES`data/${collection}/${id}:d`, id);
+      return count;
+    }
+    read(collection, id) {
+      if (!collection) throw new Error("Cannot read documents, missing collection");
+      return this.momentum.api.request({ url: `api/` + PES`data/${collection}/${id}` }).then((resp) => {
+        this.emit(PES`data/${collection}/${id}:r`, collection, resp);
+        return resp;
+      });
+    }
+    /**
+     * Update document in collection
+     * @param {string} collection Target collection
+     * @param {Document<T>} document Document to update
+     * @param {boolean} append Append or replace existing document
+     * @return {Promise<Document<T>>} New saved document
+     */
+    update(collection, document2, append) {
+      if (!collection || !document2) throw new Error("Cannot update document, missing collection or document");
+      return this.momentum.api.request({
+        url: `api/` + PES`data/${collection}/${document2._id}`,
+        method: append ? "PATCH" : "PUT",
+        body: document2
+      }).then((resp) => {
+        this.emit(PES`data/${collection}/${document2._id}:u`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Create raw MongoDB query
+     * @param {string} collection Target collection name
+     * @param {RawQuery} query Raw query
+     * @return {Promise<any>} Query response
+     */
+    raw(collection, query) {
+      if (!collection || !query) throw new Error("Cannot execute raw query, missing collection or query");
+      const mode = query.operand.startsWith("find") ? "r" : query.operand == "insertOne" ? "c" : query.operand.startsWith("delete") ? "d" : "u";
+      return this.momentum.api.request({ url: `api/` + PES`data/${collection}` + "?raw", body: query }).then((resp) => {
+        this.emit(PES`data/${collection}:${mode}`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Subscribe to live updates with callback
+     * @param path Path to data
+     * @param {(value: T[]) => any | null} callback Received changes
+     * @param opts Reload data immediately
+     * @return {() => void} Function to unsubscribe
+     */
+    sync(path, callback, opts = {}) {
+      const e = PES`data/${path}`;
+      const cache = new Cache("_id");
+      const unsubscribe = this.on(e, (event, payload) => {
+        if (event.read && Array.isArray(payload)) cache.addAll(payload);
+        else if (event.create || event.update || event.read) cache.add(payload);
+        else if (event.delete) cache.delete(+event.name);
+        callback(cache.all());
+      });
+      if (opts.reload == void 0 || opts.reload) this.read(path);
+      if (!this.subscribers.length) this.momentum.socket?.subscribe(e);
+      const key = Object.keys(this.subscribers).length.toString();
+      this.subscribers[key] = () => {
+        unsubscribe();
+        delete this.subscribers[key];
+        if (!this.subscribers.length) this.momentum.socket?.unsubscribe(e);
+      };
+      return this.subscribers[key];
+    }
+  }
+  class Discounts extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "discounts", key: "_id" });
+      this.momentum = momentum;
+    }
+  }
+  class Email extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+    }
+    /**
+     * Send an Email
+     * @param {Mail} email Email information
+     * @return {Promise<any>} SMTP Response
+     */
+    create(email) {
+      return this.momentum.api.request({ url: "api/email", body: email }).then((response) => {
+        this.emit(PES`email/${email.to || email.bcc?.[0]}:c`, email);
+        return response;
+      });
+    }
+  }
+  class Forms extends TreeAssetController {
+    constructor(momentum) {
+      super(momentum, { module: "forms", key: "path" });
+      this.momentum = momentum;
+    }
+  }
+  class Groups extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "groups", key: "_id" });
+      this.momentum = momentum;
+    }
+  }
+  class Logger extends PathEventEmitter {
+    constructor(momentum) {
+      super("logs");
+      this.momentum = momentum;
+      this.channel = this.momentum.opts.app;
+      this.logLevel = this.momentum.opts.logLevel;
+      if (["local", "server"].includes(this.channel.toLowerCase())) throw new Error(`${this.channel} is reserved`);
+      if (typeof window != "undefined") {
+        window.addEventListener("unhandledrejection", async (event) => {
+          let log = event.reason?.stack || event.reason;
+          if (event.reason?.url) log = `${event.reason.method} ${event.reason.url} -> ${event.reason.code}
+
+${log}`;
+          if (event.reason?.code == null || event.reason?.code >= 500) {
+            if (LOG_LEVEL[this.logLevel] >= 0) this.error(log);
+            else {
+              this.logs.push(this.buildLog(LOG_LEVEL.ERROR, log));
+              this.emit(`local/error:c`, this.logs);
+            }
+          } else {
+            if (LOG_LEVEL[this.logLevel] >= 1) this.warn(log);
+            else {
+              this.logs.push(this.buildLog(LOG_LEVEL.WARN, log));
+              this.emit(`local/warn:c`, this.logs);
+            }
+          }
+        });
+      }
+      console.error = (...args) => {
+        this.console.error(...args);
+        if (LOG_LEVEL[this.logLevel] >= 0) this.error(args);
+        else {
+          this.logs.push(this.buildLog(LOG_LEVEL.ERROR, args));
+          this.emit(`local/error:c`, this.logs);
+        }
+      };
+      console.warn = (...args) => {
+        this.console.warn(...args);
+        if (LOG_LEVEL[this.logLevel] >= 1) this.warn(args);
+        else {
+          this.logs.push(this.buildLog(LOG_LEVEL.WARN, args));
+          this.emit(`local/warn:c`, this.logs);
+        }
+      };
+      console.info = (...args) => {
+        this.console.info(...args);
+        if (LOG_LEVEL[this.logLevel] >= 2) this.info(args);
+        else {
+          this.logs.push(this.buildLog(LOG_LEVEL.INFO, args));
+          this.emit(`local/info:c`, this.logs);
+        }
+      };
+      console.log = (...args) => {
+        this.console.log(...args);
+        if (LOG_LEVEL[this.logLevel] >= 3) this.log(args);
+        else {
+          this.logs.push(this.buildLog(LOG_LEVEL.LOG, args));
+          this.emit(`local/log:c`, this.logs);
+        }
+      };
+      console.debug = (...args) => {
+        this.console.debug(...args);
+        if (LOG_LEVEL[this.logLevel] >= 4) this.debug(args);
+        else {
+          this.logs.push(this.buildLog(LOG_LEVEL.DEBUG, args));
+          this.emit(`local/debug:c`, this.logs);
+        }
+      };
+    }
+    static cache = {};
+    channel;
+    logLevel;
+    console = {
+      debug: console.debug,
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error
+    };
+    logs = [];
+    buildLog(level, log) {
+      return {
+        time: /* @__PURE__ */ new Date(),
+        level,
+        log: makeArray(log),
+        ctx: this.momentum.analytics.id
+      };
+    }
+    create(log, channel = this.channel) {
+      if (channel.toLowerCase() == "server") throw new Error('"Server" namespace is reserved');
+      return this.momentum.api.request({ url: `api/logs/${channel}`, body: log }).catch(() => {
+      });
+    }
+    /**
+     * Get available channels
+     * @return {Promise<string[]>} List of channel names
+     */
+    channels() {
+      return this.momentum.api.request({ url: "api/logs/channels" });
+    }
+    /**
+     * Clear logs in channel
+     * @param {string} channel Channel to clear
+     * @return {Promise<number>} Reruns once complete
+     */
+    delete(channel) {
+      if (channel.toLowerCase() == "local") {
+        const length = this.logs.length;
+        this.logs = [];
+        this.emit(`local:d`, this.logs);
+        return Promise.resolve(length);
+      }
+      return this.momentum.api.request({ url: `api/logs/${channel}`, method: "DELETE" });
+    }
+    /**
+     * Read logs from channel
+     * @param {string} channel Channel name
+     * @return {Promise<Log[]>} Logs in channel
+     */
+    read(channel) {
+      if (channel.toLowerCase() == "local") return Promise.resolve(this.logs);
+      return this.momentum.api.request({ url: `api/logs/${channel}` });
+    }
+    sync(channel, callback, opts = {}) {
+      if (!Logger.cache[channel]) Logger.cache[channel] = { subs: 1, logs: [] };
+      else Logger.cache[channel].subs++;
+      if (callback) callback(PE`logs/${channel}:r`, Logger.cache[channel].logs);
+      if (opts.reload !== false) this.read(channel).then((resp) => {
+        Logger.cache[channel].logs = resp;
+        if (callback) callback(PE`logs/${channel}:r`, resp);
+      });
+      const unsubscribe = callback ? this.on(channel, (event, payload) => {
+        if (event.delete) Logger.cache[channel].logs = [];
+        else if (event.create || event.update) Logger.cache[channel].logs.push(payload);
+        else if (event.read && Array.isArray(payload)) Logger.cache[channel].logs = payload;
+        callback(event, Logger.cache[channel].logs);
+      }) : null;
+      if (Logger.cache[channel].subs) this.momentum.socket?.subscribe(`logs/${channel}`);
+      Logger.cache[channel].unsubscribe = () => {
+        if (unsubscribe) unsubscribe();
+        Logger.cache[channel].subs--;
+        if (!Logger.cache[channel].subs) {
+          this.momentum.socket?.unsubscribe(`logs/${channel}`);
+          delete Logger.cache[channel];
+        }
+      };
+      return Logger.cache[channel].unsubscribe;
+    }
+    // Console =========================================================================================================
+    /**
+     * Create debug log
+     * @param log What you want to log
+     * @param {string} channel Channel to publish log to
+     * @return {Promise<void>} Log saved
+     */
+    debug(log, channel = this.channel) {
+      if (typeof log == "string" || Array.isArray(log)) log = this.buildLog(LOG_LEVEL.DEBUG, log);
+      this.logs.push(log);
+      this.emit(`local/debug:c`, this.logs);
+      this.create(log, channel);
+    }
+    /**
+     * Create regular log
+     * @param log What you want to log
+     * @param {string} channel Channel to publish log to
+     * @return {Promise<void>} Log saved
+     */
+    log(log, channel = this.channel) {
+      if (typeof log == "string" || Array.isArray(log)) log = this.buildLog(LOG_LEVEL.LOG, log);
+      this.logs.push(log);
+      this.emit(`local/log:c`, this.logs);
+      this.create(log, channel);
+    }
+    /**
+     * Create info log
+     * @param log What you want to log
+     * @param {string} channel Channel to publish log to
+     * @return {Promise<void>} Log saved
+     */
+    info(log, channel = this.channel) {
+      if (typeof log == "string" || Array.isArray(log)) log = this.buildLog(LOG_LEVEL.INFO, log);
+      this.logs.push(log);
+      this.emit(`local/info:c`, this.logs);
+      this.create(log, channel);
+    }
+    /**
+     * Create warning log
+     * @param log What you want to log
+     * @param {string} channel Channel to publish log to
+     * @return {Promise<void>} Log saved
+     */
+    warn(log, channel = this.channel) {
+      if (typeof log == "string" || Array.isArray(log)) log = this.buildLog(LOG_LEVEL.WARN, log);
+      this.logs.push(log);
+      this.emit(`local/warn:c`, this.logs);
+      this.create(log, channel);
+    }
+    /**
+     * Create error log
+     * @param log What you want to log
+     * @param {string} channel Channel to publish log to
+     * @return {Promise<void>} Log saved
+     */
+    error(log, channel = this.channel) {
+      if (typeof log == "string" || Array.isArray(log)) log = this.buildLog(LOG_LEVEL.ERROR, log);
+      this.logs.push(log);
+      this.emit(`local/error:c`, this.logs);
+      this.create(log, channel);
+    }
+  }
+  class Notifications extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.subscription.then((resp) => this.enabled = !!resp);
+    }
+    _enabled = false;
+    /** Are notifications enabled */
+    get enabled() {
+      return this._enabled;
+    }
+    set enabled(enabled) {
+      this._enabled = enabled;
+      this.emit(PES`notifications:${enabled ? "u" : "d"}`, enabled);
+    }
+    /** Get Push Subscription info */
+    get subscription() {
+      if (!navigator.serviceWorker?.controller) return Promise.resolve(null);
+      return navigator.serviceWorker.ready.then((sw) => sw?.pushManager?.getSubscription());
+    }
+    /**
+     * Send a notification
+     * @param {Notification} notification Notification that will be sent to user
+     * @return {Promise<void>} Returns once complete
+     */
+    create(notification) {
+      return this.momentum.api.request({ url: "api/notifications", body: notification }).then((response) => {
+        this.emit(PES`notifications/${notification.to}:c`, notification);
+        return response;
+      });
+    }
+    /**
+     * Disable device notifications
+     * @return {Promise<void>} Resolves on success
+     */
+    async disable() {
+      const subscription = await this.subscription;
+      subscription?.unsubscribe();
+      return this.momentum.api.request({ url: "api/notifications", method: "DELETE", body: {
+        p256dh: subscription?.toJSON().keys?.["p256dh"]
+      } }).then(() => this.enabled = false);
+    }
+    /**
+     * Enable device notifications
+     * @return {Promise<null>} Resolves on success
+     */
+    async enable() {
+      const granted = await Notification.requestPermission();
+      if (!granted) return null;
+      const sw = await navigator.serviceWorker.ready;
+      const token = (await this.momentum.settings.read("push_public_key"))?.value;
+      const subscription = (await sw.pushManager.subscribe({
+        userVisibleOnly: true,
+        applicationServerKey: token
+      })).toJSON();
+      return this.momentum.api.request({ url: "api/notifications", method: "PATCH", body: subscription }).then(() => this.enabled = true);
+    }
+  }
+  class Blacklist extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "blacklist", path: "routes/blacklist", key: "_id" });
+      this.momentum = momentum;
+    }
+    async update(ignore) {
+      throw new Error("Not supported");
+    }
+  }
+  class RateLimiter extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "rate_limit", path: "routes/limit", key: "_id" });
+      this.momentum = momentum;
+    }
+  }
+  class Routes extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.blacklist = new Blacklist(momentum);
+      this.rateLimiter = new RateLimiter(momentum);
+      this.relayEvents(this.blacklist);
+      this.relayEvents(this.rateLimiter);
+    }
+    blacklist;
+    rateLimiter;
+  }
+  class Templates extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "templates", key: "_id" });
+      this.momentum = momentum;
+    }
+    render(id, data) {
+      return this.momentum.api.request({ url: `/api/templates/render/${id}`, method: "POST", body: data });
+    }
+    renderHtml(html, data) {
+      return this.momentum.api.request({ url: `/api/templates/render`, method: "POST", body: { html, data } });
+    }
+  }
+  class Transactions extends AssetController {
+    constructor(momentum) {
+      super(momentum, { module: "transactions", key: "_id" });
+      this.momentum = momentum;
+    }
+    /** Stripe object */
+    stripe;
+    /**
+     * Initialize stripe API
+     * @return {Promise<any>} Returns stripe API
+     * @private
+     */
+    async initStripe() {
+      await new Promise((res) => {
+        if (this.stripe) return res(window["Stripe"]);
+        const stripeScript = document.createElement("script");
+        stripeScript.src = "https://js.stripe.com/v3/";
+        stripeScript.setAttribute("crossorigin", "anonymous");
+        stripeScript.onload = () => res();
+        document.head.appendChild(stripeScript);
+      }).then(() => this.stripe = window["Stripe"]);
+      const token = await this.momentum.settings.read("stripe_token");
+      return this.stripe(token.value);
+    }
+    /**
+     * Create a stripe client secret to complete Payment
+     * @param {string} id Payment ID
+     * @return {Promise<string>} Client secret
+     * @private
+     */
+    getToken(id) {
+      return this.momentum.api.request({ url: `api/transactions/init/${id || ""}`, method: "POST" }).then((resp) => resp.token);
+    }
+    /**
+     * Process transaction programmatically
+     * @param {string} id Transaction ID
+     * @param {Card} card Credit card information
+     * @return {Promise<any>} Stripe confirmation
+     */
+    async checkout(id, card) {
+      const [client, secret] = await Promise.all([this.initStripe(), this.getToken(id)]);
+      return client.confirmPayment({
+        clientSecret: secret,
+        confirmParams: {
+          payment_method: {
+            card: { ...card, details: void 0 },
+            billing_details: card.details || {}
+          }
+        }
+      });
+    }
+    /**
+     * Process transaction using Stripe form
+     * @param {string} id Transaction ID
+     * @param {string} element DOM element to inject form into
+     * @return {Promise<() => Promise<any>>} Callback to submit form
+     */
+    async checkoutForm(id, element) {
+      const [client, secret] = await Promise.all([this.initStripe(), this.getToken(id)]);
+      const form = client.elements({ clientSecret: secret });
+      form.create("payment").mount(element);
+      return (redirect = location.href) => client.confirmPayment({
+        elements: form,
+        redirect: "if_required",
+        confirmParams: { return_url: redirect + "?payment_status=success" }
+      });
+    }
+    /**
+     * Complete transaction via Momentum's checkout page
+     * @param {string} id Transaction ID
+     * @param {string} host Host origin attempting to login
+     * @return {Promise<string>} Translation ID on success
+     */
+    checkoutRedirect(id, host = location.origin) {
+      return new Promise(async (res, rej) => {
+        let origin2 = new URL(this.momentum.opts.checkoutUrl).origin, listener, win;
+        window.addEventListener("message", listener = (event) => {
+          const data = event?.data || {};
+          if (event.origin != origin2 || data.sender != origin2) return;
+          if (!data.response) return rej("Unknown response from payment page");
+          window.removeEventListener("message", listener);
+          win.close();
+          res(data.response);
+        });
+        win = window.open(this.checkoutUrl(id) + `&host=${host}`, "_blank");
+        if (!win) {
+          window.removeEventListener("message", listener);
+          return rej("Unable to open checkout page");
+        }
+      });
+    }
+    /**
+     * Get URL to checkout page for transaction
+     * @param {string} id Transaction ID
+     * @returns {string} URL
+     */
+    checkoutUrl(id) {
+      return encodeURI(`${this.momentum.opts.checkoutUrl}?token=${id}`);
+    }
+    async delete(key) {
+      throw new Error("Not supported");
+    }
+    /**
+     * Send recipient transaction receipt or invoice
+     * @param {string} id Translation ID
+     * @return {Promise<void>} Returns once complete
+     */
+    notify(id) {
+      return this.momentum.api.request({ url: `api/transactions/notify/${id || ""}`, method: "POST" });
+    }
+    /**
+     * Refund a transaction
+     * @param {string} key Asset primary key
+     * @return {Promise<Transaction>} Returns on success
+     */
+    async refund(key) {
+      const transaction = await this.momentum.api.request({ url: `api/${this.opts.module}/${key || ""}`, method: "DELETE" });
+      this.emit(`${key}:u`, transaction);
+      return transaction;
+    }
+  }
+  class Pdf extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+    }
+    createPdf(body, options) {
+      return this.momentum.api.request({ url: `api/` + PES`pdf`, body: { ...body, options } }).then(async (resp) => {
+        if (options?.downloadAs) {
+          let filename = options?.downloadAs || timestampFilename();
+          if (!filename.endsWith(".pdf")) filename += ".pdf";
+          downloadFile(resp, filename);
+        }
+        this.emit(PES`pdf:c`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Create a PDF from raw HTML code
+     * @param {string} html HTML code
+     * @param {PdfOptions} options PDF rendering options
+     * @return {Promise<Blob>}
+     */
+    fromHtml(html, options = {}) {
+      if (!html) throw new Error("Cannot create PDF, missing HTML");
+      return this.createPdf({ html }, options);
+    }
+    /**
+     * Create a PDF from a server template
+     * @param {RenderTemplate} template Template path
+     * @param {PdfOptions} options PDF rendering options
+     * @return {Promise<Blob>}
+     */
+    fromTemplate(template, options = {}) {
+      if (!template) throw new Error("Cannot create PDF, missing template");
+      return this.createPdf(template, options);
+    }
+    /**
+     * Create PDF from a public URL
+     * @param {string} url HTTP(s) URL
+     * @param {PdfOptions} options PDF rendering option
+     * @return {Promise<Blob>}
+     */
+    fromUrl(url, options = {}) {
+      if (!url) throw new Error("Cannot create PDF, missing URL");
+      return this.createPdf({ url }, options);
+    }
+    async toHtml(file) {
+      if (!file) file = (await fileBrowser({ accept: "application/pdf", multiple: false }))[0];
+      if (!file) return Promise.resolve("");
+      return uploadWithProgress({
+        url: `${this.momentum.url.toString()}api/pdf/html`,
+        headers: this.momentum.api.headers,
+        files: [file]
+      });
+    }
+  }
+  class Products extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.controller = new AssetController(momentum, { module: "products", key: "_id" });
+      this.relayEvents(this.controller);
+    }
+    controller;
+    get cache() {
+      return this.controller.cache;
+    }
+    /**
+     * Fetch all products
+     * @param {boolean} reload Force reload instead of using cache
+     * @return {Promise<Product[]>} List of products
+     */
+    all(reload) {
+      return this.controller.all(reload);
+    }
+    /**
+     * Fetch specific product information
+     * @param {number} id Product ID
+     * @param {boolean} reload Force reload instead of using cache
+     * @return {Promise<Product>} Found product
+     */
+    read(id, reload) {
+      return this.controller.read(id.toString(), reload);
+    }
+    /**
+     * Subscribe to live updates with callback
+     * @param {(value: Product[]) => any | null} callback Received changes
+     * @param opts Scope to single product
+     * @return {() => void} Function to unsubscribe
+     */
+    sync(callback, opts = {}) {
+      return this.controller.sync(callback, { path: opts.product ? opts.product.toString() : void 0 });
+    }
+  }
+  class Schemas extends TreeAssetController {
+    constructor(momentum) {
+      super(momentum, { module: "schemas", key: "path" });
+      this.momentum = momentum;
+    }
+  }
+  class Sms extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+    }
+    /**
+     * Send an sms to a number
+     * @param {Message} message Text that will be sent
+     * @return {Promise<any>} Twilio message instance
+     */
+    create(message) {
+      return this.momentum.api.request({ url: "api/sms", body: message }).then((resp) => this.emit(PES`sms/${message.to}`, message));
+    }
+  }
+  class Socket extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.momentum.auth.on("login:cd", (event, user) => {
+        if (user !== void 0 && this.momentum.api.token != this.token) this.connect();
+      });
+    }
+    static pollingSpeed = 15e3;
+    connection;
+    connecting;
+    connectingResolver;
+    events = {};
+    reconnect = true;
+    pending = [];
+    token;
+    reconnectTimeout;
+    connected = false;
+    scheduleReconnect() {
+      if (!this.reconnect) return;
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = setTimeout(() => {
+        this.connect();
+      }, Socket.pollingSpeed);
+    }
+    close(reconnect) {
+      console.debug("Disconnected from Momentum");
+      this.connected = false;
+      this.connection?.close();
+      this.connection = void 0;
+      this.reconnect = !!reconnect;
+      if (this.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.events = {};
+        clearTimeout(this.reconnectTimeout);
+      }
+    }
+    connect() {
+      if (!this.connecting) {
+        this.connecting = new Promise((res) => this.connectingResolver = res);
+      }
+      if (typeof navigator != "undefined" && !navigator.onLine || this.connected && this.token == this.momentum.api.token) return this.connecting;
+      if (this.connected) this.close();
+      clearTimeout(this.reconnectTimeout);
+      if (navigator.onLine) {
+        const url = this.momentum.url.toString().replace("http", "ws");
+        this.connection = new WebSocket(url + (this.momentum.api.token ? `?token=${this.momentum.api.token}&url=${location?.href || ""}` : ""));
+        this.connection.onopen = () => {
+          console.debug("Connected to Momentum");
+          this.connected = true;
+          this.token = this.momentum.api.token;
+          clearTimeout(this.reconnectTimeout);
+          Object.keys(this.events).forEach((e) => this.send("subscribe", e));
+          this.pending = this.pending.filter((p) => {
+            this.send(p.event, p.payload);
+            return false;
+          });
+          this.connectingResolver?.();
+          this.connecting = void 0;
+          this.connectingResolver = void 0;
+        };
+        this.connection.onclose = () => {
+          if (!this.reconnect) return;
+          this.close(true);
+        };
+        this.connection.onmessage = (message) => {
+          const data = JSONAttemptParse(message.data);
+          if (data.connected === false) this.close(true);
+          else this.emit(data.event, data.payload);
+        };
+        this.scheduleReconnect();
+      }
+      return this.connecting;
+    }
+    async ping() {
+      const start = Date.now();
+      if (!this.connected) await this.connect();
+      return new Promise((res) => {
+        this.once("pong", () => res(Date.now() - start));
+        this.send("ping");
+      });
+    }
+    send(channel, payload = null) {
+      if (!this.connection || this.connection.readyState !== WebSocket.OPEN) {
+        this.pending.push({ event: channel, payload });
+      } else {
+        this.connection.send(JSON.stringify({ event: channel, payload }));
+      }
+    }
+    subscribe(event) {
+      const e = new PathEvent(event).toString();
+      if (!this.events[e]) this.events[e] = 1;
+      else this.events[e]++;
+      if (this.events[e] == 1) {
+        return new Promise((res) => {
+          this.once("subscribe", (event2, payload) => {
+            if (payload.event == e) res(payload.success);
+          });
+          this.send("subscribe", e.toString());
+        });
+      } else return Promise.resolve(true);
+    }
+    async subscriptions() {
+      if (!this.connected) await this.connect();
+      return new Promise((res) => {
+        this.once("subscriptions", (event, payload) => res(payload));
+        this.send("subscriptions");
+      });
+    }
+    unsubscribe(event) {
+      const e = new PathEvent(event).toString();
+      this.events[e]--;
+      if (this.events[e] <= 0) {
+        delete this.events[e];
+        return new Promise((res) => {
+          this.once("unsubscribe", (event2, payload) => {
+            if (payload.event == e) res(payload.success);
+          });
+          this.send("unsubscribe", e.toString());
+        });
+      } else return Promise.resolve(true);
+    }
+  }
+  class Storage extends PathEventEmitter {
+    constructor(momentum, module2 = "storage") {
+      super();
+      this.momentum = momentum;
+      this.module = module2;
+      this.on(this.module, (event, payload) => {
+        if (Array.isArray(payload)) {
+          this.cache.addAll(payload);
+        } else if ((event.create || event.update || event.read) && payload != null) {
+          this.cache.add(payload);
+          this.cache.values().forEach((meta) => {
+            if (meta?.children && event.path == meta.path) meta.children = [...meta.children.filter((c) => c.path != event.name), payload.name];
+          });
+        } else if (event.delete || payload == null) {
+          if (!event.path) return this.cache.clear();
+          else this.cache.delete(event.path);
+        }
+      });
+    }
+    subscribers = {};
+    cache = new Cache("path");
+    /**
+     * List all files
+     * @param {string} path Target directory
+     * @return {Promise<DirMeta>} Directory metadata
+     */
+    all(path) {
+      if (!path) path = "/";
+      return this.momentum.api.request({ url: `api/${this.module}/${path}?all=true` }).then((resp) => {
+        this.emit(PES`${this.module}/${path}:r`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Copy one location to another
+     * @param {string} source Source location
+     * @param {string} destination Destination of copy
+     * @return {Promise<DirMeta | FileMeta>} Metadata of copy
+     */
+    copy(source, destination) {
+      if (!source) throw new Error("Cannot copy file or folder, missing source");
+      if (!destination) {
+        const path = source.split("/"), fullName = path.pop(), split = fullName.split(".");
+        destination = split.length == 1 || split.length == 2 && !split[0] ? `${fullName} (COPY)` : `${split.splice(0, split.length - 1).join(".")} (COPY).${split.at(-1)}`;
+        destination = [...path.slice(0, -1), destination].join("/");
+        if (!destination.startsWith("/")) destination = "/" + destination;
+      }
+      return this.momentum.api.request({ url: `api/${this.module}/${destination}`, body: { from: source } }).then((response) => {
+        this.emit(PES`${this.module}/${destination}:c`, response);
+        return response;
+      });
+    }
+    /**
+     * Delete location
+     * @param {string} path Target module
+     * @return {Promise<void>} Returns once complete
+     */
+    async delete(path) {
+      if (!path) throw new Error("Cannot delete file or folder, missing module");
+      const count = await this.momentum.api.request({ url: `api/${this.module}/${path}`, method: "DELETE" });
+      if (count) this.emit(PES`${this.module}/${path}:d`, path);
+      return count;
+    }
+    /**
+     * Download module
+     * @param {string} path Path to target
+     * @param {{downloadAs?: string}} opts Download filename
+     * @return {PromiseProgress<Blob>} File as blob with progress tracking
+     */
+    download(path, opts = {}) {
+      if (!path) throw new Error("Cannot download file, missing module");
+      return this.momentum.api.request({ url: `api/${this.module}/${path}?download=true`, decode: false }).then(async (response) => {
+        const blob = await response.blob();
+        const name = opts.downloadAs || path.split("/").pop();
+        downloadFile(blob, name);
+        return response;
+      });
+    }
+    /**
+     * Retrieve file/folder metadata
+     * @param {string} path Path to target
+     * @return {Promise<DirMeta | FileMeta>} Metadata
+     */
+    meta(path) {
+      if (!path) path = "/";
+      return this.momentum.api.request({ url: `api/${this.module}/${path}?meta=true` }).then((resp) => {
+        this.emit(PES`${this.module}/${path}:r`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Create a new directory
+     * @param {string} path Directory module
+     * @return {Promise<DirMeta>} New directory metadata
+     */
+    mkdir(path) {
+      if (!path) throw new Error("Cannot make directory, missing module");
+      return this.momentum.api.request({ url: `api/${this.module}/${path}`, body: { directory: true } }).then((resp) => {
+        this.emit(PES`${this.module}/${path}:c`, resp);
+        return resp;
+      });
+    }
+    /**
+     * Move a file from one location to another
+     * @param {string} source Target that will be moved
+     * @param {string} destination Destination location
+     * @return {Promise<DirMeta | FileMeta>} New file/folder metadata
+     */
+    move(source, destination) {
+      if (!source || !destination) throw new Error("Cannot move file or folder, missing source or destination");
+      if (source == destination) return this.meta(destination);
+      return this.momentum.api.request({ url: `api/${this.module}/${source}`, method: "PATCH", body: { move: destination } }).then((response) => {
+        this.emit(PES`${this.module}/${source}:u`, response);
+        return response;
+      });
+    }
+    open(path, target = "_blank") {
+      if (!path) throw new Error("Cannot download file, missing module");
+      const link = `${this.momentum.url.toString()}api/${this.module}/${path}`.replaceAll(/([^:])\/+/g, "$1/") + (!this.momentum.api.sameOrigin && this.momentum.api.token ? `?token=${this.momentum.api.token}` : "");
+      if (!target) return link;
+      return window.open(link, target);
+    }
+    /**
+     * Read file as text via extraction or OCR
+     * @param {string} path Path to target
+     * @return {Promise<string>} Extracted text
+     */
+    text(path) {
+      if (!path) throw new Error("Missing path");
+      return this.momentum.api.request({ url: `api/${this.module}/${path}?text=true` });
+    }
+    /**
+     * Upload file(s) to server, Uses file browser if no files provided
+     * @param path Path files will be uploaded to
+     * @param {File | File[] | null} files Files to upload or null to open file browser
+     * @param {string | {accept?: string, rename?: string, multiple?: boolean}} opts file browser options & rename file on upload
+     * @return {PromiseProgress<FileMeta[]>} Returns once complete with progress tracking
+     */
+    upload(path = "/", files, opts) {
+      return new PromiseProgress(async (res, rej, prog) => {
+        if (!files) files = await fileBrowser(typeof opts == "object" ? opts : void 0);
+        let f = makeArray(files);
+        if (!files || !f.length) return [];
+        if (f.length == 1 && opts?.rename) f = [new File([f[0]], opts.rename, { type: f[0].type })];
+        return uploadWithProgress({
+          url: `${this.momentum.url.toString()}api/${this.module}/${path}`,
+          headers: this.momentum.api.headers,
+          files: f
+        }).onProgress((p) => {
+          prog(p);
+        }).then((resp) => {
+          this.emit(PES`${this.module}/${path}:c`, resp);
+          res(resp);
+        }).catch((err) => rej(err));
+      });
+    }
+    /**
+     * Subscribe to live updates with callback
+     * @param path Path to data
+     * @param {(value: DirMeta | FileMeta) => any} callback Received changes
+     * @param opts Reload data immediately
+     * @return {() => void} Function to unsubscribe
+     */
+    sync(path, callback, opts = {}) {
+      const e = PE`${this.module}/${path}`;
+      const unsubscribe = callback ? this.on(e.toString(), (event) => callback(event, this.cache.get(path))) : null;
+      if (!opts.reload) this.meta(path);
+      if (!this.subscribers.length) this.momentum.socket?.subscribe(e.toString());
+      const key = Object.keys(this.subscribers).length.toString();
+      this.subscribers[key] = () => {
+        if (unsubscribe) unsubscribe();
+        delete this.subscribers[key];
+        if (!this.subscribers.length) this.momentum.socket?.unsubscribe(e.toString());
+      };
+      return this.subscribers[key];
+    }
+  }
+  class Tokens extends PathEventEmitter {
+    constructor(momentum) {
+      super();
+      this.momentum = momentum;
+      this.controller = new AssetController(momentum, { module: "tokens", key: "_id" });
+      this.relayEvents(this.controller);
+    }
+    controller;
+    get cache() {
+      return this.controller.cache;
+    }
+    /**
+     * Fetch all tokens for user
+     * @param {string} username User to search
+     * @param reload Force reload instead of using cache
+     * @return {Promise<Token[]>} List of tokens
+     */
+    all(username, reload) {
+      return this.controller.read(username, reload);
+    }
+    /**
+     * Create a new user token
+     * @param {{name: string, owner: string, expire: null | Date}} token Token settings
+     * @return {Promise<Token>} Crated token
+     */
+    create(token) {
+      return this.controller.create(token);
+    }
+    /**
+     * Delete an existing token
+     * @param {string} id Token ID
+     * @return {Promise<void>} Resolves once complete
+     */
+    delete(id) {
+      return this.controller.delete(id);
+    }
+    /**
+     * Subscribe to token changes for user
+     * @param {(value: Product[]) => any | null} callback Received changes
+     * @param opts Scope to single user
+     * @return {() => void} Function to unsubscribe
+     */
+    sync(callback, opts = {}) {
+      return this.controller.sync(callback, { path: opts.username });
+    }
+  }
+  class Users extends AssetController {
+    constructor(momentum, socket) {
+      super(momentum, { module: "users", key: "_id" });
+      this.momentum = momentum;
+      this.socket = socket;
+    }
+    afterRead(user) {
+      if (user == null) return null;
+      user.image = this.profileImage(user._id);
+      return user;
+    }
+    beforeWrite(user) {
+      delete user.image;
+      return user;
+    }
+    profileImage(username, token = true) {
+      let url = `${this.momentum.url.toString()}api/users/${username}/image`;
+      if (token && !this.momentum.api.sameOrigin && this.momentum.api.token) url += `?token=${this.momentum.api.token}`;
+      return url;
+    }
+    /**
+     * Upload new profile image for user
+     * @param {string} username Target user
+     * @param {File} file File from form input
+     * @return {PromiseProgress<void>} Returns once upload is complete, provides progress callback
+     */
+    uploadImage(username, file) {
+      return uploadWithProgress({
+        url: this.profileImage(username, false),
+        files: [file],
+        headers: this.momentum.api.headers
+      });
+    }
+  }
+  class Settings extends AssetController {
+    constructor(momentum) {
+      super(momentum, {
+        module: "settings",
+        key: "_id",
+        storage: momentum.opts?.persist ? { storage: momentum.database, key: "_settings" } : void 0
+      });
+      this.momentum = momentum;
+      this.momentum.api.on("token", () => {
+        this.cache.clear();
+        this.all(true);
+      });
+    }
+    /**
+     * Get all schemas organized into a map
+     * @param {boolean} reload Reload instead of using cache
+     * @return {Promise<TreeNode<Schema>[]>} Schemas as nested tree
+     */
+    async map(reload) {
+      const rows = await this.all(reload);
+      return rows.reduce((acc, row) => ({ ...acc, [row._id]: row.value }), {});
+    }
+    /**
+     * Subscribe to live updates with optional callback
+     * @param {(schema: Schema[]) => any} callback Receives latest data
+     * @param opts path - scope events, map - return as map or array
+     * @return {() => void}
+     */
+    sync(callback, opts = {}) {
+      return super.sync(callback ? (event, value) => callback(event, opts.map ? value.reduce((acc, row) => ({ ...acc, [row._id]: row.value }), {}) : value) : void 0, opts);
+    }
+  }
+  class Static extends Storage {
+    constructor(momentum) {
+      super(momentum, "static");
+      this.momentum = momentum;
+    }
+  }
+  const version = "1.0.0";
+  class WebRtc extends PathEventEmitter {
+    constructor(momentum) {
+      super("webrtc");
+      this.momentum = momentum;
+    }
+    get ice() {
+      const host = this.momentum.url.hostname.replace("localhost", "127.0.0.1");
+      const port = this.momentum.settings.cache.get("webrtc_port")?.value;
+      const key = this.momentum.settings.cache.get("webrtc_key")?.value;
+      return [
+        { urls: [`stun:${host}:${port}`] },
+        { urls: [`turn:${host}:${port}`], username: "momentum", credential: key }
+      ];
+    }
+    async answer(offer, stream) {
+      const rtc = new RTCPeerConnection({ iceServers: this.ice });
+      stream.getTracks().forEach((track) => rtc.addTrack(track, stream));
+      await rtc.setRemoteDescription(new RTCSessionDescription(offer));
+      const answer = await rtc.createAnswer();
+      await rtc.setLocalDescription(answer);
+      await new Promise((res) => {
+        if (rtc.iceGatheringState === "complete") return res();
+        rtc.onicegatheringstatechange = () => {
+          if (rtc.iceGatheringState === "complete") res();
+        };
+      });
+      return rtc;
+    }
+    async offer(stream) {
+      const rtc = new RTCPeerConnection({ iceServers: this.ice });
+      stream.getTracks().forEach((track) => rtc.addTrack(track, stream));
+      await rtc.setLocalDescription(await rtc.createOffer());
+      await new Promise((res) => {
+        if (rtc.iceGatheringState === "complete") return res();
+        rtc.onicegatheringstatechange = () => {
+          if (rtc.iceGatheringState === "complete") res();
+        };
+      });
+      return rtc;
+    }
+    async connect(id = randomStringBuilder(16, true, true), audio = true, video = true) {
+      const session = {
+        id,
+        uid: randomStringBuilder(8, true, true),
+        peers: {},
+        stream: await navigator.mediaDevices.getUserMedia({ audio, video }),
+        open: true,
+        disconnect: () => {
+          session.open = false;
+          Object.values(session.peers).forEach((p) => p.connection.close());
+          session.stream.getTracks().forEach((track) => track.stop());
+          this.momentum.socket?.send(`webrtc/${id}/${session.uid}:d`, {
+            uid: session.uid,
+            username: this.momentum.auth.user?._id || "Anonymous",
+            disconnect: true
+          });
+        }
+      };
+      this.momentum.socket?.subscribe(`webrtc/${id}`);
+      this.momentum.socket?.on(`webrtc/${id}`, async (event, payload) => {
+        if (event.name != session.uid) {
+          if (payload.connected) {
+            session.peers[event.name] = {
+              uid: event.name,
+              username: payload.username,
+              connection: await this.offer(session.stream)
+            };
+            this.momentum.socket?.send(`webrtc/${id}/${event.name}`, {
+              uid: session.uid,
+              username: this.momentum.auth.user?._id || "Anonymous",
+              offer: session.peers[event.name].connection.localDescription
+            });
+          } else if (payload.disconnect) {
+            session.peers[event.name].connection.close();
+            delete session.peers[event.name];
+            this.emit(id, session);
+          }
+        } else {
+          if (payload.offer) {
+            session.peers[event.name] = {
+              uid: payload.uid,
+              username: payload.username,
+              connection: await this.answer(payload.offer, session.stream)
+            };
+            session.peers[event.name].stream = session.peers[event.name].connection.getRemoteStreams()[0];
+            if (!session.peers[event.name].stream) session.peers[event.name].connection.ontrack = (e) => {
+              session.peers[event.name].stream = e.streams[0];
+              this.emit(id, session);
+            };
+            this.emit(id, session);
+            this.momentum.socket?.send(`webrtc/${id}/${payload.uid}`, {
+              uid: session.uid,
+              username: this.momentum.auth.user?._id || "Anonymous",
+              answer: session.peers[event.name].connection.localDescription
+            });
+          } else if (payload.answer) {
+            session.peers[payload.uid].connection.setRemoteDescription(new RTCSessionDescription(payload.answer));
+            session.peers[payload.uid].stream = session.peers[payload.uid].connection.getRemoteStreams()[0];
+            if (!session.peers[payload.uid].stream) session.peers[payload.uid].connection.ontrack = (e) => {
+              session.peers[payload.uid].stream = e.streams[0];
+              this.emit(id, session);
+            };
+            this.emit(id, session);
+          }
+        }
+      });
+      this.momentum.socket?.send(`webrtc/${id}/${session.uid}`, {
+        uid: session.uid,
+        username: this.momentum.auth.user?._id || "Anonymous",
+        connected: true
+      });
+      return session;
+    }
+  }
+  class Permissions {
+    constructor(momentum) {
+      this.momentum = momentum;
+    }
+    /** Get all permissions */
+    all = () => this.momentum.auth.session?.permissions || [];
+    /** Filter list of permissions to ones the user has */
+    filter = (...events) => PathEvent.filter(this.all(), ...events);
+    /** Does user have any permissions (or) */
+    has = (...events) => PathEvent.has(this.all(), ...events);
+    /** Does user have all permissions (and) */
+    hasAll = (...events) => PathEvent.hasAll(this.all(), ...events);
+    /** Raise error if user has no permissions (or) */
+    hasFatal = (...events) => PathEvent.hasFatal(this.all(), ...events);
+    /** Raise error if user missing any permissions (and) */
+    hasAllFatal = (...events) => PathEvent.hasAllFatal(this.all(), ...events);
+  }
+  class Momentum extends PathEventEmitter {
+    static pathEvent = PathEvent;
+    static version = version;
+    pathEvent = Momentum.pathEvent;
+    version = Momentum.version;
+    opts;
+    url;
+    api;
+    actions;
+    ai;
+    analytics;
+    audit;
+    auth;
+    call;
+    client;
+    data;
+    database;
+    discounts;
+    email;
+    forms;
+    groups;
+    logger;
+    notifications;
+    pdf;
+    permissions;
+    products;
+    routes;
+    schemas;
+    settings;
+    sms;
+    socket;
+    static;
+    storage;
+    templates;
+    tokens;
+    transactions;
+    users;
+    webRtc;
+    get banner() {
+      return `
+
+      ########   ##
+   ###        ###		Momentum v${Momentum.version}
+  ## ###   #### ##		App: ${this.opts.app}
+ ##  ##  ##  ##  ## 	Analytics: ${typeof this.opts.analytics == "string" ? this.opts.analytics.toUpperCase() : "DISABLED"}
+ ##   ###  ###   ## 	Logging: ${this.opts.logLevel != "NONE" ? this.opts.logLevel.toUpperCase() : "DISABLED"}
+ ##  ##  ##  ##  ## 	Offline: ${this.opts.offline ? "ENABLED" : "DISABLED"}
+  ## ####   ### ##  	Sockets: ${this.opts.socket ? "ENABLED" : "DISABLED"}
+   ###        ###		Worker:  ${this.opts.worker !== false ? "ENABLED" : "DISABLED"}
+ ##   ########
+
+`;
+    }
+    constructor(url = location.origin, opts = {}) {
+      super();
+      this.url = new URL(url);
+      this.opts = {
+        app: "Momentum App",
+        analytics: "prompt",
+        banner: true,
+        checkoutUrl: `${this.url.toString()}ui/checkout`,
+        credentialsStrategy: "auto",
+        expiredStrategy: "logout",
+        http: {},
+        installPrompt: { delay: 2, retry: 15, ...opts.installPrompt || {} },
+        logLevel: "NONE",
+        loginUrl: `${this.url.toString()}ui/login`,
+        offline: false,
+        persist: true,
+        socket: true,
+        worker: `/momentum.worker.mjs`,
+        ...opts
+      };
+      if (this.opts.banner) console.log(this.banner);
+      if (typeof window != "undefined" && typeof window["indexedDB"] != "undefined")
+        this.database = new Database(this.url.host);
+      this.api = new Api(this);
+      this.auth = new Auth(this);
+      if (this.opts.socket) {
+        this.socket = new Socket(this);
+        this.socket.on("*", (event, data) => {
+          let service = this[event.module];
+          if (event.module == "logs") service = this.logger;
+          if (service?.emit) service.emit(event, data);
+        });
+      }
+      this.settings = new Settings(this);
+      this.client = new Client(this);
+      this.actions = new Actions(this);
+      this.analytics = new Analytics(this);
+      this.ai = new Ai(this);
+      this.audit = new Audit(this);
+      this.call = new Call(this);
+      this.data = new Data(this);
+      this.discounts = new Discounts(this);
+      this.email = new Email(this);
+      this.forms = new Forms(this);
+      this.groups = new Groups(this);
+      this.logger = new Logger(this);
+      this.notifications = new Notifications(this);
+      this.pdf = new Pdf(this);
+      this.permissions = new Permissions(this);
+      this.products = new Products(this);
+      this.routes = new Routes(this);
+      this.schemas = new Schemas(this);
+      this.sms = new Sms(this);
+      this.static = new Static(this);
+      this.storage = new Storage(this);
+      this.templates = new Templates(this);
+      this.tokens = new Tokens(this);
+      this.transactions = new Transactions(this);
+      this.users = new Users(this);
+      this.webRtc = new WebRtc(this);
+      this.relayEvents(this.actions);
+      this.relayEvents(this.ai);
+      this.relayEvents(this.analytics);
+      this.relayEvents(this.api);
+      this.relayEvents(this.audit);
+      this.relayEvents(this.auth);
+      this.relayEvents(this.call);
+      this.relayEvents(this.client);
+      this.relayEvents(this.data);
+      this.relayEvents(this.discounts);
+      this.relayEvents(this.email);
+      this.relayEvents(this.forms);
+      this.relayEvents(this.groups);
+      this.relayEvents(this.logger);
+      this.relayEvents(this.notifications);
+      this.relayEvents(this.pdf);
+      this.relayEvents(this.products);
+      this.relayEvents(this.routes);
+      this.relayEvents(this.schemas);
+      this.relayEvents(this.settings);
+      this.relayEvents(this.sms);
+      this.relayEvents(this.static);
+      this.relayEvents(this.storage);
+      this.relayEvents(this.templates);
+      this.relayEvents(this.tokens);
+      this.relayEvents(this.transactions);
+      this.relayEvents(this.users);
+      this.relayEvents(this.webRtc);
+      this.users.on(`*`, () => {
+        if (!this.auth.user) return;
+        const cached = this.users.cache.get(this.auth.user._id);
+        if (cached) this.auth.user = cached;
+      });
+      if (this.opts.worker !== false && "serviceWorker" in navigator) {
+        navigator.serviceWorker.register(this.opts.worker, { type: "module" }).catch(() => console.warn("Unable to load momentum worker, some features may be limited."));
+      }
+    }
+  }
+  exports2.ActionType = ActionType;
+  exports2.Actions = Actions;
+  exports2.Ai = Ai;
+  exports2.Analytics = Analytics;
+  exports2.Api = Api;
+  exports2.Audit = Audit;
+  exports2.Auth = Auth;
+  exports2.Blacklist = Blacklist;
+  exports2.Call = Call;
+  exports2.Captcha = Captcha;
+  exports2.Client = Client;
+  exports2.Data = Data;
+  exports2.Discounts = Discounts;
+  exports2.Email = Email;
+  exports2.Forms = Forms;
+  exports2.Groups = Groups;
+  exports2.Logger = Logger;
+  exports2.Momentum = Momentum;
+  exports2.Notifications = Notifications;
+  exports2.PE = PE;
+  exports2.PES = PES;
+  exports2.PathEvent = PathEvent;
+  exports2.PathEventEmitter = PathEventEmitter;
+  exports2.Pdf = Pdf;
+  exports2.Permissions = Permissions;
+  exports2.Products = Products;
+  exports2.RateLimiter = RateLimiter;
+  exports2.Routes = Routes;
+  exports2.Schemas = Schemas;
+  exports2.Settings = Settings;
+  exports2.Sms = Sms;
+  exports2.Socket = Socket;
+  exports2.Static = Static;
+  exports2.Storage = Storage;
+  exports2.Templates = Templates;
+  exports2.Tokens = Tokens;
+  exports2.Totp = Totp;
+  exports2.Transactions = Transactions;
+  exports2.Users = Users;
+  exports2.WebRtc = WebRtc;
+  exports2.treeBuilder = treeBuilder;
+  exports2.validEvent = validEvent;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+}));