@auxilium/datalynk-client 0.7.1 → 0.8.1

package/dist/index.cjs

@@ -5,348 +5,400 @@
 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 rt = Object.defineProperty;
-  var nt = (r, t, e) => t in r ? rt(r, t, { enumerable: true, configurable: true, writable: true, value: e }) : r[t] = e;
-  var c = (r, t, e) => (nt(r, typeof t != "symbol" ? t + "" : t, e), e);
-  function ot(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 St(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 T(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, o) => e(
-        (s) => n(s),
-        (s) => o(s),
-        (s) => this.progress = s
+  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, o) => e.then((...s) => n(...s)).catch((...s) => o(...s)));
+    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((o) => n.progress = o), 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 o = super.then(e, n);
-      return this.from(o);
+    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 v {
+  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((o) => o === 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 o;
-      const n = t.toString();
-      return this.listeners[n] || (this.listeners[n] = []), (o = this.listeners[n]) == null || o.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 o = this.on(t, (...s) => {
-          n(s.length == 1 ? s[0] : s), e && e(...s), o();
+    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 o = this.on(t, (...s) => {
-          n(s.length == 1 ? s[0] : s), e && e(...s), o();
+    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(v, "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), o = new this(e.message || e.toString());
-      return Object.assign(o, {
-        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 Y 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(Y, "code", 400);
-  class H 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(H, "code", 401);
-  class W 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(W, "code", 402);
-  class z 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(z, "code", 403);
-  class K 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(K, "code", 404);
-  class J 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(J, "code", 405);
-  class Z 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(Z, "code", 406);
-  class V 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(V, "code", 500);
-  class X 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(X, "code", 501);
-  class Q 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(Q, "code", 502);
-  class _ 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(_, "code", 503);
-  class tt 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(tt, "code", 504);
-  function kt(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 Y(t);
+        return new BadRequestError(message);
       case 401:
-        return new H(t);
+        return new UnauthorizedError(message);
       case 402:
-        return new W(t);
+        return new PaymentRequiredError(message);
       case 403:
-        return new z(t);
+        return new ForbiddenError(message);
       case 404:
-        return new K(t);
+        return new NotFoundError(message);
       case 405:
-        return new J(t);
+        return new MethodNotAllowedError(message);
       case 406:
-        return new Z(t);
+        return new NotAcceptableError(message);
       case 500:
-        return new V(t);
+        return new InternalServerError(message);
       case 501:
-        return new X(t);
+        return new NotImplementedError(message);
       case 502:
-        return new Q(t);
+        return new BadGatewayError(message);
       case 503:
-        return new _(t);
+        return new ServiceUnavailableError(message);
       case 504:
-        return new tt(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 o;
-      if (!this.url && !t.url)
-        throw new Error("URL needs to be set");
-      let e = ((o = t.url) != null && o.startsWith("http") ? t.url : (this.url || "") + (t.url || "")).replace(/([^:]\/)\/+/g, "$1");
-      if (t.fragment && (e.includes("#") ? e.replace(/#.*(\?|\n)/g, (s, i) => `#${t.fragment}${i}`) : e += "#" + t.fragment), t.query) {
-        const s = Array.isArray(t.query) ? t.query : Object.keys(t.query).map((i) => ({ key: i, value: t.query[i] }));
-        e += (e.includes("?") ? "&" : "?") + s.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 = ot({
-        "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((s, i, y) => {
-        fetch(e, {
-          headers: n,
-          method: t.method || (t.body ? "POST" : "GET"),
-          body: t.body
-        }).then(async (u) => {
-          var k, U;
-          for (let a of [...Object.values(w2.interceptors), ...Object.values(this.interceptors)])
-            await new Promise((O) => a(u, () => O()));
-          const R = u.headers.get("Content-Length"), L = R ? parseInt(R, 10) : 0;
-          let M = 0;
-          const N = (k = u.body) == null ? void 0 : k.getReader(), et = new ReadableStream({
-            start(a) {
-              function O() {
-                N == null || N.read().then((B) => {
-                  if (B.done)
-                    return a.close();
-                  M += B.value.byteLength, y(M / L), a.enqueue(B.value), O();
-                }).catch((B) => a.error(B));
+      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();
               }
-              O();
+            });
+            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(et), t.decode == null || t.decode) {
-            const a = (U = u.headers.get("Content-Type")) == null ? void 0 : U.toLowerCase();
-            a != null && a.includes("form") ? u.data = await u.data.formData() : a != null && a.includes("json") ? u.data = await u.data.json() : a != null && a.includes("text") ? u.data = await u.data.text() : a != null && a.includes("application") && (u.data = await u.data.blob());
-          }
-          u.ok ? s(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 Ut(r) {
-    const t = r.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
-    return T(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 S = {
+  const CliEffects = {
     CLEAR: "\x1B[0m",
     BRIGHT: "\x1B[1m",
     DIM: "\x1B[2m",
@@ -354,7 +406,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     BLINK: "\x1B[5m",
     REVERSE: "\x1B[7m",
     HIDDEN: "\x1B[8m"
-  }, C = {
+  };
+  const CliForeground = {
     BLACK: "\x1B[30m",
     RED: "\x1B[31m",
     GREEN: "\x1B[32m",
@@ -372,65 +425,59 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     LIGHT_CYAN: "\x1B[96m",
     WHITE: "\x1B[97m"
   };
-  const g = class g2 extends v {
-    constructor(t) {
-      super(), this.namespace = t;
-    }
-    pad(t, e, n, o = false) {
-      const s = t.toString(), i = e - s.length;
-      if (i <= 0)
-        return s;
-      const y = Array(~~(i / n.length)).fill(n).join("");
-      return o ? s + y : y + s;
-    }
-    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(C.LIGHT_GREY + e + S.CLEAR);
-    }
-    log(...t) {
-      if (g2.LOG_LEVEL < 3)
-        return;
-      const e = this.format(...t);
-      g2.emit(3, e), console.log(S.CLEAR + e);
-    }
-    info(...t) {
-      if (g2.LOG_LEVEL < 2)
-        return;
-      const e = this.format(...t);
-      g2.emit(2, e), console.info(C.BLUE + e + S.CLEAR);
-    }
-    warn(...t) {
-      if (g2.LOG_LEVEL < 1)
-        return;
-      const e = this.format(...t);
-      g2.emit(1, e), console.warn(C.YELLOW + e + S.CLEAR);
-    }
-    error(...t) {
-      if (g2.LOG_LEVEL < 0)
-        return;
-      const e = this.format(...t);
-      g2.emit(0, e), console.error(C.RED + e + S.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 mt(r) {
-    return new Promise((t) => setTimeout(t, r));
+  __publicField2(_Logger, "LOG_LEVEL", 4);
+  function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
   }
-  async function _t(r, t = 100) {
-    for (; await r(); )
-      await mt(t);
+  async function sleepWhile(fn, checkInterval = 100) {
+    while (await fn()) await sleep(checkInterval);
   }
   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);
   };
@@ -1550,9 +1597,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @returns {Promise<any>} Session information returned from login request
      */
     login(spoke, login, password, twoFactor) {
-      return fetch(`${this.api.url + "login"}`, {
+      return fetch(`${this.api.url}login`, {
         method: "POST",
-        body: St(ot({
+        body: formData(clean({
           realm: spoke.trim(),
           login: login.trim(),
           password: password.trim(),
@@ -1561,7 +1608,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }))
       }).then(async (resp) => {
         const data = await resp.json().catch(() => ({}));
-        if (!resp.ok || data["error"]) throw Object.assign(kt(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;
       });
@@ -1572,9 +1619,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @return {Promise<any>}
      */
     loginGuest() {
-      return fetch(`${this.api.url.replace("/api/", "/guest/")}`).then(async (resp) => {
+      return fetch(`${this.api.url}guest`).then(async (resp) => {
         const data = await resp.json().catch(() => ({}));
-        if (!resp.ok || data["error"]) throw Object.assign(kt(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;
       });
@@ -1666,11 +1713,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         data.append("", file, file.name);
         return fetch(this.url, {
           method: "POST",
-          headers: ot({ "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(kt(resp.status, data2.error) || {}, data2);
+          if (!resp.ok || data2["error"]) throw Object.assign(errorFromCode(resp.status, data2.error) || {}, data2);
           return resp;
         });
       })).then(async (files2) => {
@@ -2065,8 +2112,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         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]);
-          this.cache = this.cache.filter((v2) => v2.id && !event.data.lost.includes(v2.id));
+          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$;
       } else if (this.unsubscribe) {
@@ -2131,22 +2178,20 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "listeners", []);
       __publicField(this, "reconnect", false);
       __publicField(this, "socket");
+      __publicField(this, "_connected", false);
       this.api = api;
       this.options = options;
+      const url = new URL(this.api.url.replace("http", "ws"));
+      url.port = "9390";
       this.options = {
-        url: this.api.url.replace("http", "ws") + ":3000",
+        url: url.origin,
         ...this.options
       };
       if (this.options.url !== false)
         api.token$.pipe(distinctUntilChanged()).subscribe(() => this.connect());
     }
-    /**
-     * Is socket connected to Datalynk
-     * @return {boolean} true if connected, false if offline
-     */
-    get open() {
-      var _a;
-      return ((_a = this.socket) == null ? void 0 : _a.readyState) == 1;
+    get connected() {
+      return this._connected;
     }
     /**
      * Add listener for all socket events
@@ -2162,6 +2207,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * Close socket connection
      */
     close() {
+      this._connected = false;
       this.reconnect = false;
       this.socket.close();
     }
@@ -2171,28 +2217,34 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @param {number} timeout Retry interval, defaults to 30s
      */
     connect(timeout = 3e4) {
-      if (this.options.url === false) throw new Error("Socket is disabled");
-      if (this.open) {
+      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}` : ""));
-      const t = setTimeout(() => {
-        if (this.open) return;
-        this.socket.close();
-        this.connect();
+      let t = setTimeout(() => {
+        if (this.reconnect && !this.connected) this.connect();
       }, timeout);
-      this.socket.onopen = () => {
-        clearTimeout(t);
-        this.reconnect = true;
-        console.debug("Datalynk Socket: Connected");
-      };
       this.socket.onmessage = (message) => {
         const payload = JSON.parse(message.data);
-        this.listeners.forEach((l) => l(payload));
+        if (payload.connected != void 0) {
+          if (payload.connected) {
+            clearTimeout(t);
+            t = null;
+            this._connected = true;
+            this.reconnect = true;
+            console.debug("Datalynk Socket: Connected");
+          } else {
+            throw new Error(`Socket failed to connect: ${payload.error}`);
+          }
+        } else {
+          this.listeners.forEach((l) => l(payload));
+        }
       };
       this.socket.onclose = () => {
-        if (this.reconnect) this.connect();
+        this._connected = false;
+        if (this.reconnect && !t) this.connect();
         console.debug("Datalynk Socket: Disconnected");
       };
     }
@@ -2212,14 +2264,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @return {Unsubscribe} Run returned function to unsubscribe callback
      */
     sliceEvents(slice, callback) {
-      _t(() => {
-        var _a;
-        return ((_a = this.socket) == null ? void 0 : _a.readyState) != 1;
-      }).then(() => this.send({ onSliceEvents: slice }));
+      let cancelled = false;
+      sleepWhile(() => !this.connected).then(() => {
+        if (!cancelled) this.send({ onSliceEvents: slice });
+      });
       const unsubscribe = this.addListener((event) => {
         if (event.type == "sliceEvents" && event.data.slice == slice) callback(event);
       });
       return () => {
+        cancelled = true;
         this.send({ offSliceEvents: slice });
         unsubscribe();
       };
@@ -2293,7 +2346,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       /** API Session token */
       __publicField(this, "token$", new BehaviorSubject(null));
       this.options = options;
-      this.url = `${url}${url.endsWith("/") ? "" : "/"}api/`;
+      this.url = `${new URL(url).origin}/api/`;
       this.options = {
         bundleTime: 100,
         origin: typeof location !== "undefined" ? location.host : "Unknown",
@@ -2321,21 +2374,20 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     /** Get session info from JWT payload */
     get jwtPayload() {
       if (!this.token) return null;
-      return Ut(this.token);
+      return jwtDecode(this.token);
     }
     _request(req, options = {}) {
       return fetch(this.url, {
         method: "POST",
-        headers: ot({
+        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 kt(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(kt(resp.status, data["error"]) || {}, data);
         return data;
       });
     }