@hinkal/common 0.0.116 → 0.0.117

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

@@ -0,0 +1,207 @@
+import { __exports as _ } from "../../../../../../../../../_virtual/index61.mjs";
+import y from "../../../../../../../../../_virtual/index71.mjs";
+import "./binary.mjs";
+import "./is-binary.mjs";
+import { b as R } from "../../../debug/src/browser.mjs";
+import { __exports as m } from "../../../../../../../../../_virtual/binary.mjs";
+import { __exports as C } from "../../../../../../../../../_virtual/is-binary.mjs";
+(function(i) {
+  Object.defineProperty(i, "__esModule", { value: !0 }), i.Decoder = i.Encoder = i.PacketType = i.protocol = void 0;
+  const N = y, f = m, h = C, u = (0, R.default)("socket.io-parser"), l = [
+    "connect",
+    "connect_error",
+    "disconnect",
+    "disconnecting",
+    "newListener",
+    "removeListener"
+    // used by the Node.js EventEmitter
+  ];
+  i.protocol = 5;
+  var r;
+  (function(n) {
+    n[n.CONNECT = 0] = "CONNECT", n[n.DISCONNECT = 1] = "DISCONNECT", n[n.EVENT = 2] = "EVENT", n[n.ACK = 3] = "ACK", n[n.CONNECT_ERROR = 4] = "CONNECT_ERROR", n[n.BINARY_EVENT = 5] = "BINARY_EVENT", n[n.BINARY_ACK = 6] = "BINARY_ACK";
+  })(r = i.PacketType || (i.PacketType = {}));
+  class A {
+    /**
+     * Encoder constructor
+     *
+     * @param {function} replacer - custom replacer to pass down to JSON.parse
+     */
+    constructor(t) {
+      this.replacer = t;
+    }
+    /**
+     * Encode a packet as a single string if non-binary, or as a
+     * buffer sequence, depending on packet type.
+     *
+     * @param {Object} obj - packet object
+     */
+    encode(t) {
+      return u("encoding packet %j", t), (t.type === r.EVENT || t.type === r.ACK) && (0, h.hasBinary)(t) ? this.encodeAsBinary({
+        type: t.type === r.EVENT ? r.BINARY_EVENT : r.BINARY_ACK,
+        nsp: t.nsp,
+        data: t.data,
+        id: t.id
+      }) : [this.encodeAsString(t)];
+    }
+    /**
+     * Encode packet as string.
+     */
+    encodeAsString(t) {
+      let e = "" + t.type;
+      return (t.type === r.BINARY_EVENT || t.type === r.BINARY_ACK) && (e += t.attachments + "-"), t.nsp && t.nsp !== "/" && (e += t.nsp + ","), t.id != null && (e += t.id), t.data != null && (e += JSON.stringify(t.data, this.replacer)), u("encoded %j as %s", t, e), e;
+    }
+    /**
+     * Encode packet as 'buffer sequence' by removing blobs, and
+     * deconstructing packet into object with placeholders and
+     * a list of buffers.
+     */
+    encodeAsBinary(t) {
+      const e = (0, f.deconstructPacket)(t), s = this.encodeAsString(e.packet), a = e.buffers;
+      return a.unshift(s), a;
+    }
+  }
+  i.Encoder = A;
+  function E(n) {
+    return Object.prototype.toString.call(n) === "[object Object]";
+  }
+  class d extends N.Emitter {
+    /**
+     * Decoder constructor
+     *
+     * @param {function} reviver - custom reviver to pass down to JSON.stringify
+     */
+    constructor(t) {
+      super(), this.reviver = t;
+    }
+    /**
+     * Decodes an encoded packet string into packet JSON.
+     *
+     * @param {String} obj - encoded packet
+     */
+    add(t) {
+      let e;
+      if (typeof t == "string") {
+        if (this.reconstructor)
+          throw new Error("got plaintext data when reconstructing a packet");
+        e = this.decodeString(t);
+        const s = e.type === r.BINARY_EVENT;
+        s || e.type === r.BINARY_ACK ? (e.type = s ? r.EVENT : r.ACK, this.reconstructor = new p(e), e.attachments === 0 && super.emitReserved("decoded", e)) : super.emitReserved("decoded", e);
+      } else if ((0, h.isBinary)(t) || t.base64)
+        if (this.reconstructor)
+          e = this.reconstructor.takeBinaryData(t), e && (this.reconstructor = null, super.emitReserved("decoded", e));
+        else
+          throw new Error("got binary data when not reconstructing a packet");
+      else
+        throw new Error("Unknown type: " + t);
+    }
+    /**
+     * Decode a packet String (JSON data)
+     *
+     * @param {String} str
+     * @return {Object} packet
+     */
+    decodeString(t) {
+      let e = 0;
+      const s = {
+        type: Number(t.charAt(0))
+      };
+      if (r[s.type] === void 0)
+        throw new Error("unknown packet type " + s.type);
+      if (s.type === r.BINARY_EVENT || s.type === r.BINARY_ACK) {
+        const c = e + 1;
+        for (; t.charAt(++e) !== "-" && e != t.length; )
+          ;
+        const o = t.substring(c, e);
+        if (o != Number(o) || t.charAt(e) !== "-")
+          throw new Error("Illegal attachments");
+        s.attachments = Number(o);
+      }
+      if (t.charAt(e + 1) === "/") {
+        const c = e + 1;
+        for (; ++e && !(t.charAt(e) === "," || e === t.length); )
+          ;
+        s.nsp = t.substring(c, e);
+      } else
+        s.nsp = "/";
+      const a = t.charAt(e + 1);
+      if (a !== "" && Number(a) == a) {
+        const c = e + 1;
+        for (; ++e; ) {
+          const o = t.charAt(e);
+          if (o == null || Number(o) != o) {
+            --e;
+            break;
+          }
+          if (e === t.length)
+            break;
+        }
+        s.id = Number(t.substring(c, e + 1));
+      }
+      if (t.charAt(++e)) {
+        const c = this.tryParse(t.substr(e));
+        if (d.isPayloadValid(s.type, c))
+          s.data = c;
+        else
+          throw new Error("invalid payload");
+      }
+      return u("decoded %s as %j", t, s), s;
+    }
+    tryParse(t) {
+      try {
+        return JSON.parse(t, this.reviver);
+      } catch {
+        return !1;
+      }
+    }
+    static isPayloadValid(t, e) {
+      switch (t) {
+        case r.CONNECT:
+          return E(e);
+        case r.DISCONNECT:
+          return e === void 0;
+        case r.CONNECT_ERROR:
+          return typeof e == "string" || E(e);
+        case r.EVENT:
+        case r.BINARY_EVENT:
+          return Array.isArray(e) && (typeof e[0] == "number" || typeof e[0] == "string" && l.indexOf(e[0]) === -1);
+        case r.ACK:
+        case r.BINARY_ACK:
+          return Array.isArray(e);
+      }
+    }
+    /**
+     * Deallocates a parser's resources
+     */
+    destroy() {
+      this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+    }
+  }
+  i.Decoder = d;
+  class p {
+    constructor(t) {
+      this.packet = t, this.buffers = [], this.reconPack = t;
+    }
+    /**
+     * Method to be called when binary data received from connection
+     * after a BINARY_EVENT packet.
+     *
+     * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+     * @return {null | Object} returns null if more binary data is expected or
+     *   a reconstructed packet object if all buffers have been received.
+     */
+    takeBinaryData(t) {
+      if (this.buffers.push(t), this.buffers.length === this.reconPack.attachments) {
+        const e = (0, f.reconstructPacket)(this.reconPack, this.buffers);
+        return this.finishedReconstruction(), e;
+      }
+      return null;
+    }
+    /**
+     * Cleans up binary packet reconstruction variables.
+     */
+    finishedReconstruction() {
+      this.reconPack = null, this.buffers = [];
+    }
+  }
+})(_);

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

@@ -0,0 +1,30 @@
+import { __exports as r } from "../../../../../../../../../_virtual/is-binary.mjs";
+Object.defineProperty(r, "__esModule", { value: !0 });
+r.hasBinary = r.isBinary = void 0;
+const a = typeof ArrayBuffer == "function", u = (t) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(t) : t.buffer instanceof ArrayBuffer, i = Object.prototype.toString, s = typeof Blob == "function" || typeof Blob < "u" && i.call(Blob) === "[object BlobConstructor]", c = typeof File == "function" || typeof File < "u" && i.call(File) === "[object FileConstructor]";
+function f(t) {
+  return a && (t instanceof ArrayBuffer || u(t)) || s && t instanceof Blob || c && t instanceof File;
+}
+r.isBinary = f;
+function n(t, l) {
+  if (!t || typeof t != "object")
+    return !1;
+  if (Array.isArray(t)) {
+    for (let e = 0, o = t.length; e < o; e++)
+      if (n(t[e]))
+        return !0;
+    return !1;
+  }
+  if (f(t))
+    return !0;
+  if (t.toJSON && typeof t.toJSON == "function" && arguments.length === 1)
+    return n(t.toJSON(), !0);
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e) && n(t[e]))
+      return !0;
+  return !1;
+}
+r.hasBinary = n;
+export {
+  r as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/standard-error/index.mjs

@@ -0,0 +1,14 @@
+var o = Object.hasOwnProperty, i = Object.getPrototypeOf, c = Error.captureStackTrace, n = e;
+function e(t, r) {
+  if (t && typeof t == "object" ? (r = t, t = void 0) : this.message = t, r)
+    for (var a in r)
+      this[a] = r[a];
+  o.call(this, "name") || (this.name = o.call(i(this), "name") ? this.name : this.constructor.name), c && !("stack" in this) && c(this, this.constructor);
+}
+e.prototype = Object.create(Error.prototype, {
+  constructor: { value: e, configurable: !0, writable: !0 }
+});
+e.prototype.name = "StandardError";
+export {
+  n as s
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/standard-http-error/codes.json.mjs

@@ -0,0 +1,66 @@
+const e = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Unordered Collection",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+export {
+  e as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/standard-http-error/index.mjs

@@ -0,0 +1,53 @@
+import { __module as a } from "../../../../../../../_virtual/index59.mjs";
+import { s as b } from "../standard-error/index.mjs";
+import E from "./codes.json.mjs";
+(function(f, o) {
+  o = f.exports = e;
+  var i = b, n = E, c = o;
+  function e(t, r, p) {
+    if (typeof t == "string" && (t = c[t]), typeof t != "number")
+      throw new TypeError("Non-numeric HTTP code");
+    typeof r == "object" && r != null && (p = r, r = null), i.call(this, r || n[t], p), this.code = t;
+  }
+  e.prototype = Object.create(i.prototype, {
+    constructor: { value: e, configurable: !0, writable: !0 }
+  }), e.prototype.name = "HttpError", Object.defineProperties(e.prototype, {
+    statusCode: s("code"),
+    statusMessage: s("message"),
+    status: {
+      configurable: !0,
+      get: function() {
+        return this.code;
+      },
+      set: function(t) {
+        Object.defineProperty(this, "status", {
+          value: t,
+          configurable: !0,
+          enumerable: !0,
+          writable: !0
+        });
+      }
+    }
+  }), e.prototype.toString = function() {
+    return this.name + ": " + this.code + " " + this.message;
+  };
+  for (var u in n) {
+    var l = n[u];
+    o[l.replace("'", "").replace(/[- ]/g, "_").toUpperCase()] = +u;
+  }
+  function s(t) {
+    return {
+      configurable: !0,
+      get: function() {
+        return this[t];
+      },
+      set: function(r) {
+        return this[t] = r;
+      }
+    };
+  }
+})(a, a.exports);
+var m = a.exports;
+export {
+  m as s
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/string-similarity-js/dist/string-similarity.mjs

@@ -0,0 +1,18 @@
+import { __exports as S } from "../../../../../../../../_virtual/string-similarity.mjs";
+(function(o) {
+  Object.defineProperty(o, "__esModule", { value: !0 }), o.stringSimilarity = void 0;
+  var w = function(i, l, a, e) {
+    if (a === void 0 && (a = 2), e === void 0 && (e = !1), e || (i = i.toLowerCase(), l = l.toLowerCase()), i.length < a || l.length < a)
+      return 0;
+    for (var f = /* @__PURE__ */ new Map(), v = 0; v < i.length - (a - 1); v++) {
+      var m = i.substr(v, a);
+      f.set(m, f.has(m) ? f.get(m) + 1 : 1);
+    }
+    for (var y = 0, r = 0; r < l.length - (a - 1); r++) {
+      var d = l.substr(r, a), _ = f.has(d) ? f.get(d) : 0;
+      _ > 0 && (f.set(d, _ - 1), y++);
+    }
+    return y * 2 / (i.length + l.length - (a - 1) * 2);
+  };
+  o.stringSimilarity = w, o.default = o.stringSimilarity;
+})(S);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/string_decoder/lib/string_decoder.mjs

@@ -0,0 +1,172 @@
+import { __exports as h } from "../../../../../../../../_virtual/string_decoder.mjs";
+import { __require as y } from "../../safe-buffer/index.mjs";
+var c;
+function k() {
+  if (c)
+    return h;
+  c = 1;
+  var n = y().Buffer, o = n.isEncoding || function(t) {
+    switch (t = "" + t, t && t.toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+      case "raw":
+        return !0;
+      default:
+        return !1;
+    }
+  };
+  function d(t) {
+    if (!t)
+      return "utf8";
+    for (var e; ; )
+      switch (t) {
+        case "utf8":
+        case "utf-8":
+          return "utf8";
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return "utf16le";
+        case "latin1":
+        case "binary":
+          return "latin1";
+        case "base64":
+        case "ascii":
+        case "hex":
+          return t;
+        default:
+          if (e)
+            return;
+          t = ("" + t).toLowerCase(), e = !0;
+      }
+  }
+  function u(t) {
+    var e = d(t);
+    if (typeof e != "string" && (n.isEncoding === o || !o(t)))
+      throw new Error("Unknown encoding: " + t);
+    return e || t;
+  }
+  h.StringDecoder = a;
+  function a(t) {
+    this.encoding = u(t);
+    var e;
+    switch (this.encoding) {
+      case "utf16le":
+        this.text = p, this.end = v, e = 4;
+        break;
+      case "utf8":
+        this.fillLast = N, e = 4;
+        break;
+      case "base64":
+        this.text = w, this.end = S, e = 3;
+        break;
+      default:
+        this.write = T, this.end = E;
+        return;
+    }
+    this.lastNeed = 0, this.lastTotal = 0, this.lastChar = n.allocUnsafe(e);
+  }
+  a.prototype.write = function(t) {
+    if (t.length === 0)
+      return "";
+    var e, r;
+    if (this.lastNeed) {
+      if (e = this.fillLast(t), e === void 0)
+        return "";
+      r = this.lastNeed, this.lastNeed = 0;
+    } else
+      r = 0;
+    return r < t.length ? e ? e + this.text(t, r) : this.text(t, r) : e || "";
+  }, a.prototype.end = C, a.prototype.text = x, a.prototype.fillLast = function(t) {
+    if (this.lastNeed <= t.length)
+      return t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), this.lastNeed -= t.length;
+  };
+  function l(t) {
+    return t <= 127 ? 0 : t >> 5 === 6 ? 2 : t >> 4 === 14 ? 3 : t >> 3 === 30 ? 4 : t >> 6 === 2 ? -1 : -2;
+  }
+  function f(t, e, r) {
+    var i = e.length - 1;
+    if (i < r)
+      return 0;
+    var s = l(e[i]);
+    return s >= 0 ? (s > 0 && (t.lastNeed = s - 1), s) : --i < r || s === -2 ? 0 : (s = l(e[i]), s >= 0 ? (s > 0 && (t.lastNeed = s - 2), s) : --i < r || s === -2 ? 0 : (s = l(e[i]), s >= 0 ? (s > 0 && (s === 2 ? s = 0 : t.lastNeed = s - 3), s) : 0));
+  }
+  function g(t, e, r) {
+    if ((e[0] & 192) !== 128)
+      return t.lastNeed = 0, "�";
+    if (t.lastNeed > 1 && e.length > 1) {
+      if ((e[1] & 192) !== 128)
+        return t.lastNeed = 1, "�";
+      if (t.lastNeed > 2 && e.length > 2 && (e[2] & 192) !== 128)
+        return t.lastNeed = 2, "�";
+    }
+  }
+  function N(t) {
+    var e = this.lastTotal - this.lastNeed, r = g(this, t);
+    if (r !== void 0)
+      return r;
+    if (this.lastNeed <= t.length)
+      return t.copy(this.lastChar, e, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    t.copy(this.lastChar, e, 0, t.length), this.lastNeed -= t.length;
+  }
+  function x(t, e) {
+    var r = f(this, t, e);
+    if (!this.lastNeed)
+      return t.toString("utf8", e);
+    this.lastTotal = r;
+    var i = t.length - (r - this.lastNeed);
+    return t.copy(this.lastChar, 0, i), t.toString("utf8", e, i);
+  }
+  function C(t) {
+    var e = t && t.length ? this.write(t) : "";
+    return this.lastNeed ? e + "�" : e;
+  }
+  function p(t, e) {
+    if ((t.length - e) % 2 === 0) {
+      var r = t.toString("utf16le", e);
+      if (r) {
+        var i = r.charCodeAt(r.length - 1);
+        if (i >= 55296 && i <= 56319)
+          return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1], r.slice(0, -1);
+      }
+      return r;
+    }
+    return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = t[t.length - 1], t.toString("utf16le", e, t.length - 1);
+  }
+  function v(t) {
+    var e = t && t.length ? this.write(t) : "";
+    if (this.lastNeed) {
+      var r = this.lastTotal - this.lastNeed;
+      return e + this.lastChar.toString("utf16le", 0, r);
+    }
+    return e;
+  }
+  function w(t, e) {
+    var r = (t.length - e) % 3;
+    return r === 0 ? t.toString("base64", e) : (this.lastNeed = 3 - r, this.lastTotal = 3, r === 1 ? this.lastChar[0] = t[t.length - 1] : (this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1]), t.toString("base64", e, t.length - r));
+  }
+  function S(t) {
+    var e = t && t.length ? this.write(t) : "";
+    return this.lastNeed ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : e;
+  }
+  function T(t) {
+    return t.toString(this.encoding);
+  }
+  function E(t) {
+    return t && t.length ? this.write(t) : "";
+  }
+  return h;
+}
+export {
+  k as __require
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/tryer/src/tryer.mjs

@@ -0,0 +1,81 @@
+import { commonjsGlobal as A } from "../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __module as l } from "../../../../../../../../_virtual/tryer.mjs";
+l.exports;
+(function(a) {
+  (function(y) {
+    a !== null ? a.exports = m : y.tryer = m;
+    function m(n) {
+      n = b(n), r();
+      function r() {
+        f() && v();
+      }
+      function f() {
+        return s("when", r);
+      }
+      function s(t, j) {
+        return n[t]() ? !0 : (I(n), R(n) ? n.fail() : _(j, N(n)), !1);
+      }
+      function v() {
+        var t;
+        if (F(n))
+          return t = n.action(), t && u(t.then) ? t.then(e, e) : e();
+        n.action(e);
+      }
+      function e() {
+        s("until", v) && n.pass();
+      }
+    }
+    function b(n) {
+      return n = n || {}, {
+        count: 0,
+        when: o(n.when),
+        until: o(n.until),
+        action: i(n.action),
+        fail: i(n.fail),
+        pass: i(n.pass),
+        interval: h(n.interval, -1e3),
+        limit: h(n.limit, -1)
+      };
+    }
+    function o(n) {
+      return c(n, u, d);
+    }
+    function u(n) {
+      return typeof n == "function";
+    }
+    function d() {
+      return !0;
+    }
+    function i(n) {
+      return c(n, u, w);
+    }
+    function w() {
+    }
+    function c(n, r, f) {
+      return r(n) ? n : f;
+    }
+    function h(n, r) {
+      return c(n, x, r);
+    }
+    function x(n) {
+      return typeof n == "number" && n === n;
+    }
+    function F(n) {
+      return n.action.length === 0;
+    }
+    function I(n) {
+      n.count += 1;
+    }
+    function R(n) {
+      return n.limit >= 0 && n.count >= n.limit;
+    }
+    function N(n) {
+      var r = n.interval;
+      return n.interval < 0 && (n.interval *= 2), r;
+    }
+    function _(n, r) {
+      setTimeout(n, Math.abs(r));
+    }
+  })(A);
+})(l);
+l.exports;