@auxilium/datalynk-client 0.8.0 → 0.8.1

package/dist/index.cjs

@@ -1,348 +1,404 @@
-(function(global2, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.utils = {}));
+(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 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",
@@ -350,7 +406,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     BLINK: "\x1B[5m",
     REVERSE: "\x1B[7m",
     HIDDEN: "\x1B[8m"
-  }, j = {
+  };
+  const CliForeground = {
     BLACK: "\x1B[30m",
     RED: "\x1B[31m",
     GREEN: "\x1B[32m",
@@ -368,191 +425,59 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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));
+  __publicField2(_Logger, "LOG_LEVEL", 4);
+  function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
   }
-  async function ie(r, t = 100) {
-    for (; await r(); ) await Ot(t);
+  async function sleepWhile(fn, checkInterval = 100) {
+    while (await fn()) await sleep(checkInterval);
   }
-  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;
-    }
-  }
-  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;
-        }
-      });
-    };
-  }
-  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);
   };
@@ -955,8 +880,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   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) {
@@ -1037,8 +962,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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() {
@@ -1674,7 +1599,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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(),
@@ -1683,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(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;
       });
@@ -1696,7 +1621,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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;
       });
@@ -1788,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: 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) => {
@@ -2187,7 +2112,7 @@ 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]);
+          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$;
@@ -2340,7 +2265,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      */
     sliceEvents(slice, callback) {
       let cancelled = false;
-      ie(() => !this.connected).then(() => {
+      sleepWhile(() => !this.connected).then(() => {
         if (!cancelled) this.send({ onSliceEvents: slice });
       });
       const unsubscribe = this.addListener((event) => {
@@ -2449,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 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;
       });
     }