@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/socket.io-client/build/cjs/socket.mjs

@@ -0,0 +1,627 @@
+import { commonjsGlobal as d } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as f } from "../../../../../../../../../_virtual/socket.mjs";
+import "../../../socket.io-parser/build/cjs/index.mjs";
+import "./on.mjs";
+import l from "../../../../../../../../../_virtual/index71.mjs";
+import { b as p } from "../../../debug/src/browser.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/index61.mjs";
+import { __exports as g } from "../../../../../../../../../_virtual/on.mjs";
+var y = d && d.__importDefault || function(a) {
+  return a && a.__esModule ? a : { default: a };
+};
+Object.defineProperty(f, "__esModule", { value: !0 });
+f.Socket = void 0;
+const r = _, u = g, m = l, k = y(p), i = k.default("socket.io-client:socket"), b = Object.freeze({
+  connect: 1,
+  connect_error: 1,
+  disconnect: 1,
+  disconnecting: 1,
+  // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+  newListener: 1,
+  removeListener: 1
+});
+class v extends m.Emitter {
+  /**
+   * `Socket` constructor.
+   */
+  constructor(t, e, s) {
+    super(), this.connected = !1, this.recovered = !1, this.receiveBuffer = [], this.sendBuffer = [], this._queue = [], this._queueSeq = 0, this.ids = 0, this.acks = {}, this.flags = {}, this.io = t, this.nsp = e, s && s.auth && (this.auth = s.auth), this._opts = Object.assign({}, s), this.io._autoConnect && this.open();
+  }
+  /**
+   * Whether the socket is currently disconnected
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("connect", () => {
+   *   console.log(socket.disconnected); // false
+   * });
+   *
+   * socket.on("disconnect", () => {
+   *   console.log(socket.disconnected); // true
+   * });
+   */
+  get disconnected() {
+    return !this.connected;
+  }
+  /**
+   * Subscribe to open, close and packet events
+   *
+   * @private
+   */
+  subEvents() {
+    if (this.subs)
+      return;
+    const t = this.io;
+    this.subs = [
+      u.on(t, "open", this.onopen.bind(this)),
+      u.on(t, "packet", this.onpacket.bind(this)),
+      u.on(t, "error", this.onerror.bind(this)),
+      u.on(t, "close", this.onclose.bind(this))
+    ];
+  }
+  /**
+   * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+   *
+   * @example
+   * const socket = io();
+   *
+   * console.log(socket.active); // true
+   *
+   * socket.on("disconnect", (reason) => {
+   *   if (reason === "io server disconnect") {
+   *     // the disconnection was initiated by the server, you need to manually reconnect
+   *     console.log(socket.active); // false
+   *   }
+   *   // else the socket will automatically try to reconnect
+   *   console.log(socket.active); // true
+   * });
+   */
+  get active() {
+    return !!this.subs;
+  }
+  /**
+   * "Opens" the socket.
+   *
+   * @example
+   * const socket = io({
+   *   autoConnect: false
+   * });
+   *
+   * socket.connect();
+   */
+  connect() {
+    return this.connected ? this : (this.subEvents(), this.io._reconnecting || this.io.open(), this.io._readyState === "open" && this.onopen(), this);
+  }
+  /**
+   * Alias for {@link connect()}.
+   */
+  open() {
+    return this.connect();
+  }
+  /**
+   * Sends a `message` event.
+   *
+   * This method mimics the WebSocket.send() method.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+   *
+   * @example
+   * socket.send("hello");
+   *
+   * // this is equivalent to
+   * socket.emit("message", "hello");
+   *
+   * @return self
+   */
+  send(...t) {
+    return t.unshift("message"), this.emit.apply(this, t), this;
+  }
+  /**
+   * Override `emit`.
+   * If the event is in `events`, it's emitted normally.
+   *
+   * @example
+   * socket.emit("hello", "world");
+   *
+   * // all serializable datastructures are supported (no need to call JSON.stringify)
+   * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+   *
+   * // with an acknowledgement from the server
+   * socket.emit("hello", "world", (val) => {
+   *   // ...
+   * });
+   *
+   * @return self
+   */
+  emit(t, ...e) {
+    if (b.hasOwnProperty(t))
+      throw new Error('"' + t.toString() + '" is a reserved event name');
+    if (e.unshift(t), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile)
+      return this._addToQueue(e), this;
+    const s = {
+      type: r.PacketType.EVENT,
+      data: e
+    };
+    if (s.options = {}, s.options.compress = this.flags.compress !== !1, typeof e[e.length - 1] == "function") {
+      const o = this.ids++;
+      i("emitting packet with ack id %d", o);
+      const h = e.pop();
+      this._registerAckCallback(o, h), s.id = o;
+    }
+    const n = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable;
+    return this.flags.volatile && (!n || !this.connected) ? i("discard packet as the transport is not currently writable") : this.connected ? (this.notifyOutgoingListeners(s), this.packet(s)) : this.sendBuffer.push(s), this.flags = {}, this;
+  }
+  /**
+   * @private
+   */
+  _registerAckCallback(t, e) {
+    var s;
+    const n = (s = this.flags.timeout) !== null && s !== void 0 ? s : this._opts.ackTimeout;
+    if (n === void 0) {
+      this.acks[t] = e;
+      return;
+    }
+    const c = this.io.setTimeoutFn(() => {
+      delete this.acks[t];
+      for (let h = 0; h < this.sendBuffer.length; h++)
+        this.sendBuffer[h].id === t && (i("removing packet with ack id %d from the buffer", t), this.sendBuffer.splice(h, 1));
+      i("event with ack id %d has timed out after %d ms", t, n), e.call(this, new Error("operation has timed out"));
+    }, n), o = (...h) => {
+      this.io.clearTimeoutFn(c), e.apply(this, h);
+    };
+    o.withError = !0, this.acks[t] = o;
+  }
+  /**
+   * Emits an event and waits for an acknowledgement
+   *
+   * @example
+   * // without timeout
+   * const response = await socket.emitWithAck("hello", "world");
+   *
+   * // with a specific timeout
+   * try {
+   *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+   * } catch (err) {
+   *   // the server did not acknowledge the event in the given delay
+   * }
+   *
+   * @return a Promise that will be fulfilled when the server acknowledges the event
+   */
+  emitWithAck(t, ...e) {
+    return new Promise((s, n) => {
+      const c = (o, h) => o ? n(o) : s(h);
+      c.withError = !0, e.push(c), this.emit(t, ...e);
+    });
+  }
+  /**
+   * Add the packet to the queue.
+   * @param args
+   * @private
+   */
+  _addToQueue(t) {
+    let e;
+    typeof t[t.length - 1] == "function" && (e = t.pop());
+    const s = {
+      id: this._queueSeq++,
+      tryCount: 0,
+      pending: !1,
+      args: t,
+      flags: Object.assign({ fromQueue: !0 }, this.flags)
+    };
+    t.push((n, ...c) => s !== this._queue[0] ? void 0 : (n !== null ? s.tryCount > this._opts.retries && (i("packet [%d] is discarded after %d tries", s.id, s.tryCount), this._queue.shift(), e && e(n)) : (i("packet [%d] was successfully sent", s.id), this._queue.shift(), e && e(null, ...c)), s.pending = !1, this._drainQueue())), this._queue.push(s), this._drainQueue();
+  }
+  /**
+   * Send the first packet of the queue, and wait for an acknowledgement from the server.
+   * @param force - whether to resend a packet that has not been acknowledged yet
+   *
+   * @private
+   */
+  _drainQueue(t = !1) {
+    if (i("draining queue"), !this.connected || this._queue.length === 0)
+      return;
+    const e = this._queue[0];
+    if (e.pending && !t) {
+      i("packet [%d] has already been sent and is waiting for an ack", e.id);
+      return;
+    }
+    e.pending = !0, e.tryCount++, i("sending packet [%d] (try n°%d)", e.id, e.tryCount), this.flags = e.flags, this.emit.apply(this, e.args);
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param packet
+   * @private
+   */
+  packet(t) {
+    t.nsp = this.nsp, this.io._packet(t);
+  }
+  /**
+   * Called upon engine `open`.
+   *
+   * @private
+   */
+  onopen() {
+    i("transport is open - connecting"), typeof this.auth == "function" ? this.auth((t) => {
+      this._sendConnectPacket(t);
+    }) : this._sendConnectPacket(this.auth);
+  }
+  /**
+   * Sends a CONNECT packet to initiate the Socket.IO session.
+   *
+   * @param data
+   * @private
+   */
+  _sendConnectPacket(t) {
+    this.packet({
+      type: r.PacketType.CONNECT,
+      data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, t) : t
+    });
+  }
+  /**
+   * Called upon engine or manager `error`.
+   *
+   * @param err
+   * @private
+   */
+  onerror(t) {
+    this.connected || this.emitReserved("connect_error", t);
+  }
+  /**
+   * Called upon engine `close`.
+   *
+   * @param reason
+   * @param description
+   * @private
+   */
+  onclose(t, e) {
+    i("close (%s)", t), this.connected = !1, delete this.id, this.emitReserved("disconnect", t, e), this._clearAcks();
+  }
+  /**
+   * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+   * the server.
+   *
+   * @private
+   */
+  _clearAcks() {
+    Object.keys(this.acks).forEach((t) => {
+      if (!this.sendBuffer.some((s) => String(s.id) === t)) {
+        const s = this.acks[t];
+        delete this.acks[t], s.withError && s.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+  /**
+   * Called with socket packet.
+   *
+   * @param packet
+   * @private
+   */
+  onpacket(t) {
+    if (t.nsp === this.nsp)
+      switch (t.type) {
+        case r.PacketType.CONNECT:
+          t.data && t.data.sid ? this.onconnect(t.data.sid, t.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          break;
+        case r.PacketType.EVENT:
+        case r.PacketType.BINARY_EVENT:
+          this.onevent(t);
+          break;
+        case r.PacketType.ACK:
+        case r.PacketType.BINARY_ACK:
+          this.onack(t);
+          break;
+        case r.PacketType.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case r.PacketType.CONNECT_ERROR:
+          this.destroy();
+          const s = new Error(t.data.message);
+          s.data = t.data.data, this.emitReserved("connect_error", s);
+          break;
+      }
+  }
+  /**
+   * Called upon a server event.
+   *
+   * @param packet
+   * @private
+   */
+  onevent(t) {
+    const e = t.data || [];
+    i("emitting event %j", e), t.id != null && (i("attaching ack callback to event"), e.push(this.ack(t.id))), this.connected ? this.emitEvent(e) : this.receiveBuffer.push(Object.freeze(e));
+  }
+  emitEvent(t) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const e = this._anyListeners.slice();
+      for (const s of e)
+        s.apply(this, t);
+    }
+    super.emit.apply(this, t), this._pid && t.length && typeof t[t.length - 1] == "string" && (this._lastOffset = t[t.length - 1]);
+  }
+  /**
+   * Produces an ack callback to emit with an event.
+   *
+   * @private
+   */
+  ack(t) {
+    const e = this;
+    let s = !1;
+    return function(...n) {
+      s || (s = !0, i("sending ack %j", n), e.packet({
+        type: r.PacketType.ACK,
+        id: t,
+        data: n
+      }));
+    };
+  }
+  /**
+   * Called upon a server acknowledgement.
+   *
+   * @param packet
+   * @private
+   */
+  onack(t) {
+    const e = this.acks[t.id];
+    if (typeof e != "function") {
+      i("bad ack %s", t.id);
+      return;
+    }
+    delete this.acks[t.id], i("calling ack %s with %j", t.id, t.data), e.withError && t.data.unshift(null), e.apply(this, t.data);
+  }
+  /**
+   * Called upon server connect.
+   *
+   * @private
+   */
+  onconnect(t, e) {
+    i("socket connected with id %s", t), this.id = t, this.recovered = e && this._pid === e, this._pid = e, this.connected = !0, this.emitBuffered(), this.emitReserved("connect"), this._drainQueue(!0);
+  }
+  /**
+   * Emit buffered events (received and emitted).
+   *
+   * @private
+   */
+  emitBuffered() {
+    this.receiveBuffer.forEach((t) => this.emitEvent(t)), this.receiveBuffer = [], this.sendBuffer.forEach((t) => {
+      this.notifyOutgoingListeners(t), this.packet(t);
+    }), this.sendBuffer = [];
+  }
+  /**
+   * Called upon server disconnect.
+   *
+   * @private
+   */
+  ondisconnect() {
+    i("server disconnect (%s)", this.nsp), this.destroy(), this.onclose("io server disconnect");
+  }
+  /**
+   * Called upon forced client/server side disconnections,
+   * this method ensures the manager stops tracking us and
+   * that reconnections don't get triggered for this.
+   *
+   * @private
+   */
+  destroy() {
+    this.subs && (this.subs.forEach((t) => t()), this.subs = void 0), this.io._destroy(this);
+  }
+  /**
+   * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+   *
+   * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("disconnect", (reason) => {
+   *   // console.log(reason); prints "io client disconnect"
+   * });
+   *
+   * socket.disconnect();
+   *
+   * @return self
+   */
+  disconnect() {
+    return this.connected && (i("performing disconnect (%s)", this.nsp), this.packet({ type: r.PacketType.DISCONNECT })), this.destroy(), this.connected && this.onclose("io client disconnect"), this;
+  }
+  /**
+   * Alias for {@link disconnect()}.
+   *
+   * @return self
+   */
+  close() {
+    return this.disconnect();
+  }
+  /**
+   * Sets the compress flag.
+   *
+   * @example
+   * socket.compress(false).emit("hello");
+   *
+   * @param compress - if `true`, compresses the sending data
+   * @return self
+   */
+  compress(t) {
+    return this.flags.compress = t, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+   * ready to send messages.
+   *
+   * @example
+   * socket.volatile.emit("hello"); // the server may or may not receive it
+   *
+   * @returns self
+   */
+  get volatile() {
+    return this.flags.volatile = !0, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+   * given number of milliseconds have elapsed without an acknowledgement from the server:
+   *
+   * @example
+   * socket.timeout(5000).emit("my-event", (err) => {
+   *   if (err) {
+   *     // the server did not acknowledge the event in the given delay
+   *   }
+   * });
+   *
+   * @returns self
+   */
+  timeout(t) {
+    return this.flags.timeout = t, this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * @example
+   * socket.onAny((event, ...args) => {
+   *   console.log(`got ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * @example
+   * socket.prependAny((event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * }
+   *
+   * socket.onAny(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAny(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAny();
+   *
+   * @param listener
+   */
+  offAny(t) {
+    if (!this._anyListeners)
+      return this;
+    if (t) {
+      const e = this._anyListeners;
+      for (let s = 0; s < e.length; s++)
+        if (t === e[s])
+          return e.splice(s, 1), this;
+    } else
+      this._anyListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAny() {
+    return this._anyListeners || [];
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.onAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.prependAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * }
+   *
+   * socket.onAnyOutgoing(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAnyOutgoing(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAnyOutgoing();
+   *
+   * @param [listener] - the catch-all listener (optional)
+   */
+  offAnyOutgoing(t) {
+    if (!this._anyOutgoingListeners)
+      return this;
+    if (t) {
+      const e = this._anyOutgoingListeners;
+      for (let s = 0; s < e.length; s++)
+        if (t === e[s])
+          return e.splice(s, 1), this;
+    } else
+      this._anyOutgoingListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAnyOutgoing() {
+    return this._anyOutgoingListeners || [];
+  }
+  /**
+   * Notify the listeners for each packet sent
+   *
+   * @param packet
+   *
+   * @private
+   */
+  notifyOutgoingListeners(t) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const e = this._anyOutgoingListeners.slice();
+      for (const s of e)
+        s.apply(this, t.data);
+    }
+  }
+}
+f.Socket = v;
+export {
+  f as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/socket.io-client/build/cjs/url.mjs

@@ -0,0 +1,21 @@
+import { commonjsGlobal as r } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as s } from "../../../../../../../../../_virtual/url.mjs";
+import "../../../engine.io-client/build/cjs/index.mjs";
+import { b as n } from "../../../debug/src/browser.mjs";
+import { __exports as a } from "../../../../../../../../../_virtual/index70.mjs";
+var i = r && r.__importDefault || function(t) {
+  return t && t.__esModule ? t : { default: t };
+};
+Object.defineProperty(s, "__esModule", { value: !0 });
+s.url = void 0;
+const c = a, _ = i(n), f = _.default("socket.io-client:url");
+function h(t, l = "", e) {
+  let o = t;
+  e = e || typeof location < "u" && location, t == null && (t = e.protocol + "//" + e.host), typeof t == "string" && (t.charAt(0) === "/" && (t.charAt(1) === "/" ? t = e.protocol + t : t = e.host + t), /^(https?|wss?):\/\//.test(t) || (f("protocol-less url %s", t), typeof e < "u" ? t = e.protocol + "//" + t : t = "https://" + t), f("parse %s", t), o = c.parse(t)), o.port || (/^(http|ws)$/.test(o.protocol) ? o.port = "80" : /^(http|ws)s$/.test(o.protocol) && (o.port = "443")), o.path = o.path || "/";
+  const p = o.host.indexOf(":") !== -1 ? "[" + o.host + "]" : o.host;
+  return o.id = o.protocol + "://" + p + ":" + o.port + l, o.href = o.protocol + "://" + p + (e && e.port === o.port ? "" : ":" + o.port), o;
+}
+s.url = h;
+export {
+  s as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/socket.io-parser/build/cjs/binary.mjs

@@ -0,0 +1,52 @@
+import { __exports as o } from "../../../../../../../../../_virtual/binary.mjs";
+import "./is-binary.mjs";
+import { __exports as i } from "../../../../../../../../../_virtual/is-binary.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.reconstructPacket = o.deconstructPacket = void 0;
+const l = i;
+function u(e) {
+  const t = [], r = e.data, n = e;
+  return n.data = c(r, t), n.attachments = t.length, { packet: n, buffers: t };
+}
+o.deconstructPacket = u;
+function c(e, t) {
+  if (!e)
+    return e;
+  if ((0, l.isBinary)(e)) {
+    const r = { _placeholder: !0, num: t.length };
+    return t.push(e), r;
+  } else if (Array.isArray(e)) {
+    const r = new Array(e.length);
+    for (let n = 0; n < e.length; n++)
+      r[n] = c(e[n], t);
+    return r;
+  } else if (typeof e == "object" && !(e instanceof Date)) {
+    const r = {};
+    for (const n in e)
+      Object.prototype.hasOwnProperty.call(e, n) && (r[n] = c(e[n], t));
+    return r;
+  }
+  return e;
+}
+function f(e, t) {
+  return e.data = s(e.data, t), delete e.attachments, e;
+}
+o.reconstructPacket = f;
+function s(e, t) {
+  if (!e)
+    return e;
+  if (e && e._placeholder === !0) {
+    if (typeof e.num == "number" && e.num >= 0 && e.num < t.length)
+      return t[e.num];
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(e))
+    for (let r = 0; r < e.length; r++)
+      e[r] = s(e[r], t);
+  else if (typeof e == "object")
+    for (const r in e)
+      Object.prototype.hasOwnProperty.call(e, r) && (e[r] = s(e[r], t));
+  return e;
+}
+export {
+  o as default
+};