@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/reader.mjs

@@ -0,0 +1,185 @@
+import { __require as d } from "./util/minimal.mjs";
+var v = s, e = d(), a, c = e.LongBits, y = e.utf8;
+function o(i, t) {
+  return RangeError("index out of range: " + i.pos + " + " + (t || 1) + " > " + i.len);
+}
+function s(i) {
+  this.buf = i, this.pos = 0, this.len = i.length;
+}
+var p = typeof Uint8Array < "u" ? function(t) {
+  if (t instanceof Uint8Array || Array.isArray(t))
+    return new s(t);
+  throw Error("illegal buffer");
+} : function(t) {
+  if (Array.isArray(t))
+    return new s(t);
+  throw Error("illegal buffer");
+}, b = function() {
+  return e.Buffer ? function(r) {
+    return (s.create = function(n) {
+      return e.Buffer.isBuffer(n) ? new a(n) : p(n);
+    })(r);
+  } : p;
+};
+s.create = b();
+s.prototype._slice = e.Array.prototype.subarray || /* istanbul ignore next */
+e.Array.prototype.slice;
+s.prototype.uint32 = /* @__PURE__ */ function() {
+  var t = 4294967295;
+  return function() {
+    if (t = (this.buf[this.pos] & 127) >>> 0, this.buf[this.pos++] < 128 || (t = (t | (this.buf[this.pos] & 127) << 7) >>> 0, this.buf[this.pos++] < 128) || (t = (t | (this.buf[this.pos] & 127) << 14) >>> 0, this.buf[this.pos++] < 128) || (t = (t | (this.buf[this.pos] & 127) << 21) >>> 0, this.buf[this.pos++] < 128) || (t = (t | (this.buf[this.pos] & 15) << 28) >>> 0, this.buf[this.pos++] < 128))
+      return t;
+    if ((this.pos += 5) > this.len)
+      throw this.pos = this.len, o(this, 10);
+    return t;
+  };
+}();
+s.prototype.int32 = function() {
+  return this.uint32() | 0;
+};
+s.prototype.sint32 = function() {
+  var t = this.uint32();
+  return t >>> 1 ^ -(t & 1) | 0;
+};
+function f() {
+  var i = new c(0, 0), t = 0;
+  if (this.len - this.pos > 4) {
+    for (; t < 4; ++t)
+      if (i.lo = (i.lo | (this.buf[this.pos] & 127) << t * 7) >>> 0, this.buf[this.pos++] < 128)
+        return i;
+    if (i.lo = (i.lo | (this.buf[this.pos] & 127) << 28) >>> 0, i.hi = (i.hi | (this.buf[this.pos] & 127) >> 4) >>> 0, this.buf[this.pos++] < 128)
+      return i;
+    t = 0;
+  } else {
+    for (; t < 3; ++t) {
+      if (this.pos >= this.len)
+        throw o(this);
+      if (i.lo = (i.lo | (this.buf[this.pos] & 127) << t * 7) >>> 0, this.buf[this.pos++] < 128)
+        return i;
+    }
+    return i.lo = (i.lo | (this.buf[this.pos++] & 127) << t * 7) >>> 0, i;
+  }
+  if (this.len - this.pos > 4) {
+    for (; t < 5; ++t)
+      if (i.hi = (i.hi | (this.buf[this.pos] & 127) << t * 7 + 3) >>> 0, this.buf[this.pos++] < 128)
+        return i;
+  } else
+    for (; t < 5; ++t) {
+      if (this.pos >= this.len)
+        throw o(this);
+      if (i.hi = (i.hi | (this.buf[this.pos] & 127) << t * 7 + 3) >>> 0, this.buf[this.pos++] < 128)
+        return i;
+    }
+  throw Error("invalid varint encoding");
+}
+s.prototype.bool = function() {
+  return this.uint32() !== 0;
+};
+function u(i, t) {
+  return (i[t - 4] | i[t - 3] << 8 | i[t - 2] << 16 | i[t - 1] << 24) >>> 0;
+}
+s.prototype.fixed32 = function() {
+  if (this.pos + 4 > this.len)
+    throw o(this, 4);
+  return u(this.buf, this.pos += 4);
+};
+s.prototype.sfixed32 = function() {
+  if (this.pos + 4 > this.len)
+    throw o(this, 4);
+  return u(this.buf, this.pos += 4) | 0;
+};
+function l() {
+  if (this.pos + 8 > this.len)
+    throw o(this, 8);
+  return new c(u(this.buf, this.pos += 4), u(this.buf, this.pos += 4));
+}
+s.prototype.float = function() {
+  if (this.pos + 4 > this.len)
+    throw o(this, 4);
+  var t = e.float.readFloatLE(this.buf, this.pos);
+  return this.pos += 4, t;
+};
+s.prototype.double = function() {
+  if (this.pos + 8 > this.len)
+    throw o(this, 4);
+  var t = e.float.readDoubleLE(this.buf, this.pos);
+  return this.pos += 8, t;
+};
+s.prototype.bytes = function() {
+  var t = this.uint32(), r = this.pos, h = this.pos + t;
+  if (h > this.len)
+    throw o(this, t);
+  if (this.pos += t, Array.isArray(this.buf))
+    return this.buf.slice(r, h);
+  if (r === h) {
+    var n = e.Buffer;
+    return n ? n.alloc(0) : new this.buf.constructor(0);
+  }
+  return this._slice.call(this.buf, r, h);
+};
+s.prototype.string = function() {
+  var t = this.bytes();
+  return y.read(t, 0, t.length);
+};
+s.prototype.skip = function(t) {
+  if (typeof t == "number") {
+    if (this.pos + t > this.len)
+      throw o(this, t);
+    this.pos += t;
+  } else
+    do
+      if (this.pos >= this.len)
+        throw o(this);
+    while (this.buf[this.pos++] & 128);
+  return this;
+};
+s.prototype.skipType = function(i) {
+  switch (i) {
+    case 0:
+      this.skip();
+      break;
+    case 1:
+      this.skip(8);
+      break;
+    case 2:
+      this.skip(this.uint32());
+      break;
+    case 3:
+      for (; (i = this.uint32() & 7) !== 4; )
+        this.skipType(i);
+      break;
+    case 5:
+      this.skip(4);
+      break;
+    default:
+      throw Error("invalid wire type " + i + " at offset " + this.pos);
+  }
+  return this;
+};
+s._configure = function(i) {
+  a = i, s.create = b(), a._configure();
+  var t = e.Long ? "toLong" : (
+    /* istanbul ignore next */
+    "toNumber"
+  );
+  e.merge(s.prototype, {
+    int64: function() {
+      return f.call(this)[t](!1);
+    },
+    uint64: function() {
+      return f.call(this)[t](!0);
+    },
+    sint64: function() {
+      return f.call(this).zzDecode()[t](!1);
+    },
+    fixed64: function() {
+      return l.call(this)[t](!0);
+    },
+    sfixed64: function() {
+      return l.call(this)[t](!1);
+    }
+  });
+};
+export {
+  v as r
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/reader_buffer.mjs

@@ -0,0 +1,19 @@
+import { r as s } from "./reader.mjs";
+import { __require as f } from "./util/minimal.mjs";
+var p = t, o = s;
+(t.prototype = Object.create(o.prototype)).constructor = t;
+var i = f();
+function t(r) {
+  o.call(this, r);
+}
+t._configure = function() {
+  i.Buffer && (t.prototype._slice = i.Buffer.prototype.slice);
+};
+t.prototype.string = function() {
+  var e = this.uint32();
+  return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + e, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + e, this.len));
+};
+t._configure();
+export {
+  p as r
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/roots.mjs

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/rpc/service.mjs

@@ -0,0 +1,56 @@
+import { __require as s } from "../util/minimal.mjs";
+var h = u, d = s();
+(u.prototype = Object.create(d.EventEmitter.prototype)).constructor = u;
+function u(n, e, o) {
+  if (typeof n != "function")
+    throw TypeError("rpcImpl must be a function");
+  d.EventEmitter.call(this), this.rpcImpl = n, this.requestDelimited = !!e, this.responseDelimited = !!o;
+}
+u.prototype.rpcCall = function n(e, o, f, l, i) {
+  if (!l)
+    throw TypeError("request must be specified");
+  var t = this;
+  if (!i)
+    return d.asPromise(n, t, e, o, f, l);
+  if (!t.rpcImpl) {
+    setTimeout(function() {
+      i(Error("already ended"));
+    }, 0);
+    return;
+  }
+  try {
+    return t.rpcImpl(
+      e,
+      o[t.requestDelimited ? "encodeDelimited" : "encode"](l).finish(),
+      function(p, r) {
+        if (p)
+          return t.emit("error", p, e), i(p);
+        if (r === null) {
+          t.end(
+            /* endedByRPC */
+            !0
+          );
+          return;
+        }
+        if (!(r instanceof f))
+          try {
+            r = f[t.responseDelimited ? "decodeDelimited" : "decode"](r);
+          } catch (m) {
+            return t.emit("error", m, e), i(m);
+          }
+        return t.emit("data", r, e), i(null, r);
+      }
+    );
+  } catch (c) {
+    t.emit("error", c, e), setTimeout(function() {
+      i(c);
+    }, 0);
+    return;
+  }
+};
+u.prototype.end = function(e) {
+  return this.rpcImpl && (e || this.rpcImpl(null, null, null), this.rpcImpl = null, this.emit("end").off()), this;
+};
+export {
+  h as s
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/rpc.mjs

@@ -0,0 +1,6 @@
+import { __exports as c } from "../../../../../../../../../../../_virtual/rpc2.mjs";
+import { s as e } from "./rpc/service.mjs";
+(function(r) {
+  var o = r;
+  o.Service = e;
+})(c);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/util/longbits.mjs

@@ -0,0 +1,75 @@
+import { __require as m } from "./minimal.mjs";
+var u, l;
+function p() {
+  if (l)
+    return u;
+  l = 1, u = i;
+  var s = m();
+  function i(o, t) {
+    this.lo = o >>> 0, this.hi = t >>> 0;
+  }
+  var h = i.zero = new i(0, 0);
+  h.toNumber = function() {
+    return 0;
+  }, h.zzEncode = h.zzDecode = function() {
+    return this;
+  }, h.length = function() {
+    return 1;
+  };
+  var c = i.zeroHash = "\0\0\0\0\0\0\0\0";
+  i.fromNumber = function(t) {
+    if (t === 0)
+      return h;
+    var n = t < 0;
+    n && (t = -t);
+    var r = t >>> 0, f = (t - r) / 4294967296 >>> 0;
+    return n && (f = ~f >>> 0, r = ~r >>> 0, ++r > 4294967295 && (r = 0, ++f > 4294967295 && (f = 0))), new i(r, f);
+  }, i.from = function(t) {
+    if (typeof t == "number")
+      return i.fromNumber(t);
+    if (s.isString(t))
+      if (s.Long)
+        t = s.Long.fromString(t);
+      else
+        return i.fromNumber(parseInt(t, 10));
+    return t.low || t.high ? new i(t.low >>> 0, t.high >>> 0) : h;
+  }, i.prototype.toNumber = function(t) {
+    if (!t && this.hi >>> 31) {
+      var n = ~this.lo + 1 >>> 0, r = ~this.hi >>> 0;
+      return n || (r = r + 1 >>> 0), -(n + r * 4294967296);
+    }
+    return this.lo + this.hi * 4294967296;
+  }, i.prototype.toLong = function(t) {
+    return s.Long ? new s.Long(this.lo | 0, this.hi | 0, !!t) : { low: this.lo | 0, high: this.hi | 0, unsigned: !!t };
+  };
+  var e = String.prototype.charCodeAt;
+  return i.fromHash = function(t) {
+    return t === c ? h : new i(
+      (e.call(t, 0) | e.call(t, 1) << 8 | e.call(t, 2) << 16 | e.call(t, 3) << 24) >>> 0,
+      (e.call(t, 4) | e.call(t, 5) << 8 | e.call(t, 6) << 16 | e.call(t, 7) << 24) >>> 0
+    );
+  }, i.prototype.toHash = function() {
+    return String.fromCharCode(
+      this.lo & 255,
+      this.lo >>> 8 & 255,
+      this.lo >>> 16 & 255,
+      this.lo >>> 24,
+      this.hi & 255,
+      this.hi >>> 8 & 255,
+      this.hi >>> 16 & 255,
+      this.hi >>> 24
+    );
+  }, i.prototype.zzEncode = function() {
+    var t = this.hi >> 31;
+    return this.hi = ((this.hi << 1 | this.lo >>> 31) ^ t) >>> 0, this.lo = (this.lo << 1 ^ t) >>> 0, this;
+  }, i.prototype.zzDecode = function() {
+    var t = -(this.lo & 1);
+    return this.lo = ((this.lo >>> 1 | this.hi << 31) ^ t) >>> 0, this.hi = (this.hi >>> 1 ^ t) >>> 0, this;
+  }, i.prototype.length = function() {
+    var t = this.lo, n = (this.lo >>> 28 | this.hi << 4) >>> 0, r = this.hi >>> 24;
+    return r === 0 ? n === 0 ? t < 16384 ? t < 128 ? 1 : 2 : t < 2097152 ? 3 : 4 : n < 16384 ? n < 128 ? 5 : 6 : n < 2097152 ? 7 : 8 : r < 128 ? 9 : 10;
+  }, u;
+}
+export {
+  p as __require
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/util/minimal.mjs

@@ -0,0 +1,141 @@
+import { commonjsGlobal as i } from "../../../../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as a } from "../../../../../../../../../../../../_virtual/minimal2.mjs";
+import { a as g } from "../../../../../../@protobufjs/aspromise/index.mjs";
+import "../../../../../../@protobufjs/base64/index.mjs";
+import { e as p } from "../../../../../../@protobufjs/eventemitter/index.mjs";
+import { f as b } from "../../../../../../@protobufjs/float/index.mjs";
+import { i as _ } from "../../../../../../@protobufjs/inquire/index.mjs";
+import "../../../../../../@protobufjs/utf8/index.mjs";
+import { p as h } from "../../../../../../@protobufjs/pool/index.mjs";
+import { __require as y } from "./longbits.mjs";
+import { __exports as d } from "../../../../../../../../../../../../_virtual/index73.mjs";
+import { __exports as B } from "../../../../../../../../../../../../_virtual/index74.mjs";
+var c;
+function P() {
+  return c ? a : (c = 1, function(m) {
+    var e = m;
+    e.asPromise = g, e.base64 = d, e.EventEmitter = p, e.float = b, e.inquire = _, e.utf8 = B, e.pool = h, e.LongBits = y(), e.isNode = !!(typeof i < "u" && i && i.process && i.process.versions && i.process.versions.node), e.global = e.isNode && i || typeof window < "u" && window || typeof self < "u" && self || i, e.emptyArray = Object.freeze ? Object.freeze([]) : (
+      /* istanbul ignore next */
+      []
+    ), e.emptyObject = Object.freeze ? Object.freeze({}) : (
+      /* istanbul ignore next */
+      {}
+    ), e.isInteger = Number.isInteger || /* istanbul ignore next */
+    function(r) {
+      return typeof r == "number" && isFinite(r) && Math.floor(r) === r;
+    }, e.isString = function(r) {
+      return typeof r == "string" || r instanceof String;
+    }, e.isObject = function(r) {
+      return r && typeof r == "object";
+    }, e.isset = /**
+     * Checks if a property on a message is considered to be present.
+     * @param {Object} obj Plain object or message instance
+     * @param {string} prop Property name
+     * @returns {boolean} `true` if considered to be present, otherwise `false`
+     */
+    e.isSet = function(r, o) {
+      var t = r[o];
+      return t != null && r.hasOwnProperty(o) ? typeof t != "object" || (Array.isArray(t) ? t.length : Object.keys(t).length) > 0 : !1;
+    }, e.Buffer = function() {
+      try {
+        var n = e.inquire("buffer").Buffer;
+        return n.prototype.utf8Write ? n : (
+          /* istanbul ignore next */
+          null
+        );
+      } catch {
+        return null;
+      }
+    }(), e._Buffer_from = null, e._Buffer_allocUnsafe = null, e.newBuffer = function(r) {
+      return typeof r == "number" ? e.Buffer ? e._Buffer_allocUnsafe(r) : new e.Array(r) : e.Buffer ? e._Buffer_from(r) : typeof Uint8Array > "u" ? r : new Uint8Array(r);
+    }, e.Array = typeof Uint8Array < "u" ? Uint8Array : Array, e.Long = /* istanbul ignore next */
+    e.global.dcodeIO && /* istanbul ignore next */
+    e.global.dcodeIO.Long || /* istanbul ignore next */
+    e.global.Long || e.inquire("long"), e.key2Re = /^true|false|0|1$/, e.key32Re = /^-?(?:0|[1-9][0-9]*)$/, e.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/, e.longToHash = function(r) {
+      return r ? e.LongBits.from(r).toHash() : e.LongBits.zeroHash;
+    }, e.longFromHash = function(r, o) {
+      var t = e.LongBits.fromHash(r);
+      return e.Long ? e.Long.fromBits(t.lo, t.hi, o) : t.toNumber(!!o);
+    };
+    function s(n, r, o) {
+      for (var t = Object.keys(r), f = 0; f < t.length; ++f)
+        (n[t[f]] === void 0 || !o) && (n[t[f]] = r[t[f]]);
+      return n;
+    }
+    e.merge = s, e.lcFirst = function(r) {
+      return r.charAt(0).toLowerCase() + r.substring(1);
+    };
+    function l(n) {
+      function r(o, t) {
+        if (!(this instanceof r))
+          return new r(o, t);
+        Object.defineProperty(this, "message", { get: function() {
+          return o;
+        } }), Error.captureStackTrace ? Error.captureStackTrace(this, r) : Object.defineProperty(this, "stack", { value: new Error().stack || "" }), t && s(this, t);
+      }
+      return r.prototype = Object.create(Error.prototype, {
+        constructor: {
+          value: r,
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        },
+        name: {
+          get: function() {
+            return n;
+          },
+          set: void 0,
+          enumerable: !1,
+          // configurable: false would accurately preserve the behavior of
+          // the original, but I'm guessing that was not intentional.
+          // For an actual error subclass, this property would
+          // be configurable.
+          configurable: !0
+        },
+        toString: {
+          value: function() {
+            return this.name + ": " + this.message;
+          },
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }
+      }), r;
+    }
+    e.newError = l, e.ProtocolError = l("ProtocolError"), e.oneOfGetter = function(r) {
+      for (var o = {}, t = 0; t < r.length; ++t)
+        o[r[t]] = 1;
+      return function() {
+        for (var f = Object.keys(this), u = f.length - 1; u > -1; --u)
+          if (o[f[u]] === 1 && this[f[u]] !== void 0 && this[f[u]] !== null)
+            return f[u];
+      };
+    }, e.oneOfSetter = function(r) {
+      return function(o) {
+        for (var t = 0; t < r.length; ++t)
+          r[t] !== o && delete this[r[t]];
+      };
+    }, e.toJSONOptions = {
+      longs: String,
+      enums: String,
+      bytes: String,
+      json: !0
+    }, e._configure = function() {
+      var n = e.Buffer;
+      if (!n) {
+        e._Buffer_from = e._Buffer_allocUnsafe = null;
+        return;
+      }
+      e._Buffer_from = n.from !== Uint8Array.from && n.from || /* istanbul ignore next */
+      function(o, t) {
+        return new n(o, t);
+      }, e._Buffer_allocUnsafe = n.allocUnsafe || /* istanbul ignore next */
+      function(o) {
+        return new n(o);
+      };
+    };
+  }(a), a);
+}
+export {
+  P as __require
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/writer.mjs

@@ -0,0 +1,133 @@
+import { __require as x } from "./util/minimal.mjs";
+var A = n, o = x(), f, u = o.LongBits, _ = o.base64, w = o.utf8;
+function s(i, t, e) {
+  this.fn = i, this.len = t, this.next = void 0, this.val = e;
+}
+function a() {
+}
+function g(i) {
+  this.head = i.head, this.tail = i.tail, this.len = i.len, this.next = i.states;
+}
+function n() {
+  this.len = 0, this.head = new s(a, 0, 0), this.tail = this.head, this.states = null;
+}
+var d = function() {
+  return o.Buffer ? function() {
+    return (n.create = function() {
+      return new f();
+    })();
+  } : function() {
+    return new n();
+  };
+};
+n.create = d();
+n.alloc = function(t) {
+  return new o.Array(t);
+};
+o.Array !== Array && (n.alloc = o.pool(n.alloc, o.Array.prototype.subarray));
+n.prototype._push = function(t, e, r) {
+  return this.tail = this.tail.next = new s(t, e, r), this.len += e, this;
+};
+function c(i, t, e) {
+  t[e] = i & 255;
+}
+function b(i, t, e) {
+  for (; i > 127; )
+    t[e++] = i & 127 | 128, i >>>= 7;
+  t[e] = i;
+}
+function l(i, t) {
+  this.len = i, this.next = void 0, this.val = t;
+}
+l.prototype = Object.create(s.prototype);
+l.prototype.fn = b;
+n.prototype.uint32 = function(t) {
+  return this.len += (this.tail = this.tail.next = new l(
+    (t = t >>> 0) < 128 ? 1 : t < 16384 ? 2 : t < 2097152 ? 3 : t < 268435456 ? 4 : 5,
+    t
+  )).len, this;
+};
+n.prototype.int32 = function(t) {
+  return t < 0 ? this._push(y, 10, u.fromNumber(t)) : this.uint32(t);
+};
+n.prototype.sint32 = function(t) {
+  return this.uint32((t << 1 ^ t >> 31) >>> 0);
+};
+function y(i, t, e) {
+  for (; i.hi; )
+    t[e++] = i.lo & 127 | 128, i.lo = (i.lo >>> 7 | i.hi << 25) >>> 0, i.hi >>>= 7;
+  for (; i.lo > 127; )
+    t[e++] = i.lo & 127 | 128, i.lo = i.lo >>> 7;
+  t[e++] = i.lo;
+}
+n.prototype.uint64 = function(t) {
+  var e = u.from(t);
+  return this._push(y, e.length(), e);
+};
+n.prototype.int64 = n.prototype.uint64;
+n.prototype.sint64 = function(t) {
+  var e = u.from(t).zzEncode();
+  return this._push(y, e.length(), e);
+};
+n.prototype.bool = function(t) {
+  return this._push(c, 1, t ? 1 : 0);
+};
+function p(i, t, e) {
+  t[e] = i & 255, t[e + 1] = i >>> 8 & 255, t[e + 2] = i >>> 16 & 255, t[e + 3] = i >>> 24;
+}
+n.prototype.fixed32 = function(t) {
+  return this._push(p, 4, t >>> 0);
+};
+n.prototype.sfixed32 = n.prototype.fixed32;
+n.prototype.fixed64 = function(t) {
+  var e = u.from(t);
+  return this._push(p, 4, e.lo)._push(p, 4, e.hi);
+};
+n.prototype.sfixed64 = n.prototype.fixed64;
+n.prototype.float = function(t) {
+  return this._push(o.float.writeFloatLE, 4, t);
+};
+n.prototype.double = function(t) {
+  return this._push(o.float.writeDoubleLE, 8, t);
+};
+var m = o.Array.prototype.set ? function(t, e, r) {
+  e.set(t, r);
+} : function(t, e, r) {
+  for (var h = 0; h < t.length; ++h)
+    e[r + h] = t[h];
+};
+n.prototype.bytes = function(t) {
+  var e = t.length >>> 0;
+  if (!e)
+    return this._push(c, 1, 0);
+  if (o.isString(t)) {
+    var r = n.alloc(e = _.length(t));
+    _.decode(t, r, 0), t = r;
+  }
+  return this.uint32(e)._push(m, e, t);
+};
+n.prototype.string = function(t) {
+  var e = w.length(t);
+  return e ? this.uint32(e)._push(w.write, e, t) : this._push(c, 1, 0);
+};
+n.prototype.fork = function() {
+  return this.states = new g(this), this.head = this.tail = new s(a, 0, 0), this.len = 0, this;
+};
+n.prototype.reset = function() {
+  return this.states ? (this.head = this.states.head, this.tail = this.states.tail, this.len = this.states.len, this.states = this.states.next) : (this.head = this.tail = new s(a, 0, 0), this.len = 0), this;
+};
+n.prototype.ldelim = function() {
+  var t = this.head, e = this.tail, r = this.len;
+  return this.reset().uint32(r), r && (this.tail.next = t.next, this.tail = e, this.len += r), this;
+};
+n.prototype.finish = function() {
+  for (var t = this.head.next, e = this.constructor.alloc(this.len), r = 0; t; )
+    t.fn(t.val, e, r), r += t.len, t = t.next;
+  return e;
+};
+n._configure = function(i) {
+  f = i, n.create = d(), f._configure();
+};
+export {
+  A as w
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@axelar-network/axelarjs-types/node_modules/protobufjs/src/writer_buffer.mjs

@@ -0,0 +1,35 @@
+import { w as u } from "./writer.mjs";
+import { __require as c } from "./util/minimal.mjs";
+var B = e, s = u;
+(e.prototype = Object.create(s.prototype)).constructor = e;
+var f = c();
+function e() {
+  s.call(this);
+}
+e._configure = function() {
+  e.alloc = f._Buffer_allocUnsafe, e.writeBytesBuffer = f.Buffer && f.Buffer.prototype instanceof Uint8Array && f.Buffer.prototype.set.name === "set" ? function(t, r, n) {
+    r.set(t, n);
+  } : function(t, r, n) {
+    if (t.copy)
+      t.copy(r, n, 0, t.length);
+    else
+      for (var o = 0; o < t.length; )
+        r[n++] = t[o++];
+  };
+};
+e.prototype.bytes = function(t) {
+  f.isString(t) && (t = f._Buffer_from(t, "base64"));
+  var r = t.length >>> 0;
+  return this.uint32(r), r && this._push(e.writeBytesBuffer, r, t), this;
+};
+function p(i, t, r) {
+  i.length < 40 ? f.utf8.write(i, t, r) : t.utf8Write ? t.utf8Write(i, r) : t.write(i, r);
+}
+e.prototype.string = function(t) {
+  var r = f.Buffer.byteLength(t);
+  return this.uint32(r), r && this._push(p, r, t), this;
+};
+e._configure();
+export {
+  B as w
+};