@glodon-aiot/agent-cli-sdk 2.4.7

package/dist/es/node_modules/engine.io-client/build/esm/contrib/has-cors.mjs

@@ -0,0 +1,9 @@
+let e = !1;
+try {
+  e = typeof XMLHttpRequest != "undefined" && "withCredentials" in new XMLHttpRequest();
+} catch (t) {
+}
+const n = e;
+export {
+  n as hasCORS
+};

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

@@ -0,0 +1,18 @@
+function l(t) {
+  let e = "";
+  for (let n in t)
+    t.hasOwnProperty(n) && (e.length && (e += "&"), e += encodeURIComponent(n) + "=" + encodeURIComponent(t[n]));
+  return e;
+}
+function p(t) {
+  let e = {}, n = t.split("&");
+  for (let o = 0, i = n.length; o < i; o++) {
+    let r = n[o].split("=");
+    e[decodeURIComponent(r[0])] = decodeURIComponent(r[1]);
+  }
+  return e;
+}
+export {
+  p as decode,
+  l as encode
+};

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

@@ -0,0 +1,24 @@
+const c = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, u = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];
+function p(t) {
+  if (t.length > 2e3)
+    throw "URI too long";
+  const o = t, i = t.indexOf("["), r = t.indexOf("]");
+  i != -1 && r != -1 && (t = t.substring(0, i) + t.substring(i, r).replace(/:/g, ";") + t.substring(r, t.length));
+  let n = c.exec(t || ""), e = {}, s = 14;
+  for (; s--; )
+    e[u[s]] = n[s] || "";
+  return i != -1 && r != -1 && (e.source = o, e.host = e.host.substring(1, e.host.length - 1).replace(/;/g, ":"), e.authority = e.authority.replace("[", "").replace("]", "").replace(/;/g, ":"), e.ipv6uri = !0), e.pathNames = a(e, e.path), e.queryKey = l(e, e.query), e;
+}
+function a(t, o) {
+  const i = /\/{2,9}/g, r = o.replace(i, "/").split("/");
+  return (o.slice(0, 1) == "/" || o.length === 0) && r.splice(0, 1), o.slice(-1) == "/" && r.splice(r.length - 1, 1), r;
+}
+function l(t, o) {
+  const i = {};
+  return o.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(r, n, e) {
+    n && (i[n] = e);
+  }), i;
+}
+export {
+  p as parse
+};

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

@@ -0,0 +1,19 @@
+const c = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split(""), n = 64, i = {};
+let r = 0, t = 0, l;
+function a(e) {
+  let o = "";
+  do
+    o = c[e % n] + o, e = Math.floor(e / n);
+  while (e > 0);
+  return o;
+}
+function d() {
+  const e = a(+/* @__PURE__ */ new Date());
+  return e !== l ? (r = 0, l = e) : e + "." + a(r++);
+}
+for (; t < n; t++)
+  i[c[t]] = t;
+export {
+  a as encode,
+  d as yeast
+};

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

@@ -0,0 +1,4 @@
+const e = (() => typeof self != "undefined" ? self : typeof window != "undefined" ? window : Function("return this")())();
+export {
+  e as globalThisShim
+};

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

@@ -0,0 +1,317 @@
+import { transports as m } from "./transports/index.mjs";
+import { installTimerFunctions as g, byteLength as y } from "./util.mjs";
+import { decode as v } from "./contrib/parseqs.mjs";
+import { parse as d } from "./contrib/parseuri.mjs";
+import { Emitter as b } from "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import { protocol as u } from "../../../engine.io-parser/build/esm/index.mjs";
+import { defaultBinaryType as T } from "./transports/websocket-constructor.browser.mjs";
+class i extends b {
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(t, e = {}) {
+    super(), this.binaryType = T, this.writeBuffer = [], t && typeof t == "object" && (e = t, t = null), t ? (t = d(t), e.hostname = t.host, e.secure = t.protocol === "https" || t.protocol === "wss", e.port = t.port, t.query && (e.query = t.query)) : e.host && (e.hostname = d(e.host).host), g(this, e), this.secure = e.secure != null ? e.secure : typeof location != "undefined" && location.protocol === "https:", e.hostname && !e.port && (e.port = this.secure ? "443" : "80"), this.hostname = e.hostname || (typeof location != "undefined" ? location.hostname : "localhost"), this.port = e.port || (typeof location != "undefined" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = e.transports || ["polling", "websocket", "webtransport"], this.writeBuffer = [], this.prevBufferLen = 0, this.opts = Object.assign({
+      path: "/engine.io",
+      agent: !1,
+      withCredentials: !1,
+      upgrade: !0,
+      timestampParam: "t",
+      rememberUpgrade: !1,
+      addTrailingSlash: !0,
+      rejectUnauthorized: !0,
+      perMessageDeflate: {
+        threshold: 1024
+      },
+      transportOptions: {},
+      closeOnBeforeunload: !1
+    }, e), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = v(this.opts.query)), this.id = null, this.upgrades = null, this.pingInterval = null, this.pingTimeout = null, this.pingTimeoutTimer = null, typeof addEventListener == "function" && (this.opts.closeOnBeforeunload && (this.beforeunloadEventListener = () => {
+      this.transport && (this.transport.removeAllListeners(), this.transport.close());
+    }, addEventListener("beforeunload", this.beforeunloadEventListener, !1)), this.hostname !== "localhost" && (this.offlineEventListener = () => {
+      this.onClose("transport close", {
+        description: "network connection lost"
+      });
+    }, addEventListener("offline", this.offlineEventListener, !1))), this.open();
+  }
+  /**
+   * Creates transport of the given type.
+   *
+   * @param {String} name - transport name
+   * @return {Transport}
+   * @private
+   */
+  createTransport(t) {
+    const e = Object.assign({}, this.opts.query);
+    e.EIO = u, e.transport = t, this.id && (e.sid = this.id);
+    const s = Object.assign({}, this.opts, {
+      query: e,
+      socket: this,
+      hostname: this.hostname,
+      secure: this.secure,
+      port: this.port
+    }, this.opts.transportOptions[t]);
+    return new m[t](s);
+  }
+  /**
+   * Initializes transport to use and starts probe.
+   *
+   * @private
+   */
+  open() {
+    let t;
+    if (this.opts.rememberUpgrade && i.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1)
+      t = "websocket";
+    else if (this.transports.length === 0) {
+      this.setTimeoutFn(() => {
+        this.emitReserved("error", "No transports available");
+      }, 0);
+      return;
+    } else
+      t = this.transports[0];
+    this.readyState = "opening";
+    try {
+      t = this.createTransport(t);
+    } catch (e) {
+      this.transports.shift(), this.open();
+      return;
+    }
+    t.open(), this.setTransport(t);
+  }
+  /**
+   * Sets the current transport. Disables the existing one (if any).
+   *
+   * @private
+   */
+  setTransport(t) {
+    this.transport && this.transport.removeAllListeners(), this.transport = t, t.on("drain", this.onDrain.bind(this)).on("packet", this.onPacket.bind(this)).on("error", this.onError.bind(this)).on("close", (e) => this.onClose("transport close", e));
+  }
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  probe(t) {
+    let e = this.createTransport(t), s = !1;
+    i.priorWebsocketSuccess = !1;
+    const r = () => {
+      s || (e.send([{
+        type: "ping",
+        data: "probe"
+      }]), e.once("packet", (o) => {
+        if (!s)
+          if (o.type === "pong" && o.data === "probe") {
+            if (this.upgrading = !0, this.emitReserved("upgrading", e), !e)
+              return;
+            i.priorWebsocketSuccess = e.name === "websocket", this.transport.pause(() => {
+              s || this.readyState !== "closed" && (c(), this.setTransport(e), e.send([{
+                type: "upgrade"
+              }]), this.emitReserved("upgrade", e), e = null, this.upgrading = !1, this.flush());
+            });
+          } else {
+            const a = new Error("probe error");
+            a.transport = e.name, this.emitReserved("upgradeError", a);
+          }
+      }));
+    };
+    function n() {
+      s || (s = !0, c(), e.close(), e = null);
+    }
+    const h = (o) => {
+      const a = new Error("probe error: " + o);
+      a.transport = e.name, n(), this.emitReserved("upgradeError", a);
+    };
+    function p() {
+      h("transport closed");
+    }
+    function l() {
+      h("socket closed");
+    }
+    function f(o) {
+      e && o.name !== e.name && n();
+    }
+    const c = () => {
+      e.removeListener("open", r), e.removeListener("error", h), e.removeListener("close", p), this.off("close", l), this.off("upgrading", f);
+    };
+    e.once("open", r), e.once("error", h), e.once("close", p), this.once("close", l), this.once("upgrading", f), this.upgrades.indexOf("webtransport") !== -1 && t !== "webtransport" ? this.setTimeoutFn(() => {
+      s || e.open();
+    }, 200) : e.open();
+  }
+  /**
+   * Called when connection is deemed open.
+   *
+   * @private
+   */
+  onOpen() {
+    if (this.readyState = "open", i.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush(), this.readyState === "open" && this.opts.upgrade) {
+      let t = 0;
+      const e = this.upgrades.length;
+      for (; t < e; t++)
+        this.probe(this.upgrades[t]);
+    }
+  }
+  /**
+   * Handles a packet.
+   *
+   * @private
+   */
+  onPacket(t) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing")
+      switch (this.emitReserved("packet", t), this.emitReserved("heartbeat"), this.resetPingTimeout(), t.type) {
+        case "open":
+          this.onHandshake(JSON.parse(t.data));
+          break;
+        case "ping":
+          this.sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong");
+          break;
+        case "error":
+          const e = new Error("server error");
+          e.code = t.data, this.onError(e);
+          break;
+        case "message":
+          this.emitReserved("data", t.data), this.emitReserved("message", t.data);
+          break;
+      }
+  }
+  /**
+   * Called upon handshake completion.
+   *
+   * @param {Object} data - handshake obj
+   * @private
+   */
+  onHandshake(t) {
+    this.emitReserved("handshake", t), this.id = t.sid, this.transport.query.sid = t.sid, this.upgrades = this.filterUpgrades(t.upgrades), this.pingInterval = t.pingInterval, this.pingTimeout = t.pingTimeout, this.maxPayload = t.maxPayload, this.onOpen(), this.readyState !== "closed" && this.resetPingTimeout();
+  }
+  /**
+   * Sets and resets ping timeout timer based on server pings.
+   *
+   * @private
+   */
+  resetPingTimeout() {
+    this.clearTimeoutFn(this.pingTimeoutTimer), this.pingTimeoutTimer = this.setTimeoutFn(() => {
+      this.onClose("ping timeout");
+    }, this.pingInterval + this.pingTimeout), this.opts.autoUnref && this.pingTimeoutTimer.unref();
+  }
+  /**
+   * Called on `drain` event
+   *
+   * @private
+   */
+  onDrain() {
+    this.writeBuffer.splice(0, this.prevBufferLen), this.prevBufferLen = 0, this.writeBuffer.length === 0 ? this.emitReserved("drain") : this.flush();
+  }
+  /**
+   * Flush write buffers.
+   *
+   * @private
+   */
+  flush() {
+    if (this.readyState !== "closed" && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+      const t = this.getWritablePackets();
+      this.transport.send(t), this.prevBufferLen = t.length, this.emitReserved("flush");
+    }
+  }
+  /**
+   * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+   * long-polling)
+   *
+   * @private
+   */
+  getWritablePackets() {
+    if (!(this.maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1))
+      return this.writeBuffer;
+    let e = 1;
+    for (let s = 0; s < this.writeBuffer.length; s++) {
+      const r = this.writeBuffer[s].data;
+      if (r && (e += y(r)), s > 0 && e > this.maxPayload)
+        return this.writeBuffer.slice(0, s);
+      e += 2;
+    }
+    return this.writeBuffer;
+  }
+  /**
+   * Sends a message.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} callback function.
+   * @return {Socket} for chaining.
+   */
+  write(t, e, s) {
+    return this.sendPacket("message", t, e, s), this;
+  }
+  send(t, e, s) {
+    return this.sendPacket("message", t, e, s), this;
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type: packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  sendPacket(t, e, s, r) {
+    if (typeof e == "function" && (r = e, e = void 0), typeof s == "function" && (r = s, s = null), this.readyState === "closing" || this.readyState === "closed")
+      return;
+    s = s || {}, s.compress = s.compress !== !1;
+    const n = {
+      type: t,
+      data: e,
+      options: s
+    };
+    this.emitReserved("packetCreate", n), this.writeBuffer.push(n), r && this.once("flush", r), this.flush();
+  }
+  /**
+   * Closes the connection.
+   */
+  close() {
+    const t = () => {
+      this.onClose("forced close"), this.transport.close();
+    }, e = () => {
+      this.off("upgrade", e), this.off("upgradeError", e), t();
+    }, s = () => {
+      this.once("upgrade", e), this.once("upgradeError", e);
+    };
+    return (this.readyState === "opening" || this.readyState === "open") && (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? s() : t();
+    }) : this.upgrading ? s() : t()), this;
+  }
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  onError(t) {
+    i.priorWebsocketSuccess = !1, this.emitReserved("error", t), this.onClose("transport error", t);
+  }
+  /**
+   * Called upon transport close.
+   *
+   * @private
+   */
+  onClose(t, e) {
+    (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") && (this.clearTimeoutFn(this.pingTimeoutTimer), this.transport.removeAllListeners("close"), this.transport.close(), this.transport.removeAllListeners(), typeof removeEventListener == "function" && (removeEventListener("beforeunload", this.beforeunloadEventListener, !1), removeEventListener("offline", this.offlineEventListener, !1)), this.readyState = "closed", this.id = null, this.emitReserved("close", t, e), this.writeBuffer = [], this.prevBufferLen = 0);
+  }
+  /**
+   * Filters upgrades, returning only those matching client transports.
+   *
+   * @param {Array} upgrades - server upgrades
+   * @private
+   */
+  filterUpgrades(t) {
+    const e = [];
+    let s = 0;
+    const r = t.length;
+    for (; s < r; s++)
+      ~this.transports.indexOf(t[s]) && e.push(t[s]);
+    return e;
+  }
+}
+i.protocol = u;
+export {
+  i as Socket
+};

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

@@ -0,0 +1,113 @@
+import "../../../engine.io-parser/build/esm/encodePacket.browser.mjs";
+import { decodePacket as o } from "../../../engine.io-parser/build/esm/decodePacket.browser.mjs";
+import "../../../engine.io-parser/build/esm/commons.mjs";
+import { Emitter as i } from "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import { installTimerFunctions as n } from "./util.mjs";
+import { encode as p } from "./contrib/parseqs.mjs";
+class h extends Error {
+  constructor(t, e, r) {
+    super(t), this.description = e, this.context = r, this.type = "TransportError";
+  }
+}
+class y extends i {
+  /**
+   * Transport abstract constructor.
+   *
+   * @param {Object} opts - options
+   * @protected
+   */
+  constructor(t) {
+    super(), this.writable = !1, n(this, t), this.opts = t, this.query = t.query, this.socket = t.socket;
+  }
+  /**
+   * Emits an error.
+   *
+   * @param {String} reason
+   * @param description
+   * @param context - the error context
+   * @return {Transport} for chaining
+   * @protected
+   */
+  onError(t, e, r) {
+    return super.emitReserved("error", new h(t, e, r)), this;
+  }
+  /**
+   * Opens the transport.
+   */
+  open() {
+    return this.readyState = "opening", this.doOpen(), this;
+  }
+  /**
+   * Closes the transport.
+   */
+  close() {
+    return (this.readyState === "opening" || this.readyState === "open") && (this.doClose(), this.onClose()), this;
+  }
+  /**
+   * Sends multiple packets.
+   *
+   * @param {Array} packets
+   */
+  send(t) {
+    this.readyState === "open" && this.write(t);
+  }
+  /**
+   * Called upon open
+   *
+   * @protected
+   */
+  onOpen() {
+    this.readyState = "open", this.writable = !0, super.emitReserved("open");
+  }
+  /**
+   * Called with data.
+   *
+   * @param {String} data
+   * @protected
+   */
+  onData(t) {
+    const e = o(t, this.socket.binaryType);
+    this.onPacket(e);
+  }
+  /**
+   * Called with a decoded packet.
+   *
+   * @protected
+   */
+  onPacket(t) {
+    super.emitReserved("packet", t);
+  }
+  /**
+   * Called upon close.
+   *
+   * @protected
+   */
+  onClose(t) {
+    this.readyState = "closed", super.emitReserved("close", t);
+  }
+  /**
+   * Pauses the transport, in order not to lose packets during an upgrade.
+   *
+   * @param onPause
+   */
+  pause(t) {
+  }
+  createUri(t, e = {}) {
+    return t + "://" + this._hostname() + this._port() + this.opts.path + this._query(e);
+  }
+  _hostname() {
+    const t = this.opts.hostname;
+    return t.indexOf(":") === -1 ? t : "[" + t + "]";
+  }
+  _port() {
+    return this.opts.port && (this.opts.secure && +(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80) ? ":" + this.opts.port : "";
+  }
+  _query(t) {
+    const e = p(t);
+    return e.length ? "?" + e : "";
+  }
+}
+export {
+  y as Transport,
+  h as TransportError
+};

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

@@ -0,0 +1,11 @@
+import { Polling as o } from "./polling.mjs";
+import { WS as r } from "./websocket.mjs";
+import { WT as t } from "./webtransport.mjs";
+const n = {
+  websocket: r,
+  webtransport: t,
+  polling: o
+};
+export {
+  n as transports
+};