@auxilium/datalynk-client 1.0.20 → 1.1.0-rc1

package/dist/index.js

@@ -0,0 +1,3513 @@
+"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);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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";
+}
+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 formatDate(format = "YYYY-MM-DD H:mm", date = /* @__PURE__ */ new Date(), tz) {
+  const timezones = [
+    ["IDLW", -12],
+    ["SST", -11],
+    ["HST", -10],
+    ["AKST", -9],
+    ["PST", -8],
+    ["MST", -7],
+    ["CST", -6],
+    ["EST", -5],
+    ["AST", -4],
+    ["BRT", -3],
+    ["MAT", -2],
+    ["AZOT", -1],
+    ["UTC", 0],
+    ["CET", 1],
+    ["EET", 2],
+    ["MSK", 3],
+    ["AST", 4],
+    ["PKT", 5],
+    ["IST", 5.5],
+    ["BST", 6],
+    ["ICT", 7],
+    ["CST", 8],
+    ["JST", 9],
+    ["AEST", 10],
+    ["SBT", 11],
+    ["FJT", 12],
+    ["TOT", 13],
+    ["LINT", 14]
+  ];
+  function adjustTz(date2, gmt) {
+    const currentOffset = date2.getTimezoneOffset();
+    const adjustedOffset = gmt * 60;
+    return new Date(date2.getTime() + (adjustedOffset + currentOffset) * 6e4);
+  }
+  function day(num) {
+    return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][num] || "Unknown";
+  }
+  function doy(date2) {
+    const start = /* @__PURE__ */ new Date(`${date2.getFullYear()}-01-01 0:00:00`);
+    return Math.ceil((date2.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24));
+  }
+  function month(num) {
+    return ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"][num] || "Unknown";
+  }
+  function suffix(num) {
+    if (num % 100 >= 11 && num % 100 <= 13) return `${num}th`;
+    switch (num % 10) {
+      case 1:
+        return `${num}st`;
+      case 2:
+        return `${num}nd`;
+      case 3:
+        return `${num}rd`;
+      default:
+        return `${num}th`;
+    }
+  }
+  function tzOffset(offset) {
+    const hours = ~~(offset / 60);
+    const minutes = offset % 60;
+    return (offset > 0 ? "-" : "") + `${hours}:${minutes.toString().padStart(2, "0")}`;
+  }
+  if (typeof date == "number" || typeof date == "string" || date == null) date = new Date(date);
+  let t;
+  if (tz == null) tz = -(date.getTimezoneOffset() / 60);
+  t = timezones.find((t2) => isNaN(tz) ? t2[0] == tz : t2[1] == tz);
+  if (!t) throw new Error(`Unknown timezone: ${tz}`);
+  date = adjustTz(date, t[1]);
+  const tokens = {
+    "YYYY": date.getFullYear().toString(),
+    "YY": date.getFullYear().toString().slice(2),
+    "MMMM": month(date.getMonth()),
+    "MMM": month(date.getMonth()).slice(0, 3),
+    "MM": (date.getMonth() + 1).toString().padStart(2, "0"),
+    "M": (date.getMonth() + 1).toString(),
+    "DDD": doy(date).toString(),
+    "DD": date.getDate().toString().padStart(2, "0"),
+    "Do": suffix(date.getDate()),
+    "D": date.getDate().toString(),
+    "dddd": day(date.getDay()),
+    "ddd": day(date.getDay()).slice(0, 3),
+    "HH": date.getHours().toString().padStart(2, "0"),
+    "H": date.getHours().toString(),
+    "hh": (date.getHours() % 12 || 12).toString().padStart(2, "0"),
+    "h": (date.getHours() % 12 || 12).toString(),
+    "mm": date.getMinutes().toString().padStart(2, "0"),
+    "m": date.getMinutes().toString(),
+    "ss": date.getSeconds().toString().padStart(2, "0"),
+    "s": date.getSeconds().toString(),
+    "SSS": date.getMilliseconds().toString().padStart(3, "0"),
+    "A": date.getHours() >= 12 ? "PM" : "AM",
+    "a": date.getHours() >= 12 ? "pm" : "am",
+    "ZZ": tzOffset(t[1] * 60).replace(":", ""),
+    "Z": tzOffset(t[1] * 60),
+    "z": typeof tz == "string" ? tz : t[0]
+  };
+  return format.replace(/YYYY|YY|MMMM|MMM|MM|M|DDD|DD|Do|D|dddd|ddd|HH|H|hh|h|mm|m|ss|s|SSS|A|a|ZZ|Z|z/g, (token) => tokens[token]);
+}
+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(exports2) {
+  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(exports2, "__esModule", { value: true });
+  __exportStar(persist$1, exports2);
+  __exportStar(memoryStorage, exports2);
+})(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(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription2;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+var config = {
+  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/api/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`,
+    color: "#c83232",
+    logo: `https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/logo.png`,
+    title: spoke.toUpperCase(),
+    textColor: "white",
+    ...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);
+  }
+  async themeDefaults() {
+    const theme = await getTheme(this.spoke, "login");
+    this.options = {
+      logoOnly: !this.options.title && !theme.found,
+      ...theme,
+      ...clean(this.options, true)
+    };
+  }
+  /** Close the login prompt */
+  close() {
+    var _a, _b;
+    (_a = document.querySelector("#datalynk-login-css")) == 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');
+		
+		#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-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 .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) => `
+	<div id="datalynk-login">
+		<!-- Used to check if image is valid -->
+		${!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">
+				${options.logo ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto;" onerror="this.style.display='none'" ${options.logoOnly ? `onload="document.querySelector('.login-title').remove()"` : ""}>` : ""}
+				<span class="login-title" style="margin-left: 0.5rem">${options.title}</span>
+			</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>
+				${options.hideApps ? "" : `
+				<div class="login-links" style="text-align: center">
+					<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">x</span>ilium
+					<span style="position: absolute; font-size: 10px; color: #c83232; top: 2px; right: 2px">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 (typeof navigator != "undefined" && !navigator.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 ? formatDate("YYYY-MM-DD", date) : 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() {
+    localStorage.removeItem("datalynk-user");
+    return this.api.request({ "$/auth/logout": {} }).then((resp) => {
+      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 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, "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);
+      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();
+      });
+    }
+  }
+  /** 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 () => {
+      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];
+        };
+        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 Promise.resolve(resp);
+      } else {
+        return onlineExec();
+      }
+    };
+  }
+  async pushChanges() {
+    if (this.offlineEnabled && navigator && navigator.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));
+      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 url = new URL(this.api.url.replace("http", "ws"));
+      url.port = "9390";
+      this.options.url = url.origin;
+    }
+    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]);
+    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 (navigator.onLine) {
+      this.socket = new WebSocket(this.options.url + (this.api.token ? `?token=${this.api.token}` : ""));
+      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 listen = () => this.send({ onSliceEvents: slice });
+    if (this.open) listen();
+    const unsubscribe = this.addListener((event) => {
+      if (event.type == "sliceEvents" && event.data.slice == slice) callback(event);
+    }, () => listen());
+    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.1.0-rc1";
+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);
+    /** 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");
+    /** Socket */
+    __publicField(this, "socket");
+    /** Superuser */
+    __publicField(this, "superuser");
+    /** 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);
+    /** 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 = {
+      offline: [],
+      origin: typeof location !== "undefined" ? location.host : "Unknown",
+      saveSession: true,
+      serviceWorker: "/service.worker.js",
+      ...options
+    };
+    if (this.options.saveSession) {
+      if (localStorage == void 0) 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.superuser = new Superuser(this);
+    if ((_a = this.options.offline) == null ? void 0 : _a.length) {
+      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));
+      this.cacheUrl();
+    }
+  }
+  /** Get session info from JWT payload */
+  get jwtPayload() {
+    if (!this.token) return null;
+    return decodeJwt(this.token);
+  }
+  /** Is token expired */
+  get expired() {
+    var _a;
+    return (((_a = this.jwtPayload) == null ? void 0 : _a.exp) ?? Infinity) * 1e3 <= Date.now();
+  }
+  /** 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) => {
+      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 cacheUrl() {
+    if (!this.options.serviceWorker || !("serviceWorker" in navigator)) return;
+    await navigator.serviceWorker.getRegistration(this.options.serviceWorker).then((reg) => reg ?? navigator.serviceWorker.register(this.options.serviceWorker, { scope: "/" }));
+    await navigator.serviceWorker.ready;
+    if (!navigator.serviceWorker.controller) return window.location.reload();
+  }
+  /**
+   * 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;
+exports.Api = Api;
+exports.ApiCall = ApiCall;
+exports.Auth = Auth;
+exports.Files = Files;
+exports.LoginPrompt = LoginPrompt;
+exports.Pdf = Pdf;
+exports.Serializer = Serializer;
+exports.Slice = Slice;
+exports.Socket = Socket;
+exports.Superuser = Superuser;
+exports.getTheme = getTheme;