@auxilium/datalynk-client 0.8.0 → 0.8.2

package/dist/index.mjs

@@ -1,344 +1,400 @@
 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 it = Object.defineProperty;
-var ct = (r, t, e) => t in r ? it(r, t, { enumerable: true, configurable: true, writable: true, value: e }) : r[t] = e;
-var c = (r, t, e) => ct(r, typeof t != "symbol" ? t + "" : t, e);
-function ut(r, t = false) {
-  if (r == null) throw new Error("Cannot clean a NULL value");
-  return Array.isArray(r) ? r = r.filter((e) => e != null) : Object.entries(r).forEach(([e, n]) => {
-    (t && n === void 0 || !t && n == null) && delete r[e];
-  }), r;
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+function clean(obj, undefinedOnly = false) {
+  if (obj == null) throw new Error("Cannot clean a NULL value");
+  if (Array.isArray(obj)) {
+    obj = obj.filter((o) => o != null);
+  } else {
+    Object.entries(obj).forEach(([key, value]) => {
+      if (undefinedOnly && value === void 0 || !undefinedOnly && value == null) delete obj[key];
+    });
+  }
+  return obj;
 }
-function $t(r) {
-  const t = new FormData();
-  return Object.entries(r).forEach(([e, n]) => t.append(e, n)), t;
+function formData(target) {
+  const data = new FormData();
+  Object.entries(target).forEach(([key, value]) => data.append(key, value));
+  return data;
 }
-function M(r) {
+function JSONAttemptParse(json) {
   try {
-    return JSON.parse(r);
+    return JSON.parse(json);
   } catch {
-    return r;
+    return json;
   }
 }
-class E extends Promise {
-  constructor(e) {
-    super((n, s) => e(
-      (o) => n(o),
-      (o) => s(o),
-      (o) => this.progress = o
+function JSONSanitize(obj, space) {
+  let cache = [];
+  return JSON.stringify(obj, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (cache.includes(value)) return;
+      cache.push(value);
+    }
+    return value;
+  }, space);
+}
+class PromiseProgress extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => executor(
+      (value) => resolve(value),
+      (reason) => reject(reason),
+      (progress) => this.progress = progress
     ));
-    c(this, "listeners", []);
-    c(this, "_progress", 0);
+    __publicField2(this, "listeners", []);
+    __publicField2(this, "_progress", 0);
   }
   get progress() {
     return this._progress;
   }
-  set progress(e) {
-    e != this._progress && (this._progress = e, this.listeners.forEach((n) => n(e)));
+  set progress(p) {
+    if (p == this._progress) return;
+    this._progress = p;
+    this.listeners.forEach((l) => l(p));
   }
-  static from(e) {
-    return e instanceof E ? e : new E((n, s) => e.then((...o) => n(...o)).catch((...o) => s(...o)));
+  static from(promise) {
+    if (promise instanceof PromiseProgress) return promise;
+    return new PromiseProgress((res, rej) => promise.then((...args) => res(...args)).catch((...args) => rej(...args)));
   }
-  from(e) {
-    const n = E.from(e);
-    return this.onProgress((s) => n.progress = s), n;
+  from(promise) {
+    const newPromise = PromiseProgress.from(promise);
+    this.onProgress((p) => newPromise.progress = p);
+    return newPromise;
   }
-  onProgress(e) {
-    return this.listeners.push(e), this;
+  onProgress(callback) {
+    this.listeners.push(callback);
+    return this;
   }
-  then(e, n) {
-    const s = super.then(e, n);
-    return this.from(s);
+  then(res, rej) {
+    const resp = super.then(res, rej);
+    return this.from(resp);
   }
-  catch(e) {
-    return this.from(super.catch(e));
+  catch(rej) {
+    return this.from(super.catch(rej));
   }
-  finally(e) {
-    return this.from(super.finally(e));
+  finally(res) {
+    return this.from(super.finally(res));
   }
 }
-class _ {
+class TypedEmitter {
   constructor() {
-    c(this, "listeners", {});
-  }
-  static emit(t, ...e) {
-    (this.listeners["*"] || []).forEach((n) => n(t, ...e)), (this.listeners[t.toString()] || []).forEach((n) => n(...e));
+    __publicField2(this, "listeners", {});
   }
-  static off(t, e) {
-    const n = t.toString();
-    this.listeners[n] = (this.listeners[n] || []).filter((s) => s === e);
+  static emit(event, ...args) {
+    (this.listeners["*"] || []).forEach((l) => l(event, ...args));
+    (this.listeners[event.toString()] || []).forEach((l) => l(...args));
   }
-  static on(t, e) {
-    var s;
-    const n = t.toString();
-    return this.listeners[n] || (this.listeners[n] = []), (s = this.listeners[n]) == null || s.push(e), () => this.off(t, e);
+  static off(event, listener) {
+    const e = event.toString();
+    this.listeners[e] = (this.listeners[e] || []).filter((l) => l === listener);
   }
-  static once(t, e) {
-    return new Promise((n) => {
-      const s = this.on(t, (...o) => {
-        n(o.length == 1 ? o[0] : o), e && e(...o), s();
+  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(t, ...e) {
-    (this.listeners["*"] || []).forEach((n) => n(t, ...e)), (this.listeners[t] || []).forEach((n) => n(...e));
-  }
-  off(t, e) {
-    this.listeners[t] = (this.listeners[t] || []).filter((n) => n === e);
+  emit(event, ...args) {
+    (this.listeners["*"] || []).forEach((l) => l(event, ...args));
+    (this.listeners[event] || []).forEach((l) => l(...args));
   }
-  on(t, e) {
-    var n;
-    return this.listeners[t] || (this.listeners[t] = []), (n = this.listeners[t]) == null || n.push(e), () => this.off(t, e);
+  off(event, listener) {
+    this.listeners[event] = (this.listeners[event] || []).filter((l) => l === listener);
   }
-  once(t, e) {
-    return new Promise((n) => {
-      const s = this.on(t, (...o) => {
-        n(o.length == 1 ? o[0] : o), e && e(...o), s();
+  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();
       });
     });
   }
 }
-c(_, "listeners", {});
-class p extends Error {
-  constructor(e, n) {
-    super(e);
-    c(this, "_code");
-    n != null && (this._code = n);
+__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(e) {
-    this._code = e;
+  set code(c) {
+    this._code = c;
   }
-  static from(e) {
-    const n = Number(e.statusCode) ?? Number(e.code), s = new this(e.message || e.toString());
-    return Object.assign(s, {
-      stack: e.stack,
-      ...e,
-      code: n ?? void 0
+  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(e) {
-    return e.constructor.code != null;
+  static instanceof(err) {
+    return err.constructor.code != void 0;
   }
   toString() {
     return this.message || super.toString();
   }
 }
-c(p, "code", 500);
-class W extends p {
-  constructor(t = "Bad Request") {
-    super(t);
+__publicField2(CustomError, "code", 500);
+class BadRequestError extends CustomError {
+  constructor(message = "Bad Request") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(W, "code", 400);
-class J extends p {
-  constructor(t = "Unauthorized") {
-    super(t);
+__publicField2(BadRequestError, "code", 400);
+class UnauthorizedError extends CustomError {
+  constructor(message = "Unauthorized") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(J, "code", 401);
-class z extends p {
-  constructor(t = "Payment Required") {
-    super(t);
+__publicField2(UnauthorizedError, "code", 401);
+class PaymentRequiredError extends CustomError {
+  constructor(message = "Payment Required") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(z, "code", 402);
-class K extends p {
-  constructor(t = "Forbidden") {
-    super(t);
+__publicField2(PaymentRequiredError, "code", 402);
+class ForbiddenError extends CustomError {
+  constructor(message = "Forbidden") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(K, "code", 403);
-class Z extends p {
-  constructor(t = "Not Found") {
-    super(t);
+__publicField2(ForbiddenError, "code", 403);
+class NotFoundError extends CustomError {
+  constructor(message = "Not Found") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(Z, "code", 404);
-class V extends p {
-  constructor(t = "Method Not Allowed") {
-    super(t);
+__publicField2(NotFoundError, "code", 404);
+class MethodNotAllowedError extends CustomError {
+  constructor(message = "Method Not Allowed") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(V, "code", 405);
-class X extends p {
-  constructor(t = "Not Acceptable") {
-    super(t);
+__publicField2(MethodNotAllowedError, "code", 405);
+class NotAcceptableError extends CustomError {
+  constructor(message = "Not Acceptable") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(X, "code", 406);
-class Q extends p {
-  constructor(t = "Internal Server Error") {
-    super(t);
+__publicField2(NotAcceptableError, "code", 406);
+class InternalServerError extends CustomError {
+  constructor(message = "Internal Server Error") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(Q, "code", 500);
-class tt extends p {
-  constructor(t = "Not Implemented") {
-    super(t);
+__publicField2(InternalServerError, "code", 500);
+class NotImplementedError extends CustomError {
+  constructor(message = "Not Implemented") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(tt, "code", 501);
-class et extends p {
-  constructor(t = "Bad Gateway") {
-    super(t);
+__publicField2(NotImplementedError, "code", 501);
+class BadGatewayError extends CustomError {
+  constructor(message = "Bad Gateway") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(et, "code", 502);
-class rt extends p {
-  constructor(t = "Service Unavailable") {
-    super(t);
+__publicField2(BadGatewayError, "code", 502);
+class ServiceUnavailableError extends CustomError {
+  constructor(message = "Service Unavailable") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(rt, "code", 503);
-class nt extends p {
-  constructor(t = "Gateway Timeout") {
-    super(t);
+__publicField2(ServiceUnavailableError, "code", 503);
+class GatewayTimeoutError extends CustomError {
+  constructor(message = "Gateway Timeout") {
+    super(message);
   }
-  static instanceof(t) {
-    return t.constructor.code == this.code;
+  static instanceof(err) {
+    return err.constructor.code == this.code;
   }
 }
-c(nt, "code", 504);
-function Yt(r, t) {
-  if (r >= 200 && r < 300) return null;
-  switch (r) {
+__publicField2(GatewayTimeoutError, "code", 504);
+function errorFromCode(code, message) {
+  switch (code) {
     case 400:
-      return new W(t);
+      return new BadRequestError(message);
     case 401:
-      return new J(t);
+      return new UnauthorizedError(message);
     case 402:
-      return new z(t);
+      return new PaymentRequiredError(message);
     case 403:
-      return new K(t);
+      return new ForbiddenError(message);
     case 404:
-      return new Z(t);
+      return new NotFoundError(message);
     case 405:
-      return new V(t);
+      return new MethodNotAllowedError(message);
     case 406:
-      return new X(t);
+      return new NotAcceptableError(message);
     case 500:
-      return new Q(t);
+      return new InternalServerError(message);
     case 501:
-      return new tt(t);
+      return new NotImplementedError(message);
     case 502:
-      return new et(t);
+      return new BadGatewayError(message);
     case 503:
-      return new rt(t);
+      return new ServiceUnavailableError(message);
     case 504:
-      return new nt(t);
+      return new GatewayTimeoutError(message);
     default:
-      return new p(t, r);
+      return new CustomError(message, code);
   }
 }
-const w = class w2 {
-  constructor(t = {}) {
-    c(this, "interceptors", {});
-    c(this, "headers", {});
-    c(this, "url");
-    this.url = t.url ?? null, this.headers = t.headers || {}, t.interceptors && t.interceptors.forEach((e) => w2.addInterceptor(e));
-  }
-  static addInterceptor(t) {
-    const e = Object.keys(w2.interceptors).length.toString();
-    return w2.interceptors[e] = t, () => {
-      w2.interceptors[e] = null;
+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(t) {
-    const e = Object.keys(this.interceptors).length.toString();
-    return this.interceptors[e] = t, () => {
-      this.interceptors[e] = null;
+  addInterceptor(fn) {
+    const key = Object.keys(this.interceptors).length.toString();
+    this.interceptors[key] = fn;
+    return () => {
+      this.interceptors[key] = null;
     };
   }
-  request(t = {}) {
-    var s;
-    if (!this.url && !t.url) throw new Error("URL needs to be set");
-    let e = ((s = t.url) != null && s.startsWith("http") ? t.url : (this.url || "") + (t.url || "")).replace(/([^:]\/)\/+/g, "$1");
-    if (t.fragment && (e.includes("#") ? e.replace(/#.*(\?|\n)/g, (o, i) => `#${t.fragment}${i}`) : e += "#" + t.fragment), t.query) {
-      const o = Array.isArray(t.query) ? t.query : Object.keys(t.query).map((i) => ({ key: i, value: t.query[i] }));
-      e += (e.includes("?") ? "&" : "?") + o.map((i) => `${i.key}=${i.value}`).join("&");
+  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 || "")).replace(/([^:]\/)\/+/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 n = ut({
-      "Content-Type": t.body ? t.body instanceof FormData ? "multipart/form-data" : "application/json" : void 0,
-      ...w2.headers,
+    const headers = clean({
+      "Content-Type": !opts.body ? void 0 : opts.body instanceof FormData ? "multipart/form-data" : "application/json",
+      ..._Http2.headers,
       ...this.headers,
-      ...t.headers
+      ...opts.headers
     });
-    return typeof t.body == "object" && t.body != null && n["Content-Type"] == "application/json" && (t.body = JSON.stringify(t.body)), new E((o, i, a) => {
-      fetch(e, {
-        headers: n,
-        method: t.method || (t.body ? "POST" : "GET"),
-        body: t.body
-      }).then(async (u) => {
-        var G, U;
-        for (let l of [...Object.values(w2.interceptors), ...Object.values(this.interceptors)])
-          await new Promise((R) => l(u, () => R()));
-        const v = u.headers.get("Content-Length"), N = v ? parseInt(v, 10) : 0;
-        let P = 0;
-        const I = (G = u.body) == null ? void 0 : G.getReader(), ot = new ReadableStream({
-          start(l) {
-            function R() {
-              I == null || I.read().then((O) => {
-                if (O.done) return l.close();
-                P += O.value.byteLength, a(P / N), l.enqueue(O.value), R();
-              }).catch((O) => l.error(O));
+    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();
             }
-            R();
+          });
+          resp.data = new Response(stream);
+          if (opts.decode == null || opts.decode) {
+            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.data.formData();
+            else if (content == null ? void 0 : content.includes("json")) resp.data = await resp.data.json();
+            else if (content == null ? void 0 : content.includes("text")) resp.data = await resp.data.text();
+            else if (content == null ? void 0 : content.includes("application")) resp.data = await resp.data.blob();
           }
-        });
-        if (u.data = new Response(ot), t.decode == null || t.decode) {
-          const l = (U = u.headers.get("Content-Type")) == null ? void 0 : U.toLowerCase();
-          l != null && l.includes("form") ? u.data = await u.data.formData() : l != null && l.includes("json") ? u.data = await u.data.json() : l != null && l.includes("text") ? u.data = await u.data.text() : l != null && l.includes("application") && (u.data = await u.data.blob());
-        }
-        u.ok ? o(u) : i(u);
-      });
+          if (resp.ok) res(resp);
+          else rej(resp);
+        }).catch((err) => rej(err));
+      } catch (err) {
+        rej(err);
+      }
     });
   }
 };
-c(w, "interceptors", {}), c(w, "headers", {});
-function Ht(r) {
-  const t = r.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
-  return M(decodeURIComponent(atob(t).split("").map(function(e) {
-    return "%" + ("00" + e.charCodeAt(0).toString(16)).slice(-2);
+__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 x = {
+const CliEffects = {
   CLEAR: "\x1B[0m",
   BRIGHT: "\x1B[1m",
   DIM: "\x1B[2m",
@@ -346,7 +402,8 @@ const x = {
   BLINK: "\x1B[5m",
   REVERSE: "\x1B[7m",
   HIDDEN: "\x1B[8m"
-}, j = {
+};
+const CliForeground = {
   BLACK: "\x1B[30m",
   RED: "\x1B[31m",
   GREEN: "\x1B[32m",
@@ -364,191 +421,59 @@ const x = {
   LIGHT_CYAN: "\x1B[96m",
   WHITE: "\x1B[97m"
 };
-const g = class g2 extends _ {
-  constructor(t) {
-    super(), this.namespace = t;
-  }
-  pad(t, e, n, s = false) {
-    const o = t.toString(), i = e - o.length;
-    if (i <= 0) return o;
-    const a = Array(~~(i / n.length)).fill(n).join("");
-    return s ? o + a : a + o;
-  }
-  format(...t) {
-    const e = /* @__PURE__ */ new Date();
-    return `${`${e.getFullYear()}-${e.getMonth() + 1}-${e.getDate()} ${this.pad(e.getHours().toString(), 2, "0")}:${this.pad(e.getMinutes().toString(), 2, "0")}:${this.pad(e.getSeconds().toString(), 2, "0")}.${this.pad(e.getMilliseconds().toString(), 3, "0", true)}`}${this.namespace ? ` [${this.namespace}]` : ""} ${t.join(" ")}`;
-  }
-  debug(...t) {
-    if (g2.LOG_LEVEL < 4) return;
-    const e = this.format(...t);
-    g2.emit(4, e), console.debug(j.LIGHT_GREY + e + x.CLEAR);
-  }
-  log(...t) {
-    if (g2.LOG_LEVEL < 3) return;
-    const e = this.format(...t);
-    g2.emit(3, e), console.log(x.CLEAR + e);
-  }
-  info(...t) {
-    if (g2.LOG_LEVEL < 2) return;
-    const e = this.format(...t);
-    g2.emit(2, e), console.info(j.BLUE + e + x.CLEAR);
-  }
-  warn(...t) {
-    if (g2.LOG_LEVEL < 1) return;
-    const e = this.format(...t);
-    g2.emit(1, e), console.warn(j.YELLOW + e + x.CLEAR);
-  }
-  error(...t) {
-    if (g2.LOG_LEVEL < 0) return;
-    const e = this.format(...t);
-    g2.emit(0, e), console.error(j.RED + e + x.CLEAR);
+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);
   }
 };
-c(g, "LOG_LEVEL", 4);
-function Ot(r) {
-  return new Promise((t) => setTimeout(t, r));
-}
-async function ie(r, t = 100) {
-  for (; await r(); ) await Ot(t);
-}
-var $ = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, xt = {}, S = {};
-Object.defineProperty(S, "__esModule", { value: true });
-S.persist = S.Persist = void 0;
-class st {
-  /**
-   * @param {string} key Primary key value will be stored under
-   * @param {PersistOptions<T>} options Configure using {@link PersistOptions}
-   */
-  constructor(t, e = {}) {
-    c(this, "key");
-    c(this, "options");
-    c(this, "storage");
-    c(this, "watches", {});
-    c(this, "_value");
-    this.key = t, this.options = e, this.storage = e.storage || localStorage, this.load();
-  }
-  /** Current value or default if undefined */
-  get value() {
-    var t;
-    return this._value !== void 0 ? this._value : (t = this.options) == null ? void 0 : t.default;
-  }
-  /** Set value with proxy object wrapper to sync future changes */
-  set value(t) {
-    t == null || typeof t != "object" ? this._value = t : this._value = new Proxy(t, {
-      get: (e, n) => typeof e[n] == "function" ? (...o) => {
-        const i = e[n](...o);
-        return this.save(), i;
-      } : e[n],
-      set: (e, n, s) => (e[n] = s, this.save(), true)
-    }), this.save();
-  }
-  /** Notify listeners of change */
-  notify(t) {
-    Object.values(this.watches).forEach((e) => e(t));
-  }
-  /** Delete value from storage */
-  clear() {
-    this.storage.removeItem(this.key);
-  }
-  /** Save current value to storage */
-  save() {
-    this._value === void 0 ? this.clear() : this.storage.setItem(this.key, JSON.stringify(this._value)), this.notify(this.value);
-  }
-  /** Load value from storage */
-  load() {
-    if (this.storage[this.key] != null) {
-      let t = JSON.parse(this.storage.getItem(this.key));
-      t != null && typeof t == "object" && this.options.type && (t.__proto__ = this.options.type.prototype), this.value = t;
-    } else
-      this.value = this.options.default || void 0;
-  }
-  /**
-   * Callback function which is run when there are changes
-   *
-   * @param {(value: T) => any} fn Callback will run on each change; it's passed the next value & it's return is ignored
-   * @returns {() => void} Function which will unsubscribe the watch/callback when called
-   */
-  watch(t) {
-    const e = Object.keys(this.watches).length;
-    return this.watches[e] = t, () => {
-      delete this.watches[e];
-    };
-  }
-  /**
-   * Return value as JSON string
-   *
-   * @returns {string} Stringified object as JSON
-   */
-  toString() {
-    return JSON.stringify(this.value);
-  }
-  /**
-   * Return current value
-   *
-   * @returns {T} Current value
-   */
-  valueOf() {
-    return this.value;
-  }
+__publicField2(_Logger, "LOG_LEVEL", 4);
+function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
 }
-S.Persist = st;
-function Bt(r) {
-  return (t, e) => {
-    const n = (r == null ? void 0 : r.key) || `${t.constructor.name}.${e.toString()}`, s = new st(n, r);
-    Object.defineProperty(t, e, {
-      get: function() {
-        return s.value;
-      },
-      set: function(o) {
-        s.value = o;
-      }
-    });
-  };
+async function sleepWhile(fn, checkInterval = 100) {
+  while (await fn()) await sleep(checkInterval);
 }
-S.persist = Bt;
-var L = {};
-Object.defineProperty(L, "__esModule", { value: true });
-L.MemoryStorage = void 0;
-class At {
-  get length() {
-    return Object.keys(this).length;
-  }
-  clear() {
-    Object.keys(this).forEach((t) => this.removeItem(t));
-  }
-  getItem(t) {
-    return this[t];
-  }
-  key(t) {
-    return Object.keys(this)[t];
-  }
-  removeItem(t) {
-    delete this[t];
-  }
-  setItem(t, e) {
-    this[t] = e;
-  }
-}
-L.MemoryStorage = At;
-(function(r) {
-  var t = $ && $.__createBinding || (Object.create ? function(n, s, o, i) {
-    i === void 0 && (i = o);
-    var a = Object.getOwnPropertyDescriptor(s, o);
-    (!a || ("get" in a ? !s.__esModule : a.writable || a.configurable)) && (a = { enumerable: true, get: function() {
-      return s[o];
-    } }), Object.defineProperty(n, i, a);
-  } : function(n, s, o, i) {
-    i === void 0 && (i = o), n[i] = s[o];
-  }), e = $ && $.__exportStar || function(n, s) {
-    for (var o in n) o !== "default" && !Object.prototype.hasOwnProperty.call(s, o) && t(s, n, o);
-  };
-  Object.defineProperty(r, "__esModule", { value: true }), e(S, r), e(L, r);
-})(xt);
 var extendStatics = function(d, b) {
   extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
     d2.__proto__ = b2;
   } || function(d2, b2) {
-    for (var p2 in b2) if (Object.prototype.hasOwnProperty.call(b2, p2)) d2[p2] = b2[p2];
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
   };
   return extendStatics(d, b);
 };
@@ -951,8 +876,8 @@ var EMPTY_OBSERVER = {
 var observable = function() {
   return typeof Symbol === "function" && Symbol.observable || "@@observable";
 }();
-function identity(x2) {
-  return x2;
+function identity(x) {
+  return x;
 }
 function pipeFromArray(fns) {
   if (fns.length === 0) {
@@ -1033,8 +958,8 @@ var Observable = function() {
     promiseCtor = getPromiseCtor(promiseCtor);
     return new promiseCtor(function(resolve, reject) {
       var value;
-      _this.subscribe(function(x2) {
-        return value = x2;
+      _this.subscribe(function(x) {
+        return value = x;
       }, function(err) {
         return reject(err);
       }, function() {
@@ -1670,7 +1595,7 @@ class Auth {
   login(spoke, login, password, twoFactor) {
     return fetch(`${this.api.url}login`, {
       method: "POST",
-      body: $t(ut({
+      body: formData(clean({
         realm: spoke.trim(),
         login: login.trim(),
         password: password.trim(),
@@ -1679,7 +1604,7 @@ class Auth {
       }))
     }).then(async (resp) => {
       const data = await resp.json().catch(() => ({}));
-      if (!resp.ok || data["error"]) throw Object.assign(Yt(resp.status, data.error) || {}, data);
+      if (!resp.ok || data["error"]) throw Object.assign(errorFromCode(resp.status, data.error) || {}, data);
       this.api.token = data["token"];
       return data;
     });
@@ -1692,7 +1617,7 @@ class Auth {
   loginGuest() {
     return fetch(`${this.api.url}guest`).then(async (resp) => {
       const data = await resp.json().catch(() => ({}));
-      if (!resp.ok || data["error"]) throw Object.assign(Yt(resp.status, data.error) || {}, data);
+      if (!resp.ok || data["error"]) throw Object.assign(errorFromCode(resp.status, data.error) || {}, data);
       this.api.token = data["token"];
       return data;
     });
@@ -1784,11 +1709,11 @@ class Files {
       data.append("", file, file.name);
       return fetch(this.url, {
         method: "POST",
-        headers: ut({ "Authorization": this.api.token ? `Bearer ${this.api.token}` : "" }),
+        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(Yt(resp.status, data2.error) || {}, data2);
+        if (!resp.ok || data2["error"]) throw Object.assign(errorFromCode(resp.status, data2.error) || {}, data2);
         return resp;
       });
     })).then(async (files2) => {
@@ -2183,7 +2108,7 @@ class Slice {
       new Slice(this.slice, this.api).select().exec().rows().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).exec().rows().then((rows) => this.cache = [...this.cache.filter((c2) => c2.id != null && !ids.includes(c2.id)), ...rows]);
+        new Slice(this.slice, this.api).select(ids).exec().rows().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$;
@@ -2247,9 +2172,9 @@ class Slice {
 class Socket {
   constructor(api, options = {}) {
     __publicField(this, "listeners", []);
-    __publicField(this, "reconnect", false);
+    __publicField(this, "retry");
     __publicField(this, "socket");
-    __publicField(this, "_connected", false);
+    __publicField(this, "open", false);
     this.api = api;
     this.options = options;
     const url = new URL(this.api.url.replace("http", "ws"));
@@ -2261,9 +2186,6 @@ class Socket {
     if (this.options.url !== false)
       api.token$.pipe(distinctUntilChanged()).subscribe(() => this.connect());
   }
-  get connected() {
-    return this._connected;
-  }
   /**
    * Add listener for all socket events
    *
@@ -2278,46 +2200,46 @@ class Socket {
    * Close socket connection
    */
   close() {
-    this._connected = false;
-    this.reconnect = false;
-    this.socket.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 interval, defaults to 30s
+   * @param {number} timeout Retry to connect every x seconds
    */
-  connect(timeout = 3e4) {
-    if (!this.options.url) throw new Error("Socket is disabled");
-    if (this.connected) {
-      this.reconnect = false;
-      this.socket.close();
-    }
-    this.socket = new WebSocket(this.options.url + (this.api.token ? `?token=${this.api.token}` : ""));
-    let t = setTimeout(() => {
-      if (this.reconnect && !this.connected) this.connect();
-    }, timeout);
-    this.socket.onmessage = (message) => {
-      const payload = JSON.parse(message.data);
-      if (payload.connected != void 0) {
-        if (payload.connected) {
-          clearTimeout(t);
-          t = null;
-          this._connected = true;
-          this.reconnect = true;
-          console.debug("Datalynk Socket: Connected");
+  connect(timeout = 30) {
+    if (!this.options.url) throw new Error("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");
+          } else {
+            throw new Error(`Datalynk socket failed: ${payload.error}`);
+          }
         } else {
-          throw new Error(`Socket failed to connect: ${payload.error}`);
+          this.listeners.forEach((l) => l(payload));
         }
-      } else {
-        this.listeners.forEach((l) => l(payload));
-      }
-    };
-    this.socket.onclose = () => {
-      this._connected = false;
-      if (this.reconnect && !t) this.connect();
-      console.debug("Datalynk Socket: Disconnected");
-    };
+      };
+    }
   }
   /**
    * Send data to socket server
@@ -2325,7 +2247,9 @@ class Socket {
    * @param payload Data that will be serialized
    */
   send(payload) {
-    this.socket.send(JSON.stringify(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
@@ -2336,7 +2260,7 @@ class Socket {
    */
   sliceEvents(slice, callback) {
     let cancelled = false;
-    ie(() => !this.connected).then(() => {
+    sleepWhile(() => !this.open).then(() => {
       if (!cancelled) this.send({ onSliceEvents: slice });
     });
     const unsubscribe = this.addListener((event) => {
@@ -2445,21 +2369,20 @@ class Api {
   /** Get session info from JWT payload */
   get jwtPayload() {
     if (!this.token) return null;
-    return Ht(this.token);
+    return jwtDecode(this.token);
   }
   _request(req, options = {}) {
     return fetch(this.url, {
       method: "POST",
-      headers: ut({
+      headers: clean({
         Authorization: this.token ? `Bearer ${this.token}` : void 0,
         "Content-Type": "application/json"
       }),
       body: JSON.stringify(Api.translateTokens(req))
     }).then(async (resp) => {
-      if (!resp.ok) throw Yt(resp.status);
-      let data = await resp.json();
+      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);
-      if (data["error"]) throw Object.assign(Yt(resp.status, data["error"]) || {}, data);
       return data;
     });
   }