@auxilium/datalynk-client 1.0.15 → 1.0.16

package/dist/index.cjs

@@ -0,0 +1,2754 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.utils = {}));
+})(this, function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp2 = (obj, key, value2) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key] = value2;
+  var __publicField2 = (obj, key, value2) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value2);
+  function clean(obj, undefinedOnly = false) {
+    if (obj == null) throw new Error("Cannot clean a NULL value");
+    if (Array.isArray(obj)) {
+      obj = obj.filter((o) => o != null);
+    } else {
+      Object.entries(obj).forEach(([key, value2]) => {
+        if (undefinedOnly && value2 === void 0 || !undefinedOnly && value2 == null) delete obj[key];
+      });
+    }
+    return obj;
+  }
+  function JSONAttemptParse(json) {
+    try {
+      return JSON.parse(json);
+    } catch {
+      return json;
+    }
+  }
+  function JSONSanitize(obj, space) {
+    return JSON.stringify(obj, (key, value2) => {
+      return value2;
+    }, space);
+  }
+  function blackOrWhite(background) {
+    const exploded = background == null ? void 0 : background.match(background.length >= 6 ? /\w\w/g : /\w/g);
+    if (!exploded) return "black";
+    const [r2, g, b2] = exploded.map((hex) => parseInt(hex, 16));
+    const luminance = (0.299 * r2 + 0.587 * g + 0.114 * b2) / 255;
+    return luminance > 0.5 ? "black" : "white";
+  }
+  class PromiseProgress extends Promise {
+    constructor(executor) {
+      super((resolve, reject) => executor(
+        (value2) => resolve(value2),
+        (reason) => reject(reason),
+        (progress) => this.progress = progress
+      ));
+      __publicField2(this, "listeners", []);
+      __publicField2(this, "_progress", 0);
+    }
+    get progress() {
+      return this._progress;
+    }
+    set progress(p2) {
+      if (p2 == this._progress) return;
+      this._progress = p2;
+      this.listeners.forEach((l) => l(p2));
+    }
+    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((p2) => newPromise.progress = p2);
+      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 = 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(fn) {
+      const key = Object.keys(_Http2.interceptors).length.toString();
+      _Http2.interceptors[key] = fn;
+      return () => {
+        _Http2.interceptors[key] = null;
+      };
+    }
+    addInterceptor(fn) {
+      const key = Object.keys(this.interceptors).length.toString();
+      this.interceptors[key] = fn;
+      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 fn of [...Object.values(_Http2.interceptors), ...Object.values(this.interceptors)]) {
+              await new Promise((res2) => fn(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 jwtDecode(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 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);
+  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;
+  }
+  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, "options");
+      __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 = {
+        title: this.spoke,
+        background: "#ffffff",
+        color: "#c83232",
+        textColor: "#000000",
+        ...clean(options, true)
+      };
+      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 (options.persist === false) this.persist.parentElement.remove();
+      this.form.onsubmit = (event) => this.login(event);
+    }
+    /** 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.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: ${blackOrWhite(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: ${blackOrWhite(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">
+		<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.title}
+			</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) {
+      /** Current user as an observable */
+      __publicField(this, "user$", new BehaviorSubject(void 0));
+      this.api = api;
+      this.api.token$.subscribe(async (token) => {
+        if (token === void 0) return;
+        this.user = await this.current(token);
+      });
+    }
+    /** 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;
+      return this.api.request({ "$/auth/current": {} }, { token }).then((resp) => (resp == null ? void 0 : resp.login) ? resp : 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;
+      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) {
+        if (((_a = this.api.jwtPayload) == null ? void 0 : _a.realm) != spoke) {
+          this.api.token = null;
+          location.reload();
+        }
+      } else {
+        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() {
+      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) {
+      __publicField(this, "url");
+      this.api = api;
+      this.url = `${this.api.url}file`;
+    }
+    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.url}?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 = [];
+      if (files instanceof FileList) f = Array.from(files);
+      else f = Array.isArray(files) ? files : [files];
+      return Promise.all(f.map((file) => {
+        const data = new FormData();
+        data.append("", file, file.name);
+        return fetch(this.url, {
+          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 resp;
+        });
+      })).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();
+          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(":")
+        };
+      }
+    }
+  };
+  const _Slice = 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, "operation");
+      __publicField(this, "popField");
+      __publicField(this, "request", {});
+      /** Log response automatically */
+      __publicField(this, "debugging");
+      /** Unsubscribe from changes, undefined if not subscribed */
+      __publicField(this, "unsubscribe");
+      /** Cached slice data as an observable */
+      __publicField(this, "cache$", new BehaviorSubject([]));
+      /**
+       * 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.slice = slice;
+      this.api = api;
+    }
+    /** Cached slice data */
+    get cache() {
+      return this.cache$.getValue();
+    }
+    /** Set cached data & alert subscribers */
+    set cache(cache) {
+      this.cache$.next(cache);
+    }
+    /** 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");
+      return this.api.request(this.raw, 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");
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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) {
+        new _Slice(this.slice, this.api).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];
+          new _Slice(this.slice, this.api).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;
+      }
+    }
+    /**
+     * 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 == "==") 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;
+    }
+  };
+  __publicField(_Slice, "api");
+  let Slice = _Slice;
+  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.0.16";
+  class Api {
+    /**
+     * Connect to Datalynk & send requests
+     *
+     * @example
+     * ```ts
+     * const api = new Api('https://spoke.auxiliumgroup.com');
+     * ```
+     *
+     * @param {string} url API URL
+     * @param {ApiOptions} options
+     */
+    constructor(url, 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", {});
+      /** API URL */
+      __publicField(this, "url");
+      /** Package version */
+      __publicField(this, "version", version);
+      /** API Session token */
+      __publicField(this, "token$", new BehaviorSubject(void 0));
+      /** Helpers */
+      /** Authentication */
+      __publicField(this, "auth", new Auth(this));
+      /** File */
+      __publicField(this, "files", new Files(this));
+      /** PDF */
+      __publicField(this, "pdf", new Pdf(this));
+      /** Socket */
+      __publicField(this, "socket");
+      /** Superuser */
+      __publicField(this, "superuser", new Superuser(this));
+      this.options = options;
+      this.url = `${new URL(url).origin}/api/`;
+      this.options = {
+        bundleTime: 100,
+        origin: typeof location !== "undefined" ? location.host : "Unknown",
+        saveSession: true,
+        ...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);
+        });
+      }
+      Slice.api = this;
+      this.socket = new Socket(this, { url: options.socket });
+    }
+    get token() {
+      return this.token$.getValue();
+    }
+    set token(token) {
+      this.token$.next(token);
+    }
+    /** Get session info from JWT payload */
+    get jwtPayload() {
+      if (!this.token) return null;
+      return jwtDecode(this.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;
+      });
+    }
+    /**
+     * 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 {
+              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 Slice)) 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 Slice)) 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} slice Slice number the object will target
+     * @returns {Slice<T = any>} Object for making requests & caching rows
+     */
+    slice(slice) {
+      return new Slice(slice, this);
+    }
+  }
+  exports2.Api = Api;
+  exports2.Auth = Auth;
+  exports2.Files = Files;
+  exports2.LoginPrompt = LoginPrompt;
+  exports2.Pdf = Pdf;
+  exports2.Serializer = Serializer;
+  exports2.Slice = Slice;
+  exports2.Socket = Socket;
+  exports2.Superuser = Superuser;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});