@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/package.json.mjs

@@ -0,0 +1,73 @@
+const t = "elliptic", i = "6.5.5", n = "EC cryptography", s = "lib/elliptic.js", e = [
+  "lib"
+], r = {
+  lint: "eslint lib test",
+  "lint:fix": "npm run lint -- --fix",
+  unit: "istanbul test _mocha --reporter=spec test/index.js",
+  test: "npm run lint && npm run unit",
+  version: "grunt dist && git add dist/"
+}, c = {
+  type: "git",
+  url: "git@github.com:indutny/elliptic"
+}, o = [
+  "EC",
+  "Elliptic",
+  "curve",
+  "Cryptography"
+], l = "Fedor Indutny <fedor@indutny.com>", u = "MIT", p = {
+  url: "https://github.com/indutny/elliptic/issues"
+}, a = "https://github.com/indutny/elliptic", d = {
+  brfs: "^2.0.2",
+  coveralls: "^3.1.0",
+  eslint: "^7.6.0",
+  grunt: "^1.2.1",
+  "grunt-browserify": "^5.3.0",
+  "grunt-cli": "^1.3.2",
+  "grunt-contrib-connect": "^3.0.0",
+  "grunt-contrib-copy": "^1.0.0",
+  "grunt-contrib-uglify": "^5.0.0",
+  "grunt-mocha-istanbul": "^5.0.2",
+  "grunt-saucelabs": "^9.0.1",
+  istanbul: "^0.4.5",
+  mocha: "^8.0.1"
+}, g = {
+  "bn.js": "^4.11.9",
+  brorand: "^1.1.0",
+  "hash.js": "^1.0.0",
+  "hmac-drbg": "^1.0.1",
+  inherits: "^2.0.4",
+  "minimalistic-assert": "^1.0.1",
+  "minimalistic-crypto-utils": "^1.0.1"
+}, m = {
+  name: t,
+  version: i,
+  description: n,
+  main: s,
+  files: e,
+  scripts: r,
+  repository: c,
+  keywords: o,
+  author: l,
+  license: u,
+  bugs: p,
+  homepage: a,
+  devDependencies: d,
+  dependencies: g
+};
+export {
+  l as author,
+  p as bugs,
+  m as default,
+  g as dependencies,
+  n as description,
+  d as devDependencies,
+  e as files,
+  a as homepage,
+  o as keywords,
+  u as license,
+  s as main,
+  t as name,
+  c as repository,
+  r as scripts,
+  i as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/engine.io-client/build/cjs/contrib/has-cors.mjs

@@ -0,0 +1,12 @@
+import { __exports as e } from "../../../../../../../../../../_virtual/has-cors.mjs";
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.hasCORS = void 0;
+let t = !1;
+try {
+  t = typeof XMLHttpRequest < "u" && "withCredentials" in new XMLHttpRequest();
+} catch {
+}
+e.hasCORS = t;
+export {
+  e as default
+};

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

@@ -0,0 +1,22 @@
+import { __exports as n } from "../../../../../../../../../../_virtual/parseqs.mjs";
+Object.defineProperty(n, "__esModule", { value: !0 });
+n.decode = n.encode = void 0;
+function l(t) {
+  let e = "";
+  for (let o in t)
+    t.hasOwnProperty(o) && (e.length && (e += "&"), e += encodeURIComponent(o) + "=" + encodeURIComponent(t[o]));
+  return e;
+}
+n.encode = l;
+function p(t) {
+  let e = {}, o = t.split("&");
+  for (let r = 0, i = o.length; r < i; r++) {
+    let d = o[r].split("=");
+    e[decodeURIComponent(d[0])] = decodeURIComponent(d[1]);
+  }
+  return e;
+}
+n.decode = p;
+export {
+  n as default
+};

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

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

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

@@ -0,0 +1,30 @@
+import { __exports as d } from "../../../../../../../../../../_virtual/yeast.mjs";
+Object.defineProperty(d, "__esModule", { value: !0 });
+d.yeast = d.decode = d.encode = void 0;
+const l = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split(""), r = 64, s = {};
+let c = 0, t = 0, a;
+function n(e) {
+  let o = "";
+  do
+    o = l[e % r] + o, e = Math.floor(e / r);
+  while (e > 0);
+  return o;
+}
+d.encode = n;
+function f(e) {
+  let o = 0;
+  for (t = 0; t < e.length; t++)
+    o = o * r + s[e.charAt(t)];
+  return o;
+}
+d.decode = f;
+function i() {
+  const e = n(+/* @__PURE__ */ new Date());
+  return e !== a ? (c = 0, a = e) : e + "." + n(c++);
+}
+d.yeast = i;
+for (; t < r; t++)
+  s[l[t]] = t;
+export {
+  d as default
+};

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

@@ -0,0 +1,7 @@
+import { __exports as e } from "../../../../../../../../../_virtual/globalThis.browser.mjs";
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.globalThisShim = void 0;
+e.globalThisShim = typeof self < "u" ? self : typeof window < "u" ? window : Function("return this")();
+export {
+  e as default
+};

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

@@ -0,0 +1,42 @@
+import { __exports as u } from "../../../../../../../../../_virtual/index70.mjs";
+import "./socket.mjs";
+import "./transport.mjs";
+import "./transports/index.mjs";
+import "./util.mjs";
+import "./contrib/parseuri.mjs";
+import "./transports/websocket-constructor.browser.mjs";
+import { __exports as a } from "../../../../../../../../../_virtual/socket2.mjs";
+import { __exports as c } from "../../../../../../../../../_virtual/transport.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/index76.mjs";
+import { __exports as m } from "../../../../../../../../../_virtual/util2.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/parseuri.mjs";
+import { __exports as f } from "../../../../../../../../../_virtual/websocket-constructor.browser.mjs";
+(function(r) {
+  Object.defineProperty(r, "__esModule", { value: !0 }), r.nextTick = r.parse = r.installTimerFunctions = r.transports = r.TransportError = r.Transport = r.protocol = r.Socket = void 0;
+  const t = a;
+  Object.defineProperty(r, "Socket", { enumerable: !0, get: function() {
+    return t.Socket;
+  } }), r.protocol = t.Socket.protocol;
+  var e = c;
+  Object.defineProperty(r, "Transport", { enumerable: !0, get: function() {
+    return e.Transport;
+  } }), Object.defineProperty(r, "TransportError", { enumerable: !0, get: function() {
+    return e.TransportError;
+  } });
+  var o = p;
+  Object.defineProperty(r, "transports", { enumerable: !0, get: function() {
+    return o.transports;
+  } });
+  var n = m;
+  Object.defineProperty(r, "installTimerFunctions", { enumerable: !0, get: function() {
+    return n.installTimerFunctions;
+  } });
+  var i = _;
+  Object.defineProperty(r, "parse", { enumerable: !0, get: function() {
+    return i.parse;
+  } });
+  var s = f;
+  Object.defineProperty(r, "nextTick", { enumerable: !0, get: function() {
+    return s.nextTick;
+  } });
+})(u);

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

@@ -0,0 +1,338 @@
+import { commonjsGlobal as m } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as c } from "../../../../../../../../../_virtual/socket2.mjs";
+import "./transports/index.mjs";
+import "./util.mjs";
+import "./contrib/parseqs.mjs";
+import "./contrib/parseuri.mjs";
+import { b as k } from "../../../debug/src/browser.mjs";
+import w from "../../../../../../../../../_virtual/index71.mjs";
+import "../../../engine.io-parser/build/cjs/index.mjs";
+import "./transports/websocket-constructor.browser.mjs";
+import { __exports as T } from "../../../../../../../../../_virtual/index76.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/util2.mjs";
+import { __exports as S } from "../../../../../../../../../_virtual/parseqs.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/parseuri.mjs";
+import { __exports as L } from "../../../../../../../../../_virtual/index79.mjs";
+import { __exports as B } from "../../../../../../../../../_virtual/websocket-constructor.browser.mjs";
+var x = m && m.__importDefault || function(p) {
+  return p && p.__esModule ? p : { default: p };
+};
+Object.defineProperty(c, "__esModule", { value: !0 });
+c.Socket = void 0;
+const P = T, y = _, R = S, b = E, j = x(k), O = w, v = L, C = B, r = (0, j.default)("engine.io-client:socket");
+class n extends O.Emitter {
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(e, t = {}) {
+    super(), this.binaryType = C.defaultBinaryType, this.writeBuffer = [], e && typeof e == "object" && (t = e, e = null), e ? (e = (0, b.parse)(e), t.hostname = e.host, t.secure = e.protocol === "https" || e.protocol === "wss", t.port = e.port, e.query && (t.query = e.query)) : t.host && (t.hostname = (0, b.parse)(t.host).host), (0, y.installTimerFunctions)(this, t), this.secure = t.secure != null ? t.secure : typeof location < "u" && location.protocol === "https:", t.hostname && !t.port && (t.port = this.secure ? "443" : "80"), this.hostname = t.hostname || (typeof location < "u" ? location.hostname : "localhost"), this.port = t.port || (typeof location < "u" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = t.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
+    }, t), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = (0, R.decode)(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(e) {
+    r('creating transport "%s"', e);
+    const t = Object.assign({}, this.opts.query);
+    t.EIO = v.protocol, t.transport = e, this.id && (t.sid = this.id);
+    const s = Object.assign({}, this.opts, {
+      query: t,
+      socket: this,
+      hostname: this.hostname,
+      secure: this.secure,
+      port: this.port
+    }, this.opts.transportOptions[e]);
+    return r("options: %j", s), new P.transports[e](s);
+  }
+  /**
+   * Initializes transport to use and starts probe.
+   *
+   * @private
+   */
+  open() {
+    let e;
+    if (this.opts.rememberUpgrade && n.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1)
+      e = "websocket";
+    else if (this.transports.length === 0) {
+      this.setTimeoutFn(() => {
+        this.emitReserved("error", "No transports available");
+      }, 0);
+      return;
+    } else
+      e = this.transports[0];
+    this.readyState = "opening";
+    try {
+      e = this.createTransport(e);
+    } catch (t) {
+      r("error while creating transport: %s", t), this.transports.shift(), this.open();
+      return;
+    }
+    e.open(), this.setTransport(e);
+  }
+  /**
+   * Sets the current transport. Disables the existing one (if any).
+   *
+   * @private
+   */
+  setTransport(e) {
+    r("setting transport %s", e.name), this.transport && (r("clearing existing transport %s", this.transport.name), this.transport.removeAllListeners()), this.transport = e, e.on("drain", this.onDrain.bind(this)).on("packet", this.onPacket.bind(this)).on("error", this.onError.bind(this)).on("close", (t) => this.onClose("transport close", t));
+  }
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  probe(e) {
+    r('probing transport "%s"', e);
+    let t = this.createTransport(e), s = !1;
+    n.priorWebsocketSuccess = !1;
+    const i = () => {
+      s || (r('probe transport "%s" opened', e), t.send([{ type: "ping", data: "probe" }]), t.once("packet", (o) => {
+        if (!s)
+          if (o.type === "pong" && o.data === "probe") {
+            if (r('probe transport "%s" pong', e), this.upgrading = !0, this.emitReserved("upgrading", t), !t)
+              return;
+            n.priorWebsocketSuccess = t.name === "websocket", r('pausing current transport "%s"', this.transport.name), this.transport.pause(() => {
+              s || this.readyState !== "closed" && (r("changing transport and sending upgrade packet"), g(), this.setTransport(t), t.send([{ type: "upgrade" }]), this.emitReserved("upgrade", t), t = null, this.upgrading = !1, this.flush());
+            });
+          } else {
+            r('probe transport "%s" failed', e);
+            const h = new Error("probe error");
+            h.transport = t.name, this.emitReserved("upgradeError", h);
+          }
+      }));
+    };
+    function a() {
+      s || (s = !0, g(), t.close(), t = null);
+    }
+    const l = (o) => {
+      const h = new Error("probe error: " + o);
+      h.transport = t.name, a(), r('probe transport "%s" failed because of error: %s', e, o), this.emitReserved("upgradeError", h);
+    };
+    function f() {
+      l("transport closed");
+    }
+    function d() {
+      l("socket closed");
+    }
+    function u(o) {
+      t && o.name !== t.name && (r('"%s" works - aborting "%s"', o.name, t.name), a());
+    }
+    const g = () => {
+      t.removeListener("open", i), t.removeListener("error", l), t.removeListener("close", f), this.off("close", d), this.off("upgrading", u);
+    };
+    t.once("open", i), t.once("error", l), t.once("close", f), this.once("close", d), this.once("upgrading", u), this.upgrades.indexOf("webtransport") !== -1 && e !== "webtransport" ? this.setTimeoutFn(() => {
+      s || t.open();
+    }, 200) : t.open();
+  }
+  /**
+   * Called when connection is deemed open.
+   *
+   * @private
+   */
+  onOpen() {
+    if (r("socket open"), this.readyState = "open", n.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush(), this.readyState === "open" && this.opts.upgrade) {
+      r("starting upgrade probes");
+      let e = 0;
+      const t = this.upgrades.length;
+      for (; e < t; e++)
+        this.probe(this.upgrades[e]);
+    }
+  }
+  /**
+   * Handles a packet.
+   *
+   * @private
+   */
+  onPacket(e) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing")
+      switch (r('socket receive: type "%s", data "%s"', e.type, e.data), this.emitReserved("packet", e), this.emitReserved("heartbeat"), this.resetPingTimeout(), e.type) {
+        case "open":
+          this.onHandshake(JSON.parse(e.data));
+          break;
+        case "ping":
+          this.sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong");
+          break;
+        case "error":
+          const t = new Error("server error");
+          t.code = e.data, this.onError(t);
+          break;
+        case "message":
+          this.emitReserved("data", e.data), this.emitReserved("message", e.data);
+          break;
+      }
+    else
+      r('packet received with socket readyState "%s"', this.readyState);
+  }
+  /**
+   * Called upon handshake completion.
+   *
+   * @param {Object} data - handshake obj
+   * @private
+   */
+  onHandshake(e) {
+    this.emitReserved("handshake", e), this.id = e.sid, this.transport.query.sid = e.sid, this.upgrades = this.filterUpgrades(e.upgrades), this.pingInterval = e.pingInterval, this.pingTimeout = e.pingTimeout, this.maxPayload = e.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 e = this.getWritablePackets();
+      r("flushing %d packets in socket", e.length), this.transport.send(e), this.prevBufferLen = e.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 t = 1;
+    for (let s = 0; s < this.writeBuffer.length; s++) {
+      const i = this.writeBuffer[s].data;
+      if (i && (t += (0, y.byteLength)(i)), s > 0 && t > this.maxPayload)
+        return r("only send %d out of %d packets", s, this.writeBuffer.length), this.writeBuffer.slice(0, s);
+      t += 2;
+    }
+    return r("payload size is %d (max: %d)", t, this.maxPayload), this.writeBuffer;
+  }
+  /**
+   * Sends a message.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} callback function.
+   * @return {Socket} for chaining.
+   */
+  write(e, t, s) {
+    return this.sendPacket("message", e, t, s), this;
+  }
+  send(e, t, s) {
+    return this.sendPacket("message", e, t, s), this;
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type: packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  sendPacket(e, t, s, i) {
+    if (typeof t == "function" && (i = t, t = void 0), typeof s == "function" && (i = s, s = null), this.readyState === "closing" || this.readyState === "closed")
+      return;
+    s = s || {}, s.compress = s.compress !== !1;
+    const a = {
+      type: e,
+      data: t,
+      options: s
+    };
+    this.emitReserved("packetCreate", a), this.writeBuffer.push(a), i && this.once("flush", i), this.flush();
+  }
+  /**
+   * Closes the connection.
+   */
+  close() {
+    const e = () => {
+      this.onClose("forced close"), r("socket closing - telling transport to close"), this.transport.close();
+    }, t = () => {
+      this.off("upgrade", t), this.off("upgradeError", t), e();
+    }, s = () => {
+      this.once("upgrade", t), this.once("upgradeError", t);
+    };
+    return (this.readyState === "opening" || this.readyState === "open") && (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? s() : e();
+    }) : this.upgrading ? s() : e()), this;
+  }
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  onError(e) {
+    r("socket error %j", e), n.priorWebsocketSuccess = !1, this.emitReserved("error", e), this.onClose("transport error", e);
+  }
+  /**
+   * Called upon transport close.
+   *
+   * @private
+   */
+  onClose(e, t) {
+    (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") && (r('socket close with reason: "%s"', e), 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", e, t), this.writeBuffer = [], this.prevBufferLen = 0);
+  }
+  /**
+   * Filters upgrades, returning only those matching client transports.
+   *
+   * @param {Array} upgrades - server upgrades
+   * @private
+   */
+  filterUpgrades(e) {
+    const t = [];
+    let s = 0;
+    const i = e.length;
+    for (; s < i; s++)
+      ~this.transports.indexOf(e[s]) && t.push(e[s]);
+    return t;
+  }
+}
+c.Socket = n;
+n.protocol = v.protocol;
+export {
+  c as default
+};