@glodon-aiot/agent-cli-ui 2.4.7

package/dist/es/node_modules/engine.io-client/build/esm/transports/polling.mjs

@@ -0,0 +1,273 @@
+import { Transport as d } from "../transport.mjs";
+import { yeast as l } from "../contrib/yeast.mjs";
+import { decodePayload as c, encodePayload as p } from "../../../../engine.io-parser/build/esm/index.mjs";
+import { XHR as a, createCookieJar as u } from "./xmlhttprequest.browser.mjs";
+import { Emitter as f } from "../../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import { installTimerFunctions as m, pick as y } from "../util.mjs";
+import { globalThisShim as x } from "../globalThis.browser.mjs";
+function q() {
+}
+const v = function() {
+  return new a({
+    xdomain: !1
+  }).responseType != null;
+}();
+class S extends d {
+  /**
+   * XHR Polling constructor.
+   *
+   * @param {Object} opts
+   * @package
+   */
+  constructor(t) {
+    if (super(t), this.polling = !1, typeof location != "undefined") {
+      const e = location.protocol === "https:";
+      let i = location.port;
+      i || (i = e ? "443" : "80"), this.xd = typeof location != "undefined" && t.hostname !== location.hostname || i !== t.port;
+    }
+    const s = t && t.forceBase64;
+    this.supportsBinary = v && !s, this.opts.withCredentials && (this.cookieJar = u());
+  }
+  get name() {
+    return "polling";
+  }
+  /**
+   * Opens the socket (triggers polling). We write a PING message to determine
+   * when the transport is open.
+   *
+   * @protected
+   */
+  doOpen() {
+    this.poll();
+  }
+  /**
+   * Pauses polling.
+   *
+   * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+   * @package
+   */
+  pause(t) {
+    this.readyState = "pausing";
+    const s = () => {
+      this.readyState = "paused", t();
+    };
+    if (this.polling || !this.writable) {
+      let e = 0;
+      this.polling && (e++, this.once("pollComplete", function() {
+        --e || s();
+      })), this.writable || (e++, this.once("drain", function() {
+        --e || s();
+      }));
+    } else
+      s();
+  }
+  /**
+   * Starts polling cycle.
+   *
+   * @private
+   */
+  poll() {
+    this.polling = !0, this.doPoll(), this.emitReserved("poll");
+  }
+  /**
+   * Overloads onData to detect payloads.
+   *
+   * @protected
+   */
+  onData(t) {
+    const s = (e) => {
+      if (this.readyState === "opening" && e.type === "open" && this.onOpen(), e.type === "close")
+        return this.onClose({
+          description: "transport closed by the server"
+        }), !1;
+      this.onPacket(e);
+    };
+    c(t, this.socket.binaryType).forEach(s), this.readyState !== "closed" && (this.polling = !1, this.emitReserved("pollComplete"), this.readyState === "open" && this.poll());
+  }
+  /**
+   * For polling, send a close packet.
+   *
+   * @protected
+   */
+  doClose() {
+    const t = () => {
+      this.write([{
+        type: "close"
+      }]);
+    };
+    this.readyState === "open" ? t() : this.once("open", t);
+  }
+  /**
+   * Writes a packets payload.
+   *
+   * @param {Array} packets - data packets
+   * @protected
+   */
+  write(t) {
+    this.writable = !1, p(t, (s) => {
+      this.doWrite(s, () => {
+        this.writable = !0, this.emitReserved("drain");
+      });
+    });
+  }
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const t = this.opts.secure ? "https" : "http", s = this.query || {};
+    return this.opts.timestampRequests !== !1 && (s[this.opts.timestampParam] = l()), !this.supportsBinary && !s.sid && (s.b64 = 1), this.createUri(t, s);
+  }
+  /**
+   * Creates a request.
+   *
+   * @param {String} method
+   * @private
+   */
+  request(t = {}) {
+    return Object.assign(t, {
+      xd: this.xd,
+      cookieJar: this.cookieJar
+    }, this.opts), new o(this.uri(), t);
+  }
+  /**
+   * Sends data.
+   *
+   * @param {String} data to send.
+   * @param {Function} called upon flush.
+   * @private
+   */
+  doWrite(t, s) {
+    const e = this.request({
+      method: "POST",
+      data: t
+    });
+    e.on("success", s), e.on("error", (i, h) => {
+      this.onError("xhr post error", i, h);
+    });
+  }
+  /**
+   * Starts a poll cycle.
+   *
+   * @private
+   */
+  doPoll() {
+    const t = this.request();
+    t.on("data", this.onData.bind(this)), t.on("error", (s, e) => {
+      this.onError("xhr poll error", s, e);
+    }), this.pollXhr = t;
+  }
+}
+class o extends f {
+  /**
+   * Request constructor
+   *
+   * @param {Object} options
+   * @package
+   */
+  constructor(t, s) {
+    super(), m(this, s), this.opts = s, this.method = s.method || "GET", this.uri = t, this.data = s.data !== void 0 ? s.data : null, this.create();
+  }
+  /**
+   * Creates the XHR object and sends the request.
+   *
+   * @private
+   */
+  create() {
+    var t;
+    const s = y(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    s.xdomain = !!this.opts.xd;
+    const e = this.xhr = new a(s);
+    try {
+      e.open(this.method, this.uri, !0);
+      try {
+        if (this.opts.extraHeaders) {
+          e.setDisableHeaderCheck && e.setDisableHeaderCheck(!0);
+          for (let i in this.opts.extraHeaders)
+            this.opts.extraHeaders.hasOwnProperty(i) && e.setRequestHeader(i, this.opts.extraHeaders[i]);
+        }
+      } catch (i) {
+      }
+      if (this.method === "POST")
+        try {
+          e.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+        } catch (i) {
+        }
+      try {
+        e.setRequestHeader("Accept", "*/*");
+      } catch (i) {
+      }
+      (t = this.opts.cookieJar) === null || t === void 0 || t.addCookies(e), "withCredentials" in e && (e.withCredentials = this.opts.withCredentials), this.opts.requestTimeout && (e.timeout = this.opts.requestTimeout), e.onreadystatechange = () => {
+        var i;
+        e.readyState === 3 && ((i = this.opts.cookieJar) === null || i === void 0 || i.parseCookies(e)), e.readyState === 4 && (e.status === 200 || e.status === 1223 ? this.onLoad() : this.setTimeoutFn(() => {
+          this.onError(typeof e.status == "number" ? e.status : 0);
+        }, 0));
+      }, e.send(this.data);
+    } catch (i) {
+      this.setTimeoutFn(() => {
+        this.onError(i);
+      }, 0);
+      return;
+    }
+    typeof document != "undefined" && (this.index = o.requestsCount++, o.requests[this.index] = this);
+  }
+  /**
+   * Called upon error.
+   *
+   * @private
+   */
+  onError(t) {
+    this.emitReserved("error", t, this.xhr), this.cleanup(!0);
+  }
+  /**
+   * Cleans up house.
+   *
+   * @private
+   */
+  cleanup(t) {
+    if (!(typeof this.xhr == "undefined" || this.xhr === null)) {
+      if (this.xhr.onreadystatechange = q, t)
+        try {
+          this.xhr.abort();
+        } catch (s) {
+        }
+      typeof document != "undefined" && delete o.requests[this.index], this.xhr = null;
+    }
+  }
+  /**
+   * Called upon load.
+   *
+   * @private
+   */
+  onLoad() {
+    const t = this.xhr.responseText;
+    t !== null && (this.emitReserved("data", t), this.emitReserved("success"), this.cleanup());
+  }
+  /**
+   * Aborts the request.
+   *
+   * @package
+   */
+  abort() {
+    this.cleanup();
+  }
+}
+o.requestsCount = 0;
+o.requests = {};
+if (typeof document != "undefined") {
+  if (typeof attachEvent == "function")
+    attachEvent("onunload", n);
+  else if (typeof addEventListener == "function") {
+    const r = "onpagehide" in x ? "pagehide" : "unload";
+    addEventListener(r, n, !1);
+  }
+}
+function n() {
+  for (let r in o.requests)
+    o.requests.hasOwnProperty(r) && o.requests[r].abort();
+}
+export {
+  S as Polling,
+  o as Request
+};

package/dist/es/node_modules/engine.io-client/build/esm/transports/websocket-constructor.browser.mjs

@@ -0,0 +1,8 @@
+import { globalThisShim as o } from "../globalThis.browser.mjs";
+const s = (() => typeof Promise == "function" && typeof Promise.resolve == "function" ? (e) => Promise.resolve().then(e) : (e, r) => r(e, 0))(), n = o.WebSocket || o.MozWebSocket, c = !0, l = "arraybuffer";
+export {
+  n as WebSocket,
+  l as defaultBinaryType,
+  s as nextTick,
+  c as usingBrowserWebSocket
+};

package/dist/es/node_modules/engine.io-client/build/esm/transports/websocket.mjs

@@ -0,0 +1,87 @@
+import { Transport as c } from "../transport.mjs";
+import { yeast as h } from "../contrib/yeast.mjs";
+import { pick as p } from "../util.mjs";
+import { usingBrowserWebSocket as i, WebSocket as r, nextTick as d } from "./websocket-constructor.browser.mjs";
+import { encodePacket as u } from "../../../../engine.io-parser/build/esm/encodePacket.browser.mjs";
+import "../../../../engine.io-parser/build/esm/commons.mjs";
+import "../../../../engine.io-parser/build/esm/contrib/base64-arraybuffer.mjs";
+const n = typeof navigator != "undefined" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class B extends c {
+  /**
+   * WebSocket transport constructor.
+   *
+   * @param {Object} opts - connection options
+   * @protected
+   */
+  constructor(t) {
+    super(t), this.supportsBinary = !t.forceBase64;
+  }
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    if (!this.check())
+      return;
+    const t = this.uri(), e = this.opts.protocols, s = n ? {} : p(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+    this.opts.extraHeaders && (s.headers = this.opts.extraHeaders);
+    try {
+      this.ws = i && !n ? e ? new r(t, e) : new r(t) : new r(t, e, s);
+    } catch (o) {
+      return this.emitReserved("error", o);
+    }
+    this.ws.binaryType = this.socket.binaryType, this.addEventListeners();
+  }
+  /**
+   * Adds event listeners to the socket
+   *
+   * @private
+   */
+  addEventListeners() {
+    this.ws.onopen = () => {
+      this.opts.autoUnref && this.ws._socket.unref(), this.onOpen();
+    }, this.ws.onclose = (t) => this.onClose({
+      description: "websocket connection closed",
+      context: t
+    }), this.ws.onmessage = (t) => this.onData(t.data), this.ws.onerror = (t) => this.onError("websocket error", t);
+  }
+  write(t) {
+    this.writable = !1;
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e], o = e === t.length - 1;
+      u(s, this.supportsBinary, (a) => {
+        const m = {};
+        try {
+          i && this.ws.send(a);
+        } catch (w) {
+        }
+        o && d(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    typeof this.ws != "undefined" && (this.ws.close(), this.ws = null);
+  }
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const t = this.opts.secure ? "wss" : "ws", e = this.query || {};
+    return this.opts.timestampRequests && (e[this.opts.timestampParam] = h()), this.supportsBinary || (e.b64 = 1), this.createUri(t, e);
+  }
+  /**
+   * Feature detection for WebSocket.
+   *
+   * @return {Boolean} whether this transport is available.
+   * @private
+   */
+  check() {
+    return !!r;
+  }
+}
+export {
+  B as WS
+};

package/dist/es/node_modules/engine.io-client/build/esm/transports/webtransport.mjs

@@ -0,0 +1,52 @@
+import { Transport as h } from "../transport.mjs";
+import { nextTick as c } from "./websocket-constructor.browser.mjs";
+import { createPacketDecoderStream as p, createPacketEncoderStream as d } from "../../../../engine.io-parser/build/esm/index.mjs";
+class f extends h {
+  get name() {
+    return "webtransport";
+  }
+  doOpen() {
+    typeof WebTransport == "function" && (this.transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]), this.transport.closed.then(() => {
+      this.onClose();
+    }).catch((t) => {
+      this.onError("webtransport error", t);
+    }), this.transport.ready.then(() => {
+      this.transport.createBidirectionalStream().then((t) => {
+        const e = p(Number.MAX_SAFE_INTEGER, this.socket.binaryType), i = t.readable.pipeThrough(e).getReader(), r = d();
+        r.readable.pipeTo(t.writable), this.writer = r.writable.getWriter();
+        const s = () => {
+          i.read().then(({
+            done: n,
+            value: a
+          }) => {
+            n || (this.onPacket(a), s());
+          }).catch((n) => {
+          });
+        };
+        s();
+        const o = {
+          type: "open"
+        };
+        this.query.sid && (o.data = `{"sid":"${this.query.sid}"}`), this.writer.write(o).then(() => this.onOpen());
+      });
+    }));
+  }
+  write(t) {
+    this.writable = !1;
+    for (let e = 0; e < t.length; e++) {
+      const i = t[e], r = e === t.length - 1;
+      this.writer.write(i).then(() => {
+        r && c(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    var t;
+    (t = this.transport) === null || t === void 0 || t.close();
+  }
+}
+export {
+  f as WT
+};

package/dist/es/node_modules/engine.io-client/build/esm/transports/xmlhttprequest.browser.mjs

@@ -0,0 +1,21 @@
+import { hasCORS as i } from "../contrib/has-cors.mjs";
+import { globalThisShim as n } from "../globalThis.browser.mjs";
+function a(e) {
+  const t = e.xdomain;
+  try {
+    if (typeof XMLHttpRequest != "undefined" && (!t || i))
+      return new XMLHttpRequest();
+  } catch (o) {
+  }
+  if (!t)
+    try {
+      return new n[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch (o) {
+    }
+}
+function f() {
+}
+export {
+  a as XHR,
+  f as createCookieJar
+};

package/dist/es/node_modules/engine.io-client/build/esm/util.mjs

@@ -0,0 +1,23 @@
+import { globalThisShim as r } from "./globalThis.browser.mjs";
+function f(e, ...t) {
+  return t.reduce((i, n) => (e.hasOwnProperty(n) && (i[n] = e[n]), i), {});
+}
+const l = r.setTimeout, s = r.clearTimeout;
+function m(e, t) {
+  t.useNativeTimers ? (e.setTimeoutFn = l.bind(r), e.clearTimeoutFn = s.bind(r)) : (e.setTimeoutFn = r.setTimeout.bind(r), e.clearTimeoutFn = r.clearTimeout.bind(r));
+}
+const T = 1.33;
+function h(e) {
+  return typeof e == "string" ? o(e) : Math.ceil((e.byteLength || e.size) * T);
+}
+function o(e) {
+  let t = 0, i = 0;
+  for (let n = 0, u = e.length; n < u; n++)
+    t = e.charCodeAt(n), t < 128 ? i += 1 : t < 2048 ? i += 2 : t < 55296 || t >= 57344 ? i += 3 : (n++, i += 4);
+  return i;
+}
+export {
+  h as byteLength,
+  m as installTimerFunctions,
+  f as pick
+};

package/dist/es/node_modules/engine.io-parser/build/esm/commons.mjs

@@ -0,0 +1,21 @@
+const e = /* @__PURE__ */ Object.create(null);
+e.open = "0";
+e.close = "1";
+e.ping = "2";
+e.pong = "3";
+e.message = "4";
+e.upgrade = "5";
+e.noop = "6";
+const o = /* @__PURE__ */ Object.create(null);
+Object.keys(e).forEach((r) => {
+  o[e[r]] = r;
+});
+const t = {
+  type: "error",
+  data: "parser error"
+};
+export {
+  t as ERROR_PACKET,
+  e as PACKET_TYPES,
+  o as PACKET_TYPES_REVERSE
+};

package/dist/es/node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.mjs

@@ -0,0 +1,14 @@
+const i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = typeof Uint8Array == "undefined" ? [] : new Uint8Array(256);
+for (let e = 0; e < i.length; e++)
+  r[i.charCodeAt(e)] = e;
+const g = (e) => {
+  let t = e.length * 0.75, y = e.length, n, o = 0, h, d, c, l;
+  e[e.length - 1] === "=" && (t--, e[e.length - 2] === "=" && t--);
+  const A = new ArrayBuffer(t), f = new Uint8Array(A);
+  for (n = 0; n < y; n += 4)
+    h = r[e.charCodeAt(n)], d = r[e.charCodeAt(n + 1)], c = r[e.charCodeAt(n + 2)], l = r[e.charCodeAt(n + 3)], f[o++] = h << 2 | d >> 4, f[o++] = (d & 15) << 4 | c >> 2, f[o++] = (c & 3) << 6 | l & 63;
+  return A;
+};
+export {
+  g as decode
+};

package/dist/es/node_modules/engine.io-parser/build/esm/decodePacket.browser.mjs

@@ -0,0 +1,39 @@
+import { PACKET_TYPES_REVERSE as s, ERROR_PACKET as n } from "./commons.mjs";
+import { decode as u } from "./contrib/base64-arraybuffer.mjs";
+const o = typeof ArrayBuffer == "function", a = (r, e) => {
+  if (typeof r != "string")
+    return {
+      type: "message",
+      data: f(r, e)
+    };
+  const t = r.charAt(0);
+  return t === "b" ? {
+    type: "message",
+    data: i(r.substring(1), e)
+  } : s[t] ? r.length > 1 ? {
+    type: s[t],
+    data: r.substring(1)
+  } : {
+    type: s[t]
+  } : n;
+}, i = (r, e) => {
+  if (o) {
+    const t = u(r);
+    return f(t, e);
+  } else
+    return {
+      base64: !0,
+      data: r
+    };
+}, f = (r, e) => {
+  switch (e) {
+    case "blob":
+      return r instanceof Blob ? r : new Blob([r]);
+    case "arraybuffer":
+    default:
+      return r instanceof ArrayBuffer ? r : r.buffer;
+  }
+};
+export {
+  a as decodePacket
+};

package/dist/es/node_modules/engine.io-parser/build/esm/encodePacket.browser.mjs

@@ -0,0 +1,28 @@
+import { PACKET_TYPES as B } from "./commons.mjs";
+const u = typeof Blob == "function" || typeof Blob != "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", s = typeof ArrayBuffer == "function", y = (e) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(e) : e && e.buffer instanceof ArrayBuffer, c = ({
+  type: e,
+  data: r
+}, n, t) => u && r instanceof Blob ? n ? t(r) : o(r, t) : s && (r instanceof ArrayBuffer || y(r)) ? n ? t(r) : o(new Blob([r]), t) : t(B[e] + (r || "")), o = (e, r) => {
+  const n = new FileReader();
+  return n.onload = function() {
+    const t = n.result.split(",")[1];
+    r("b" + (t || ""));
+  }, n.readAsDataURL(e);
+};
+function i(e) {
+  return e instanceof Uint8Array ? e : e instanceof ArrayBuffer ? new Uint8Array(e) : new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+let f;
+function l(e, r) {
+  if (u && e.data instanceof Blob)
+    return e.data.arrayBuffer().then(i).then(r);
+  if (s && (e.data instanceof ArrayBuffer || y(e.data)))
+    return r(i(e.data));
+  c(e, !1, (n) => {
+    f || (f = new TextEncoder()), r(f.encode(n));
+  });
+}
+export {
+  c as encodePacket,
+  l as encodePacketToBinary
+};

package/dist/es/node_modules/engine.io-parser/build/esm/index.mjs

@@ -0,0 +1,105 @@
+import { encodePacket as b, encodePacketToBinary as m } from "./encodePacket.browser.mjs";
+import { decodePacket as h } from "./decodePacket.browser.mjs";
+import { ERROR_PACKET as g } from "./commons.mjs";
+const y = String.fromCharCode(30), A = (r, a) => {
+  const n = r.length, t = new Array(n);
+  let e = 0;
+  r.forEach((i, l) => {
+    b(i, !1, (f) => {
+      t[l] = f, ++e === n && a(t.join(y));
+    });
+  });
+}, D = (r, a) => {
+  const n = r.split(y), t = [];
+  for (let e = 0; e < n.length; e++) {
+    const i = h(n[e], a);
+    if (t.push(i), i.type === "error")
+      break;
+  }
+  return t;
+};
+function E() {
+  return new TransformStream({
+    transform(r, a) {
+      m(r, (n) => {
+        const t = n.length;
+        let e;
+        if (t < 126)
+          e = new Uint8Array(1), new DataView(e.buffer).setUint8(0, t);
+        else if (t < 65536) {
+          e = new Uint8Array(3);
+          const i = new DataView(e.buffer);
+          i.setUint8(0, 126), i.setUint16(1, t);
+        } else {
+          e = new Uint8Array(9);
+          const i = new DataView(e.buffer);
+          i.setUint8(0, 127), i.setBigUint64(1, BigInt(t));
+        }
+        r.data && typeof r.data != "string" && (e[0] |= 128), a.enqueue(e), a.enqueue(n);
+      });
+    }
+  });
+}
+let d;
+function s(r) {
+  return r.reduce((a, n) => a + n.length, 0);
+}
+function c(r, a) {
+  if (r[0].length === a)
+    return r.shift();
+  const n = new Uint8Array(a);
+  let t = 0;
+  for (let e = 0; e < a; e++)
+    n[e] = r[0][t++], t === r[0].length && (r.shift(), t = 0);
+  return r.length && t < r[0].length && (r[0] = r[0].slice(t)), n;
+}
+function T(r, a) {
+  d || (d = new TextDecoder());
+  const n = [];
+  let t = 0, e = -1, i = !1;
+  return new TransformStream({
+    transform(l, f) {
+      for (n.push(l); ; ) {
+        if (t === 0) {
+          if (s(n) < 1)
+            break;
+          const o = c(n, 1);
+          i = (o[0] & 128) === 128, e = o[0] & 127, e < 126 ? t = 3 : e === 126 ? t = 1 : t = 2;
+        } else if (t === 1) {
+          if (s(n) < 2)
+            break;
+          const o = c(n, 2);
+          e = new DataView(o.buffer, o.byteOffset, o.length).getUint16(0), t = 3;
+        } else if (t === 2) {
+          if (s(n) < 8)
+            break;
+          const o = c(n, 8), u = new DataView(o.buffer, o.byteOffset, o.length), w = u.getUint32(0);
+          if (w > Math.pow(2, 53 - 32) - 1) {
+            f.enqueue(g);
+            break;
+          }
+          e = w * Math.pow(2, 32) + u.getUint32(4), t = 3;
+        } else {
+          if (s(n) < e)
+            break;
+          const o = c(n, e);
+          f.enqueue(h(i ? o : d.decode(o), a)), t = 0;
+        }
+        if (e === 0 || e > r) {
+          f.enqueue(g);
+          break;
+        }
+      }
+    }
+  });
+}
+const x = 4;
+export {
+  T as createPacketDecoderStream,
+  E as createPacketEncoderStream,
+  h as decodePacket,
+  D as decodePayload,
+  b as encodePacket,
+  A as encodePayload,
+  x as protocol
+};