mezon-js 2.13.66 → 2.13.68

package/dist/mezon-js.esm.mjs

@@ -1,5 +1,9 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -14,6 +18,25 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __commonJS = (cb, mod2) => function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -35,6 +58,2228 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// ../../node_modules/long/src/long.js
+var require_long = __commonJS({
+  "../../node_modules/long/src/long.js"(exports2, module2) {
+    module2.exports = Long4;
+    var wasm = null;
+    try {
+      wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        13,
+        2,
+        96,
+        0,
+        1,
+        127,
+        96,
+        4,
+        127,
+        127,
+        127,
+        127,
+        1,
+        127,
+        3,
+        7,
+        6,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        6,
+        6,
+        1,
+        127,
+        1,
+        65,
+        0,
+        11,
+        7,
+        50,
+        6,
+        3,
+        109,
+        117,
+        108,
+        0,
+        1,
+        5,
+        100,
+        105,
+        118,
+        95,
+        115,
+        0,
+        2,
+        5,
+        100,
+        105,
+        118,
+        95,
+        117,
+        0,
+        3,
+        5,
+        114,
+        101,
+        109,
+        95,
+        115,
+        0,
+        4,
+        5,
+        114,
+        101,
+        109,
+        95,
+        117,
+        0,
+        5,
+        8,
+        103,
+        101,
+        116,
+        95,
+        104,
+        105,
+        103,
+        104,
+        0,
+        0,
+        10,
+        191,
+        1,
+        6,
+        4,
+        0,
+        35,
+        0,
+        11,
+        36,
+        1,
+        1,
+        126,
+        32,
+        0,
+        173,
+        32,
+        1,
+        173,
+        66,
+        32,
+        134,
+        132,
+        32,
+        2,
+        173,
+        32,
+        3,
+        173,
+        66,
+        32,
+        134,
+        132,
+        126,
+        34,
+        4,
+        66,
+        32,
+        135,
+        167,
+        36,
+        0,
+        32,
+        4,
+        167,
+        11,
+        36,
+        1,
+        1,
+        126,
+        32,
+        0,
+        173,
+        32,
+        1,
+        173,
+        66,
+        32,
+        134,
+        132,
+        32,
+        2,
+        173,
+        32,
+        3,
+        173,
+        66,
+        32,
+        134,
+        132,
+        127,
+        34,
+        4,
+        66,
+        32,
+        135,
+        167,
+        36,
+        0,
+        32,
+        4,
+        167,
+        11,
+        36,
+        1,
+        1,
+        126,
+        32,
+        0,
+        173,
+        32,
+        1,
+        173,
+        66,
+        32,
+        134,
+        132,
+        32,
+        2,
+        173,
+        32,
+        3,
+        173,
+        66,
+        32,
+        134,
+        132,
+        128,
+        34,
+        4,
+        66,
+        32,
+        135,
+        167,
+        36,
+        0,
+        32,
+        4,
+        167,
+        11,
+        36,
+        1,
+        1,
+        126,
+        32,
+        0,
+        173,
+        32,
+        1,
+        173,
+        66,
+        32,
+        134,
+        132,
+        32,
+        2,
+        173,
+        32,
+        3,
+        173,
+        66,
+        32,
+        134,
+        132,
+        129,
+        34,
+        4,
+        66,
+        32,
+        135,
+        167,
+        36,
+        0,
+        32,
+        4,
+        167,
+        11,
+        36,
+        1,
+        1,
+        126,
+        32,
+        0,
+        173,
+        32,
+        1,
+        173,
+        66,
+        32,
+        134,
+        132,
+        32,
+        2,
+        173,
+        32,
+        3,
+        173,
+        66,
+        32,
+        134,
+        132,
+        130,
+        34,
+        4,
+        66,
+        32,
+        135,
+        167,
+        36,
+        0,
+        32,
+        4,
+        167,
+        11
+      ])), {}).exports;
+    } catch (e) {
+    }
+    function Long4(low, high, unsigned) {
+      this.low = low | 0;
+      this.high = high | 0;
+      this.unsigned = !!unsigned;
+    }
+    Long4.prototype.__isLong__;
+    Object.defineProperty(Long4.prototype, "__isLong__", { value: true });
+    function isLong(obj) {
+      return (obj && obj["__isLong__"]) === true;
+    }
+    Long4.isLong = isLong;
+    var INT_CACHE = {};
+    var UINT_CACHE = {};
+    function fromInt(value, unsigned) {
+      var obj, cachedObj, cache;
+      if (unsigned) {
+        value >>>= 0;
+        if (cache = 0 <= value && value < 256) {
+          cachedObj = UINT_CACHE[value];
+          if (cachedObj)
+            return cachedObj;
+        }
+        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);
+        if (cache)
+          UINT_CACHE[value] = obj;
+        return obj;
+      } else {
+        value |= 0;
+        if (cache = -128 <= value && value < 128) {
+          cachedObj = INT_CACHE[value];
+          if (cachedObj)
+            return cachedObj;
+        }
+        obj = fromBits(value, value < 0 ? -1 : 0, false);
+        if (cache)
+          INT_CACHE[value] = obj;
+        return obj;
+      }
+    }
+    Long4.fromInt = fromInt;
+    function fromNumber(value, unsigned) {
+      if (isNaN(value))
+        return unsigned ? UZERO : ZERO;
+      if (unsigned) {
+        if (value < 0)
+          return UZERO;
+        if (value >= TWO_PWR_64_DBL)
+          return MAX_UNSIGNED_VALUE;
+      } else {
+        if (value <= -TWO_PWR_63_DBL)
+          return MIN_VALUE;
+        if (value + 1 >= TWO_PWR_63_DBL)
+          return MAX_VALUE;
+      }
+      if (value < 0)
+        return fromNumber(-value, unsigned).neg();
+      return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+    }
+    Long4.fromNumber = fromNumber;
+    function fromBits(lowBits, highBits, unsigned) {
+      return new Long4(lowBits, highBits, unsigned);
+    }
+    Long4.fromBits = fromBits;
+    var pow_dbl = Math.pow;
+    function fromString(str, unsigned, radix) {
+      if (str.length === 0)
+        throw Error("empty string");
+      if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
+        return ZERO;
+      if (typeof unsigned === "number") {
+        radix = unsigned, unsigned = false;
+      } else {
+        unsigned = !!unsigned;
+      }
+      radix = radix || 10;
+      if (radix < 2 || 36 < radix)
+        throw RangeError("radix");
+      var p;
+      if ((p = str.indexOf("-")) > 0)
+        throw Error("interior hyphen");
+      else if (p === 0) {
+        return fromString(str.substring(1), unsigned, radix).neg();
+      }
+      var radixToPower = fromNumber(pow_dbl(radix, 8));
+      var result = ZERO;
+      for (var i = 0; i < str.length; i += 8) {
+        var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
+        if (size < 8) {
+          var power = fromNumber(pow_dbl(radix, size));
+          result = result.mul(power).add(fromNumber(value));
+        } else {
+          result = result.mul(radixToPower);
+          result = result.add(fromNumber(value));
+        }
+      }
+      result.unsigned = unsigned;
+      return result;
+    }
+    Long4.fromString = fromString;
+    function fromValue(val, unsigned) {
+      if (typeof val === "number")
+        return fromNumber(val, unsigned);
+      if (typeof val === "string")
+        return fromString(val, unsigned);
+      return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
+    }
+    Long4.fromValue = fromValue;
+    var TWO_PWR_16_DBL = 1 << 16;
+    var TWO_PWR_24_DBL = 1 << 24;
+    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
+    var ZERO = fromInt(0);
+    Long4.ZERO = ZERO;
+    var UZERO = fromInt(0, true);
+    Long4.UZERO = UZERO;
+    var ONE = fromInt(1);
+    Long4.ONE = ONE;
+    var UONE = fromInt(1, true);
+    Long4.UONE = UONE;
+    var NEG_ONE = fromInt(-1);
+    Long4.NEG_ONE = NEG_ONE;
+    var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
+    Long4.MAX_VALUE = MAX_VALUE;
+    var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
+    Long4.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
+    var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
+    Long4.MIN_VALUE = MIN_VALUE;
+    var LongPrototype = Long4.prototype;
+    LongPrototype.toInt = function toInt() {
+      return this.unsigned ? this.low >>> 0 : this.low;
+    };
+    LongPrototype.toNumber = function toNumber() {
+      if (this.unsigned)
+        return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+      return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+    };
+    LongPrototype.toString = function toString(radix) {
+      radix = radix || 10;
+      if (radix < 2 || 36 < radix)
+        throw RangeError("radix");
+      if (this.isZero())
+        return "0";
+      if (this.isNegative()) {
+        if (this.eq(MIN_VALUE)) {
+          var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
+          return div.toString(radix) + rem1.toInt().toString(radix);
+        } else
+          return "-" + this.neg().toString(radix);
+      }
+      var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
+      var result = "";
+      while (true) {
+        var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
+        rem = remDiv;
+        if (rem.isZero())
+          return digits + result;
+        else {
+          while (digits.length < 6)
+            digits = "0" + digits;
+          result = "" + digits + result;
+        }
+      }
+    };
+    LongPrototype.getHighBits = function getHighBits() {
+      return this.high;
+    };
+    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
+      return this.high >>> 0;
+    };
+    LongPrototype.getLowBits = function getLowBits() {
+      return this.low;
+    };
+    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
+      return this.low >>> 0;
+    };
+    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
+      if (this.isNegative())
+        return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
+      var val = this.high != 0 ? this.high : this.low;
+      for (var bit = 31; bit > 0; bit--)
+        if ((val & 1 << bit) != 0)
+          break;
+      return this.high != 0 ? bit + 33 : bit + 1;
+    };
+    LongPrototype.isZero = function isZero() {
+      return this.high === 0 && this.low === 0;
+    };
+    LongPrototype.eqz = LongPrototype.isZero;
+    LongPrototype.isNegative = function isNegative() {
+      return !this.unsigned && this.high < 0;
+    };
+    LongPrototype.isPositive = function isPositive() {
+      return this.unsigned || this.high >= 0;
+    };
+    LongPrototype.isOdd = function isOdd() {
+      return (this.low & 1) === 1;
+    };
+    LongPrototype.isEven = function isEven() {
+      return (this.low & 1) === 0;
+    };
+    LongPrototype.equals = function equals(other) {
+      if (!isLong(other))
+        other = fromValue(other);
+      if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
+        return false;
+      return this.high === other.high && this.low === other.low;
+    };
+    LongPrototype.eq = LongPrototype.equals;
+    LongPrototype.notEquals = function notEquals(other) {
+      return !this.eq(
+        /* validates */
+        other
+      );
+    };
+    LongPrototype.neq = LongPrototype.notEquals;
+    LongPrototype.ne = LongPrototype.notEquals;
+    LongPrototype.lessThan = function lessThan(other) {
+      return this.comp(
+        /* validates */
+        other
+      ) < 0;
+    };
+    LongPrototype.lt = LongPrototype.lessThan;
+    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
+      return this.comp(
+        /* validates */
+        other
+      ) <= 0;
+    };
+    LongPrototype.lte = LongPrototype.lessThanOrEqual;
+    LongPrototype.le = LongPrototype.lessThanOrEqual;
+    LongPrototype.greaterThan = function greaterThan(other) {
+      return this.comp(
+        /* validates */
+        other
+      ) > 0;
+    };
+    LongPrototype.gt = LongPrototype.greaterThan;
+    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
+      return this.comp(
+        /* validates */
+        other
+      ) >= 0;
+    };
+    LongPrototype.gte = LongPrototype.greaterThanOrEqual;
+    LongPrototype.ge = LongPrototype.greaterThanOrEqual;
+    LongPrototype.compare = function compare(other) {
+      if (!isLong(other))
+        other = fromValue(other);
+      if (this.eq(other))
+        return 0;
+      var thisNeg = this.isNegative(), otherNeg = other.isNegative();
+      if (thisNeg && !otherNeg)
+        return -1;
+      if (!thisNeg && otherNeg)
+        return 1;
+      if (!this.unsigned)
+        return this.sub(other).isNegative() ? -1 : 1;
+      return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
+    };
+    LongPrototype.comp = LongPrototype.compare;
+    LongPrototype.negate = function negate() {
+      if (!this.unsigned && this.eq(MIN_VALUE))
+        return MIN_VALUE;
+      return this.not().add(ONE);
+    };
+    LongPrototype.neg = LongPrototype.negate;
+    LongPrototype.add = function add(addend) {
+      if (!isLong(addend))
+        addend = fromValue(addend);
+      var a48 = this.high >>> 16;
+      var a32 = this.high & 65535;
+      var a16 = this.low >>> 16;
+      var a00 = this.low & 65535;
+      var b48 = addend.high >>> 16;
+      var b32 = addend.high & 65535;
+      var b16 = addend.low >>> 16;
+      var b00 = addend.low & 65535;
+      var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+      c00 += a00 + b00;
+      c16 += c00 >>> 16;
+      c00 &= 65535;
+      c16 += a16 + b16;
+      c32 += c16 >>> 16;
+      c16 &= 65535;
+      c32 += a32 + b32;
+      c48 += c32 >>> 16;
+      c32 &= 65535;
+      c48 += a48 + b48;
+      c48 &= 65535;
+      return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+    };
+    LongPrototype.subtract = function subtract(subtrahend) {
+      if (!isLong(subtrahend))
+        subtrahend = fromValue(subtrahend);
+      return this.add(subtrahend.neg());
+    };
+    LongPrototype.sub = LongPrototype.subtract;
+    LongPrototype.multiply = function multiply(multiplier) {
+      if (this.isZero())
+        return ZERO;
+      if (!isLong(multiplier))
+        multiplier = fromValue(multiplier);
+      if (wasm) {
+        var low = wasm.mul(
+          this.low,
+          this.high,
+          multiplier.low,
+          multiplier.high
+        );
+        return fromBits(low, wasm.get_high(), this.unsigned);
+      }
+      if (multiplier.isZero())
+        return ZERO;
+      if (this.eq(MIN_VALUE))
+        return multiplier.isOdd() ? MIN_VALUE : ZERO;
+      if (multiplier.eq(MIN_VALUE))
+        return this.isOdd() ? MIN_VALUE : ZERO;
+      if (this.isNegative()) {
+        if (multiplier.isNegative())
+          return this.neg().mul(multiplier.neg());
+        else
+          return this.neg().mul(multiplier).neg();
+      } else if (multiplier.isNegative())
+        return this.mul(multiplier.neg()).neg();
+      if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
+        return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
+      var a48 = this.high >>> 16;
+      var a32 = this.high & 65535;
+      var a16 = this.low >>> 16;
+      var a00 = this.low & 65535;
+      var b48 = multiplier.high >>> 16;
+      var b32 = multiplier.high & 65535;
+      var b16 = multiplier.low >>> 16;
+      var b00 = multiplier.low & 65535;
+      var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+      c00 += a00 * b00;
+      c16 += c00 >>> 16;
+      c00 &= 65535;
+      c16 += a16 * b00;
+      c32 += c16 >>> 16;
+      c16 &= 65535;
+      c16 += a00 * b16;
+      c32 += c16 >>> 16;
+      c16 &= 65535;
+      c32 += a32 * b00;
+      c48 += c32 >>> 16;
+      c32 &= 65535;
+      c32 += a16 * b16;
+      c48 += c32 >>> 16;
+      c32 &= 65535;
+      c32 += a00 * b32;
+      c48 += c32 >>> 16;
+      c32 &= 65535;
+      c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+      c48 &= 65535;
+      return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+    };
+    LongPrototype.mul = LongPrototype.multiply;
+    LongPrototype.divide = function divide(divisor) {
+      if (!isLong(divisor))
+        divisor = fromValue(divisor);
+      if (divisor.isZero())
+        throw Error("division by zero");
+      if (wasm) {
+        if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
+          return this;
+        }
+        var low = (this.unsigned ? wasm.div_u : wasm.div_s)(
+          this.low,
+          this.high,
+          divisor.low,
+          divisor.high
+        );
+        return fromBits(low, wasm.get_high(), this.unsigned);
+      }
+      if (this.isZero())
+        return this.unsigned ? UZERO : ZERO;
+      var approx, rem, res;
+      if (!this.unsigned) {
+        if (this.eq(MIN_VALUE)) {
+          if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
+            return MIN_VALUE;
+          else if (divisor.eq(MIN_VALUE))
+            return ONE;
+          else {
+            var halfThis = this.shr(1);
+            approx = halfThis.div(divisor).shl(1);
+            if (approx.eq(ZERO)) {
+              return divisor.isNegative() ? ONE : NEG_ONE;
+            } else {
+              rem = this.sub(divisor.mul(approx));
+              res = approx.add(rem.div(divisor));
+              return res;
+            }
+          }
+        } else if (divisor.eq(MIN_VALUE))
+          return this.unsigned ? UZERO : ZERO;
+        if (this.isNegative()) {
+          if (divisor.isNegative())
+            return this.neg().div(divisor.neg());
+          return this.neg().div(divisor).neg();
+        } else if (divisor.isNegative())
+          return this.div(divisor.neg()).neg();
+        res = ZERO;
+      } else {
+        if (!divisor.unsigned)
+          divisor = divisor.toUnsigned();
+        if (divisor.gt(this))
+          return UZERO;
+        if (divisor.gt(this.shru(1)))
+          return UONE;
+        res = UZERO;
+      }
+      rem = this;
+      while (rem.gte(divisor)) {
+        approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
+        var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
+        while (approxRem.isNegative() || approxRem.gt(rem)) {
+          approx -= delta;
+          approxRes = fromNumber(approx, this.unsigned);
+          approxRem = approxRes.mul(divisor);
+        }
+        if (approxRes.isZero())
+          approxRes = ONE;
+        res = res.add(approxRes);
+        rem = rem.sub(approxRem);
+      }
+      return res;
+    };
+    LongPrototype.div = LongPrototype.divide;
+    LongPrototype.modulo = function modulo(divisor) {
+      if (!isLong(divisor))
+        divisor = fromValue(divisor);
+      if (wasm) {
+        var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(
+          this.low,
+          this.high,
+          divisor.low,
+          divisor.high
+        );
+        return fromBits(low, wasm.get_high(), this.unsigned);
+      }
+      return this.sub(this.div(divisor).mul(divisor));
+    };
+    LongPrototype.mod = LongPrototype.modulo;
+    LongPrototype.rem = LongPrototype.modulo;
+    LongPrototype.not = function not() {
+      return fromBits(~this.low, ~this.high, this.unsigned);
+    };
+    LongPrototype.and = function and(other) {
+      if (!isLong(other))
+        other = fromValue(other);
+      return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
+    };
+    LongPrototype.or = function or(other) {
+      if (!isLong(other))
+        other = fromValue(other);
+      return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
+    };
+    LongPrototype.xor = function xor(other) {
+      if (!isLong(other))
+        other = fromValue(other);
+      return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
+    };
+    LongPrototype.shiftLeft = function shiftLeft(numBits) {
+      if (isLong(numBits))
+        numBits = numBits.toInt();
+      if ((numBits &= 63) === 0)
+        return this;
+      else if (numBits < 32)
+        return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
+      else
+        return fromBits(0, this.low << numBits - 32, this.unsigned);
+    };
+    LongPrototype.shl = LongPrototype.shiftLeft;
+    LongPrototype.shiftRight = function shiftRight(numBits) {
+      if (isLong(numBits))
+        numBits = numBits.toInt();
+      if ((numBits &= 63) === 0)
+        return this;
+      else if (numBits < 32)
+        return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
+      else
+        return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+    };
+    LongPrototype.shr = LongPrototype.shiftRight;
+    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
+      if (isLong(numBits))
+        numBits = numBits.toInt();
+      numBits &= 63;
+      if (numBits === 0)
+        return this;
+      else {
+        var high = this.high;
+        if (numBits < 32) {
+          var low = this.low;
+          return fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits, this.unsigned);
+        } else if (numBits === 32)
+          return fromBits(high, 0, this.unsigned);
+        else
+          return fromBits(high >>> numBits - 32, 0, this.unsigned);
+      }
+    };
+    LongPrototype.shru = LongPrototype.shiftRightUnsigned;
+    LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
+    LongPrototype.toSigned = function toSigned() {
+      if (!this.unsigned)
+        return this;
+      return fromBits(this.low, this.high, false);
+    };
+    LongPrototype.toUnsigned = function toUnsigned() {
+      if (this.unsigned)
+        return this;
+      return fromBits(this.low, this.high, true);
+    };
+    LongPrototype.toBytes = function toBytes(le) {
+      return le ? this.toBytesLE() : this.toBytesBE();
+    };
+    LongPrototype.toBytesLE = function toBytesLE() {
+      var hi = this.high, lo = this.low;
+      return [
+        lo & 255,
+        lo >>> 8 & 255,
+        lo >>> 16 & 255,
+        lo >>> 24,
+        hi & 255,
+        hi >>> 8 & 255,
+        hi >>> 16 & 255,
+        hi >>> 24
+      ];
+    };
+    LongPrototype.toBytesBE = function toBytesBE() {
+      var hi = this.high, lo = this.low;
+      return [
+        hi >>> 24,
+        hi >>> 16 & 255,
+        hi >>> 8 & 255,
+        hi & 255,
+        lo >>> 24,
+        lo >>> 16 & 255,
+        lo >>> 8 & 255,
+        lo & 255
+      ];
+    };
+    Long4.fromBytes = function fromBytes(bytes, unsigned, le) {
+      return le ? Long4.fromBytesLE(bytes, unsigned) : Long4.fromBytesBE(bytes, unsigned);
+    };
+    Long4.fromBytesLE = function fromBytesLE(bytes, unsigned) {
+      return new Long4(
+        bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
+        bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
+        unsigned
+      );
+    };
+    Long4.fromBytesBE = function fromBytesBE(bytes, unsigned) {
+      return new Long4(
+        bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
+        bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
+        unsigned
+      );
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/aspromise/index.js
+var require_aspromise = __commonJS({
+  "../../node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = asPromise;
+    function asPromise(fn, ctx) {
+      var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
+      while (index < arguments.length)
+        params[offset++] = arguments[index++];
+      return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err) {
+          if (pending) {
+            pending = false;
+            if (err)
+              reject(err);
+            else {
+              var params2 = new Array(arguments.length - 1), offset2 = 0;
+              while (offset2 < params2.length)
+                params2[offset2++] = arguments[offset2];
+              resolve.apply(null, params2);
+            }
+          }
+        };
+        try {
+          fn.apply(ctx || null, params);
+        } catch (err) {
+          if (pending) {
+            pending = false;
+            reject(err);
+          }
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/base64/index.js
+var require_base64 = __commonJS({
+  "../../node_modules/@protobufjs/base64/index.js"(exports2) {
+    "use strict";
+    var base64 = exports2;
+    base64.length = function length(string) {
+      var p = string.length;
+      if (!p)
+        return 0;
+      var n = 0;
+      while (--p % 4 > 1 && string.charAt(p) === "=")
+        ++n;
+      return Math.ceil(string.length * 3) / 4 - n;
+    };
+    var b64 = new Array(64);
+    var s64 = new Array(123);
+    for (i = 0; i < 64; )
+      s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+    var i;
+    base64.encode = function encode3(buffer, start, end) {
+      var parts = null, chunk = [];
+      var i2 = 0, j = 0, t;
+      while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+          case 0:
+            chunk[i2++] = b64[b >> 2];
+            t = (b & 3) << 4;
+            j = 1;
+            break;
+          case 1:
+            chunk[i2++] = b64[t | b >> 4];
+            t = (b & 15) << 2;
+            j = 2;
+            break;
+          case 2:
+            chunk[i2++] = b64[t | b >> 6];
+            chunk[i2++] = b64[b & 63];
+            j = 0;
+            break;
+        }
+        if (i2 > 8191) {
+          (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+          i2 = 0;
+        }
+      }
+      if (j) {
+        chunk[i2++] = b64[t];
+        chunk[i2++] = 61;
+        if (j === 1)
+          chunk[i2++] = 61;
+      }
+      if (parts) {
+        if (i2)
+          parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
+        return parts.join("");
+      }
+      return String.fromCharCode.apply(String, chunk.slice(0, i2));
+    };
+    var invalidEncoding = "invalid encoding";
+    base64.decode = function decode4(string, buffer, offset) {
+      var start = offset;
+      var j = 0, t;
+      for (var i2 = 0; i2 < string.length; ) {
+        var c = string.charCodeAt(i2++);
+        if (c === 61 && j > 1)
+          break;
+        if ((c = s64[c]) === void 0)
+          throw Error(invalidEncoding);
+        switch (j) {
+          case 0:
+            t = c;
+            j = 1;
+            break;
+          case 1:
+            buffer[offset++] = t << 2 | (c & 48) >> 4;
+            t = c;
+            j = 2;
+            break;
+          case 2:
+            buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+            t = c;
+            j = 3;
+            break;
+          case 3:
+            buffer[offset++] = (t & 3) << 6 | c;
+            j = 0;
+            break;
+        }
+      }
+      if (j === 1)
+        throw Error(invalidEncoding);
+      return offset - start;
+    };
+    base64.test = function test(string) {
+      return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/eventemitter/index.js
+var require_eventemitter = __commonJS({
+  "../../node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = EventEmitter;
+    function EventEmitter() {
+      this._listeners = {};
+    }
+    EventEmitter.prototype.on = function on(evt, fn, ctx) {
+      (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn,
+        ctx: ctx || this
+      });
+      return this;
+    };
+    EventEmitter.prototype.off = function off(evt, fn) {
+      if (evt === void 0)
+        this._listeners = {};
+      else {
+        if (fn === void 0)
+          this._listeners[evt] = [];
+        else {
+          var listeners = this._listeners[evt];
+          for (var i = 0; i < listeners.length; )
+            if (listeners[i].fn === fn)
+              listeners.splice(i, 1);
+            else
+              ++i;
+        }
+      }
+      return this;
+    };
+    EventEmitter.prototype.emit = function emit(evt) {
+      var listeners = this._listeners[evt];
+      if (listeners) {
+        var args = [], i = 1;
+        for (; i < arguments.length; )
+          args.push(arguments[i++]);
+        for (i = 0; i < listeners.length; )
+          listeners[i].fn.apply(listeners[i++].ctx, args);
+      }
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/float/index.js
+var require_float = __commonJS({
+  "../../node_modules/@protobufjs/float/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = factory(factory);
+    function factory(exports3) {
+      if (typeof Float32Array !== "undefined") (function() {
+        var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
+        function writeFloat_f32_cpy(val, buf, pos) {
+          f32[0] = val;
+          buf[pos] = f8b[0];
+          buf[pos + 1] = f8b[1];
+          buf[pos + 2] = f8b[2];
+          buf[pos + 3] = f8b[3];
+        }
+        function writeFloat_f32_rev(val, buf, pos) {
+          f32[0] = val;
+          buf[pos] = f8b[3];
+          buf[pos + 1] = f8b[2];
+          buf[pos + 2] = f8b[1];
+          buf[pos + 3] = f8b[0];
+        }
+        exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+        function readFloat_f32_cpy(buf, pos) {
+          f8b[0] = buf[pos];
+          f8b[1] = buf[pos + 1];
+          f8b[2] = buf[pos + 2];
+          f8b[3] = buf[pos + 3];
+          return f32[0];
+        }
+        function readFloat_f32_rev(buf, pos) {
+          f8b[3] = buf[pos];
+          f8b[2] = buf[pos + 1];
+          f8b[1] = buf[pos + 2];
+          f8b[0] = buf[pos + 3];
+          return f32[0];
+        }
+        exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+      })();
+      else (function() {
+        function writeFloat_ieee754(writeUint, val, buf, pos) {
+          var sign = val < 0 ? 1 : 0;
+          if (sign)
+            val = -val;
+          if (val === 0)
+            writeUint(1 / val > 0 ? (
+              /* positive */
+              0
+            ) : (
+              /* negative 0 */
+              2147483648
+            ), buf, pos);
+          else if (isNaN(val))
+            writeUint(2143289344, buf, pos);
+          else if (val > 34028234663852886e22)
+            writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+          else if (val < 11754943508222875e-54)
+            writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
+          else {
+            var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+            writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+          }
+        }
+        exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+        function readFloat_ieee754(readUint, buf, pos) {
+          var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
+          return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+        }
+        exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+      })();
+      if (typeof Float64Array !== "undefined") (function() {
+        var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
+        function writeDouble_f64_cpy(val, buf, pos) {
+          f64[0] = val;
+          buf[pos] = f8b[0];
+          buf[pos + 1] = f8b[1];
+          buf[pos + 2] = f8b[2];
+          buf[pos + 3] = f8b[3];
+          buf[pos + 4] = f8b[4];
+          buf[pos + 5] = f8b[5];
+          buf[pos + 6] = f8b[6];
+          buf[pos + 7] = f8b[7];
+        }
+        function writeDouble_f64_rev(val, buf, pos) {
+          f64[0] = val;
+          buf[pos] = f8b[7];
+          buf[pos + 1] = f8b[6];
+          buf[pos + 2] = f8b[5];
+          buf[pos + 3] = f8b[4];
+          buf[pos + 4] = f8b[3];
+          buf[pos + 5] = f8b[2];
+          buf[pos + 6] = f8b[1];
+          buf[pos + 7] = f8b[0];
+        }
+        exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+        function readDouble_f64_cpy(buf, pos) {
+          f8b[0] = buf[pos];
+          f8b[1] = buf[pos + 1];
+          f8b[2] = buf[pos + 2];
+          f8b[3] = buf[pos + 3];
+          f8b[4] = buf[pos + 4];
+          f8b[5] = buf[pos + 5];
+          f8b[6] = buf[pos + 6];
+          f8b[7] = buf[pos + 7];
+          return f64[0];
+        }
+        function readDouble_f64_rev(buf, pos) {
+          f8b[7] = buf[pos];
+          f8b[6] = buf[pos + 1];
+          f8b[5] = buf[pos + 2];
+          f8b[4] = buf[pos + 3];
+          f8b[3] = buf[pos + 4];
+          f8b[2] = buf[pos + 5];
+          f8b[1] = buf[pos + 6];
+          f8b[0] = buf[pos + 7];
+          return f64[0];
+        }
+        exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+      })();
+      else (function() {
+        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+          var sign = val < 0 ? 1 : 0;
+          if (sign)
+            val = -val;
+          if (val === 0) {
+            writeUint(0, buf, pos + off0);
+            writeUint(1 / val > 0 ? (
+              /* positive */
+              0
+            ) : (
+              /* negative 0 */
+              2147483648
+            ), buf, pos + off1);
+          } else if (isNaN(val)) {
+            writeUint(0, buf, pos + off0);
+            writeUint(2146959360, buf, pos + off1);
+          } else if (val > 17976931348623157e292) {
+            writeUint(0, buf, pos + off0);
+            writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+          } else {
+            var mantissa;
+            if (val < 22250738585072014e-324) {
+              mantissa = val / 5e-324;
+              writeUint(mantissa >>> 0, buf, pos + off0);
+              writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+            } else {
+              var exponent = Math.floor(Math.log(val) / Math.LN2);
+              if (exponent === 1024)
+                exponent = 1023;
+              mantissa = val * Math.pow(2, -exponent);
+              writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+              writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+            }
+          }
+        }
+        exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+          var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
+          var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
+          return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+        }
+        exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+      })();
+      return exports3;
+    }
+    function writeUintLE(val, buf, pos) {
+      buf[pos] = val & 255;
+      buf[pos + 1] = val >>> 8 & 255;
+      buf[pos + 2] = val >>> 16 & 255;
+      buf[pos + 3] = val >>> 24;
+    }
+    function writeUintBE(val, buf, pos) {
+      buf[pos] = val >>> 24;
+      buf[pos + 1] = val >>> 16 & 255;
+      buf[pos + 2] = val >>> 8 & 255;
+      buf[pos + 3] = val & 255;
+    }
+    function readUintLE(buf, pos) {
+      return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
+    }
+    function readUintBE(buf, pos) {
+      return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/inquire/index.js
+var require_inquire = __commonJS({
+  "../../node_modules/@protobufjs/inquire/index.js"(exports, module) {
+    "use strict";
+    module.exports = inquire;
+    function inquire(moduleName) {
+      try {
+        var mod = eval("quire".replace(/^/, "re"))(moduleName);
+        if (mod && (mod.length || Object.keys(mod).length))
+          return mod;
+      } catch (e) {
+      }
+      return null;
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/utf8/index.js
+var require_utf8 = __commonJS({
+  "../../node_modules/@protobufjs/utf8/index.js"(exports2) {
+    "use strict";
+    var utf8 = exports2;
+    utf8.length = function utf8_length(string) {
+      var len = 0, c = 0;
+      for (var i = 0; i < string.length; ++i) {
+        c = string.charCodeAt(i);
+        if (c < 128)
+          len += 1;
+        else if (c < 2048)
+          len += 2;
+        else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
+          ++i;
+          len += 4;
+        } else
+          len += 3;
+      }
+      return len;
+    };
+    utf8.read = function utf8_read(buffer, start, end) {
+      var len = end - start;
+      if (len < 1)
+        return "";
+      var parts = null, chunk = [], i = 0, t;
+      while (start < end) {
+        t = buffer[start++];
+        if (t < 128)
+          chunk[i++] = t;
+        else if (t > 191 && t < 224)
+          chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+        else if (t > 239 && t < 365) {
+          t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
+          chunk[i++] = 55296 + (t >> 10);
+          chunk[i++] = 56320 + (t & 1023);
+        } else
+          chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+        if (i > 8191) {
+          (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+          i = 0;
+        }
+      }
+      if (parts) {
+        if (i)
+          parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+      }
+      return String.fromCharCode.apply(String, chunk.slice(0, i));
+    };
+    utf8.write = function utf8_write(string, buffer, offset) {
+      var start = offset, c1, c2;
+      for (var i = 0; i < string.length; ++i) {
+        c1 = string.charCodeAt(i);
+        if (c1 < 128) {
+          buffer[offset++] = c1;
+        } else if (c1 < 2048) {
+          buffer[offset++] = c1 >> 6 | 192;
+          buffer[offset++] = c1 & 63 | 128;
+        } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
+          c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+          ++i;
+          buffer[offset++] = c1 >> 18 | 240;
+          buffer[offset++] = c1 >> 12 & 63 | 128;
+          buffer[offset++] = c1 >> 6 & 63 | 128;
+          buffer[offset++] = c1 & 63 | 128;
+        } else {
+          buffer[offset++] = c1 >> 12 | 224;
+          buffer[offset++] = c1 >> 6 & 63 | 128;
+          buffer[offset++] = c1 & 63 | 128;
+        }
+      }
+      return offset - start;
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/pool/index.js
+var require_pool = __commonJS({
+  "../../node_modules/@protobufjs/pool/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = pool;
+    function pool(alloc, slice, size) {
+      var SIZE = size || 8192;
+      var MAX = SIZE >>> 1;
+      var slab = null;
+      var offset = SIZE;
+      return function pool_alloc(size2) {
+        if (size2 < 1 || size2 > MAX)
+          return alloc(size2);
+        if (offset + size2 > SIZE) {
+          slab = alloc(SIZE);
+          offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size2);
+        if (offset & 7)
+          offset = (offset | 7) + 1;
+        return buf;
+      };
+    }
+  }
+});
+
+// ../../node_modules/protobufjs/src/util/longbits.js
+var require_longbits = __commonJS({
+  "../../node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
+    "use strict";
+    module2.exports = LongBits;
+    var util = require_minimal();
+    function LongBits(lo, hi) {
+      this.lo = lo >>> 0;
+      this.hi = hi >>> 0;
+    }
+    var zero = LongBits.zero = new LongBits(0, 0);
+    zero.toNumber = function() {
+      return 0;
+    };
+    zero.zzEncode = zero.zzDecode = function() {
+      return this;
+    };
+    zero.length = function() {
+      return 1;
+    };
+    var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
+    LongBits.fromNumber = function fromNumber(value) {
+      if (value === 0)
+        return zero;
+      var sign = value < 0;
+      if (sign)
+        value = -value;
+      var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
+      if (sign) {
+        hi = ~hi >>> 0;
+        lo = ~lo >>> 0;
+        if (++lo > 4294967295) {
+          lo = 0;
+          if (++hi > 4294967295)
+            hi = 0;
+        }
+      }
+      return new LongBits(lo, hi);
+    };
+    LongBits.from = function from(value) {
+      if (typeof value === "number")
+        return LongBits.fromNumber(value);
+      if (util.isString(value)) {
+        if (util.Long)
+          value = util.Long.fromString(value);
+        else
+          return LongBits.fromNumber(parseInt(value, 10));
+      }
+      return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+    };
+    LongBits.prototype.toNumber = function toNumber(unsigned) {
+      if (!unsigned && this.hi >>> 31) {
+        var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
+        if (!lo)
+          hi = hi + 1 >>> 0;
+        return -(lo + hi * 4294967296);
+      }
+      return this.lo + this.hi * 4294967296;
+    };
+    LongBits.prototype.toLong = function toLong(unsigned) {
+      return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
+    };
+    var charCodeAt = String.prototype.charCodeAt;
+    LongBits.fromHash = function fromHash(hash) {
+      if (hash === zeroHash)
+        return zero;
+      return new LongBits(
+        (charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0,
+        (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0
+      );
+    };
+    LongBits.prototype.toHash = function toHash() {
+      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
+      );
+    };
+    LongBits.prototype.zzEncode = function zzEncode() {
+      var mask = this.hi >> 31;
+      this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+      this.lo = (this.lo << 1 ^ mask) >>> 0;
+      return this;
+    };
+    LongBits.prototype.zzDecode = function zzDecode() {
+      var mask = -(this.lo & 1);
+      this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+      this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+      return this;
+    };
+    LongBits.prototype.length = function length() {
+      var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
+      return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+    };
+  }
+});
+
+// ../../node_modules/protobufjs/src/util/minimal.js
+var require_minimal = __commonJS({
+  "../../node_modules/protobufjs/src/util/minimal.js"(exports2) {
+    "use strict";
+    var util = exports2;
+    util.asPromise = require_aspromise();
+    util.base64 = require_base64();
+    util.EventEmitter = require_eventemitter();
+    util.float = require_float();
+    util.inquire = require_inquire();
+    util.utf8 = require_utf8();
+    util.pool = require_pool();
+    util.LongBits = require_longbits();
+    util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
+    util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
+    util.emptyArray = Object.freeze ? Object.freeze([]) : (
+      /* istanbul ignore next */
+      []
+    );
+    util.emptyObject = Object.freeze ? Object.freeze({}) : (
+      /* istanbul ignore next */
+      {}
+    );
+    util.isInteger = Number.isInteger || /* istanbul ignore next */
+    function isInteger(value) {
+      return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+    };
+    util.isString = function isString(value) {
+      return typeof value === "string" || value instanceof String;
+    };
+    util.isObject = function isObject(value) {
+      return value && typeof value === "object";
+    };
+    util.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`
+     */
+    util.isSet = function isSet3(obj, prop) {
+      var value = obj[prop];
+      if (value != null && obj.hasOwnProperty(prop))
+        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+      return false;
+    };
+    util.Buffer = function() {
+      try {
+        var Buffer2 = util.inquire("buffer").Buffer;
+        return Buffer2.prototype.utf8Write ? Buffer2 : (
+          /* istanbul ignore next */
+          null
+        );
+      } catch (e) {
+        return null;
+      }
+    }();
+    util._Buffer_from = null;
+    util._Buffer_allocUnsafe = null;
+    util.newBuffer = function newBuffer(sizeOrArray) {
+      return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
+    };
+    util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    util.Long = /* istanbul ignore next */
+    util.global.dcodeIO && /* istanbul ignore next */
+    util.global.dcodeIO.Long || /* istanbul ignore next */
+    util.global.Long || util.inquire("long");
+    util.key2Re = /^true|false|0|1$/;
+    util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
+    util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
+    util.longToHash = function longToHash(value) {
+      return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
+    };
+    util.longFromHash = function longFromHash(hash, unsigned) {
+      var bits = util.LongBits.fromHash(hash);
+      if (util.Long)
+        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
+      return bits.toNumber(Boolean(unsigned));
+    };
+    function merge(dst, src, ifNotSet) {
+      for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+        if (dst[keys[i]] === void 0 || !ifNotSet)
+          dst[keys[i]] = src[keys[i]];
+      return dst;
+    }
+    util.merge = merge;
+    util.lcFirst = function lcFirst(str) {
+      return str.charAt(0).toLowerCase() + str.substring(1);
+    };
+    function newError(name) {
+      function CustomError(message, properties) {
+        if (!(this instanceof CustomError))
+          return new CustomError(message, properties);
+        Object.defineProperty(this, "message", { get: function() {
+          return message;
+        } });
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, CustomError);
+        else
+          Object.defineProperty(this, "stack", { value: new Error().stack || "" });
+        if (properties)
+          merge(this, properties);
+      }
+      (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
+      Object.defineProperty(CustomError.prototype, "name", { get: function() {
+        return name;
+      } });
+      CustomError.prototype.toString = function toString() {
+        return this.name + ": " + this.message;
+      };
+      return CustomError;
+    }
+    util.newError = newError;
+    util.ProtocolError = newError("ProtocolError");
+    util.oneOfGetter = function getOneOf(fieldNames) {
+      var fieldMap = {};
+      for (var i = 0; i < fieldNames.length; ++i)
+        fieldMap[fieldNames[i]] = 1;
+      return function() {
+        for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
+          if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
+            return keys[i2];
+      };
+    };
+    util.oneOfSetter = function setOneOf(fieldNames) {
+      return function(name) {
+        for (var i = 0; i < fieldNames.length; ++i)
+          if (fieldNames[i] !== name)
+            delete this[fieldNames[i]];
+      };
+    };
+    util.toJSONOptions = {
+      longs: String,
+      enums: String,
+      bytes: String,
+      json: true
+    };
+    util._configure = function() {
+      var Buffer2 = util.Buffer;
+      if (!Buffer2) {
+        util._Buffer_from = util._Buffer_allocUnsafe = null;
+        return;
+      }
+      util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || /* istanbul ignore next */
+      function Buffer_from(value, encoding) {
+        return new Buffer2(value, encoding);
+      };
+      util._Buffer_allocUnsafe = Buffer2.allocUnsafe || /* istanbul ignore next */
+      function Buffer_allocUnsafe(size) {
+        return new Buffer2(size);
+      };
+    };
+  }
+});
+
+// ../../node_modules/protobufjs/src/writer.js
+var require_writer = __commonJS({
+  "../../node_modules/protobufjs/src/writer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Writer;
+    var util = require_minimal();
+    var BufferWriter;
+    var LongBits = util.LongBits;
+    var base64 = util.base64;
+    var utf8 = util.utf8;
+    function Op(fn, len, val) {
+      this.fn = fn;
+      this.len = len;
+      this.next = void 0;
+      this.val = val;
+    }
+    function noop() {
+    }
+    function State(writer) {
+      this.head = writer.head;
+      this.tail = writer.tail;
+      this.len = writer.len;
+      this.next = writer.states;
+    }
+    function Writer() {
+      this.len = 0;
+      this.head = new Op(noop, 0, 0);
+      this.tail = this.head;
+      this.states = null;
+    }
+    var create = function create2() {
+      return util.Buffer ? function create_buffer_setup() {
+        return (Writer.create = function create_buffer() {
+          return new BufferWriter();
+        })();
+      } : function create_array() {
+        return new Writer();
+      };
+    };
+    Writer.create = create();
+    Writer.alloc = function alloc(size) {
+      return new util.Array(size);
+    };
+    if (util.Array !== Array)
+      Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
+    Writer.prototype._push = function push(fn, len, val) {
+      this.tail = this.tail.next = new Op(fn, len, val);
+      this.len += len;
+      return this;
+    };
+    function writeByte(val, buf, pos) {
+      buf[pos] = val & 255;
+    }
+    function writeVarint32(val, buf, pos) {
+      while (val > 127) {
+        buf[pos++] = val & 127 | 128;
+        val >>>= 7;
+      }
+      buf[pos] = val;
+    }
+    function VarintOp(len, val) {
+      this.len = len;
+      this.next = void 0;
+      this.val = val;
+    }
+    VarintOp.prototype = Object.create(Op.prototype);
+    VarintOp.prototype.fn = writeVarint32;
+    Writer.prototype.uint32 = function write_uint32(value) {
+      this.len += (this.tail = this.tail.next = new VarintOp(
+        (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5,
+        value
+      )).len;
+      return this;
+    };
+    Writer.prototype.int32 = function write_int32(value) {
+      return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+    };
+    Writer.prototype.sint32 = function write_sint32(value) {
+      return this.uint32((value << 1 ^ value >> 31) >>> 0);
+    };
+    function writeVarint64(val, buf, pos) {
+      while (val.hi) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+        val.hi >>>= 7;
+      }
+      while (val.lo > 127) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = val.lo >>> 7;
+      }
+      buf[pos++] = val.lo;
+    }
+    Writer.prototype.uint64 = function write_uint64(value) {
+      var bits = LongBits.from(value);
+      return this._push(writeVarint64, bits.length(), bits);
+    };
+    Writer.prototype.int64 = Writer.prototype.uint64;
+    Writer.prototype.sint64 = function write_sint64(value) {
+      var bits = LongBits.from(value).zzEncode();
+      return this._push(writeVarint64, bits.length(), bits);
+    };
+    Writer.prototype.bool = function write_bool(value) {
+      return this._push(writeByte, 1, value ? 1 : 0);
+    };
+    function writeFixed32(val, buf, pos) {
+      buf[pos] = val & 255;
+      buf[pos + 1] = val >>> 8 & 255;
+      buf[pos + 2] = val >>> 16 & 255;
+      buf[pos + 3] = val >>> 24;
+    }
+    Writer.prototype.fixed32 = function write_fixed32(value) {
+      return this._push(writeFixed32, 4, value >>> 0);
+    };
+    Writer.prototype.sfixed32 = Writer.prototype.fixed32;
+    Writer.prototype.fixed64 = function write_fixed64(value) {
+      var bits = LongBits.from(value);
+      return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    };
+    Writer.prototype.sfixed64 = Writer.prototype.fixed64;
+    Writer.prototype.float = function write_float(value) {
+      return this._push(util.float.writeFloatLE, 4, value);
+    };
+    Writer.prototype.double = function write_double(value) {
+      return this._push(util.float.writeDoubleLE, 8, value);
+    };
+    var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
+      buf.set(val, pos);
+    } : function writeBytes_for(val, buf, pos) {
+      for (var i = 0; i < val.length; ++i)
+        buf[pos + i] = val[i];
+    };
+    Writer.prototype.bytes = function write_bytes(value) {
+      var len = value.length >>> 0;
+      if (!len)
+        return this._push(writeByte, 1, 0);
+      if (util.isString(value)) {
+        var buf = Writer.alloc(len = base64.length(value));
+        base64.decode(value, buf, 0);
+        value = buf;
+      }
+      return this.uint32(len)._push(writeBytes, len, value);
+    };
+    Writer.prototype.string = function write_string(value) {
+      var len = utf8.length(value);
+      return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
+    };
+    Writer.prototype.fork = function fork() {
+      this.states = new State(this);
+      this.head = this.tail = new Op(noop, 0, 0);
+      this.len = 0;
+      return this;
+    };
+    Writer.prototype.reset = function reset() {
+      if (this.states) {
+        this.head = this.states.head;
+        this.tail = this.states.tail;
+        this.len = this.states.len;
+        this.states = this.states.next;
+      } else {
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len = 0;
+      }
+      return this;
+    };
+    Writer.prototype.ldelim = function ldelim() {
+      var head = this.head, tail = this.tail, len = this.len;
+      this.reset().uint32(len);
+      if (len) {
+        this.tail.next = head.next;
+        this.tail = tail;
+        this.len += len;
+      }
+      return this;
+    };
+    Writer.prototype.finish = function finish() {
+      var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
+      while (head) {
+        head.fn(head.val, buf, pos);
+        pos += head.len;
+        head = head.next;
+      }
+      return buf;
+    };
+    Writer._configure = function(BufferWriter_) {
+      BufferWriter = BufferWriter_;
+      Writer.create = create();
+      BufferWriter._configure();
+    };
+  }
+});
+
+// ../../node_modules/protobufjs/src/writer_buffer.js
+var require_writer_buffer = __commonJS({
+  "../../node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = BufferWriter;
+    var Writer = require_writer();
+    (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+    var util = require_minimal();
+    function BufferWriter() {
+      Writer.call(this);
+    }
+    BufferWriter._configure = function() {
+      BufferWriter.alloc = util._Buffer_allocUnsafe;
+      BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
+        buf.set(val, pos);
+      } : function writeBytesBuffer_copy(val, buf, pos) {
+        if (val.copy)
+          val.copy(buf, pos, 0, val.length);
+        else for (var i = 0; i < val.length; )
+          buf[pos++] = val[i++];
+      };
+    };
+    BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
+      if (util.isString(value))
+        value = util._Buffer_from(value, "base64");
+      var len = value.length >>> 0;
+      this.uint32(len);
+      if (len)
+        this._push(BufferWriter.writeBytesBuffer, len, value);
+      return this;
+    };
+    function writeStringBuffer(val, buf, pos) {
+      if (val.length < 40)
+        util.utf8.write(val, buf, pos);
+      else if (buf.utf8Write)
+        buf.utf8Write(val, pos);
+      else
+        buf.write(val, pos);
+    }
+    BufferWriter.prototype.string = function write_string_buffer(value) {
+      var len = util.Buffer.byteLength(value);
+      this.uint32(len);
+      if (len)
+        this._push(writeStringBuffer, len, value);
+      return this;
+    };
+    BufferWriter._configure();
+  }
+});
+
+// ../../node_modules/protobufjs/src/reader.js
+var require_reader = __commonJS({
+  "../../node_modules/protobufjs/src/reader.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Reader;
+    var util = require_minimal();
+    var BufferReader;
+    var LongBits = util.LongBits;
+    var utf8 = util.utf8;
+    function indexOutOfRange(reader, writeLength) {
+      return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+    }
+    function Reader(buffer) {
+      this.buf = buffer;
+      this.pos = 0;
+      this.len = buffer.length;
+    }
+    var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
+      if (buffer instanceof Uint8Array || Array.isArray(buffer))
+        return new Reader(buffer);
+      throw Error("illegal buffer");
+    } : function create_array2(buffer) {
+      if (Array.isArray(buffer))
+        return new Reader(buffer);
+      throw Error("illegal buffer");
+    };
+    var create = function create2() {
+      return util.Buffer ? function create_buffer_setup(buffer) {
+        return (Reader.create = function create_buffer(buffer2) {
+          return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
+        })(buffer);
+      } : create_array;
+    };
+    Reader.create = create();
+    Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */
+    util.Array.prototype.slice;
+    Reader.prototype.uint32 = /* @__PURE__ */ function read_uint32_setup() {
+      var value = 4294967295;
+      return function read_uint32() {
+        value = (this.buf[this.pos] & 127) >>> 0;
+        if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+        if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+        if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+        if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+        if (this.buf[this.pos++] < 128) return value;
+        if ((this.pos += 5) > this.len) {
+          this.pos = this.len;
+          throw indexOutOfRange(this, 10);
+        }
+        return value;
+      };
+    }();
+    Reader.prototype.int32 = function read_int32() {
+      return this.uint32() | 0;
+    };
+    Reader.prototype.sint32 = function read_sint32() {
+      var value = this.uint32();
+      return value >>> 1 ^ -(value & 1) | 0;
+    };
+    function readLongVarint() {
+      var bits = new LongBits(0, 0);
+      var i = 0;
+      if (this.len - this.pos > 4) {
+        for (; i < 4; ++i) {
+          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return bits;
+        i = 0;
+      } else {
+        for (; i < 3; ++i) {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+        return bits;
+      }
+      if (this.len - this.pos > 4) {
+        for (; i < 5; ++i) {
+          bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+      } else {
+        for (; i < 5; ++i) {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+          bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+      }
+      throw Error("invalid varint encoding");
+    }
+    Reader.prototype.bool = function read_bool() {
+      return this.uint32() !== 0;
+    };
+    function readFixed32_end(buf, end) {
+      return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+    }
+    Reader.prototype.fixed32 = function read_fixed32() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      return readFixed32_end(this.buf, this.pos += 4);
+    };
+    Reader.prototype.sfixed32 = function read_sfixed32() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      return readFixed32_end(this.buf, this.pos += 4) | 0;
+    };
+    function readFixed64() {
+      if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 8);
+      return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+    }
+    Reader.prototype.float = function read_float() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      var value = util.float.readFloatLE(this.buf, this.pos);
+      this.pos += 4;
+      return value;
+    };
+    Reader.prototype.double = function read_double() {
+      if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 4);
+      var value = util.float.readDoubleLE(this.buf, this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Reader.prototype.bytes = function read_bytes() {
+      var length = this.uint32(), start = this.pos, end = this.pos + length;
+      if (end > this.len)
+        throw indexOutOfRange(this, length);
+      this.pos += length;
+      if (Array.isArray(this.buf))
+        return this.buf.slice(start, end);
+      return start === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start, end);
+    };
+    Reader.prototype.string = function read_string() {
+      var bytes = this.bytes();
+      return utf8.read(bytes, 0, bytes.length);
+    };
+    Reader.prototype.skip = function skip(length) {
+      if (typeof length === "number") {
+        if (this.pos + length > this.len)
+          throw indexOutOfRange(this, length);
+        this.pos += length;
+      } else {
+        do {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+        } while (this.buf[this.pos++] & 128);
+      }
+      return this;
+    };
+    Reader.prototype.skipType = function(wireType) {
+      switch (wireType) {
+        case 0:
+          this.skip();
+          break;
+        case 1:
+          this.skip(8);
+          break;
+        case 2:
+          this.skip(this.uint32());
+          break;
+        case 3:
+          while ((wireType = this.uint32() & 7) !== 4) {
+            this.skipType(wireType);
+          }
+          break;
+        case 5:
+          this.skip(4);
+          break;
+        /* istanbul ignore next */
+        default:
+          throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+      }
+      return this;
+    };
+    Reader._configure = function(BufferReader_) {
+      BufferReader = BufferReader_;
+      Reader.create = create();
+      BufferReader._configure();
+      var fn = util.Long ? "toLong" : (
+        /* istanbul ignore next */
+        "toNumber"
+      );
+      util.merge(Reader.prototype, {
+        int64: function read_int64() {
+          return readLongVarint.call(this)[fn](false);
+        },
+        uint64: function read_uint64() {
+          return readLongVarint.call(this)[fn](true);
+        },
+        sint64: function read_sint64() {
+          return readLongVarint.call(this).zzDecode()[fn](false);
+        },
+        fixed64: function read_fixed64() {
+          return readFixed64.call(this)[fn](true);
+        },
+        sfixed64: function read_sfixed64() {
+          return readFixed64.call(this)[fn](false);
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/protobufjs/src/reader_buffer.js
+var require_reader_buffer = __commonJS({
+  "../../node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = BufferReader;
+    var Reader = require_reader();
+    (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+    var util = require_minimal();
+    function BufferReader(buffer) {
+      Reader.call(this, buffer);
+    }
+    BufferReader._configure = function() {
+      if (util.Buffer)
+        BufferReader.prototype._slice = util.Buffer.prototype.slice;
+    };
+    BufferReader.prototype.string = function read_string_buffer() {
+      var len = this.uint32();
+      return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+    };
+    BufferReader._configure();
+  }
+});
+
+// ../../node_modules/protobufjs/src/rpc/service.js
+var require_service = __commonJS({
+  "../../node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Service;
+    var util = require_minimal();
+    (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+    function Service(rpcImpl, requestDelimited, responseDelimited) {
+      if (typeof rpcImpl !== "function")
+        throw TypeError("rpcImpl must be a function");
+      util.EventEmitter.call(this);
+      this.rpcImpl = rpcImpl;
+      this.requestDelimited = Boolean(requestDelimited);
+      this.responseDelimited = Boolean(responseDelimited);
+    }
+    Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+      if (!request)
+        throw TypeError("request must be specified");
+      var self2 = this;
+      if (!callback)
+        return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
+      if (!self2.rpcImpl) {
+        setTimeout(function() {
+          callback(Error("already ended"));
+        }, 0);
+        return void 0;
+      }
+      try {
+        return self2.rpcImpl(
+          method,
+          requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
+          function rpcCallback(err, response) {
+            if (err) {
+              self2.emit("error", err, method);
+              return callback(err);
+            }
+            if (response === null) {
+              self2.end(
+                /* endedByRPC */
+                true
+              );
+              return void 0;
+            }
+            if (!(response instanceof responseCtor)) {
+              try {
+                response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
+              } catch (err2) {
+                self2.emit("error", err2, method);
+                return callback(err2);
+              }
+            }
+            self2.emit("data", response, method);
+            return callback(null, response);
+          }
+        );
+      } catch (err) {
+        self2.emit("error", err, method);
+        setTimeout(function() {
+          callback(err);
+        }, 0);
+        return void 0;
+      }
+    };
+    Service.prototype.end = function end(endedByRPC) {
+      if (this.rpcImpl) {
+        if (!endedByRPC)
+          this.rpcImpl(null, null, null);
+        this.rpcImpl = null;
+        this.emit("end").off();
+      }
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/protobufjs/src/rpc.js
+var require_rpc = __commonJS({
+  "../../node_modules/protobufjs/src/rpc.js"(exports2) {
+    "use strict";
+    var rpc = exports2;
+    rpc.Service = require_service();
+  }
+});
+
+// ../../node_modules/protobufjs/src/roots.js
+var require_roots = __commonJS({
+  "../../node_modules/protobufjs/src/roots.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {};
+  }
+});
+
+// ../../node_modules/protobufjs/src/index-minimal.js
+var require_index_minimal = __commonJS({
+  "../../node_modules/protobufjs/src/index-minimal.js"(exports2) {
+    "use strict";
+    var protobuf = exports2;
+    protobuf.build = "minimal";
+    protobuf.Writer = require_writer();
+    protobuf.BufferWriter = require_writer_buffer();
+    protobuf.Reader = require_reader();
+    protobuf.BufferReader = require_reader_buffer();
+    protobuf.util = require_minimal();
+    protobuf.rpc = require_rpc();
+    protobuf.roots = require_roots();
+    protobuf.configure = configure;
+    function configure() {
+      protobuf.util._configure();
+      protobuf.Writer._configure(protobuf.BufferWriter);
+      protobuf.Reader._configure(protobuf.BufferReader);
+    }
+    configure();
+  }
+});
+
+// ../../node_modules/protobufjs/minimal.js
+var require_minimal2 = __commonJS({
+  "../../node_modules/protobufjs/minimal.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_index_minimal();
+  }
+});
+
 // ../../node_modules/whatwg-fetch/fetch.js
 var g = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
 typeof global !== "undefined" && global || {};
@@ -664,36 +2909,684 @@ function buildFetchOptions(method, options, bodyJson) {
   if (bodyJson) {
     fetchOptions.body = bodyJson;
   }
-  return fetchOptions;
+  return fetchOptions;
+}
+function b64EncodeUnicode(str) {
+  return encode(encodeURIComponent(str).replace(
+    /%([0-9A-F]{2})/g,
+    function toSolidBytes(_match, p1) {
+      return String.fromCharCode(Number("0x" + p1));
+    }
+  ));
+}
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(decode2(str).split("").map(function(c) {
+    return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+  }).join(""));
+}
+function safeJSONParse(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch (error) {
+    if (jsonStr !== "") {
+      const fixedJsonStr = jsonStr.replace(/\n/g, "\\n");
+      try {
+        return JSON.parse(fixedJsonStr);
+      } catch (e) {
+        console.error("Error parsing JSON:", jsonStr, error);
+      }
+    }
+    return { t: jsonStr };
+  }
+}
+
+// api/api.ts
+var import_long3 = __toESM(require_long());
+var import_minimal4 = __toESM(require_minimal2());
+
+// google/protobuf/struct.ts
+var import_minimal = __toESM(require_minimal2());
+
+// google/protobuf/timestamp.ts
+var import_long = __toESM(require_long());
+var import_minimal2 = __toESM(require_minimal2());
+function createBaseTimestamp() {
+  return { seconds: 0, nanos: 0 };
+}
+var Timestamp = {
+  encode(message, writer = import_minimal2.default.Writer.create()) {
+    if (message.seconds !== 0) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal2.default.Reader ? input : import_minimal2.default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.seconds = longToNumber(reader.int64());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.nanos = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.seconds !== 0) {
+      obj.seconds = Math.round(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+  create(base) {
+    return Timestamp.fromPartial(base != null ? base : {});
+  },
+  fromPartial(object) {
+    var _a, _b;
+    const message = createBaseTimestamp();
+    message.seconds = (_a = object.seconds) != null ? _a : 0;
+    message.nanos = (_b = object.nanos) != null ? _b : 0;
+    return message;
+  }
+};
+function longToNumber(long) {
+  if (long.gt(globalThis.Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (long.lt(globalThis.Number.MIN_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+if (import_minimal2.default.util.Long !== import_long.default) {
+  import_minimal2.default.util.Long = import_long.default;
+  import_minimal2.default.configure();
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// google/protobuf/wrappers.ts
+var import_long2 = __toESM(require_long());
+var import_minimal3 = __toESM(require_minimal2());
+if (import_minimal3.default.util.Long !== import_long2.default) {
+  import_minimal3.default.util.Long = import_long2.default;
+  import_minimal3.default.configure();
+}
+
+// api/api.ts
+function createBaseAccount() {
+  return {
+    user: void 0,
+    email: "",
+    qr_code: "",
+    verify_time: void 0,
+    disable_time: void 0,
+    logo: "",
+    splash_screen: "",
+    encrypt_private_key: "",
+    password_setted: false
+  };
+}
+var Account = {
+  encode(message, writer = import_minimal4.default.Writer.create()) {
+    if (message.user !== void 0) {
+      User.encode(message.user, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.email !== void 0 && message.email !== "") {
+      writer.uint32(18).string(message.email);
+    }
+    if (message.qr_code !== void 0 && message.qr_code !== "") {
+      writer.uint32(26).string(message.qr_code);
+    }
+    if (message.verify_time !== void 0) {
+      Timestamp.encode(toTimestamp(message.verify_time), writer.uint32(34).fork()).ldelim();
+    }
+    if (message.disable_time !== void 0) {
+      Timestamp.encode(toTimestamp(message.disable_time), writer.uint32(42).fork()).ldelim();
+    }
+    if (message.logo !== void 0 && message.logo !== "") {
+      writer.uint32(50).string(message.logo);
+    }
+    if (message.splash_screen !== void 0 && message.splash_screen !== "") {
+      writer.uint32(58).string(message.splash_screen);
+    }
+    if (message.encrypt_private_key !== void 0 && message.encrypt_private_key !== "") {
+      writer.uint32(66).string(message.encrypt_private_key);
+    }
+    if (message.password_setted !== void 0 && message.password_setted !== false) {
+      writer.uint32(72).bool(message.password_setted);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.email = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.qr_code = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.verify_time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.disable_time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.logo = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.splash_screen = reader.string();
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.encrypt_private_key = reader.string();
+          continue;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+          message.password_setted = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      user: isSet2(object.user) ? User.fromJSON(object.user) : void 0,
+      email: isSet2(object.email) ? globalThis.String(object.email) : "",
+      qr_code: isSet2(object.qr_code) ? globalThis.String(object.qr_code) : "",
+      verify_time: isSet2(object.verify_time) ? fromJsonTimestamp(object.verify_time) : void 0,
+      disable_time: isSet2(object.disable_time) ? fromJsonTimestamp(object.disable_time) : void 0,
+      logo: isSet2(object.logo) ? globalThis.String(object.logo) : "",
+      splash_screen: isSet2(object.splash_screen) ? globalThis.String(object.splash_screen) : "",
+      encrypt_private_key: isSet2(object.encrypt_private_key) ? globalThis.String(object.encrypt_private_key) : "",
+      password_setted: isSet2(object.password_setted) ? globalThis.Boolean(object.password_setted) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.user !== void 0) {
+      obj.user = User.toJSON(message.user);
+    }
+    if (message.email !== void 0 && message.email !== "") {
+      obj.email = message.email;
+    }
+    if (message.qr_code !== void 0 && message.qr_code !== "") {
+      obj.qr_code = message.qr_code;
+    }
+    if (message.verify_time !== void 0) {
+      obj.verify_time = message.verify_time.toISOString();
+    }
+    if (message.disable_time !== void 0) {
+      obj.disable_time = message.disable_time.toISOString();
+    }
+    if (message.logo !== void 0 && message.logo !== "") {
+      obj.logo = message.logo;
+    }
+    if (message.splash_screen !== void 0 && message.splash_screen !== "") {
+      obj.splash_screen = message.splash_screen;
+    }
+    if (message.encrypt_private_key !== void 0 && message.encrypt_private_key !== "") {
+      obj.encrypt_private_key = message.encrypt_private_key;
+    }
+    if (message.password_setted !== void 0 && message.password_setted !== false) {
+      obj.password_setted = message.password_setted;
+    }
+    return obj;
+  },
+  create(base) {
+    return Account.fromPartial(base != null ? base : {});
+  },
+  fromPartial(object) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const message = createBaseAccount();
+    message.user = object.user !== void 0 && object.user !== null ? User.fromPartial(object.user) : void 0;
+    message.email = (_a = object.email) != null ? _a : "";
+    message.qr_code = (_b = object.qr_code) != null ? _b : "";
+    message.verify_time = (_c = object.verify_time) != null ? _c : void 0;
+    message.disable_time = (_d = object.disable_time) != null ? _d : void 0;
+    message.logo = (_e = object.logo) != null ? _e : "";
+    message.splash_screen = (_f = object.splash_screen) != null ? _f : "";
+    message.encrypt_private_key = (_g = object.encrypt_private_key) != null ? _g : "";
+    message.password_setted = (_h = object.password_setted) != null ? _h : false;
+    return message;
+  }
+};
+function createBaseUser() {
+  return {
+    id: "",
+    username: "",
+    display_name: "",
+    avatar_url: "",
+    lang_tag: "",
+    location: "",
+    timezone: "",
+    user_status: "",
+    online: false,
+    phone_number: "",
+    edge_count: 0,
+    create_time: void 0,
+    update_time: void 0,
+    about_me: "",
+    join_time: void 0,
+    is_mobile: false,
+    dob: void 0,
+    mezon_id: "",
+    list_nick_names: [],
+    status: ""
+  };
 }
-function b64EncodeUnicode(str) {
-  return encode(encodeURIComponent(str).replace(
-    /%([0-9A-F]{2})/g,
-    function toSolidBytes(_match, p1) {
-      return String.fromCharCode(Number("0x" + p1));
+var User = {
+  encode(message, writer = import_minimal4.default.Writer.create()) {
+    if (message.id !== void 0 && message.id !== "") {
+      writer.uint32(10).string(message.id);
     }
-  ));
-}
-function b64DecodeUnicode(str) {
-  return decodeURIComponent(decode2(str).split("").map(function(c) {
-    return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-  }).join(""));
-}
-function safeJSONParse(jsonStr) {
-  try {
-    return JSON.parse(jsonStr);
-  } catch (error) {
-    if (jsonStr !== "") {
-      const fixedJsonStr = jsonStr.replace(/\n/g, "\\n");
-      try {
-        return JSON.parse(fixedJsonStr);
-      } catch (e) {
-        console.error("Error parsing JSON:", jsonStr, error);
+    if (message.username !== void 0 && message.username !== "") {
+      writer.uint32(18).string(message.username);
+    }
+    if (message.display_name !== void 0 && message.display_name !== "") {
+      writer.uint32(26).string(message.display_name);
+    }
+    if (message.avatar_url !== void 0 && message.avatar_url !== "") {
+      writer.uint32(34).string(message.avatar_url);
+    }
+    if (message.lang_tag !== void 0 && message.lang_tag !== "") {
+      writer.uint32(42).string(message.lang_tag);
+    }
+    if (message.location !== void 0 && message.location !== "") {
+      writer.uint32(50).string(message.location);
+    }
+    if (message.timezone !== void 0 && message.timezone !== "") {
+      writer.uint32(58).string(message.timezone);
+    }
+    if (message.user_status !== void 0 && message.user_status !== "") {
+      writer.uint32(66).string(message.user_status);
+    }
+    if (message.online !== void 0 && message.online !== false) {
+      writer.uint32(72).bool(message.online);
+    }
+    if (message.phone_number !== void 0 && message.phone_number !== "") {
+      writer.uint32(82).string(message.phone_number);
+    }
+    if (message.edge_count !== void 0 && message.edge_count !== 0) {
+      writer.uint32(88).int32(message.edge_count);
+    }
+    if (message.create_time !== void 0) {
+      Timestamp.encode(toTimestamp(message.create_time), writer.uint32(98).fork()).ldelim();
+    }
+    if (message.update_time !== void 0) {
+      Timestamp.encode(toTimestamp(message.update_time), writer.uint32(106).fork()).ldelim();
+    }
+    if (message.about_me !== void 0 && message.about_me !== "") {
+      writer.uint32(114).string(message.about_me);
+    }
+    if (message.join_time !== void 0) {
+      Timestamp.encode(toTimestamp(message.join_time), writer.uint32(122).fork()).ldelim();
+    }
+    if (message.is_mobile !== void 0 && message.is_mobile !== false) {
+      writer.uint32(128).bool(message.is_mobile);
+    }
+    if (message.dob !== void 0) {
+      Timestamp.encode(toTimestamp(message.dob), writer.uint32(138).fork()).ldelim();
+    }
+    if (message.mezon_id !== void 0 && message.mezon_id !== "") {
+      writer.uint32(146).string(message.mezon_id);
+    }
+    if (message.list_nick_names !== void 0 && message.list_nick_names.length !== 0) {
+      for (const v of message.list_nick_names) {
+        writer.uint32(154).string(v);
       }
     }
-    return { t: jsonStr };
+    if (message.status !== void 0 && message.status !== "") {
+      writer.uint32(162).string(message.status);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal4.default.Reader ? input : import_minimal4.default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseUser();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.username = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.display_name = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.avatar_url = reader.string();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.lang_tag = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.location = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.timezone = reader.string();
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.user_status = reader.string();
+          continue;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+          message.online = reader.bool();
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+          message.phone_number = reader.string();
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+          message.edge_count = reader.int32();
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+          message.create_time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 13:
+          if (tag !== 106) {
+            break;
+          }
+          message.update_time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 14:
+          if (tag !== 114) {
+            break;
+          }
+          message.about_me = reader.string();
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+          message.join_time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 16:
+          if (tag !== 128) {
+            break;
+          }
+          message.is_mobile = reader.bool();
+          continue;
+        case 17:
+          if (tag !== 138) {
+            break;
+          }
+          message.dob = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 18:
+          if (tag !== 146) {
+            break;
+          }
+          message.mezon_id = reader.string();
+          continue;
+        case 19:
+          if (tag !== 154) {
+            break;
+          }
+          message.list_nick_names.push(reader.string());
+          continue;
+        case 20:
+          if (tag !== 162) {
+            break;
+          }
+          message.status = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet2(object.id) ? globalThis.String(object.id) : "",
+      username: isSet2(object.username) ? globalThis.String(object.username) : "",
+      display_name: isSet2(object.display_name) ? globalThis.String(object.display_name) : "",
+      avatar_url: isSet2(object.avatar_url) ? globalThis.String(object.avatar_url) : "",
+      lang_tag: isSet2(object.lang_tag) ? globalThis.String(object.lang_tag) : "",
+      location: isSet2(object.location) ? globalThis.String(object.location) : "",
+      timezone: isSet2(object.timezone) ? globalThis.String(object.timezone) : "",
+      user_status: isSet2(object.user_status) ? globalThis.String(object.user_status) : "",
+      online: isSet2(object.online) ? globalThis.Boolean(object.online) : false,
+      phone_number: isSet2(object.phone_number) ? globalThis.String(object.phone_number) : "",
+      edge_count: isSet2(object.edge_count) ? globalThis.Number(object.edge_count) : 0,
+      create_time: isSet2(object.create_time) ? fromJsonTimestamp(object.create_time) : void 0,
+      update_time: isSet2(object.update_time) ? fromJsonTimestamp(object.update_time) : void 0,
+      about_me: isSet2(object.about_me) ? globalThis.String(object.about_me) : "",
+      join_time: isSet2(object.join_time) ? fromJsonTimestamp(object.join_time) : void 0,
+      is_mobile: isSet2(object.is_mobile) ? globalThis.Boolean(object.is_mobile) : false,
+      dob: isSet2(object.dob) ? fromJsonTimestamp(object.dob) : void 0,
+      mezon_id: isSet2(object.mezon_id) ? globalThis.String(object.mezon_id) : "",
+      list_nick_names: globalThis.Array.isArray(object == null ? void 0 : object.list_nick_names) ? object.list_nick_names.map((e) => globalThis.String(e)) : [],
+      status: isSet2(object.status) ? globalThis.String(object.status) : ""
+    };
+  },
+  toJSON(message) {
+    var _a;
+    const obj = {};
+    if (message.id !== void 0 && message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.username !== void 0 && message.username !== "") {
+      obj.username = message.username;
+    }
+    if (message.display_name !== void 0 && message.display_name !== "") {
+      obj.display_name = message.display_name;
+    }
+    if (message.avatar_url !== void 0 && message.avatar_url !== "") {
+      obj.avatar_url = message.avatar_url;
+    }
+    if (message.lang_tag !== void 0 && message.lang_tag !== "") {
+      obj.lang_tag = message.lang_tag;
+    }
+    if (message.location !== void 0 && message.location !== "") {
+      obj.location = message.location;
+    }
+    if (message.timezone !== void 0 && message.timezone !== "") {
+      obj.timezone = message.timezone;
+    }
+    if (message.user_status !== void 0 && message.user_status !== "") {
+      obj.user_status = message.user_status;
+    }
+    if (message.online !== void 0 && message.online !== false) {
+      obj.online = message.online;
+    }
+    if (message.phone_number !== void 0 && message.phone_number !== "") {
+      obj.phone_number = message.phone_number;
+    }
+    if (message.edge_count !== void 0 && message.edge_count !== 0) {
+      obj.edge_count = Math.round(message.edge_count);
+    }
+    if (message.create_time !== void 0) {
+      obj.create_time = message.create_time.toISOString();
+    }
+    if (message.update_time !== void 0) {
+      obj.update_time = message.update_time.toISOString();
+    }
+    if (message.about_me !== void 0 && message.about_me !== "") {
+      obj.about_me = message.about_me;
+    }
+    if (message.join_time !== void 0) {
+      obj.join_time = message.join_time.toISOString();
+    }
+    if (message.is_mobile !== void 0 && message.is_mobile !== false) {
+      obj.is_mobile = message.is_mobile;
+    }
+    if (message.dob !== void 0) {
+      obj.dob = message.dob.toISOString();
+    }
+    if (message.mezon_id !== void 0 && message.mezon_id !== "") {
+      obj.mezon_id = message.mezon_id;
+    }
+    if ((_a = message.list_nick_names) == null ? void 0 : _a.length) {
+      obj.list_nick_names = message.list_nick_names;
+    }
+    if (message.status !== void 0 && message.status !== "") {
+      obj.status = message.status;
+    }
+    return obj;
+  },
+  create(base) {
+    return User.fromPartial(base != null ? base : {});
+  },
+  fromPartial(object) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+    const message = createBaseUser();
+    message.id = (_a = object.id) != null ? _a : "";
+    message.username = (_b = object.username) != null ? _b : "";
+    message.display_name = (_c = object.display_name) != null ? _c : "";
+    message.avatar_url = (_d = object.avatar_url) != null ? _d : "";
+    message.lang_tag = (_e = object.lang_tag) != null ? _e : "";
+    message.location = (_f = object.location) != null ? _f : "";
+    message.timezone = (_g = object.timezone) != null ? _g : "";
+    message.user_status = (_h = object.user_status) != null ? _h : "";
+    message.online = (_i = object.online) != null ? _i : false;
+    message.phone_number = (_j = object.phone_number) != null ? _j : "";
+    message.edge_count = (_k = object.edge_count) != null ? _k : 0;
+    message.create_time = (_l = object.create_time) != null ? _l : void 0;
+    message.update_time = (_m = object.update_time) != null ? _m : void 0;
+    message.about_me = (_n = object.about_me) != null ? _n : "";
+    message.join_time = (_o = object.join_time) != null ? _o : void 0;
+    message.is_mobile = (_p = object.is_mobile) != null ? _p : false;
+    message.dob = (_q = object.dob) != null ? _q : void 0;
+    message.mezon_id = (_r = object.mezon_id) != null ? _r : "";
+    message.list_nick_names = ((_s = object.list_nick_names) == null ? void 0 : _s.map((e) => e)) || [];
+    message.status = (_t = object.status) != null ? _t : "";
+    return message;
+  }
+};
+function toTimestamp(date) {
+  const seconds = Math.trunc(date.getTime() / 1e3);
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp(t) {
+  let millis = (t.seconds || 0) * 1e3;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
   }
 }
+if (import_minimal4.default.util.Long !== import_long3.default) {
+  import_minimal4.default.util.Long = import_long3.default;
+  import_minimal4.default.configure();
+}
+function isSet2(value) {
+  return value !== null && value !== void 0;
+}
 
 // api.gen.ts
 var MezonApi = class {
@@ -765,18 +3658,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -1845,18 +4740,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2119,18 +5016,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2177,18 +5076,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2280,18 +5181,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2311,18 +5214,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2339,18 +5244,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2367,18 +5274,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2626,18 +5535,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -2977,18 +5888,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3002,18 +5915,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3090,18 +6005,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3283,18 +6200,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3390,18 +6309,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3449,18 +6370,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3475,18 +6398,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3501,18 +6426,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3732,18 +6659,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -3907,18 +6836,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4196,18 +7127,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4224,18 +7157,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4281,18 +7216,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4528,18 +7465,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4706,18 +7645,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4741,18 +7682,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -4775,18 +7718,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5068,18 +8013,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5094,18 +8041,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5156,18 +8105,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5181,18 +8132,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5239,18 +8192,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5413,18 +8368,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -5638,18 +8595,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -6089,18 +9048,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -6408,18 +9369,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -6930,18 +9893,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Account.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -9290,12 +12255,16 @@ var Client = class {
               lang_tag: gu.user.lang_tag,
               location: gu.user.location,
               online: gu.user.online,
-              is_mobile: (_a = gu.user) == null ? void 0 : _a.is_mobile,
+              is_mobile: ((_a = gu.user) == null ? void 0 : _a.is_mobile) || false,
               timezone: gu.user.timezone,
               update_time: gu.user.update_time,
               username: gu.user.username,
               user_status: gu.user.user_status,
-              status: gu.user.status
+              status: gu.user.status,
+              about_me: gu.user.about_me,
+              mezon_id: gu.user.mezon_id,
+              list_nick_names: gu.user.list_nick_names,
+              phone_number: gu.user.phone_number
             },
             role_id: gu.role_id,
             clan_nick: gu.clan_nick,
@@ -9540,9 +12509,13 @@ var Client = class {
               timezone: f.user.timezone,
               update_time: f.user.update_time,
               username: f.user.username,
-              is_mobile: (_a = f.user) == null ? void 0 : _a.is_mobile,
+              is_mobile: ((_a = f.user) == null ? void 0 : _a.is_mobile) || false,
               user_status: f.user.user_status,
-              status: f.user.status
+              status: f.user.status,
+              mezon_id: f.user.mezon_id,
+              list_nick_names: f.user.list_nick_names,
+              phone_number: f.user.phone_number,
+              about_me: f.user.about_me
             },
             state: f.state,
             source_id: f.source_id