@auxilium/datalynk-client 1.3.3 → 1.3.5

package/dist/index.cjs

@@ -0,0 +1,3990 @@
+(function(global2, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.utils = {}));
+})(this, function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  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) {
+    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 == null ? void 0 : obj2.hasOwnProperty(prop2))) {
+        return void 0;
+      }
+      return obj2[prop2];
+    }, obj);
+  }
+  function isEqual(a, b) {
+    const ta = typeof a, tb = typeof b;
+    if (ta != "object" || a == null || (tb != "object" || b == null))
+      return ta == "function" && tb == "function" ? a.toString() == b.toString() : a === b;
+    const keys = Object.keys(a);
+    if (keys.length != Object.keys(b).length) return false;
+    return Object.keys(a).every((key) => isEqual(a[key], b[key]));
+  }
+  function JSONAttemptParse(json) {
+    try {
+      return JSON.parse(json);
+    } catch {
+      return 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);
+  }
+  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 == null ? void 0 : 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 sortByProp(prop, reverse = false) {
+    return function(a, b) {
+      const aVal = dotNotation(a, prop);
+      const bVal = dotNotation(b, prop);
+      if (typeof aVal == "number" && typeof bVal == "number")
+        return (reverse ? -1 : 1) * (aVal - bVal);
+      if (aVal > bVal) return reverse ? -1 : 1;
+      if (aVal < bVal) return reverse ? 1 : -1;
+      return 0;
+    };
+  }
+  function makeArray(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  class Database {
+    constructor(database, tables, version2) {
+      __publicField2(this, "connection");
+      __publicField2(this, "tables");
+      this.database = database;
+      this.version = version2;
+      this.connection = new Promise((resolve, reject) => {
+        const req = indexedDB.open(this.database, this.version);
+        this.tables = tables.map((t) => {
+          t = typeof t == "object" ? t : { name: t };
+          return { ...t, name: t.name.toString() };
+        });
+        const tableNames = new ASet(this.tables.map((t) => t.name));
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => {
+          const db = req.result;
+          if (tableNames.symmetricDifference(new ASet(Array.from(db.objectStoreNames))).length) {
+            db.close();
+            Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+          } else {
+            this.version = db.version;
+            resolve(db);
+          }
+        };
+        req.onupgradeneeded = () => {
+          const db = req.result;
+          const existingTables = new ASet(Array.from(db.objectStoreNames));
+          existingTables.difference(tableNames).forEach((name) => db.deleteObjectStore(name));
+          tableNames.difference(existingTables).forEach((name) => db.createObjectStore(name));
+        };
+      });
+    }
+    includes(name) {
+      return !!this.tables.find((t) => t.name == name.toString());
+    }
+    table(name) {
+      return new Table(this, name.toString());
+    }
+  }
+  class Table {
+    constructor(database, name) {
+      this.database = database;
+      this.name = name;
+    }
+    async tx(table, fn2, readonly = false) {
+      const db = await this.database.connection;
+      const tx = db.transaction(table, readonly ? "readonly" : "readwrite");
+      const store = tx.objectStore(table);
+      return new Promise((resolve, reject) => {
+        const request = fn2(store);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+    }
+    add(value, key) {
+      return this.tx(this.name, (store) => store.add(value, key));
+    }
+    count() {
+      return this.tx(this.name, (store) => store.count(), true);
+    }
+    put(key, value) {
+      return this.tx(this.name, (store) => store.put(value, key));
+    }
+    getAll() {
+      return this.tx(this.name, (store) => store.getAll(), true);
+    }
+    getAllKeys() {
+      return this.tx(this.name, (store) => store.getAllKeys(), true);
+    }
+    get(key) {
+      return this.tx(this.name, (store) => store.get(key), true);
+    }
+    delete(key) {
+      return this.tx(this.name, (store) => store.delete(key));
+    }
+    clear() {
+      return this.tx(this.name, (store) => store.clear());
+    }
+  }
+  function contrast(background) {
+    const exploded = background == null ? void 0 : background.match(background.length >= 6 ? /[0-9a-fA-F]{2}/g : /[0-9a-fA-F]/g);
+    if (!exploded || (exploded == null ? void 0 : 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 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("");
+  }
+  class PromiseProgress extends Promise {
+    constructor(executor) {
+      super((resolve, reject) => executor(
+        (value) => resolve(value),
+        (reason) => reject(reason),
+        (progress) => this.progress = progress
+      ));
+      __publicField2(this, "listeners", []);
+      __publicField2(this, "_progress", 0);
+    }
+    get progress() {
+      return this._progress;
+    }
+    set progress(p) {
+      if (p == this._progress) return;
+      this._progress = p;
+      this.listeners.forEach((l) => l(p));
+    }
+    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 sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async function sleepWhile(fn2, checkInterval = 100) {
+    while (await fn2()) await sleep(checkInterval);
+  }
+  class TypedEmitter {
+    constructor() {
+      __publicField2(this, "listeners", {});
+    }
+    static emit(event, ...args) {
+      (this.listeners["*"] || []).forEach((l) => l(event, ...args));
+      (this.listeners[event.toString()] || []).forEach((l) => l(...args));
+    }
+    static off(event, listener) {
+      const e = event.toString();
+      this.listeners[e] = (this.listeners[e] || []).filter((l) => l != listener);
+    }
+    static on(event, listener) {
+      var _a;
+      const e = event.toString();
+      if (!this.listeners[e]) this.listeners[e] = [];
+      (_a = this.listeners[e]) == null ? void 0 : _a.push(listener);
+      return () => this.off(event, listener);
+    }
+    static once(event, listener) {
+      return new Promise((res) => {
+        const unsubscribe = this.on(event, (...args) => {
+          res(args.length == 1 ? args[0] : args);
+          if (listener) listener(...args);
+          unsubscribe();
+        });
+      });
+    }
+    emit(event, ...args) {
+      (this.listeners["*"] || []).forEach((l) => l(event, ...args));
+      (this.listeners[event] || []).forEach((l) => l(...args));
+    }
+    off(event, listener) {
+      this.listeners[event] = (this.listeners[event] || []).filter((l) => l != listener);
+    }
+    on(event, listener) {
+      var _a;
+      if (!this.listeners[event]) this.listeners[event] = [];
+      (_a = this.listeners[event]) == null ? void 0 : _a.push(listener);
+      return () => this.off(event, listener);
+    }
+    once(event, listener) {
+      return new Promise((res) => {
+        const unsubscribe = this.on(event, (...args) => {
+          res(args.length == 1 ? args[0] : args);
+          if (listener) listener(...args);
+          unsubscribe();
+        });
+      });
+    }
+  }
+  __publicField2(TypedEmitter, "listeners", {});
+  class CustomError extends Error {
+    constructor(message, code) {
+      super(message);
+      __publicField2(this, "_code");
+      if (code != null) this._code = code;
+    }
+    get code() {
+      return this._code || this.constructor.code;
+    }
+    set code(c) {
+      this._code = c;
+    }
+    static from(err) {
+      const code = Number(err.statusCode) ?? Number(err.code);
+      const newErr = new this(err.message || err.toString());
+      return Object.assign(newErr, {
+        stack: err.stack,
+        ...err,
+        code: code ?? void 0
+      });
+    }
+    static instanceof(err) {
+      return err.constructor.code != void 0;
+    }
+    toString() {
+      return this.message || super.toString();
+    }
+  }
+  __publicField2(CustomError, "code", 500);
+  class BadRequestError extends CustomError {
+    constructor(message = "Bad Request") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(BadRequestError, "code", 400);
+  class UnauthorizedError extends CustomError {
+    constructor(message = "Unauthorized") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(UnauthorizedError, "code", 401);
+  class PaymentRequiredError extends CustomError {
+    constructor(message = "Payment Required") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(PaymentRequiredError, "code", 402);
+  class ForbiddenError extends CustomError {
+    constructor(message = "Forbidden") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(ForbiddenError, "code", 403);
+  class NotFoundError extends CustomError {
+    constructor(message = "Not Found") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(NotFoundError, "code", 404);
+  class MethodNotAllowedError extends CustomError {
+    constructor(message = "Method Not Allowed") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(MethodNotAllowedError, "code", 405);
+  class NotAcceptableError extends CustomError {
+    constructor(message = "Not Acceptable") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(NotAcceptableError, "code", 406);
+  class InternalServerError extends CustomError {
+    constructor(message = "Internal Server Error") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(InternalServerError, "code", 500);
+  class NotImplementedError extends CustomError {
+    constructor(message = "Not Implemented") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(NotImplementedError, "code", 501);
+  class BadGatewayError extends CustomError {
+    constructor(message = "Bad Gateway") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(BadGatewayError, "code", 502);
+  class ServiceUnavailableError extends CustomError {
+    constructor(message = "Service Unavailable") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(ServiceUnavailableError, "code", 503);
+  class GatewayTimeoutError extends CustomError {
+    constructor(message = "Gateway Timeout") {
+      super(message);
+    }
+    static instanceof(err) {
+      return err.constructor.code == this.code;
+    }
+  }
+  __publicField2(GatewayTimeoutError, "code", 504);
+  function errorFromCode(code, message) {
+    switch (code) {
+      case 400:
+        return new BadRequestError(message);
+      case 401:
+        return new UnauthorizedError(message);
+      case 402:
+        return new PaymentRequiredError(message);
+      case 403:
+        return new ForbiddenError(message);
+      case 404:
+        return new NotFoundError(message);
+      case 405:
+        return new MethodNotAllowedError(message);
+      case 406:
+        return new NotAcceptableError(message);
+      case 500:
+        return new InternalServerError(message);
+      case 501:
+        return new NotImplementedError(message);
+      case 502:
+        return new BadGatewayError(message);
+      case 503:
+        return new ServiceUnavailableError(message);
+      case 504:
+        return new GatewayTimeoutError(message);
+      default:
+        return new CustomError(message, code);
+    }
+  }
+  class HttpResponse extends Response {
+    constructor(resp, stream) {
+      const body = [204, 205, 304].includes(resp.status) ? null : stream;
+      super(body, {
+        headers: resp.headers,
+        status: resp.status,
+        statusText: resp.statusText
+      });
+      __publicField2(this, "data");
+      __publicField2(this, "ok");
+      __publicField2(this, "redirected");
+      __publicField2(this, "type");
+      __publicField2(this, "url");
+      this.ok = resp.ok;
+      this.redirected = resp.redirected;
+      this.type = resp.type;
+      this.url = resp.url;
+    }
+  }
+  const _Http = class _Http2 {
+    constructor(defaults = {}) {
+      __publicField2(this, "interceptors", {});
+      __publicField2(this, "headers", {});
+      __publicField2(this, "url");
+      this.url = defaults.url ?? null;
+      this.headers = defaults.headers || {};
+      if (defaults.interceptors) {
+        defaults.interceptors.forEach((i) => _Http2.addInterceptor(i));
+      }
+    }
+    static addInterceptor(fn2) {
+      const key = Object.keys(_Http2.interceptors).length.toString();
+      _Http2.interceptors[key] = fn2;
+      return () => {
+        _Http2.interceptors[key] = null;
+      };
+    }
+    addInterceptor(fn2) {
+      const key = Object.keys(this.interceptors).length.toString();
+      this.interceptors[key] = fn2;
+      return () => {
+        this.interceptors[key] = null;
+      };
+    }
+    request(opts = {}) {
+      var _a;
+      if (!this.url && !opts.url) throw new Error("URL needs to be set");
+      let url = ((_a = opts.url) == null ? void 0 : _a.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",
+        ..._Http2.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) => {
+            var _a2, _b;
+            for (let fn2 of [...Object.values(_Http2.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 = (_a2 = resp.body) == null ? void 0 : _a2.getReader();
+            const stream = new ReadableStream({
+              start(controller) {
+                function push() {
+                  reader == null ? void 0 : 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 = (_b = resp.headers.get("Content-Type")) == null ? void 0 : _b.toLowerCase();
+              if (content == null ? void 0 : content.includes("form")) resp.data = await resp.formData();
+              else if (content == null ? void 0 : content.includes("json")) resp.data = await resp.json();
+              else if (content == null ? void 0 : content.includes("text")) resp.data = await resp.text();
+              else if (content == null ? void 0 : content.includes("application")) resp.data = await resp.blob();
+            }
+            if (resp.ok) res(resp);
+            else rej(resp);
+          }).catch((err) => rej(err));
+        } catch (err) {
+          rej(err);
+        }
+      });
+    }
+  };
+  __publicField2(_Http, "interceptors", {});
+  __publicField2(_Http, "headers", {});
+  function decodeJwt(token) {
+    const base64 = token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
+    return JSONAttemptParse(decodeURIComponent(atob(base64).split("").map(function(c) {
+      return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join("")));
+  }
+  const CliEffects = {
+    CLEAR: "\x1B[0m"
+  };
+  const CliForeground = {
+    RED: "\x1B[31m",
+    YELLOW: "\x1B[33m",
+    BLUE: "\x1B[34m",
+    LIGHT_GREY: "\x1B[37m"
+  };
+  const _Logger = class _Logger2 extends TypedEmitter {
+    constructor(namespace) {
+      super();
+      this.namespace = namespace;
+    }
+    format(...text) {
+      const now = /* @__PURE__ */ new Date();
+      const timestamp = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()} ${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now.getMilliseconds().toString().padEnd(3, "0")}`;
+      return `${timestamp}${this.namespace ? ` [${this.namespace}]` : ""} ${text.map((t) => typeof t == "string" ? t : JSONSanitize(t, 2)).join(" ")}`;
+    }
+    debug(...args) {
+      if (_Logger2.LOG_LEVEL < 4) return;
+      const str = this.format(...args);
+      _Logger2.emit(4, str);
+      console.debug(CliForeground.LIGHT_GREY + str + CliEffects.CLEAR);
+    }
+    log(...args) {
+      if (_Logger2.LOG_LEVEL < 3) return;
+      const str = this.format(...args);
+      _Logger2.emit(3, str);
+      console.log(CliEffects.CLEAR + str);
+    }
+    info(...args) {
+      if (_Logger2.LOG_LEVEL < 2) return;
+      const str = this.format(...args);
+      _Logger2.emit(2, str);
+      console.info(CliForeground.BLUE + str + CliEffects.CLEAR);
+    }
+    warn(...args) {
+      if (_Logger2.LOG_LEVEL < 1) return;
+      const str = this.format(...args);
+      _Logger2.emit(1, str);
+      console.warn(CliForeground.YELLOW + str + CliEffects.CLEAR);
+    }
+    error(...args) {
+      if (_Logger2.LOG_LEVEL < 0) return;
+      const str = this.format(...args);
+      _Logger2.emit(0, str);
+      console.error(CliForeground.RED + str + CliEffects.CLEAR);
+    }
+  };
+  __publicField2(_Logger, "LOG_LEVEL", 4);
+  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+  var dist = {};
+  var persist$1 = {};
+  Object.defineProperty(persist$1, "__esModule", { value: true });
+  persist$1.persist = persist$1.Persist = void 0;
+  class Persist {
+    /**
+     * @param {string} key Primary key value will be stored under
+     * @param {PersistOptions<T>} options Configure using {@link PersistOptions}
+     */
+    constructor(key, options = {}) {
+      __publicField2(this, "key");
+      __publicField2(this, "options");
+      __publicField2(this, "storage");
+      __publicField2(this, "watches", {});
+      __publicField2(this, "_value");
+      this.key = key;
+      this.options = options;
+      this.storage = options.storage || localStorage;
+      this.load();
+    }
+    /** Current value or default if undefined */
+    get value() {
+      var _a;
+      return this._value !== void 0 ? this._value : (_a = this.options) == null ? void 0 : _a.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();
+    }
+    /** 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$1.Persist = Persist;
+  function persist(options) {
+    return (target, prop) => {
+      const key = (options == null ? void 0 : 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$1.persist = persist;
+  var memoryStorage = {};
+  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;
+  (function(exports3) {
+    var __createBinding = commonjsGlobal && commonjsGlobal.__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 = commonjsGlobal && commonjsGlobal.__exportStar || function(m, exports22) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports22, p)) __createBinding(exports22, m, p);
+    };
+    Object.defineProperty(exports3, "__esModule", { value: true });
+    __exportStar(persist$1, exports3);
+    __exportStar(memoryStorage, exports3);
+  })(dist);
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+      next: function() {
+        if (o && i >= o.length) o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    } catch (error) {
+      e = { error };
+    } finally {
+      try {
+        if (r && !r.done && (m = i["return"])) m.call(i);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return ar;
+  }
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  }
+  typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  function isFunction(value) {
+    return typeof value === "function";
+  }
+  function createErrorClass(createImpl) {
+    var _super = function(instance) {
+      Error.call(instance);
+      instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+  }
+  var UnsubscriptionError = createErrorClass(function(_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+      _super(this);
+      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+        return i + 1 + ") " + err.toString();
+      }).join("\n  ") : "";
+      this.name = "UnsubscriptionError";
+      this.errors = errors;
+    };
+  });
+  function arrRemove(arr, item) {
+    if (arr) {
+      var index = arr.indexOf(item);
+      0 <= index && arr.splice(index, 1);
+    }
+  }
+  var Subscription = function() {
+    function Subscription2(initialTeardown) {
+      this.initialTeardown = initialTeardown;
+      this.closed = false;
+      this._parentage = null;
+      this._finalizers = null;
+    }
+    Subscription2.prototype.unsubscribe = function() {
+      var e_1, _a, e_2, _b;
+      var errors;
+      if (!this.closed) {
+        this.closed = true;
+        var _parentage = this._parentage;
+        if (_parentage) {
+          this._parentage = null;
+          if (Array.isArray(_parentage)) {
+            try {
+              for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                var parent_1 = _parentage_1_1.value;
+                parent_1.remove(this);
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          } else {
+            _parentage.remove(this);
+          }
+        }
+        var initialFinalizer = this.initialTeardown;
+        if (isFunction(initialFinalizer)) {
+          try {
+            initialFinalizer();
+          } catch (e) {
+            errors = e instanceof UnsubscriptionError ? e.errors : [e];
+          }
+        }
+        var _finalizers = this._finalizers;
+        if (_finalizers) {
+          this._finalizers = null;
+          try {
+            for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+              var finalizer = _finalizers_1_1.value;
+              try {
+                execFinalizer(finalizer);
+              } catch (err) {
+                errors = errors !== null && errors !== void 0 ? errors : [];
+                if (err instanceof UnsubscriptionError) {
+                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                } else {
+                  errors.push(err);
+                }
+              }
+            }
+          } catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+          } finally {
+            try {
+              if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+            } finally {
+              if (e_2) throw e_2.error;
+            }
+          }
+        }
+        if (errors) {
+          throw new UnsubscriptionError(errors);
+        }
+      }
+    };
+    Subscription2.prototype.add = function(teardown) {
+      var _a;
+      if (teardown && teardown !== this) {
+        if (this.closed) {
+          execFinalizer(teardown);
+        } else {
+          if (teardown instanceof Subscription2) {
+            if (teardown.closed || teardown._hasParent(this)) {
+              return;
+            }
+            teardown._addParent(this);
+          }
+          (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+        }
+      }
+    };
+    Subscription2.prototype._hasParent = function(parent2) {
+      var _parentage = this._parentage;
+      return _parentage === parent2 || Array.isArray(_parentage) && _parentage.includes(parent2);
+    };
+    Subscription2.prototype._addParent = function(parent2) {
+      var _parentage = this._parentage;
+      this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent2), _parentage) : _parentage ? [_parentage, parent2] : parent2;
+    };
+    Subscription2.prototype._removeParent = function(parent2) {
+      var _parentage = this._parentage;
+      if (_parentage === parent2) {
+        this._parentage = null;
+      } else if (Array.isArray(_parentage)) {
+        arrRemove(_parentage, parent2);
+      }
+    };
+    Subscription2.prototype.remove = function(teardown) {
+      var _finalizers = this._finalizers;
+      _finalizers && arrRemove(_finalizers, teardown);
+      if (teardown instanceof Subscription2) {
+        teardown._removeParent(this);
+      }
+    };
+    Subscription2.EMPTY = function() {
+      var empty = new Subscription2();
+      empty.closed = true;
+      return empty;
+    }();
+    return Subscription2;
+  }();
+  var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+  function isSubscription(value) {
+    return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+  }
+  function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+      finalizer();
+    } else {
+      finalizer.unsubscribe();
+    }
+  }
+  var config = {
+    Promise: void 0
+  };
+  var timeoutProvider = {
+    setTimeout: function(handler, timeout) {
+      var args = [];
+      for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+      }
+      return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function(handle) {
+      return clearTimeout(handle);
+    },
+    delegate: void 0
+  };
+  function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function() {
+      {
+        throw err;
+      }
+    });
+  }
+  function noop() {
+  }
+  function errorContext(cb) {
+    {
+      cb();
+    }
+  }
+  var Subscriber = function(_super) {
+    __extends(Subscriber2, _super);
+    function Subscriber2(destination) {
+      var _this = _super.call(this) || this;
+      _this.isStopped = false;
+      if (destination) {
+        _this.destination = destination;
+        if (isSubscription(destination)) {
+          destination.add(_this);
+        }
+      } else {
+        _this.destination = EMPTY_OBSERVER;
+      }
+      return _this;
+    }
+    Subscriber2.create = function(next, error, complete) {
+      return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber2.prototype.next = function(value) {
+      if (this.isStopped) ;
+      else {
+        this._next(value);
+      }
+    };
+    Subscriber2.prototype.error = function(err) {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._error(err);
+      }
+    };
+    Subscriber2.prototype.complete = function() {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._complete();
+      }
+    };
+    Subscriber2.prototype.unsubscribe = function() {
+      if (!this.closed) {
+        this.isStopped = true;
+        _super.prototype.unsubscribe.call(this);
+        this.destination = null;
+      }
+    };
+    Subscriber2.prototype._next = function(value) {
+      this.destination.next(value);
+    };
+    Subscriber2.prototype._error = function(err) {
+      try {
+        this.destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    Subscriber2.prototype._complete = function() {
+      try {
+        this.destination.complete();
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    return Subscriber2;
+  }(Subscription);
+  var ConsumerObserver = function() {
+    function ConsumerObserver2(partialObserver) {
+      this.partialObserver = partialObserver;
+    }
+    ConsumerObserver2.prototype.next = function(value) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.next) {
+        try {
+          partialObserver.next(value);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    ConsumerObserver2.prototype.error = function(err) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.error) {
+        try {
+          partialObserver.error(err);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      } else {
+        handleUnhandledError(err);
+      }
+    };
+    ConsumerObserver2.prototype.complete = function() {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.complete) {
+        try {
+          partialObserver.complete();
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    return ConsumerObserver2;
+  }();
+  var SafeSubscriber = function(_super) {
+    __extends(SafeSubscriber2, _super);
+    function SafeSubscriber2(observerOrNext, error, complete) {
+      var _this = _super.call(this) || this;
+      var partialObserver;
+      if (isFunction(observerOrNext) || !observerOrNext) {
+        partialObserver = {
+          next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+          error: error !== null && error !== void 0 ? error : void 0,
+          complete: complete !== null && complete !== void 0 ? complete : void 0
+        };
+      } else {
+        {
+          partialObserver = observerOrNext;
+        }
+      }
+      _this.destination = new ConsumerObserver(partialObserver);
+      return _this;
+    }
+    return SafeSubscriber2;
+  }(Subscriber);
+  function handleUnhandledError(error) {
+    {
+      reportUnhandledError(error);
+    }
+  }
+  function defaultErrorHandler(err) {
+    throw err;
+  }
+  var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop
+  };
+  var observable = function() {
+    return typeof Symbol === "function" && Symbol.observable || "@@observable";
+  }();
+  function identity(x) {
+    return x;
+  }
+  function pipeFromArray(fns) {
+    if (fns.length === 0) {
+      return identity;
+    }
+    if (fns.length === 1) {
+      return fns[0];
+    }
+    return function piped(input) {
+      return fns.reduce(function(prev, fn) {
+        return fn(prev);
+      }, input);
+    };
+  }
+  var Observable = function() {
+    function Observable2(subscribe) {
+      if (subscribe) {
+        this._subscribe = subscribe;
+      }
+    }
+    Observable2.prototype.lift = function(operator) {
+      var observable2 = new Observable2();
+      observable2.source = this;
+      observable2.operator = operator;
+      return observable2;
+    };
+    Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+      var _this = this;
+      var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+      errorContext(function() {
+        var _a = _this, operator = _a.operator, source = _a.source;
+        subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+      });
+      return subscriber;
+    };
+    Observable2.prototype._trySubscribe = function(sink) {
+      try {
+        return this._subscribe(sink);
+      } catch (err) {
+        sink.error(err);
+      }
+    };
+    Observable2.prototype.forEach = function(next, promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var subscriber = new SafeSubscriber({
+          next: function(value) {
+            try {
+              next(value);
+            } catch (err) {
+              reject(err);
+              subscriber.unsubscribe();
+            }
+          },
+          error: reject,
+          complete: resolve
+        });
+        _this.subscribe(subscriber);
+      });
+    };
+    Observable2.prototype._subscribe = function(subscriber) {
+      var _a;
+      return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable2.prototype[observable] = function() {
+      return this;
+    };
+    Observable2.prototype.pipe = function() {
+      var operations = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        operations[_i] = arguments[_i];
+      }
+      return pipeFromArray(operations)(this);
+    };
+    Observable2.prototype.toPromise = function(promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var value;
+        _this.subscribe(function(x) {
+          return value = x;
+        }, function(err) {
+          return reject(err);
+        }, function() {
+          return resolve(value);
+        });
+      });
+    };
+    Observable2.create = function(subscribe) {
+      return new Observable2(subscribe);
+    };
+    return Observable2;
+  }();
+  function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+  }
+  function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+  }
+  function isSubscriber(value) {
+    return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+  }
+  function hasLift(source) {
+    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+  }
+  function operate(init) {
+    return function(source) {
+      if (hasLift(source)) {
+        return source.lift(function(liftedSource) {
+          try {
+            return init(liftedSource, this);
+          } catch (err) {
+            this.error(err);
+          }
+        });
+      }
+      throw new TypeError("Unable to lift unknown Observable type");
+    };
+  }
+  function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+  }
+  var OperatorSubscriber = function(_super) {
+    __extends(OperatorSubscriber2, _super);
+    function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+      var _this = _super.call(this, destination) || this;
+      _this.onFinalize = onFinalize;
+      _this.shouldUnsubscribe = shouldUnsubscribe;
+      _this._next = onNext ? function(value) {
+        try {
+          onNext(value);
+        } catch (err) {
+          destination.error(err);
+        }
+      } : _super.prototype._next;
+      _this._error = onError ? function(err) {
+        try {
+          onError(err);
+        } catch (err2) {
+          destination.error(err2);
+        } finally {
+          this.unsubscribe();
+        }
+      } : _super.prototype._error;
+      _this._complete = onComplete ? function() {
+        try {
+          onComplete();
+        } catch (err) {
+          destination.error(err);
+        } finally {
+          this.unsubscribe();
+        }
+      } : _super.prototype._complete;
+      return _this;
+    }
+    OperatorSubscriber2.prototype.unsubscribe = function() {
+      var _a;
+      if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+        var closed_1 = this.closed;
+        _super.prototype.unsubscribe.call(this);
+        !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+      }
+    };
+    return OperatorSubscriber2;
+  }(Subscriber);
+  var ObjectUnsubscribedError = createErrorClass(function(_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+      _super(this);
+      this.name = "ObjectUnsubscribedError";
+      this.message = "object unsubscribed";
+    };
+  });
+  var Subject = function(_super) {
+    __extends(Subject2, _super);
+    function Subject2() {
+      var _this = _super.call(this) || this;
+      _this.closed = false;
+      _this.currentObservers = null;
+      _this.observers = [];
+      _this.isStopped = false;
+      _this.hasError = false;
+      _this.thrownError = null;
+      return _this;
+    }
+    Subject2.prototype.lift = function(operator) {
+      var subject = new AnonymousSubject(this, this);
+      subject.operator = operator;
+      return subject;
+    };
+    Subject2.prototype._throwIfClosed = function() {
+      if (this.closed) {
+        throw new ObjectUnsubscribedError();
+      }
+    };
+    Subject2.prototype.next = function(value) {
+      var _this = this;
+      errorContext(function() {
+        var e_1, _a;
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          if (!_this.currentObservers) {
+            _this.currentObservers = Array.from(_this.observers);
+          }
+          try {
+            for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var observer = _c.value;
+              observer.next(value);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        }
+      });
+    };
+    Subject2.prototype.error = function(err) {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.hasError = _this.isStopped = true;
+          _this.thrownError = err;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().error(err);
+          }
+        }
+      });
+    };
+    Subject2.prototype.complete = function() {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.isStopped = true;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().complete();
+          }
+        }
+      });
+    };
+    Subject2.prototype.unsubscribe = function() {
+      this.isStopped = this.closed = true;
+      this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject2.prototype, "observed", {
+      get: function() {
+        var _a;
+        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Subject2.prototype._trySubscribe = function(subscriber) {
+      this._throwIfClosed();
+      return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject2.prototype._subscribe = function(subscriber) {
+      this._throwIfClosed();
+      this._checkFinalizedStatuses(subscriber);
+      return this._innerSubscribe(subscriber);
+    };
+    Subject2.prototype._innerSubscribe = function(subscriber) {
+      var _this = this;
+      var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+      if (hasError || isStopped) {
+        return EMPTY_SUBSCRIPTION;
+      }
+      this.currentObservers = null;
+      observers.push(subscriber);
+      return new Subscription(function() {
+        _this.currentObservers = null;
+        arrRemove(observers, subscriber);
+      });
+    };
+    Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+      if (hasError) {
+        subscriber.error(thrownError);
+      } else if (isStopped) {
+        subscriber.complete();
+      }
+    };
+    Subject2.prototype.asObservable = function() {
+      var observable2 = new Observable();
+      observable2.source = this;
+      return observable2;
+    };
+    Subject2.create = function(destination, source) {
+      return new AnonymousSubject(destination, source);
+    };
+    return Subject2;
+  }(Observable);
+  var AnonymousSubject = function(_super) {
+    __extends(AnonymousSubject2, _super);
+    function AnonymousSubject2(destination, source) {
+      var _this = _super.call(this) || this;
+      _this.destination = destination;
+      _this.source = source;
+      return _this;
+    }
+    AnonymousSubject2.prototype.next = function(value) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject2.prototype.error = function(err) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject2.prototype.complete = function() {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject2.prototype._subscribe = function(subscriber) {
+      var _a, _b;
+      return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject2;
+  }(Subject);
+  var BehaviorSubject = function(_super) {
+    __extends(BehaviorSubject2, _super);
+    function BehaviorSubject2(_value) {
+      var _this = _super.call(this) || this;
+      _this._value = _value;
+      return _this;
+    }
+    Object.defineProperty(BehaviorSubject2.prototype, "value", {
+      get: function() {
+        return this.getValue();
+      },
+      enumerable: false,
+      configurable: true
+    });
+    BehaviorSubject2.prototype._subscribe = function(subscriber) {
+      var subscription = _super.prototype._subscribe.call(this, subscriber);
+      !subscription.closed && subscriber.next(this._value);
+      return subscription;
+    };
+    BehaviorSubject2.prototype.getValue = function() {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+      if (hasError) {
+        throw thrownError;
+      }
+      this._throwIfClosed();
+      return _value;
+    };
+    BehaviorSubject2.prototype.next = function(value) {
+      _super.prototype.next.call(this, this._value = value);
+    };
+    return BehaviorSubject2;
+  }(Subject);
+  var EmptyError = createErrorClass(function(_super) {
+    return function EmptyErrorImpl() {
+      _super(this);
+      this.name = "EmptyError";
+      this.message = "no elements in sequence";
+    };
+  });
+  function lastValueFrom(source, config2) {
+    return new Promise(function(resolve, reject) {
+      var _hasValue = false;
+      var _value;
+      source.subscribe({
+        next: function(value) {
+          _value = value;
+          _hasValue = true;
+        },
+        error: reject,
+        complete: function() {
+          if (_hasValue) {
+            resolve(_value);
+          } else {
+            reject(new EmptyError());
+          }
+        }
+      });
+    });
+  }
+  function filter(predicate, thisArg) {
+    return operate(function(source, subscriber) {
+      var index = 0;
+      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        return predicate.call(thisArg, value, index++) && subscriber.next(value);
+      }));
+    });
+  }
+  function distinctUntilChanged(comparator, keySelector) {
+    if (keySelector === void 0) {
+      keySelector = identity;
+    }
+    comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
+    return operate(function(source, subscriber) {
+      var previousKey;
+      var first = true;
+      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        var currentKey = keySelector(value);
+        if (first || !comparator(previousKey, currentKey)) {
+          first = false;
+          previousKey = currentKey;
+          subscriber.next(value);
+        }
+      }));
+    });
+  }
+  function defaultCompare(a, b) {
+    return a === b;
+  }
+  function skip(count) {
+    return filter(function(_, index) {
+      return count <= index;
+    });
+  }
+  function takeWhile(predicate, inclusive) {
+    return operate(function(source, subscriber) {
+      var index = 0;
+      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        var result = predicate(value, index++);
+        (result || inclusive) && subscriber.next(value);
+        !result && subscriber.complete();
+      }));
+    });
+  }
+  async function getTheme(spoke, scope) {
+    let theme = await fetch(`https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/theme.json`).then((res) => res.json()).catch(() => null);
+    if (scope && theme != null && theme[scope]) theme = { ...theme, ...theme[scope] };
+    return {
+      found: !!theme,
+      background: `https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/background.jpg`,
+      backgroundColor: void 0,
+      color: "#c83232",
+      glow: "#c83232",
+      logo: `https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/logo.png`,
+      logoPosition: "left",
+      hideLogo: false,
+      hideApps: false,
+      persist: true,
+      title: spoke.toUpperCase(),
+      textColor: "white",
+      titleFontFamily: "sans-serif",
+      titleFontUrl: "https://fonts.cdnfonts.com/css/ar-blanca",
+      titleFontSize: "45px",
+      titleTextShadow: "0 0 3px black",
+      subtitle: "",
+      subtitleFontFamily: "sans-serif",
+      subtitleFontUrl: "",
+      subtitleFontSize: "36px",
+      subtitleTextColor: "white",
+      subtitleTextShadow: "0 0 3px black",
+      ...theme || {}
+    };
+  }
+  const _LoginPrompt = class _LoginPrompt {
+    constructor(api, spoke, options = {}) {
+      __publicField(this, "alert");
+      __publicField(this, "button");
+      __publicField(this, "form");
+      __publicField(this, "password");
+      __publicField(this, "persist");
+      __publicField(this, "username");
+      __publicField(this, "_done");
+      /** Promise which resolves once login is complete */
+      __publicField(this, "done", new Promise((res) => {
+        this._done = res;
+      }));
+      this.api = api;
+      this.spoke = spoke;
+      this.options = options;
+      this.themeDefaults().then(() => this.render());
+    }
+    async render() {
+      this.close();
+      document.head.innerHTML += _LoginPrompt.css(this.options);
+      const div = document.createElement("div");
+      div.innerHTML = _LoginPrompt.template(this.options);
+      document.body.appendChild(div);
+      this.alert = document.querySelector("#datalynk-login-alert");
+      this.button = document.querySelector("#datalynk-login-form button");
+      this.form = document.querySelector("#datalynk-login-form");
+      this.password = document.querySelector('#datalynk-login-form input[name="password"]');
+      this.persist = document.querySelector('#datalynk-login-form input[name="persist"]');
+      this.username = document.querySelector('#datalynk-login-form input[name="username"]');
+      if (this.options.persist === false) this.persist.parentElement.remove();
+      this.form.onsubmit = (event) => this.login(event);
+      const pwaLink = document.querySelector("#pwa-install-link");
+      if (pwaLink) {
+        pwaLink.addEventListener("click", async (e) => {
+          var _a;
+          e.preventDefault();
+          if ((_a = this.api.pwa) == null ? void 0 : _a.deferredPrompt) {
+            this.api.pwa.deferredPrompt.prompt();
+            const choice = await this.api.pwa.deferredPrompt.userChoice;
+            if (choice.outcome === "accepted") {
+              console.log("PWA installed via login link");
+            }
+            this.api.pwa.deferredPrompt = null;
+          } else {
+            this.api.pwa.prompt();
+          }
+        });
+      }
+    }
+    async themeDefaults() {
+      const theme = await getTheme(this.spoke, "login");
+      const cleaned = clean(this.options, true);
+      this.options = {
+        ...theme,
+        ...cleaned,
+        logoOnly: !this.options.title && !theme.found,
+        logoPosition: cleaned.logoPosition ?? theme.logoPosition ?? "left",
+        hideLogo: cleaned.hideLogo ?? theme.hideLogo ?? false,
+        platform: this.api.pwa.platform,
+        ...Object.prototype.hasOwnProperty.call(this.api.options, "pwaSettings") && {
+          pwaSettings: this.api.options.pwaSettings
+        }
+      };
+    }
+    /** Close the login prompt */
+    close() {
+      var _a, _b;
+      (_a = document.querySelector("#datalynk-login-styles")) == null ? void 0 : _a.remove();
+      (_b = document.querySelector("#datalynk-login")) == null ? void 0 : _b.remove();
+    }
+    /** Check if login prompt is still open */
+    isOpen() {
+      return !!document.querySelector("#datalynk-login");
+    }
+    /** Login form submit event */
+    login(event) {
+      event.preventDefault();
+      const data = new FormData(event.target);
+      this.alert.classList.add("hidden");
+      this.username.disabled = true;
+      this.password.disabled = true;
+      this.persist.disabled = true;
+      this.button.disabled = true;
+      return this.api.auth.login(
+        this.spoke,
+        data.get("username"),
+        data.get("password"),
+        { expire: this.persist.checked ? null : void 0 }
+      ).then((data2) => {
+        this.close();
+        this._done();
+        return data2;
+      }).catch((err) => {
+        this.alert.classList.remove("hidden");
+        this.alert.innerHTML = err.message;
+        this.password.value = "";
+        this.username.disabled = false;
+        this.password.disabled = false;
+        this.persist.disabled = false;
+        this.button.disabled = false;
+      });
+    }
+  };
+  /** Dynamically create CSS style */
+  __publicField(_LoginPrompt, "css", (options) => `
+	<style id="datalynk-login-styles">
+		@import url('https://fonts.cdnfonts.com/css/ar-blanca');
+		${options.titleFontUrl ? `@import url('${options.titleFontUrl}');` : ""}
+		${options.subtitleFontUrl ? `@import url('${options.subtitleFontUrl}');` : ""}
+		
+		#datalynk-login {
+			--theme-background: ${options.backgroundColor ? options.backgroundColor : `url(${options.background})`};
+			--theme-container: #000000cc;
+			--theme-glow: ${options.glow || options.color};
+			--theme-primary: ${options.color};
+			--theme-text: ${options.textColor};
+			
+			position: fixed;
+			left: 0;
+			top: 0;
+			right: 0;
+			bottom: 0;
+			background: var(--theme-background);
+			background-repeat: no-repeat;
+            background-size: cover;
+			font-family: sans-serif;
+			z-index: 1000;
+		}
+
+		#datalynk-login .added-links {
+			color: var(--theme-text);
+			position: fixed;
+			bottom: 0;
+			right: 0;
+			padding: 0.25rem;
+		}
+		
+		#datalynk-login .added-links a, #datalynk-login .added-links a:hover, #datalynk-login .added-links a:visited {
+			color: var(--theme-text);
+			text-shadow: 0 0 10px black;
+		}
+	
+		#datalynk-login-alert {
+			padding: 0.75rem;
+			background: rgba(0,0,0,0.5);
+			color: white;
+			border-radius: 5px;
+			margin-bottom: 1rem;
+			border: grey 1px solid;
+		}
+	
+		#datalynk-login label {
+			color: white;
+			font-size: 20px;
+		}
+	
+		#datalynk-login input {
+			width: calc(100% - 20px);
+			padding: 12px 9px 9px 9px;
+			margin: 1px;
+			border: 1px solid #ddd;
+			border-radius: 5px;
+			background-color: white;
+			color: black;
+		}
+	
+		#datalynk-login .login-container {
+			position: fixed;
+			top: 50%;
+			left: 0;
+			right: 0;
+			transform: translateY(-50%);
+		}
+		
+		#datalynk-login .login-header {
+			display: flex;
+			justify-content: center;
+			align-items: center;
+			color: var(--theme-text);
+			text-align: center;
+			font-size: 32px;
+			margin-bottom: 2rem;
+		}
+
+		#datalynk-login .login-title {
+			font-family: ${options.titleFontFamily || "sans-serif"};
+			font-size: ${options.titleFontSize || "32px"};
+			${options.titleTextShadow ? `text-shadow: ${options.titleTextShadow};` : ""}
+		}
+			
+		#datalynk-login .login-subtitle {
+			font-family: ${options.subtitleFontFamily || "sans-serif"};
+			font-size: ${options.subtitleFontSize || "20px"};
+			color: ${options.subtitleTextColor || "white"};
+			${options.subtitleTextShadow ? `text-shadow: ${options.subtitleTextShadow};` : ""}
+			margin-top: 0.5rem;
+		}
+
+		#datalynk-login .login-content {
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+			background: var(--theme-container);
+			border-top: var(--theme-glow) 1px solid;
+			box-shadow: 0 -10px 20px -10px var(--theme-glow);
+		}
+	
+		#datalynk-login .login-body {
+			padding: ${options.hideApps ? "3.5rem 0" : "3.5rem 0 1.5rem 0"};
+			width: 100%;
+			max-width: 400px;;
+			color: white;
+		}
+		
+		#datalynk-login input:disabled {
+			color: #333;
+			background-color: #ccc;
+		}
+		
+		#datalynk-login input[type="checkbox"] {
+		    height: 15px;
+		    margin: 0;
+		    padding: 0;
+		    accent-color: var(--theme-primary);
+		}
+		
+		#datalynk-login button {
+			background-color: var(--theme-primary);
+			background-image: none;
+			border: 0;
+			color: ${contrast(options.color)};
+			padding: 8px 24px;
+			border-radius: 5px;
+		}
+	
+		#datalynk-login button:disabled {
+			cursor: pointer;
+			filter: brightness(90%);
+		}
+	
+		#datalynk-login button:hover:not(:disabled) {
+			cursor: pointer;
+			filter: ${contrast(options.color) == "black" ? "brightness(105%)" : "brightness(80%)"};
+		}
+	
+		#datalynk-login .login-links{
+			display: flex;
+			padding: 0 0 1.5rem 0;
+		}
+	
+		#datalynk-login .login-links a {
+			text-decoration: none;
+		}
+
+		#datalynk-login #pwa-install-link {
+			display: inline-flex;
+			align-items: center;
+			gap: 0.4rem; /* space between icon and text */
+			font-size: 16px;
+			text-decoration: none;
+			color: var(--theme-text);
+			text-shadow: 0 0 10px black;
+		}
+			
+		#datalynk-login .login-links img {
+			width: 150px;
+			height: auto;
+		}
+	
+		#datalynk-login .hidden {
+			display: none;
+		}
+		
+		#datalynk-login .login-footer {
+			transform: translateY(-18px);
+		}
+		
+		#datalynk-login .sloped-div {
+			position: absolute;
+			height: 45px;
+			width: 200px;
+			background: var(--theme-container);
+			clip-path: polygon(0 20px, 100% 20px, 85% 60px, 15% 60px);
+		}
+	</style>`);
+  /** Dynamically create HTML */
+  __publicField(_LoginPrompt, "template", (options) => {
+    var _a;
+    return `
+	<div id="datalynk-login">
+		${!options.backgroundColor ? `<img src="${options.background}" onerror="document.querySelector('#datalynk-login').style.backgroundImage = 'url(https://datalynk.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/datalynk/background.jpg)'" style="width: 0; height: 0;"/>` : ""}
+		<div class="added-links">
+			${(options.addLinks || []).map((link) => `<a href="${link.url || "#"}" target="_blank">${link.text}</a>`).join(" | ")}
+		</div>
+		<div class="login-container">
+			<div class="login-header" style="flex-direction: ${["aboveTitle", "belowTitle", "belowSubtitle"].includes(options.logoPosition || "") ? "column" : "row"};">
+				${!options.hideLogo && options.logo && options.logoPosition === "aboveTitle" ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto; margin-bottom: 0.5rem;" onerror="this.style.display='none'">` : ""}
+
+				${!options.hideLogo && options.logo && options.logoPosition === "left" ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto; margin-right: 0.5rem;" onerror="this.style.display='none'">` : ""}
+
+				<div style="display: flex; flex-direction: column; align-items: center;">
+					<span class="login-title">${options.title || ""}</span>
+					${options.logo && !options.hideLogo && options.logoPosition === "belowTitle" ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto; margin-top: 0.5rem;" onerror="this.style.display='none'">` : ""}
+					${options.subtitle ? `<span class="login-subtitle">${options.subtitle}</span>` : ""}
+					${options.logo && !options.hideLogo && options.logoPosition === "belowSubtitle" ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto; margin-top: 0.5rem;" onerror="this.style.display='none'">` : ""}
+				</div>
+
+				${!options.hideLogo && options.logo && options.logoPosition === "right" ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto; margin-left: 0.5rem;" onerror="this.style.display='none'">` : ""}
+			</div>
+			<div class="login-content">
+				<div class="login-body" style="max-width: 300px">
+					<div id="datalynk-login-alert" class="hidden"></div>
+					<form id="datalynk-login-form">
+						<div>
+							<label for="username">Email or Username</label>
+							<input id="username" name="username" type="text" autocomplete="username">
+						</div>
+						<br>
+						<div>
+							<label for="password">Password</label>
+							<input id="password" name="password" type="password" autocomplete="current-password">
+						</div>
+						<br>
+						<label style="display: block; margin-bottom: 0.75rem;">
+							<input type="checkbox" name="persist" style="width: 20px"> Stay Logged In
+						</label>
+						<button type="submit">Login</button>
+					</form>
+				</div>
+				<div class="login-links" style="text-align: center">
+					${((_a = options == null ? void 0 : options.pwaSettings) == null ? void 0 : _a.loginLink) === true && !["ios", "mac"].includes(options.platform) ? `
+					<a href="#" id="pwa-install-link" style="margin-right: 1rem;" title="Install App">
+						<svg xmlns="http://www.w3.org/2000/svg" height="40px" viewBox="0 0 24 24" width="40px" fill="${options.color || "#0B76FC"}">
+							<path d="M12 16l4-5h-3V4h-2v7H8z"/><path d="M20 18H4v-2h16v2z"/>
+						</svg> Download App
+					</a>` : ""}
+					${options.hideApps ? "" : `
+					<a href="https://itunes.apple.com/ca/app/auxilium-mobile/id1166379280?mt=8" target="_blank">
+						<img alt="App Store" src="https://datalynk.auxiliumgroup.com/api/js/auxilium/dijits/templates/login/_common/mobile_apple_transparent.png">
+					</a>
+					<a href="https://play.google.com/store/apps/details?id=com.auxilium.auxiliummobilesolutions&amp;hl=en" target="_blank">
+						<img alt="Playstore" src="https://datalynk.auxiliumgroup.com/api/js/auxilium/dijits/templates/login/_common/mobile_google_transparent.png">
+					</a>`}
+				</div>
+			</div>
+			<div class="login-footer" style="position: relative; display: flex; align-items: center; justify-content: center;">
+				<div class="sloped-div"></div>
+				<a href="https://auxiliumgroup.com" target="_blank" style="position: relative; height: 40px; display: flex; align-items: center; text-decoration: none; font-family: 'AR BLANCA', serif; font-size: 26px; color: white;">
+					Au<span style="font-size: 52px; color: #c83232; margin-bottom: 5px; font-family: 'AR BLANCA', serif;">x</span>ilium
+					<span style="position: absolute; font-size: 10px; color: #c83232; top: 2px; right: 2px; font-family: 'AR BLANCA', serif;">Group</span>
+				</a>
+			</div>
+		</div>
+	</div>
+	`;
+  });
+  let LoginPrompt = _LoginPrompt;
+  class Auth {
+    constructor(api) {
+      __publicField(this, "onlinePrompt");
+      /** Current user as an observable */
+      __publicField(this, "user$", new BehaviorSubject(void 0));
+      var _a;
+      this.api = api;
+      this.api.token$.subscribe(async (token) => {
+        if (token === void 0) return;
+        this.user = await this.current(token);
+      });
+      if ((_a = this.api.options.offline) == null ? void 0 : _a.length)
+        this.user$.pipe(filter((u) => u !== void 0)).subscribe((u) => localStorage.setItem("datalynk-user", JSON.stringify(u)));
+    }
+    /** Current user */
+    get user() {
+      return this.user$.getValue();
+    }
+    /** Set current user info */
+    set user(user) {
+      this.user$.next(user);
+    }
+    get spoke() {
+      var _a;
+      return ((_a = this.api.jwtPayload) == null ? void 0 : _a.realm) || null;
+    }
+    /**
+     * Get current user associated with API token
+     *
+     * @return {Promise<User | null>}
+     */
+    async current(token = this.api.token) {
+      var _a;
+      if (!token) return null;
+      else if (token == ((_a = this.user) == null ? void 0 : _a.token)) return this.user;
+      else if (!this.api.online && typeof localStorage != "undefined" && localStorage.getItem("datalynk-user"))
+        return JSON.parse(localStorage.getItem("datalynk-user"));
+      return this.api.request([{ "$/auth/current": {} }, { "$/env/me": {} }], { token }).then((resp) => resp[0] || resp[1] ? { ...resp[0], ...resp[1] } : null);
+    }
+    /**
+     * Automatically handle sessions by checking localStorage & URL parameters for a token & prompting
+     * user with a login screen if required
+     *
+     * @param {string} spoke Desired spoke
+     * @param {LoginPromptOptions} options Aesthetic options
+     * @return {Promise<void>} Login complete
+     */
+    async handleLogin(spoke, options) {
+      var _a, _b;
+      if (this.onlinePrompt) window.removeEventListener("online", this.onlinePrompt);
+      if ((_a = this.api.options.offline) == null ? void 0 : _a.length) window.removeEventListener("online", this.onlinePrompt = () => this.handleLogin(spoke, options));
+      const urlToken = new URLSearchParams(location.search).get("datalynkToken");
+      if (urlToken) {
+        this.api.token = urlToken;
+        location.href = location.href.replace(/datalynkToken=.*?(&|$)/gm, "");
+      } else if (this.api.token && !this.api.expired) {
+        if (((_b = this.api.jwtPayload) == null ? void 0 : _b.realm) != spoke) {
+          this.api.token = null;
+          location.reload();
+        }
+      } else {
+        this.api.token = null;
+        await this.loginPrompt(spoke, options).done;
+        location.reload();
+      }
+    }
+    /**
+     * Check whether user has a token
+     *
+     * @return {boolean} True if session token authenticated
+     */
+    isAuthenticated() {
+      return !!this.user && !this.user.guest;
+    }
+    /**
+     * Check if the current user is a guest
+     *
+     * @return {boolean} True if guest
+     */
+    isGuest() {
+      var _a;
+      return !!((_a = this.user) == null ? void 0 : _a.guest);
+    }
+    /**
+     * Check if user is a system administrator
+     *
+     * @return {Promise<boolean>} True if system administrator
+     */
+    async isSysAdmin() {
+      return !!(await this.api.slice("sysadmin").select().where("auth_ref", "==", "$viewer").rows().exec()).length;
+    }
+    /**
+     * Check if user is a table administrator
+     *
+     * @return {Promise<boolean>} True if table administrator
+     */
+    async isTableAdmin() {
+      return !!(await this.api.slice("tableadmins").select().where("auth_ref", "==", "$viewer").rows().exec()).length;
+    }
+    /**
+     * Check if user is a user administrator
+     *
+     * @return {Promise<boolean>} True if user administrator
+     */
+    async isUserAdmin() {
+      return !!(await this.api.slice("useradmins").select().where("auth_ref", "==", "$viewer").rows().exec()).length;
+    }
+    /**
+     * Perform login and save the session token
+     *
+     * @param {string} login Login username or email
+     * @param {string} password Password for account
+     * @param {string} spoke Override login spoke
+     * @param {twoFactor?: string, expire?: string} opts 2FA code & expire date (YYYY-MM-DD)
+     * @returns {Promise<User>} User account
+     */
+    login(spoke, login, password, opts) {
+      const date = /* @__PURE__ */ new Date();
+      date.setFullYear(date.getFullYear() + 1);
+      return fetch(`${this.api.url}login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(clean({
+          realm: spoke.trim(),
+          login: login.trim(),
+          password: password.trim(),
+          secret: opts == null ? void 0 : opts.twoFactor,
+          expireAt: (opts == null ? void 0 : opts.expire) == null ? `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, "0")}-${date.getDate().toString().padStart(2, "0")}` : opts == null ? void 0 : opts.expire,
+          dateFormat: "ISO8601"
+        }))
+      }).then(async (resp) => {
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok || data["error"]) throw Object.assign(errorFromCode(resp.status, data.error) || {}, data);
+        this.api.token = data["token"];
+        return data;
+      });
+    }
+    /**
+     * Login as guest user
+     *
+     * @return {Promise<User>} Guest account
+     */
+    loginGuest() {
+      return fetch(`${this.api.url}guest`).then(async (resp) => {
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok || data["error"]) throw Object.assign(errorFromCode(resp.status, data.error) || {}, data);
+        this.api.token = data["token"];
+        return data;
+      });
+    }
+    /**
+     * Create Login UI
+     *
+     * @param {string} spoke Desired spoke
+     * @param {LoginPromptOptions} options Aesthetic options
+     * @return {LoginPrompt} Login prompt
+     */
+    loginPrompt(spoke, options) {
+      return new LoginPrompt(this.api, spoke, options);
+    }
+    /**
+     * Logout current user
+     *
+     * @return {Promise<{closed: string, new: string}>}
+     */
+    logout(reload = true) {
+      localStorage.removeItem("datalynk-user");
+      return this.api.request({ "$/auth/logout": {} }).then((resp) => {
+        if (reload) location.reload();
+        this.api.token = null;
+        return resp;
+      });
+    }
+    /**
+     * Reset user account password
+     *
+     * @param {string} login User login
+     * @param {string} newPassword New password
+     * @param {string} code Reset code sent with `resetRequest`
+     * @return {Promise<any>} New session
+     */
+    reset(login, newPassword, code) {
+      return this.api.request({
+        "$/auth/mobile/rescue": {
+          user: login,
+          password: newPassword,
+          pin: code
+        }
+      }).then((resp) => {
+        if (resp.token) this.api.token = resp.token;
+        return resp;
+      });
+    }
+    /**
+     * Request reset code for user
+     *
+     * @param {string} login User to reset
+     * @param {"email" | "sms" | "voice"} mode Method of sending reset code
+     * @return {Promise<any>} Unknown
+     */
+    resetRequest(login, mode) {
+      if (mode == "email") return this.api.request({ "$/auth/rescue_email": { user: { $or: { login, email: login } } } });
+      return this.api.request({ "$/auth/mobile/generate": { user: login, method: mode } });
+    }
+  }
+  class PWA {
+    constructor(api) {
+      __publicField(this, "deferredPrompt", null);
+      this.api = api;
+    }
+    // Holds the beforeinstallprompt event
+    get headless() {
+      return typeof window == "undefined";
+    }
+    get iframe() {
+      return (parent == null ? void 0 : parent.location) != location;
+    }
+    get mobile() {
+      return ["android", "ios"].includes(this.platform);
+    }
+    get platform() {
+      const userAgent = navigator.userAgent || navigator.vendor;
+      if (/windows/i.test(userAgent)) return "windows";
+      else if (/android/i.test(userAgent)) return "android";
+      else if (/iPad|iPhone|iPod/.test(userAgent)) return "ios";
+      else if (/macintosh|mac os x/i.test(userAgent)) return "mac";
+      else if (/linux/i.test(userAgent)) return "linux";
+      else return "unknown";
+    }
+    get pwa() {
+      return matchMedia("(display-mode: standalone)").matches || (navigator == null ? void 0 : navigator.standalone) || document.referrer.includes("android-app://");
+    }
+    bindInstallButton() {
+      const installBtn = document.querySelector("#installPwaBtn");
+      if (!installBtn) return;
+      installBtn.onclick = async () => {
+        var _a;
+        this.deferredPrompt.prompt();
+        const choice = await this.deferredPrompt.userChoice;
+        if (choice.outcome === "accepted") {
+          console.log("PWA installed");
+          localStorage.removeItem(`${this.api.options.name}:pwa`);
+        }
+        this.deferredPrompt = null;
+        (_a = document.querySelector(".pwa-prompt")) == null ? void 0 : _a.remove();
+      };
+    }
+    /** Setup the PWA */
+    async setup(manifest = {}) {
+      var _a, _b, _c;
+      window.addEventListener("beforeinstallprompt", (e) => {
+        e.preventDefault();
+        this.deferredPrompt = e;
+        const actions = document.querySelector(".pwa-prompt-actions");
+        if (actions && !actions.querySelector("#installPwaBtn")) {
+          actions.innerHTML = `<button id="installPwaBtn">Install App</button>`;
+          this.bindInstallButton();
+        }
+      });
+      const settings = {
+        timeout: (((_a = this.api.options.pwaSettings) == null ? void 0 : _a.timeout) ?? 30) * 1e3,
+        // default 30s
+        dismissExpiry: ((_b = this.api.options.pwaSettings) == null ? void 0 : _b.dismissExpiry) ?? 7,
+        // default 7 days
+        loginLink: ((_c = this.api.options.pwaSettings) == null ? void 0 : _c.loginLink) ?? false
+      };
+      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);
+      };
+      meta("name", "mobile-web-app-capable", "yes");
+      meta("name", "apple-mobile-web-app-status-bar-style", "default");
+      meta("name", "apple-mobile-web-app-title", this.api.options.name);
+      meta("name", "apple-touch-icon", `https://datalynk-client.scarborough.auxilium.world/logo.png`);
+      meta("name", "apple-touch-startup-image", `https://datalynk-client.scarborough.auxilium.world/logo.png`);
+      if (!document.querySelector('link[rel="manifest"]')) {
+        const link = document.createElement("link");
+        link.rel = "manifest";
+        const base = String(this.api.url).replace(/\/+$/, "");
+        const startUrl = location.pathname;
+        const scopePath = startUrl.endsWith("/") ? startUrl : startUrl.replace(/[^/]+$/, "");
+        const manifestObj = {
+          name: this.api.options.name,
+          short_name: this.api.options.name,
+          start_url: startUrl,
+          scope: scopePath || "/",
+          display: "standalone",
+          ...this.api.options.manifest || {},
+          ...manifest || {}
+        };
+        link.href = `${base}/manifest?json=${encodeURIComponent(JSON.stringify(manifestObj))}`;
+        document.head.append(link);
+      }
+      if (!this.headless && !this.iframe && !this.pwa && this.platform != "mac") setTimeout(() => {
+        const dismissedDate = localStorage.getItem(`${this.api.options.name}:pwa`);
+        if (settings.dismissExpiry > 0 && dismissedDate) {
+          const diffDays = (Date.now() - new Date(dismissedDate).getTime()) / (1e3 * 60 * 60 * 24);
+          if (diffDays < settings.dismissExpiry) return;
+        } else if (settings.dismissExpiry === 0) {
+          localStorage.removeItem(`${this.api.options.name}:pwa`);
+        }
+        this.prompt();
+      }, settings.timeout);
+    }
+    /** Prompt user to install the app */
+    async prompt(platform) {
+      var _a;
+      if (document.querySelector(".pwa-prompt")) return;
+      const android = (platform || this.platform) == "android";
+      let style = document.querySelector("style.pwa");
+      if (!style) {
+        style = document.createElement("style");
+        style.classList.add("pwa");
+        style.innerHTML = `
+			.pwa-prompt {
+				position: fixed;
+				bottom: 0;
+				left: 50%;
+				transform: translateX(-50%);
+				background: #fff;
+				color: #222;
+				width: min(100vw, 450px);
+				border-radius: 8px 8px 0 0;
+				box-shadow: 0 -4px 12px rgba(0,0,0,0.2);
+				font-family: system-ui, sans-serif;
+				animation: slideUp 0.35s ease forwards;
+				z-index: 10000;
+				box-shadow: 0px 10px 5px 3px #0000007d;
+			}
+			.pwa-prompt-header {
+				display: flex;
+				align-items: center;
+   				background: linear-gradient(140deg, #080808, #454242bf);
+				color: #fff;
+				padding: 0.75rem 1rem;
+				position: relative;
+				border-radius: 10px 10px 0px 0px;
+			}
+			.pwa-prompt-header img {
+				height: 28px;
+				margin-right: 0.5rem;
+			}
+			.pwa-prompt-header h1 {
+				font-size: 1rem;
+				margin: 0;
+				flex-grow: 1;
+			}
+			.pwa-prompt-close {
+				position: absolute;
+				right: 12px;
+				top: 10px;
+				background: transparent;
+				border: none;
+				color: #fff;
+				font-size: 18px;
+				cursor: pointer;
+			}
+			.pwa-prompt-body {
+				padding: 1rem;
+				font-size: 0.9rem;
+				text-align: center;
+			}
+			.pwa-prompt-actions {
+				text-align: center;
+				padding: 0.75rem 1rem 1rem;
+			}
+			.pwa-prompt-actions button {
+				background: #c33031;
+				color: #fff;
+				border: none;
+				padding: 0.6rem 1.2rem;
+				border-radius: 6px;
+				cursor: pointer;
+				font-size: 0.9rem;
+			}
+			.pwa-steps ol {
+				padding-left: 1.25rem;
+				text-align: left;
+			}
+			.pwa-prompt-actions table {
+				width: 100%;
+				margin: 0;
+			}
+			.pwa-prompt-actions td {
+				padding: 0.5rem;
+			}
+			@keyframes slideUp {
+				from { transform: translate(-50%, 100%); opacity: 0; }
+				to { transform: translate(-50%, 0); opacity: 1; }
+			}`;
+        document.head.append(style);
+      }
+      const prompt = document.createElement("div");
+      prompt.classList.add("pwa-prompt");
+      prompt.innerHTML = `
+			<div class="pwa-prompt-header">
+				<img src="https://datalynk-client.scarborough.auxilium.world/logo.png" alt="Logo" />
+				<h1>Install ${this.api.options.name}</h1>
+				<button class="pwa-prompt-close">&times;</button>
+			</div>
+			<div class="pwa-prompt-body">
+				${this.deferredPrompt ? "Click below to install the app directly to your device." : "Add this app to your home screen for a faster, fullscreen experience."}
+			</div>
+			<div class="pwa-prompt-actions">
+				${this.deferredPrompt ? `<button id="installPwaBtn">Install App</button>` : `
+						<table>
+							<tr>
+								<td style="width:40px;text-align:center">
+									${android ? '<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="black" style="transform: scale(1.5)"><path d="M480-160q-33 0-56.5-23.5T400-240q0-33 23.5-56.5T480-320q33 0 56.5 23.5T560-240q0 33-23.5 56.5T480-160Zm0-240q-33 0-56.5-23.5T400-480q0-33 23.5-56.5T480-560q33 0 56.5 23.5T560-480q0 33-23.5 56.5T480-400Zm0-240q-33 0-56.5-23.5T400-720q0-33 23.5-56.5T480-800q33 0 56.5 23.5T560-720q0 33-23.5 56.5T480-640Z"/></svg>' : '<svg viewBox="0 0 566 670" xmlns="http://www.w3.org/2000/svg" fill="#c33031" height="40px"><path d="M255 12c4-4 10-8 16-8s12 3 16 8l94 89c3 4 6 7 8 12 2 6 0 14-5 19-7 8-20 9-28 2l-7-7-57-60 2 54v276c0 12-10 22-22 22-12 1-24-10-23-22V110l1-43-60 65c-5 5-13 8-21 6a19 19 0 0 1-16-17c-1-7 2-13 7-18l95-91z" /><path d="M43 207c16-17 40-23 63-23h83v46h-79c-12 0-25 3-33 13-8 9-10 21-10 33v260c0 13 0 27 6 38 5 12 18 18 30 19l14 1h302c14 0 28 0 40-8 11-7 16-21 16-34V276c0-11-2-24-9-33-8-10-22-13-34-13h-78v-46h75c13 0 25 1 37 4 16 4 31 13 41 27 11 17 14 37 14 57v280c0 20-3 41-15 58a71 71 0 0 1-45 27c-11 2-23 3-34 3H109c-19-1-40-4-56-15-14-9-23-23-27-38-4-12-5-25-5-38V270c1-22 6-47 22-63z" /></svg>'}
+								</td>
+								<td>1) ${android ? "Open the dropdown menu" : 'Tap the "Share" button'}</td>
+							</tr>
+							<tr>
+								<td style="width:40px;text-align:center">
+									${android ? '<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="black" style="transform: scale(-1.5, 1.5)"><path d="M280-40q-33 0-56.5-23.5T200-120v-720q0-33 23.5-56.5T280-920h280v80H280v40h280v80H280v480h400v-80h80v200q0 33-23.5 56.5T680-40H280Zm0-120v40h400v-40H280Zm440-240L520-600l56-56 104 104v-288h80v288l104-104 56 56-200 200ZM280-800v-40 40Zm0 640v40-40Z"/></svg>' : '<svg viewBox="0 0 578 584" xmlns="http://www.w3.org/2000/svg" fill="black" height="34px"><path d="M101 35l19-1h333c12 0 23 0 35 3 17 3 34 12 44 27 13 16 16 38 16 58v329c0 19 0 39-8 57a65 65 0 0 1-37 37c-18 7-38 7-57 7H130c-21 1-44 0-63-10-14-7-25-20-30-34-6-15-8-30-8-45V121c1-21 5-44 19-61 13-16 33-23 53-25m7 46c-10 1-19 6-24 14-7 8-9 20-9 31v334c0 12 2 25 10 34 9 10 23 12 35 12h336c14 1 30-3 38-15 6-9 8-20 8-31V125c0-12-2-24-10-33-9-9-22-12-35-12H121l-13 1z" /><path d="M271 161c9-11 31-10 38 4 3 5 3 11 3 17v87h88c7 0 16 1 21 7 6 6 7 14 6 22a21 21 0 0 1-10 14c-5 4-11 5-17 5h-88v82c0 7-1 15-6 20-10 10-29 10-37-2-3-6-4-13-4-19v-81h-87c-8-1-17-3-23-9-5-6-6-15-4-22a21 21 0 0 1 11-14c6-3 13-3 19-3h84v-88c0-7 1-14 6-20z" /></svg>'}
+								</td>
+								<td>2) Select "Add to Home Screen"</td>
+							</tr>
+						</table>
+					`}
+			</div>
+		`;
+      const closeBtn = prompt.querySelector(".pwa-prompt-close");
+      const dismissExpiry = ((_a = this.api.options.pwaSettings) == null ? void 0 : _a.dismissExpiry) ?? 7;
+      closeBtn.onclick = () => {
+        dismissExpiry > 0 ? localStorage.setItem(`${this.api.options.name}:pwa`, (/* @__PURE__ */ new Date()).toISOString()) : localStorage.removeItem(`${this.api.options.name}:pwa`);
+        prompt.remove();
+      };
+      document.body.append(prompt);
+      if (this.deferredPrompt) this.bindInstallButton();
+    }
+  }
+  class Files {
+    constructor(api) {
+      this.api = api;
+    }
+    associate(fileIds, slice, row, field, execute = true) {
+      const req = { [`${execute ? "!" : "$"}/tools/file/update`]: { slice, row, field, ids: fileIds } };
+      if (execute) return this.api.request(req);
+      return req;
+    }
+    /**
+     * Get an authenticated URL to fetch files from
+     *
+     * @param {number} id File ID
+     * @param {boolean} ignoreToken Ignore authentication
+     * @return {string} URL file can be viewed at
+     */
+    get(id, ignoreToken) {
+      return `${this.api.url}file?id=${id}${ignoreToken ? "" : `&token=${this.api.token}`}`;
+    }
+    /**
+     * Upload file(s) to the API & optionally associate them with a row
+     *
+     * @param {FileList | File | File[]} files Files to be uploaded
+     * @param {{slice: number, row: any, field: string, pk?: string}} associate Row to associate with
+     */
+    upload(files, associate) {
+      let f = files instanceof FileList ? Array.from(files) : makeArray(files);
+      return Promise.all(f.map((file) => {
+        const data = new FormData();
+        data.append("uploadedfiles[]", file, file.name);
+        return fetch(`${this.api.url}upload.php`, {
+          method: "POST",
+          headers: clean({ "Authorization": this.api.token ? `Bearer ${this.api.token}` : "" }),
+          body: data
+        }).then(async (resp) => {
+          const data2 = await resp.json().catch(() => ({}));
+          if (!resp.ok || data2["error"]) throw Object.assign(errorFromCode(resp.status, data2.error) || {}, data2);
+          return data2.files.uploadedfiles[0];
+        });
+      })).then(async (files2) => {
+        if (associate) {
+          let id = typeof associate.row == "number" ? associate.row : associate.row[associate.pk || "id"];
+          if (!id) id = await this.api.slice(associate.slice).insert(associate.row).id().exec();
+          await this.associate(files2.map((f2) => f2.id), associate == null ? void 0 : associate.slice, associate == null ? void 0 : associate.row, associate == null ? void 0 : associate.field);
+        }
+        return files2;
+      });
+    }
+  }
+  class Pdf {
+    constructor(api) {
+      this.api = api;
+    }
+    /**
+     * Create a PDF from a public URL
+     * @param {string} url Target URL address
+     * @param {{slice: number, row: number, field: string} | null} associate Optionally associate PDF with a slice row
+     * @param {PdfOptions} options PDF options for rendering & uploading
+     * @return {Promise<any>} Either the PDF file number or the updated slice row response if associated
+     */
+    async fromUrl(url, associate, options = {}) {
+      return this.api.request({ "$/slice/utils/urlToPdf": { url, ...options } }).then((file) => {
+        if (associate) return this.api.files.associate(file, associate.slice, associate.row, associate.field);
+        return file;
+      });
+    }
+  }
+  const Serializer = {
+    /**
+     * From Datalynk syntax to JS
+     */
+    deserialize: {
+      /**
+       * Convert date time string to javascript date object
+       *
+       * @param {string} datetime datetime string (YYYY/MM/DD hh:mm:ss)
+       * @returns {Date} JS Date object
+       */
+      "$/tools/date": (datetime) => {
+        let a = datetime.split(/[^0-9]+/).map((part) => Number(part));
+        return new Date(a[0], a[1] - 1, a[2], a[3], a[4], a[5]);
+      },
+      /**
+       * Convert date string to javascript date object
+       *
+       * @param {string} date date string (YYYY/MM/DD)
+       * @returns {Date} JS Date object
+       */
+      "$/tools/date_strict": (date) => {
+        let a = date.split(/[^0-9]+/).map((part) => Number(part));
+        let d = new Date(a[0], a[1] - 1, a[2], 0, 0, 0);
+        d["hint"] = "date";
+        return d;
+      },
+      /**
+       * Convert time string to javascript date object
+       *
+       * @param {string} time time string (YYYY/MM/DD)
+       * @returns {Date} JS Date object
+       */
+      "$/tools/time_strict": (time) => {
+        let a = time.split(/[^0-9]+/).map((part) => Number(part));
+        let d = /* @__PURE__ */ new Date();
+        d.setHours(a[0]);
+        d.setMinutes(a[1]);
+        d.setSeconds(a[2]);
+        d["hint"] = "time";
+        return d;
+      },
+      /**
+       * Convert string to constant
+       *
+       * @param {string} constant string to be converted
+       * @returns {any} the actual constant
+       */
+      "$/tools/const": (constant) => {
+        let types = {
+          "infinity": Infinity,
+          "-infinity": -Infinity,
+          "nan": NaN
+        };
+        try {
+          return types[constant["$/tools/const"].toLowerCase()];
+        } catch (ignored) {
+          return void 0;
+        }
+      },
+      /**
+       * Large requests are formatted into parallel arrays
+       *
+       * @param {object} obj Object of metadata and data
+       * @returns {Array} Actual object reconstructed
+       */
+      "$/tools/dltable": function(obj) {
+        let meta = obj["meta"];
+        let col;
+        let fn = [];
+        for (let i in meta) {
+          col = meta[i];
+          fn.push("this['" + col.name + "'] = ");
+          if (col.cast == null) {
+            fn.push("a[" + i + "];\n");
+          } else if (col.cast === "num") {
+            fn.push("a[" + i + "] && parseFloat(a[" + i + "]);\n");
+          } else {
+            if (col["native"] === "date") {
+              fn.push("a[" + i + "] && dateParse(a[" + i + "]);\n");
+              fn.push("a[" + i + "] && (this['" + col.name + "'].hint = 'date');\n");
+            } else if (col["native"] === "time") {
+              fn.push("a[" + i + "] && timeParse(a[" + i + "]);\n");
+              fn.push("a[" + i + "] && (this['" + col.name + "'].hint = 'time');\n");
+            } else {
+              fn.push("a[" + i + "] && datetimeParse(a[" + i + "]);\n");
+            }
+          }
+        }
+        let dateTimeParse, dateParse, timeParse;
+        let now = /* @__PURE__ */ new Date();
+        let yyyy = now.getFullYear();
+        let mm = now.getMonth();
+        let dd = now.getDate();
+        dateTimeParse = function(dt) {
+          dt = dt.split(/[^0-9]+/);
+          return new Date(dt[0], dt[1] - 1, dt[2], dt[3], dt[4], dt[5]);
+        };
+        dateParse = function(d) {
+          d = d.split(/[- :]/);
+          let res2 = new Date(d[0], d[1] - 1, d[2], 0, 0, 0);
+          res2["hint"] = "date";
+          return res2;
+        };
+        timeParse = function(t) {
+          t = t.split(/[^0-9]+/, t);
+          let res2 = new Date(yyyy, mm, dd, t[0], t[1], t[2]);
+          res2["hint"] = "time";
+          return res2;
+        };
+        let ctor = Function("datetimeParse", "dateParse", "timeParse", "a", fn.join(""));
+        let res = [];
+        let rows = obj["rows"];
+        for (let i in rows) {
+          res[i] = new ctor(dateTimeParse, dateParse, timeParse, rows[i]);
+        }
+        res["meta"] = meta;
+        res["rowConstructor"] = ctor;
+        return res;
+      }
+    },
+    /**
+     * From JS to Datalynk syntax
+     */
+    serialize: {
+      /**
+       * Convert JS date to datalynk datetime string
+       */
+      "Date": (date) => {
+        return {
+          "$/tools/date": [date.getFullYear(), date.getMonth() + 1, date.getDate()].join("/") + " " + [date.getHours(), date.getMinutes(), date.getSeconds()].join(":")
+        };
+      }
+    }
+  };
+  class ApiCall {
+    constructor(api, slice) {
+      __publicField(this, "operation");
+      __publicField(this, "popField");
+      __publicField(this, "request", {});
+      /** Log response automatically */
+      __publicField(this, "debugging");
+      /**
+       * Whitelist and alias fields. Alias of `fields()`
+       * @example
+       * ```ts
+       * const id: {id: number, field2: any}[] = await new Slice<T>(12345)
+       * 		.select().alias({id: 'id', field1: 'field2'}).exec().keys();
+       * ```
+       * @param {object} aliasKeyVals List of properties to whitelist and what to rename them to
+       * @return {Slice<T>}
+       */
+      __publicField(this, "alias", this.fields);
+      this.api = api;
+      this.slice = slice;
+    }
+    /** Get raw API request */
+    get raw() {
+      return clean({
+        [this.operation]: {
+          ...this.request,
+          slice: this.slice
+        },
+        "$pop": this.popField ? this.popField : void 0
+      });
+    }
+    /**
+     * Add an 'AND' condition inside the where argument
+     * @example
+     * ```ts
+     * const rows: T[] = await new Slice<T>(12345).select()
+     *                 .where('field1', '>', 1)
+     *                 .and()
+     *                 .where({field2: 2, field3: 3})
+     *                 .exec().rows();
+     * ```
+     * @return {Slice<T>}
+     */
+    and() {
+      var _a;
+      if (((_a = this.request.where) == null ? void 0 : _a[0]) == "$and") return this;
+      if (this.request.where) this.request.where = ["$and", this.request.where];
+      else this.request.where = ["$and"];
+      return this;
+    }
+    /**
+     * Count the returned rows
+     * @example
+     * ```ts
+     * const count = await new Slice(12345).count()
+     * 					.where({field1: 1})
+     * 					.exec().count();
+     * ```
+     * @param {object | string} arg Count argument
+     * @return {Slice<T>}
+     */
+    count(arg = "id") {
+      this.operation = "$/slice/report";
+      this.request.fields = { count: ["$count", typeof arg == "object" ? arg : ["$field", arg]] };
+      return this.pop("rows:0:count");
+    }
+    /**
+     * Output the formed request to the console for inspection
+     * @param {boolean} enabled Enable/Disable console logging
+     * @return {Slice<T>}
+     */
+    debug(enabled = true) {
+      this.debugging = enabled;
+      return this;
+    }
+    /**
+     * Set the request type to delete
+     * @example
+     * ```ts
+     * await new Slice(12345).delete(id).exec();
+     * ```
+     * @param {number | number[]} id ID(s) to delete
+     * @return {Slice<T>}
+     */
+    delete(id) {
+      this.operation = "$/slice/delete";
+      if (id) {
+        if (Array.isArray(id)) this.where("id", "$in", id);
+        else this.where("id", "==", id);
+      }
+      return this;
+    }
+    /**
+     * Filter rows from slice based on an excel expression
+     * @example
+     * ```ts
+     * const rows: T[] = await new Slice<T>(12345).select()
+     *                 .excel('contains({property}, foobar)')
+     *                 .exec().rows();
+     * ```
+     * @param formula Excel formula to use as where clause
+     * @return {Slice<T>}
+     */
+    excel(formula) {
+      this.where(["$excel", formula]);
+      return this;
+    }
+    /**
+     * Compile the request and send it
+     * @param {ApiRequestOptions} options API Request options
+     * @return {Promise<T = any>} API response
+     */
+    exec(options) {
+      if (!this.operation) throw new Error("No operation chosen");
+      const request = this.raw;
+      return this.api.request(request, options).then((resp) => {
+        if (this.debugging) console.log(resp);
+        return resp;
+      });
+    }
+    fields(keys) {
+      this.request.fields = Array.isArray(keys) ? keys.reduce((acc, key) => ({ ...acc, [key]: key }), {}) : keys;
+      return this;
+    }
+    /**
+     * Unwrap response returning the first ID
+     * @return {Slice<T>}
+     */
+    id() {
+      return this.pop("rows:0:id");
+    }
+    /**
+     * Set the request type to insert
+     * @example
+     * ```ts
+     * const id: number = await new Slice<T>(12345).insert([
+     * 		{field1: 1},
+     *		{field1: 2}
+     * ]).exec().keys();
+     * ```
+     * @param {T | T[]} rows Rows to be inserted into the slice
+     * @return {Slice<T>}
+     */
+    insert(rows) {
+      this.operation = "$/slice/xinsert";
+      if (!this.request.rows) this.request.rows = [];
+      if (Array.isArray(rows)) this.request.rows = this.request.rows.concat(rows);
+      else this.request.rows.push(rows);
+      return this;
+    }
+    /**
+     * Limit number of rows returned
+     * @example
+     * ```ts
+     * const rows: T[] = await new Slice<T>(12345).select().limit(10)
+     *                 .exec().rows();
+     * ```
+     * @param {number} num Number of rows to return
+     * @return {Slice<T>}
+     */
+    limit(num) {
+      this.request.limit = num;
+      return this;
+    }
+    /**
+     * Add an 'OR' condition inside the where argument
+     * @example
+     * ```ts
+     * const rows: T[] = await new Slice<T>(12345).select()
+     *                 .where('field1', '>', 1)
+     *                 .or()
+     *                 .where({field2: 2, field3: 3})
+     *                 .or()
+     *                 .where(['$gt', ['$field', field4], 4)
+     *                 .exec().rows();
+     * ```
+     * @return {Slice<T>}
+     */
+    or() {
+      var _a;
+      if (((_a = this.request.where) == null ? void 0 : _a[0]) == "$or") {
+        this.request.where.push(null);
+        return this;
+      }
+      if (this.request.where) this.request.where = ["$or", this.request.where, null];
+      else this.request.where = ["$or", null];
+      return this;
+    }
+    /**
+     * Order rows by a field
+     * @example
+     * ```ts
+     * const rows: T[] = new Slice<T>(12345).select().order('field1', true) // true = ascending
+     * 					.exec().rows();
+     * ```
+     * @param {string} field property name
+     * @param {boolean} ascending Sort in ascending or descending order
+     * @return {Slice<T>}
+     */
+    order(field, ascending = true) {
+      if (!this.request.order) this.request.order = [];
+      this.request.order.push([ascending ? "$asc" : "$desc", ["$field", field]]);
+      return this;
+    }
+    /**
+     * Unwrap response, returning the field
+     * @param {string} field Colon seperated path: `rows:0`
+     * @return {Slice<T>}
+     */
+    pop(field) {
+      this.popField = field;
+      return this;
+    }
+    /**
+     * Unwrap response returning the first row
+     * @return {Slice<T>}
+     */
+    row() {
+      return this.pop("rows:0");
+    }
+    /**
+     * Unwrap response returning the rows
+     * @return {Slice<T>}
+     */
+    rows() {
+      return this.pop("rows");
+    }
+    /**
+     * Save multiple rows to the slice, automatically inserts/updates
+     * @param {T} rows Rows to add to slice
+     * @returns {this<T>}
+     */
+    save(rows) {
+      this.operation = "$/slice/multisave";
+      this.request.rows = makeArray(rows);
+      return this;
+    }
+    /**
+     * Set the request type to select
+     * @example
+     * ```ts
+     * const rows: T[] = new Slice<T>(12345).select().exec().rows();
+     * const row: T = new Slice<T>(12345).select(id).exec().row();
+     * ```
+     * @param {number | number[]} id ID(s) to select, leaving blank will return all rows
+     * @return {Slice<T>}
+     */
+    select(id) {
+      this.operation = "$/slice/report";
+      if (id) {
+        if (Array.isArray(id)) this.where("id", "$in", id);
+        else this.where("id", "==", id);
+      }
+      return this;
+    }
+    /**
+     * Set the request type to update
+     * @example
+     * ```ts
+     * const ids: number[] = await new Slice<Type>(12345).update([
+     * 		{id: 1, field1: 1},
+     * 		{id: 2, field1: 1}
+     * ]).exec().keys();
+     * ```
+     * @param {T | T[]} rows Rows to be updated, each row must have an ID
+     * @return {Slice<T>}
+     */
+    update(rows) {
+      this.operation = "$/slice/xupdate";
+      if (!this.request.rows) this.request.rows = [];
+      if (Array.isArray(rows)) this.request.rows = this.request.rows.concat(rows);
+      else this.request.rows.push(rows);
+      return this;
+    }
+    /**
+     * Add where condition to request
+     * @example
+     * ```ts
+     * const rows: T[] = await new Slice<T>(12345).select()
+     *                 .where('field1', '>', 1)
+     *                 .where({field2: 2, field3: 3}) // Automatic AND
+     *                 .or()
+     *                 .where(['$gt', ['$field', field4], 4)
+     *                 .exec().rows();
+     * ```
+     * @param {string | object} field property to compare or a map of equality comparisons
+     * @param {string} operator Operation to compare with. Accepts JS operators (>=, ==, !=, ...) as well as datalynk styax ($gte, $eq, $is, $not, ...)
+     * @param {any} value value to compare against
+     * @return {Slice<T>}
+     */
+    where(field, operator, value) {
+      if (this.request.where && this.request.where[0] != "$or") this.and();
+      const raw = Array.isArray(field);
+      if (typeof field == "object" && !raw) {
+        Object.entries(field).forEach(([key, value2]) => this.where(key, "==", value2));
+      } else {
+        const w = raw ? field : [(() => {
+          if (operator == null ? void 0 : operator.startsWith("$")) return operator;
+          if (operator == "==") return "$eq";
+          if (operator == "!=") return "$neq";
+          if (operator == ">") return "$gt";
+          if (operator == ">=") return "$gte";
+          if (operator == "<") return "$lt";
+          if (operator == "<=") return "$lte";
+          if (operator == "!") return "$not";
+          if (operator == "%") return "$mod";
+          if (operator == null ? void 0 : operator.startsWith("$")) return operator;
+          throw new Error(`Unknown operator: ${operator}`);
+        })(), ["$field", field], value];
+        if (!this.request.where) this.request.where = w;
+        else {
+          if (this.request.where[0] == "$or") {
+            const i = this.request.where.length - 1;
+            if (this.request.where[i] == null) this.request.where[i] = w;
+            else {
+              if (this.request.where[i][0] == "$and") this.request.where[i].push(w);
+              else this.request.where[i] = ["$and", this.request.where[i], w];
+            }
+          } else this.request.where.push(w);
+        }
+      }
+      return this;
+    }
+  }
+  class Slice {
+    /**
+     * An object to aid in constructing requests
+     *
+     * @param {number} slice Slice ID to interact with
+     * @param {Api} api Api to send the requests through
+     */
+    constructor(slice, api) {
+      __publicField(this, "table");
+      __publicField(this, "info");
+      __publicField(this, "loaded", false);
+      __publicField(this, "pendingInsert", 0);
+      /** Unsubscribe from changes, undefined if not subscribed */
+      __publicField(this, "unsubscribe");
+      /** Cached slice data as an observable */
+      __publicField(this, "cache$", new BehaviorSubject([]));
+      var _a;
+      this.slice = slice;
+      this.api = api;
+      if (this.offlineEnabled) {
+        this.table = (_a = api.database) == null ? void 0 : _a.table(slice.toString());
+        this.table.getAll().then((resp) => this.cache = resp).finally(() => this.loaded = true);
+        this.cache$.pipe(skip(1)).subscribe(async (cache) => {
+          var _a2;
+          await ((_a2 = this.table) == null ? void 0 : _a2.clear());
+          await Promise.all(cache.map((c) => {
+            var _a3;
+            return (_a3 = this.table) == null ? void 0 : _a3.put(c.id, c);
+          }));
+          this.fixIncrement();
+        });
+        this.sync();
+        window.addEventListener("online", async () => {
+          if (this.api.expired) await lastValueFrom(this.api.auth.user$.pipe(skip(1), takeWhile((u) => !u || this.api.expired, true)));
+          this.pushChanges();
+        });
+      } else {
+        this.loaded = true;
+      }
+    }
+    /** Cached slice data */
+    get cache() {
+      return this.cache$.getValue();
+    }
+    /** Set cached data & alert subscribers */
+    set cache(cache) {
+      this.cache$.next(cache);
+    }
+    /** Is slice offline support enabled */
+    get offlineEnabled() {
+      var _a;
+      return (_a = this.api.database) == null ? void 0 : _a.includes(this.slice.toString());
+    }
+    fixIncrement() {
+      var _a;
+      this.pendingInsert = ((_a = this.cache.toSorted(sortByProp("id")).pop()) == null ? void 0 : _a["id"]) || 0;
+    }
+    execWrapper(call) {
+      const onlineExec = call.exec.bind(call);
+      return async () => {
+        if (this.offlineEnabled && navigator && !(navigator == null ? void 0 : navigator.onLine)) {
+          const where = (row, condition) => {
+            if (Array.isArray(condition) ? !condition.length : condition == null) return true;
+            if (!Array.isArray(condition)) return condition;
+            if (condition[0] == "$field") return row[condition[1]];
+            if (condition[0] == "$not") return !where(row, condition.slice(1));
+            if (condition[0] == "$and") return condition.slice(1).filter((v) => where(row, v)).length == condition.length - 1;
+            if (condition[0] == "$or") return !!condition.slice(1).find((v) => where(row, v));
+            if (condition[0] == "$eq") return where(row, condition[1]) == where(row, condition[2]);
+            if (condition[0] == "$neq") return where(row, condition[1]) != where(row, condition[2]);
+            if (condition[0] == "$gt") return where(row, condition[1]) > where(row, condition[2]);
+            if (condition[0] == "$gte") return where(row, condition[1]) >= where(row, condition[2]);
+            if (condition[0] == "$lt") return where(row, condition[1]) < where(row, condition[2]);
+            if (condition[0] == "$lte") return where(row, condition[1]) <= where(row, condition[2]);
+            if (condition[0] == "$mod") return where(row, condition[1]) % where(row, condition[2]);
+            return condition[0];
+          };
+          await sleepWhile(() => !this.loaded);
+          let request = call.raw, resp = {};
+          if (request["$/slice/delete"]) {
+            const found = this.cache.filter((r) => where(r, request["$/slice/delete"]["where"])).map((r) => r.id);
+            this.cache = this.cache.map((r) => found.includes(r.id) ? { ...r, _sync: "delete" } : r);
+            resp = {
+              affected: found.length,
+              "ignored-keys": [],
+              keys: found,
+              tx: null
+            };
+          } else if (request["$/slice/report"]) {
+            resp["rows"] = deepCopy(this.cache).filter((r) => (r == null ? void 0 : r._sync) != "delete").filter((r) => r && where(r, request["$/slice/report"]["where"]));
+            if (request["order"]) resp["rows"] = resp["rows"].toSorted(sortByProp(request["order"][1][1], request["order"] == "$desc"));
+            if (request["limit"]) resp["rows"] = resp["rows"].slice(0, request["limit"]);
+            if (request["fields"]) {
+              if (request["fields"]["$count"]) resp["rows"] = { count: resp["rows"].length };
+              else resp["rows"] = resp["rows"].map((r) => Object.entries(request["fields"]).reduce((acc, [k, v]) => ({
+                ...acc,
+                [v]: r[k]
+              }), {}));
+            }
+          } else if (request["$/slice/xinsert"]) {
+            const rows = request["$/slice/xinsert"]["rows"].map((r) => ({
+              ...r,
+              id: -++this.pendingInsert,
+              _sync: "insert"
+            }));
+            this.cache = [...this.cache, ...rows];
+            resp = {
+              failed: [],
+              granted: rows.map((r) => Object.keys(r).reduce((acc, key) => ({ ...acc, [key]: true }), {})),
+              "ignored-fields": [],
+              keys: rows.map((r) => r.id),
+              publish: 1,
+              tx: null
+            };
+          } else if (request["$/slice/xupdate"]) {
+            const ids = request["$/slice/xupdate"]["rows"].map((r) => r.id);
+            this.cache = [
+              ...this.cache.filter((c) => !ids.includes(c.id)),
+              ...request["$/slice/xupdate"]["rows"].map((r) => ({ ...r, _sync: "update" }))
+            ].toSorted(sortByProp("id"));
+            resp = {
+              failed: [],
+              granted: request["$/slice/xupdate"]["rows"].map((r) => Object.keys(r).reduce((acc, key) => ({
+                ...acc,
+                [key]: true
+              }), {})),
+              "ignored-fields": [],
+              keys: request["$/slice/xupdate"]["rows"].map((r) => r.id),
+              publish: 1,
+              tx: null
+            };
+          }
+          if (request["$pop"])
+            resp = request["$pop"].split(":").reduce((acc, key) => acc[JSONAttemptParse(key)], resp);
+          return resp;
+        } else {
+          return onlineExec();
+        }
+      };
+    }
+    async pushChanges() {
+      if (this.offlineEnabled && this.api.online) {
+        await Promise.allSettled(
+          this.cache.values().map((value) => {
+            if (value._sync == "delete") {
+              return this.delete(value.id).exec();
+            } else if (value._sync == "insert") {
+              return this.insert({ ...value, id: void 0, _sync: void 0 }).exec();
+            } else if (value._sync == "update") {
+              return this.update({
+                ...value,
+                _sync: void 0
+              }).where("_updatedDate", "==", value.modified).exec();
+            }
+          }).filter((r) => !!r)
+        );
+      }
+    }
+    /**
+     * Get slice information
+     * @param reload Ignore cache & reload info
+     * @return {Promise<SliceInfo>}
+     */
+    async getInfo(reload) {
+      var _a, _b, _c;
+      const getType = (field) => {
+        if (field.options) {
+          let t = field.options.split("|").map((o) => `'${o}'`).join(" | ");
+          if (field.type == "control_checkbox") t = `(${t})[]`;
+          return t;
+        }
+        if (field.type == "control_checkbox" || field.type == "boolean") return "boolean";
+        if (field.type == "control_new_date" || field.type == "control_new_time" || field.type == "control_new_datetime" || field.type == "Date")
+          return "Date";
+        if (field.type == "control_number" || field.type == "number") return "number";
+        return "string";
+      };
+      if (this.info && !reload) return Promise.resolve(this.info);
+      this.info = await this.api.request({ "$/slice/fetch": { slice: this.slice } });
+      const fields = ((_c = (_b = (_a = this.info) == null ? void 0 : _a.meta) == null ? void 0 : _b.presentation) == null ? void 0 : _c.fields) ? Object.values(this.info.meta.presentation.fields) : [];
+      this.info.types = fields.filter((value) => value.id != void 0).map((value) => {
+        var _a2;
+        return {
+          key: value.id.toString(),
+          options: (_a2 = value.options) == null ? void 0 : _a2.split("|"),
+          readonly: !!value.readonly || value.id.startsWith("fid") || ["id", "creatorRef", "created", "modifierRef", "modified"].includes(value.id),
+          required: !!value.required,
+          type: getType(value)
+        };
+      });
+      return this.info;
+    }
+    /**
+     * Synchronize cache with server
+     * @example
+     * ```ts
+     * const slice: Slice = new Slice<T>(Slices.Contact);
+     * slice.sync().subscribe((rows: T[]) => {});
+     * ```
+     * @param {boolean} on Enable/disable events
+     * @return {BehaviorSubject<T[]>} Cache which can be subscribed to
+     */
+    sync(on = true) {
+      if (on) {
+        this.pushChanges().then(() => this.select().rows().exec().then((rows) => {
+          this.cache = rows;
+          this.loaded = true;
+        }));
+        if (!this.unsubscribe) this.unsubscribe = this.api.socket.sliceEvents(this.slice, (event) => {
+          const ids = [...event.data.new, ...event.data.changed];
+          this.select(ids).rows().exec().then((rows) => this.cache = [...this.cache.filter((c) => c.id != null && !ids.includes(c.id)), ...rows]);
+          this.cache = this.cache.filter((v) => v.id && !event.data.lost.includes(v.id));
+        });
+        return this.cache$;
+      } else if (this.unsubscribe) {
+        this.unsubscribe();
+        this.unsubscribe = null;
+      }
+    }
+    // Transaction wrapper =============================================================================================
+    /**
+     * {@inheritDoc ApiCall.count}
+     */
+    count(arg = "id") {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.count(arg);
+    }
+    /**
+     * {@inheritDoc ApiCall.delete}
+     */
+    delete(id) {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.delete(id);
+    }
+    /**
+     * {@inheritDoc ApiCall.insert}
+     */
+    insert(rows) {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.insert(rows);
+    }
+    /**
+     * {@inheritDoc ApiCall.save}
+     */
+    save(rows) {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.save(rows);
+    }
+    /**
+     * {@inheritDoc ApiCall.select}
+     */
+    select(id) {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.select(id);
+    }
+    /**
+     * {@inheritDoc ApiCall.update}
+     */
+    update(rows) {
+      const call = new ApiCall(this.api, this.slice);
+      call.exec = this.execWrapper(call);
+      return call.update(rows);
+    }
+  }
+  class Socket {
+    constructor(api, options = {}) {
+      __publicField(this, "listeners", []);
+      // [ Callback, Re-subscribe ]
+      __publicField(this, "retry");
+      __publicField(this, "socket");
+      __publicField(this, "open", false);
+      this.api = api;
+      this.options = options;
+      if (!options.url && options.url !== false) {
+        const origin = new URL(this.api.url).origin;
+        this.options.url = origin.replace("http", "ws").replace(/:\d+/g, "") + `:9390`;
+      }
+      if (this.options.url !== false)
+        api.token$.pipe(filter((u) => u !== void 0), distinctUntilChanged()).subscribe(() => this.connect());
+    }
+    /**
+     * Add listener for all socket events
+     *
+     * @param {SocketListener} fn Callback function
+     *
+     *
+     *
+     *
+     * @return {Unsubscribe} Function to unsubscribe callback
+     */
+    addListener(fn, reconnect) {
+      this.listeners.push([fn, reconnect]);
+      if (this.open) reconnect();
+      return () => this.listeners = this.listeners.filter((l) => l[0] != fn);
+    }
+    /**
+     * Close socket connection
+     */
+    close() {
+      var _a;
+      if (this.open) console.debug("Datalynk socket: disconnected");
+      this.open = false;
+      (_a = this.socket) == null ? void 0 : _a.close();
+      this.socket = void 0;
+      if (this.retry) clearTimeout(this.retry);
+      this.retry = null;
+    }
+    /**
+     * Connect socket client to socket server
+     * @param {number} timeout Retry to connect every x seconds
+     */
+    connect(timeout = 30) {
+      if (this.options.url === false) return console.warn("Datalynk socket disabled");
+      if (this.open) this.close();
+      this.retry = setTimeout(() => {
+        if (this.open) return;
+        this.close();
+        this.connect();
+      }, timeout * 1e3);
+      if (this.api.online) {
+        this.socket = new WebSocket(this.options.url + (this.api.token ? `?token=${this.api.token}&origin=${location.href}` : ""));
+        this.socket.onopen = () => clearTimeout(this.retry);
+        this.socket.onclose = () => {
+          if (this.open) this.connect(timeout);
+        };
+        this.socket.onmessage = (message) => {
+          const payload = JSON.parse(message.data);
+          if (payload.connected != void 0) {
+            if (payload.connected) {
+              this.open = true;
+              console.debug("Datalynk socket: connected");
+              this.listeners.forEach((l) => l[1]());
+            } else {
+              throw new Error(`Datalynk socket failed: ${payload.error}`);
+            }
+          } else {
+            this.listeners.forEach((l) => l[0](payload));
+          }
+        };
+      }
+    }
+    /**
+     * Send data to socket server
+     *
+     * @param payload Data that will be serialized
+     */
+    send(payload) {
+      var _a;
+      if (!this.open) throw new Error("Datalynk socket not connected");
+      (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify(payload));
+    }
+    /**
+     * Run callback whenever the server notifies us of slice changes
+     *
+     * @param {number | number[]} slice Slice to subscribe to
+     * @param {SocketListener<SocketEventSlice>} callback Function to run on changes
+     * @return {Unsubscribe} Run returned function to unsubscribe callback
+     */
+    sliceEvents(slice, callback) {
+      const unsubscribe = this.addListener((event) => {
+        if (event.type == "sliceEvents" && event.data.slice == slice) callback(event);
+      }, () => this.send({ onSliceEvents: slice }));
+      return () => {
+        this.send({ offSliceEvents: slice });
+        unsubscribe();
+      };
+    }
+  }
+  class Superuser {
+    constructor(api) {
+      this.api = api;
+    }
+    /**
+     * Switch to another user by ID
+     *
+     * @param {number} userId User ID
+     * @return {Promise<any>} New session
+     */
+    assume(userId) {
+      return this.api.request({ "$/report/users/become": { id: userId } }).then((resp) => {
+        if (resp.token) this.api.token = resp.token;
+        return resp;
+      });
+    }
+    /**
+     * Enable the superuser flag, required to make any of the requests in this helper
+     *
+     * @param {string} username Superuser account
+     * @param {string} password Superuser password
+     * @return {Promise<any>} Unknown
+     */
+    enable(username, password) {
+      return this.api.request({ "$/superuser/validate": {
+        name: username,
+        password
+      } });
+    }
+  }
+  const version = "1.3.5";
+  class WebRtc {
+    constructor(api) {
+      __publicField(this, "ice");
+      var _a, _b, _c, _d, _e, _f;
+      this.api = api;
+      this.ice = [
+        ...((_b = (_a = api.options) == null ? void 0 : _a.webrtc) == null ? void 0 : _b.ice) || [],
+        { urls: ["stun:" + ((_c = this.api.options.webrtc) == null ? void 0 : _c.url)] },
+        clean({
+          urls: ["turn:" + ((_d = this.api.options.webrtc) == null ? void 0 : _d.url)],
+          username: (_e = this.api.options.webrtc) == null ? void 0 : _e.username,
+          credential: (_f = this.api.options.webrtc) == null ? void 0 : _f.password
+        })
+      ];
+    }
+    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;
+    }
+    /**
+     * Create a new WebRTC connection to a room
+     * @param {string} id Room ID
+     * @param {boolean} audio Stream local audio to room/peers
+     * @param {boolean} video Stream local video to room/peers
+     * @returns {Promise<WebRTCSession>} Connection session
+     */
+    async connect(id = randomStringBuilder(16, true, true), audio = true, video = true) {
+      const session = {
+        open: true,
+        id,
+        uid: randomStringBuilder(8, true, true),
+        peers: {},
+        stream: await navigator.mediaDevices.getUserMedia({ audio, video }),
+        disconnect: null,
+        onConnected: null
+      };
+      const handleTracks = (session2, uid) => {
+        if (!session2.open || !session2.onConnected) return;
+        const peer = session2.peers[uid];
+        const streams = peer.connection.getRemoteStreams();
+        if (streams[0]) session2.onConnected(peer, streams[0]);
+        else peer.connection.ontrack = ({ streams: streams2 }) => {
+          if (session2.open && session2.onConnected) session2.onConnected(peer, streams2[0]);
+        };
+      };
+      const unsubscribe = this.api.socket.addListener(async (event) => {
+        var _a, _b, _c, _d;
+        const key = Object.keys(event)[0];
+        if (key == `webrtc/${id}`) {
+          if (event[key].connected) {
+            const payload = event[key].connected;
+            session.peers[payload.uid] = {
+              uid: payload.uid,
+              username: payload.username,
+              connection: await this.offer(session.stream)
+            };
+            this.api.socket.send({ [`webrtc/${id}`]: { offer: {
+              to: payload.uid,
+              uid: session.uid,
+              username: (_a = this.api.auth.user) == null ? void 0 : _a.login,
+              offer: session.peers[payload.uid].connection.localDescription
+            } } });
+          } else if (event[key].disconnected) {
+            session.peers[event[key].disconnected.uid].connection.close();
+            delete session.peers[event[key].disconnected.uid];
+          } else if (event[key].offer && event[key].offer.to == session.uid) {
+            const payload = event[key].offer;
+            session.peers[payload.uid] = {
+              uid: payload.uid,
+              username: payload.username,
+              connection: await this.answer(payload.offer, session.stream)
+            };
+            this.api.socket.send({ [`webrtc/${id}`]: { answer: {
+              to: payload.uid,
+              uid: session.uid,
+              username: (_b = this.api.auth.user) == null ? void 0 : _b.login,
+              answer: session.peers[payload.uid].connection.localDescription
+            } } });
+            handleTracks(session, payload.uid);
+          } else if (event[key].answer && event[key].answer.to == session.uid) {
+            (_d = (_c = session.peers[event[key].answer.uid]) == null ? void 0 : _c.connection) == null ? void 0 : _d.setRemoteDescription(new RTCSessionDescription(event[key].answer.answer));
+            handleTracks(session, event[key].answer.uid);
+          }
+        }
+      }, () => {
+        var _a;
+        return this.api.socket.send({ [`webrtc/${id}`]: { connected: { uid: session.uid, username: (_a = this.api.auth.user) == null ? void 0 : _a.login } } });
+      });
+      session.disconnect = () => {
+        var _a;
+        session.open = false;
+        session.peers = {};
+        this.api.socket.send({ [`webrtc/${id}`]: { disconnected: { uid: session.uid, username: (_a = this.api.auth.user) == null ? void 0 : _a.login } } });
+        unsubscribe();
+      };
+      return session;
+    }
+  }
+  const _Api = class _Api {
+    /**
+     * Connect to Datalynk & send requests
+     *
+     * @example
+     * ```ts
+     * const api = new Api('https://spoke.auxiliumgroup.com');
+     * ```
+     *
+     * @param {string} origin API URL
+     * @param {ApiOptions} options
+     */
+    constructor(origin, options = {}) {
+      /** Current requests bundle */
+      __publicField(this, "bundle", []);
+      /** Bundle lifecycle tracking */
+      __publicField(this, "bundleOngoing", false);
+      /** Track online state */
+      __publicField(this, "heartbeat", {
+        interval: null,
+        target: "version.php",
+        timeout: 6e4
+      });
+      /** LocalStorage key for persisting logins */
+      __publicField(this, "localStorageKey", "datalynk-token");
+      /** Pending requests cache */
+      __publicField(this, "pending", {});
+      /** Helpers */
+      /** Authentication */
+      __publicField(this, "auth");
+      /** File */
+      __publicField(this, "files");
+      /** PDF */
+      __publicField(this, "pdf");
+      /** PWA setup & prompt */
+      __publicField(this, "pwa");
+      /** Socket */
+      __publicField(this, "socket");
+      /** Superuser */
+      __publicField(this, "superuser");
+      /** WebRTC */
+      __publicField(this, "webrtc");
+      /** Offline database */
+      __publicField(this, "database");
+      /** Options */
+      __publicField(this, "options");
+      /** Created slices */
+      __publicField(this, "sliceCache", /* @__PURE__ */ new Map());
+      /** API URL */
+      __publicField(this, "url");
+      /** Client library version */
+      __publicField(this, "version", version);
+      __publicField(this, "onlineOverride", false);
+      __publicField(this, "_online", typeof navigator == "undefined" ? true : navigator.onLine);
+      /** API Session token */
+      __publicField(this, "token$", new BehaviorSubject(void 0));
+      var _a, _b;
+      this.origin = origin;
+      this.url = `${new URL(origin).origin}/api/`;
+      this.options = {
+        manifest: {},
+        name: typeof document != "undefined" ? document.title : "Datalynk",
+        offline: [],
+        origin: typeof location !== "undefined" ? location.host : "Unknown",
+        saveSession: true,
+        serviceWorker: "/service.worker.mjs",
+        ...options,
+        webrtc: {
+          url: "scarborough.auxilium.world:3478",
+          username: "auxilium-webrtc",
+          password: "UU3qkD95Tg54eF",
+          ...options.webrtc || {}
+        }
+      };
+      if (this.options.saveSession) {
+        if (typeof localStorage == "undefined") return;
+        this.token = localStorage.getItem(this.localStorageKey) || null;
+        this.token$.pipe(distinctUntilChanged()).subscribe((token) => {
+          if (token) localStorage.setItem(this.localStorageKey, token);
+          else localStorage.removeItem(this.localStorageKey);
+        });
+      }
+      this.socket = new Socket(this, { url: options.socket });
+      this.auth = new Auth(this);
+      this.files = new Files(this);
+      this.pdf = new Pdf(this);
+      this.pwa = new PWA(this);
+      this.superuser = new Superuser(this);
+      this.webrtc = new WebRtc(this);
+      if (typeof window !== "undefined") {
+        const handleOffline = (state) => {
+          this._online = state;
+          this.offlineBanner();
+        };
+        window.addEventListener("online", () => handleOffline(true));
+        window.addEventListener("offline", () => handleOffline(false));
+        this.startHeartbeat();
+        this.offlineBanner();
+      }
+      if ((_a = this.options.offline) == null ? void 0 : _a.length) {
+        this.pwa.setup();
+        if (typeof indexedDB == "undefined") throw new Error("Cannot enable offline support, indexedDB is not available in this environment");
+        this.database = new Database("datalynk", this.options.offline);
+        (_b = this.options.offline) == null ? void 0 : _b.forEach((id) => this.slice(id));
+        if (this.options.serviceWorker && typeof navigator["serviceWorker"] != "undefined") {
+          (async () => {
+            const init = () => {
+              var _a2;
+              (_a2 = navigator.serviceWorker.controller) == null ? void 0 : _a2.postMessage({ options: { ...this.options, url: this.url } });
+              this.token$.subscribe((token) => {
+                var _a3;
+                return (_a3 = navigator.serviceWorker.controller) == null ? void 0 : _a3.postMessage({ token });
+              });
+            };
+            await navigator.serviceWorker.getRegistration(this.options.serviceWorker).then((reg) => reg ?? navigator.serviceWorker.register(this.options.serviceWorker, { scope: "/", type: "module" }));
+            navigator.serviceWorker.ready.then(() => {
+              if (navigator.serviceWorker.controller) navigator.serviceWorker.ready.then(() => init());
+              else navigator.serviceWorker.addEventListener("controllerchange", () => init(), { once: true });
+            });
+          })();
+        }
+      }
+    }
+    /** Is token expired */
+    get expired() {
+      var _a;
+      return (((_a = this.jwtPayload) == null ? void 0 : _a.exp) ?? Infinity) * 1e3 <= Date.now();
+    }
+    /** Get session info from JWT payload */
+    get jwtPayload() {
+      if (!this.token) return null;
+      return decodeJwt(this.token);
+    }
+    /** Check if we are connected */
+    get online() {
+      return this._online;
+    }
+    get offline() {
+      return !this._online;
+    }
+    /** Override connection status */
+    set online(value) {
+      if (value == null) {
+        this.onlineOverride = false;
+        this._online = typeof navigator == "undefined" ? true : navigator.onLine;
+      } else {
+        this.onlineOverride = true;
+        if (value == this.online) return;
+        this._online = value;
+        if (value) this.startHeartbeat();
+        else this.stopHeartbeat();
+      }
+      this.offlineBanner();
+    }
+    /** Logged in spoke */
+    get spoke() {
+      var _a;
+      return (_a = this.jwtPayload) == null ? void 0 : _a.realm;
+    }
+    get token() {
+      return this.token$.getValue();
+    }
+    set token(token) {
+      this.token$.next(token);
+    }
+    _request(req, options = {}) {
+      const token = options.token || this.token;
+      return fetch(this.url, {
+        method: "POST",
+        headers: clean({
+          Authorization: token ? `Bearer ${token}` : void 0,
+          "Content-Type": "application/json",
+          "X-Date-Return-Format": this.options.legacyDates ? void 0 : "ISO8601"
+        }),
+        body: JSON.stringify(_Api.translateTokens(req))
+      }).then(async (resp) => {
+        this.online = true;
+        let data = JSONAttemptParse(await resp.text());
+        if (!resp.ok || (data == null ? void 0 : data.error)) throw Object.assign(errorFromCode(resp.status, data.error), data);
+        if (!options.raw) data = _Api.translateTokens(data);
+        return data;
+      });
+    }
+    async checkConnection() {
+      if (typeof navigator != "undefined" && !navigator.onLine) {
+        this._online = false;
+        return;
+      }
+      if (this.onlineOverride) return;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.heartbeat.timeout);
+      try {
+        const response = await fetch(this.url + this.heartbeat.target, { signal: controller.signal });
+        this._online = response.ok;
+      } catch (error) {
+        this._online = false;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    offlineBanner() {
+      if (this.options.offlineBanner === false || typeof document == "undefined") return;
+      const banner = document.querySelector(".datalynk-offline-banner");
+      if (this.online) {
+        banner == null ? void 0 : banner.remove();
+      } else if (!banner) {
+        const b = document.createElement("div");
+        b.className = "datalynk-offline-banner";
+        Object.assign(b.style, { position: "fixed", [this.options.offlineBanner === "top" ? "top" : "bottom"]: "0", left: "0", right: "0", padding: ".75rem", fontSize: "1rem", fontWeight: "bolder", backgroundColor: "#dc3545", color: "#fff", textAlign: "center", zIndex: "9999" });
+        b.innerHTML = "⚠️ You are offline, please reconnect to sync changes";
+        document.body.appendChild(b);
+      }
+    }
+    startHeartbeat() {
+      this.stopHeartbeat();
+      this.heartbeat.interval = setInterval(() => this.checkConnection(), this.heartbeat.timeout / 2);
+      this.checkConnection();
+    }
+    stopHeartbeat() {
+      if (this.heartbeat.interval) {
+        clearInterval(this.heartbeat.interval);
+        this.heartbeat.interval = null;
+      }
+    }
+    /**
+     * Get list of slices
+     * @return {Promise<number[]>}
+     */
+    getSlices() {
+      return this.request({ "$/tools/action_chain": [
+        { "!/env/me": {} },
+        { "!/slice/permissionsLite": {} },
+        { "!/tools/column": { "col": "id", "rows": { "$_": "1:rows" } } }
+      ] });
+    }
+    /**
+     * Parses API request/response object for special Datalynk tokens & converts them to native JS objects
+     *
+     * @param obj An API request or response
+     * @return {Object} Api request or response with translated tokens
+     * @private
+     */
+    static translateTokens(obj) {
+      let dot = (obj2, param) => param.split(".").reduce((acc, index) => acc[index], obj2);
+      let queue = Object.keys(obj);
+      queue.forEach((key) => {
+        let val = dot(obj, key);
+        if (val !== null && typeof val == "object") {
+          Object.keys(val).forEach((index) => {
+            if (index in Serializer.deserialize) {
+              val = Serializer.deserialize[index](val[index]);
+            } else if (index in Serializer.serialize) {
+              val = Serializer.serialize[index](val[index]);
+            } else if (val[index] == "Yes") {
+              val[index] = true;
+            } else if (val[index] == "No") {
+              val[index] = false;
+            } else {
+              queue.push(`${key}.${index}`);
+            }
+          });
+        }
+      });
+      return obj;
+    }
+    /**
+     * Chain multiple requests to execute together
+     * @param {Slice<any>} requests List of requests to chain
+     * @return {Promise<any>} API Response
+     */
+    chain(...requests) {
+      const arr = requests.length == 1 && Array.isArray(requests[0]) ? requests[0] : requests;
+      return this.request({ "$/tools/action_chain": arr.map((r) => {
+        if (!(r instanceof ApiCall)) return r;
+        const req = r.raw;
+        Object.keys(req).forEach((key) => {
+          if (key.startsWith("$/")) {
+            req[key.replace("$", "!")] = req[key];
+            delete req[key];
+          }
+        });
+        return req;
+      }) });
+    }
+    /**
+     * Organize multiple requests into a single mapped request
+     * @param {{[p: string]: any}} request Map of requests
+     * @return {Promise<any>} Map of API Responses
+     */
+    chainMap(request) {
+      return this.request({ "$/tools/do": [
+        ...Object.entries(request).flatMap(([key, r]) => {
+          if (!(r instanceof ApiCall)) return [key, r];
+          const req = r.raw;
+          Object.keys(req).forEach((key2) => {
+            if (key2.startsWith("$/")) {
+              req[key2.replace("$", "!")] = req[key2];
+              delete req[key2];
+            }
+          });
+          return [key, req];
+        }),
+        "returnAllBoilerplate",
+        { "$_": "*" }
+      ] }, {});
+    }
+    /**
+     * Exact same as `request` method, but logs the response in the console automatically
+     *
+     * @param {object | string} data Datalynk request as object or string
+     * @param {ApiRequestOptions} options
+     * @returns {Promise<any>} Datalynk response
+     */
+    debug(data, options = {}) {
+      return this.request(data, options).then((data2) => {
+        console.log(data2);
+        return data2;
+      }).catch((err) => {
+        console.error(err);
+        return err;
+      });
+    }
+    /**
+     * Send a request to Datalynk
+     *
+     * @example
+     * ```ts
+     * const response = await api.request('$/auth/current');
+     * ```
+     *
+     * @param {object} data Request using Datalynk API syntax. Strings will be converted: '$/auth/current' -> {'$/auth/current': {}}
+     * @param {ApiRequestOptions} options
+     * @returns {Promise<any>} Datalynk response or error
+     */
+    request(data, options = {}) {
+      data = typeof data == "string" ? { [data]: {} } : data;
+      if (options.noOptimize) {
+        return new Promise((res, rej) => {
+          this._request(data, options).then((resp) => {
+            (resp == null ? void 0 : resp.error) ? rej(resp) : res(resp);
+          }).catch((err) => rej(err));
+        });
+      }
+      let key = JSON.stringify(data);
+      if (!this.pending[key]) {
+        this.pending[key] = new Promise((res, rej) => this.bundle.push({ data, res, rej }));
+        this.pending[key].catch().then(() => delete this.pending[key]);
+        if (!this.bundleOngoing) {
+          this.bundleOngoing = true;
+          setTimeout(() => {
+            let originalBundle = this.bundle;
+            this.bundle = [];
+            this.bundleOngoing = false;
+            data = originalBundle.map((row) => row.data);
+            this._request(data, options).then((resp) => {
+              if (!(resp instanceof Array)) resp = [resp];
+              resp.forEach((row, i) => (row == null ? void 0 : row.error) ? originalBundle[i].rej(row.error) : originalBundle[i].res(row));
+            }).catch((err) => originalBundle.forEach((req) => req.rej(err)));
+          }, this.options.bundleTime);
+        }
+      }
+      return this.pending[key];
+    }
+    /**
+     * Create a slice object using the API
+     *
+     * @example
+     * ```ts
+     * const contactsSlice = api.slice<Contacts>(12345);
+     * const allContacts = await contactsSlice.select().exec().rows();
+     * const unsubscribe = contactsSlice.sync().subscribe(rows => console.log(rows));
+     * ```
+     *
+     * @param {number} id Slice ID the object will target
+     * @returns {Slice<T = any>} Object for making requests & caching rows
+     */
+    slice(id) {
+      if (!this.sliceCache.has(+id)) this.sliceCache.set(+id, new Slice(id, this));
+      return this.sliceCache.get(+id);
+    }
+  };
+  /** Client library version */
+  __publicField(_Api, "version", version);
+  let Api = _Api;
+  exports2.Api = Api;
+  exports2.ApiCall = ApiCall;
+  exports2.Auth = Auth;
+  exports2.Files = Files;
+  exports2.LoginPrompt = LoginPrompt;
+  exports2.PWA = PWA;
+  exports2.Pdf = Pdf;
+  exports2.Serializer = Serializer;
+  exports2.Slice = Slice;
+  exports2.Socket = Socket;
+  exports2.Superuser = Superuser;
+  exports2.getTheme = getTheme;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});