@qwen-code/qwen-code 0.17.0 → 0.17.1-nightly.20260604.16dd99fa3

package/chunks/{chunk-J5VCSWPA.js → chunk-3PJXIDKI.js}

@@ -5,15 +5,16 @@ import {
 } from "./chunk-A4BMJM77.js";
 import {
   __commonJS,
-  __name
+  __name,
+  __require
 } from "./chunk-J2S4EL5Y.js";
 
 // node_modules/@protobufjs/aspromise/index.js
 var require_aspromise = __commonJS({
-  "node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
+  "node_modules/@protobufjs/aspromise/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = asPromise;
+    module.exports = asPromise;
     function asPromise(fn, ctx) {
       var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
       while (index < arguments.length)
@@ -48,10 +49,10 @@ var require_aspromise = __commonJS({
 
 // node_modules/@protobufjs/base64/index.js
 var require_base64 = __commonJS({
-  "node_modules/@protobufjs/base64/index.js"(exports2) {
+  "node_modules/@protobufjs/base64/index.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var base64 = exports2;
+    var base64 = exports;
     base64.length = /* @__PURE__ */ __name(function length(string) {
       var p = string.length;
       if (!p)
@@ -149,12 +150,12 @@ var require_base64 = __commonJS({
 
 // node_modules/@protobufjs/eventemitter/index.js
 var require_eventemitter = __commonJS({
-  "node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
+  "node_modules/@protobufjs/eventemitter/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = EventEmitter;
+    module.exports = EventEmitter;
     function EventEmitter() {
-      this._listeners = {};
+      this._listeners = /* @__PURE__ */ Object.create(null);
     }
     __name(EventEmitter, "EventEmitter");
     EventEmitter.prototype.on = /* @__PURE__ */ __name(function on(evt, fn, ctx) {
@@ -166,12 +167,14 @@ var require_eventemitter = __commonJS({
     }, "on");
     EventEmitter.prototype.off = /* @__PURE__ */ __name(function off(evt, fn) {
       if (evt === void 0)
-        this._listeners = {};
+        this._listeners = /* @__PURE__ */ Object.create(null);
       else {
         if (fn === void 0)
           this._listeners[evt] = [];
         else {
           var listeners = this._listeners[evt];
+          if (!listeners)
+            return this;
           for (var i = 0; i < listeners.length; )
             if (listeners[i].fn === fn)
               listeners.splice(i, 1);
@@ -197,11 +200,11 @@ var require_eventemitter = __commonJS({
 
 // node_modules/@protobufjs/float/index.js
 var require_float = __commonJS({
-  "node_modules/@protobufjs/float/index.js"(exports2, module2) {
+  "node_modules/@protobufjs/float/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = factory(factory);
-    function factory(exports3) {
+    module.exports = factory(factory);
+    function factory(exports2) {
       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) {
@@ -220,8 +223,8 @@ var require_float = __commonJS({
           buf[pos + 3] = f8b[0];
         }
         __name(writeFloat_f32_rev, "writeFloat_f32_rev");
-        exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-        exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+        exports2.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        exports2.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
         function readFloat_f32_cpy(buf, pos) {
           f8b[0] = buf[pos];
           f8b[1] = buf[pos + 1];
@@ -238,8 +241,8 @@ var require_float = __commonJS({
           return f32[0];
         }
         __name(readFloat_f32_rev, "readFloat_f32_rev");
-        exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+        exports2.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        exports2.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
       })();
       else (function() {
         function writeFloat_ieee754(writeUint, val, buf, pos) {
@@ -266,15 +269,15 @@ var require_float = __commonJS({
           }
         }
         __name(writeFloat_ieee754, "writeFloat_ieee754");
-        exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+        exports2.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports2.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);
         }
         __name(readFloat_ieee754, "readFloat_ieee754");
-        exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+        exports2.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports2.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;
@@ -302,8 +305,8 @@ var require_float = __commonJS({
           buf[pos + 7] = f8b[0];
         }
         __name(writeDouble_f64_rev, "writeDouble_f64_rev");
-        exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-        exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+        exports2.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        exports2.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
         function readDouble_f64_cpy(buf, pos) {
           f8b[0] = buf[pos];
           f8b[1] = buf[pos + 1];
@@ -328,8 +331,8 @@ var require_float = __commonJS({
           return f64[0];
         }
         __name(readDouble_f64_rev, "readDouble_f64_rev");
-        exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+        exports2.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        exports2.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
       })();
       else (function() {
         function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
@@ -368,18 +371,18 @@ var require_float = __commonJS({
           }
         }
         __name(writeDouble_ieee754, "writeDouble_ieee754");
-        exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+        exports2.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports2.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);
         }
         __name(readDouble_ieee754, "readDouble_ieee754");
-        exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+        exports2.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports2.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
       })();
-      return exports3;
+      return exports2;
     }
     __name(factory, "factory");
     function writeUintLE(val, buf, pos) {
@@ -415,12 +418,15 @@ var require_inquire = __commonJS({
     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) {
+        if (typeof __require !== "function") {
+          return null;
+        }
+        var mod = __require(moduleName);
+        if (mod && (mod.length || Object.keys(mod).length)) return mod;
+        return null;
+      } catch (err) {
+        return null;
       }
-      return null;
     }
     __name(inquire, "inquire");
   }
@@ -428,10 +434,11 @@ var require_inquire = __commonJS({
 
 // node_modules/@protobufjs/utf8/index.js
 var require_utf8 = __commonJS({
-  "node_modules/@protobufjs/utf8/index.js"(exports2) {
+  "node_modules/@protobufjs/utf8/index.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var utf8 = exports2;
+    var utf8 = exports;
+    var replacementChar = "\uFFFD";
     utf8.length = /* @__PURE__ */ __name(function utf8_length(string) {
       var len = 0, c = 0;
       for (var i = 0; i < string.length; ++i) {
@@ -449,33 +456,32 @@ var require_utf8 = __commonJS({
       return len;
     }, "utf8_length");
     utf8.read = /* @__PURE__ */ __name(function utf8_read(buffer, start, end) {
-      var len = end - start;
-      if (len < 1)
+      if (end - start < 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("");
+      var str = "";
+      for (var i = start; i < end; ) {
+        var t = buffer[i++];
+        if (t <= 127) {
+          str += String.fromCharCode(t);
+        } else if (t >= 192 && t < 224) {
+          var c2 = (t & 31) << 6 | buffer[i++] & 63;
+          str += c2 >= 128 ? String.fromCharCode(c2) : replacementChar;
+        } else if (t >= 224 && t < 240) {
+          var c3 = (t & 15) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+          str += c3 >= 2048 ? String.fromCharCode(c3) : replacementChar;
+        } else if (t >= 240) {
+          var t2 = (t & 7) << 18 | (buffer[i++] & 63) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+          if (t2 < 65536 || t2 > 1114111)
+            str += replacementChar;
+          else {
+            t2 -= 65536;
+            str += String.fromCharCode(55296 + (t2 >> 10));
+            str += String.fromCharCode(56320 + (t2 & 1023));
+          }
+        }
       }
-      return String.fromCharCode.apply(String, chunk.slice(0, i));
+      return str;
     }, "utf8_read");
     utf8.write = /* @__PURE__ */ __name(function utf8_write(string, buffer, offset) {
       var start = offset, c1, c2;
@@ -506,10 +512,10 @@ var require_utf8 = __commonJS({
 
 // node_modules/@protobufjs/pool/index.js
 var require_pool = __commonJS({
-  "node_modules/@protobufjs/pool/index.js"(exports2, module2) {
+  "node_modules/@protobufjs/pool/index.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = pool;
+    module.exports = pool;
     function pool(alloc, slice, size) {
       var SIZE = size || 8192;
       var MAX = SIZE >>> 1;
@@ -534,10 +540,10 @@ var require_pool = __commonJS({
 
 // node_modules/protobufjs/src/util/longbits.js
 var require_longbits = __commonJS({
-  "node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
+  "node_modules/protobufjs/src/util/longbits.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = LongBits;
+    module.exports = LongBits;
     var util = require_minimal();
     function LongBits(lo, hi) {
       this.lo = lo >>> 0;
@@ -636,12 +642,1000 @@ var require_longbits = __commonJS({
   }
 });
 
+// node_modules/long/umd/index.js
+var require_umd = __commonJS({
+  "node_modules/long/umd/index.js"(exports, module) {
+    init_esbuild_shims();
+    (function(global2, factory) {
+      function preferDefault(exports2) {
+        return exports2.default || exports2;
+      }
+      __name(preferDefault, "preferDefault");
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          var exports2 = {};
+          factory(exports2);
+          return preferDefault(exports2);
+        });
+      } else if (typeof exports === "object") {
+        factory(exports);
+        if (typeof module === "object") module.exports = preferDefault(exports);
+      } else {
+        (function() {
+          var exports2 = {};
+          factory(exports2);
+          global2.Long = preferDefault(exports2);
+        })();
+      }
+    })(
+      typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports,
+      function(_exports) {
+        "use strict";
+        Object.defineProperty(_exports, "__esModule", {
+          value: true
+        });
+        _exports.default = void 0;
+        var wasm = null;
+        try {
+          wasm = new WebAssembly.Instance(
+            new WebAssembly.Module(
+              new Uint8Array([
+                // \0asm
+                0,
+                97,
+                115,
+                109,
+                // version 1
+                1,
+                0,
+                0,
+                0,
+                // section "type"
+                1,
+                13,
+                2,
+                // 0, () => i32
+                96,
+                0,
+                1,
+                127,
+                // 1, (i32, i32, i32, i32) => i32
+                96,
+                4,
+                127,
+                127,
+                127,
+                127,
+                1,
+                127,
+                // section "function"
+                3,
+                7,
+                6,
+                // 0, type 0
+                0,
+                // 1, type 1
+                1,
+                // 2, type 1
+                1,
+                // 3, type 1
+                1,
+                // 4, type 1
+                1,
+                // 5, type 1
+                1,
+                // section "global"
+                6,
+                6,
+                1,
+                // 0, "high", mutable i32
+                127,
+                1,
+                65,
+                0,
+                11,
+                // section "export"
+                7,
+                50,
+                6,
+                // 0, "mul"
+                3,
+                109,
+                117,
+                108,
+                0,
+                1,
+                // 1, "div_s"
+                5,
+                100,
+                105,
+                118,
+                95,
+                115,
+                0,
+                2,
+                // 2, "div_u"
+                5,
+                100,
+                105,
+                118,
+                95,
+                117,
+                0,
+                3,
+                // 3, "rem_s"
+                5,
+                114,
+                101,
+                109,
+                95,
+                115,
+                0,
+                4,
+                // 4, "rem_u"
+                5,
+                114,
+                101,
+                109,
+                95,
+                117,
+                0,
+                5,
+                // 5, "get_high"
+                8,
+                103,
+                101,
+                116,
+                95,
+                104,
+                105,
+                103,
+                104,
+                0,
+                0,
+                // section "code"
+                10,
+                191,
+                1,
+                6,
+                // 0, "get_high"
+                4,
+                0,
+                35,
+                0,
+                11,
+                // 1, "mul"
+                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,
+                // 2, "div_s"
+                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,
+                // 3, "div_u"
+                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,
+                // 4, "rem_s"
+                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,
+                // 5, "rem_u"
+                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 {
+        }
+        function Long(low, high, unsigned) {
+          this.low = low | 0;
+          this.high = high | 0;
+          this.unsigned = !!unsigned;
+        }
+        __name(Long, "Long");
+        Long.prototype.__isLong__;
+        Object.defineProperty(Long.prototype, "__isLong__", {
+          value: true
+        });
+        function isLong(obj) {
+          return (obj && obj["__isLong__"]) === true;
+        }
+        __name(isLong, "isLong");
+        function ctz32(value) {
+          var c = Math.clz32(value & -value);
+          return value ? 31 - c : c;
+        }
+        __name(ctz32, "ctz32");
+        Long.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, 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;
+          }
+        }
+        __name(fromInt, "fromInt");
+        Long.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
+          );
+        }
+        __name(fromNumber, "fromNumber");
+        Long.fromNumber = fromNumber;
+        function fromBits(lowBits, highBits, unsigned) {
+          return new Long(lowBits, highBits, unsigned);
+        }
+        __name(fromBits, "fromBits");
+        Long.fromBits = fromBits;
+        var pow_dbl = Math.pow;
+        function fromString(str, unsigned, radix) {
+          if (str.length === 0) throw Error("empty string");
+          if (typeof unsigned === "number") {
+            radix = unsigned;
+            unsigned = false;
+          } else {
+            unsigned = !!unsigned;
+          }
+          if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
+            return unsigned ? UZERO : ZERO;
+          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;
+        }
+        __name(fromString, "fromString");
+        Long.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
+          );
+        }
+        __name(fromValue, "fromValue");
+        Long.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);
+        Long.ZERO = ZERO;
+        var UZERO = fromInt(0, true);
+        Long.UZERO = UZERO;
+        var ONE = fromInt(1);
+        Long.ONE = ONE;
+        var UONE = fromInt(1, true);
+        Long.UONE = UONE;
+        var NEG_ONE = fromInt(-1);
+        Long.NEG_ONE = NEG_ONE;
+        var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
+        Long.MAX_VALUE = MAX_VALUE;
+        var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
+        Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
+        var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
+        Long.MIN_VALUE = MIN_VALUE;
+        var LongPrototype = Long.prototype;
+        LongPrototype.toInt = /* @__PURE__ */ __name(function toInt() {
+          return this.unsigned ? this.low >>> 0 : this.low;
+        }, "toInt");
+        LongPrototype.toNumber = /* @__PURE__ */ __name(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);
+        }, "toNumber");
+        LongPrototype.toString = /* @__PURE__ */ __name(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;
+            }
+          }
+        }, "toString");
+        LongPrototype.getHighBits = /* @__PURE__ */ __name(function getHighBits() {
+          return this.high;
+        }, "getHighBits");
+        LongPrototype.getHighBitsUnsigned = /* @__PURE__ */ __name(function getHighBitsUnsigned() {
+          return this.high >>> 0;
+        }, "getHighBitsUnsigned");
+        LongPrototype.getLowBits = /* @__PURE__ */ __name(function getLowBits() {
+          return this.low;
+        }, "getLowBits");
+        LongPrototype.getLowBitsUnsigned = /* @__PURE__ */ __name(function getLowBitsUnsigned() {
+          return this.low >>> 0;
+        }, "getLowBitsUnsigned");
+        LongPrototype.getNumBitsAbs = /* @__PURE__ */ __name(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;
+        }, "getNumBitsAbs");
+        LongPrototype.isSafeInteger = /* @__PURE__ */ __name(function isSafeInteger() {
+          var top11Bits = this.high >> 21;
+          if (!top11Bits) return true;
+          if (this.unsigned) return false;
+          return top11Bits === -1 && !(this.low === 0 && this.high === -2097152);
+        }, "isSafeInteger");
+        LongPrototype.isZero = /* @__PURE__ */ __name(function isZero() {
+          return this.high === 0 && this.low === 0;
+        }, "isZero");
+        LongPrototype.eqz = LongPrototype.isZero;
+        LongPrototype.isNegative = /* @__PURE__ */ __name(function isNegative() {
+          return !this.unsigned && this.high < 0;
+        }, "isNegative");
+        LongPrototype.isPositive = /* @__PURE__ */ __name(function isPositive() {
+          return this.unsigned || this.high >= 0;
+        }, "isPositive");
+        LongPrototype.isOdd = /* @__PURE__ */ __name(function isOdd() {
+          return (this.low & 1) === 1;
+        }, "isOdd");
+        LongPrototype.isEven = /* @__PURE__ */ __name(function isEven() {
+          return (this.low & 1) === 0;
+        }, "isEven");
+        LongPrototype.equals = /* @__PURE__ */ __name(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;
+        }, "equals");
+        LongPrototype.eq = LongPrototype.equals;
+        LongPrototype.notEquals = /* @__PURE__ */ __name(function notEquals(other) {
+          return !this.eq(
+            /* validates */
+            other
+          );
+        }, "notEquals");
+        LongPrototype.neq = LongPrototype.notEquals;
+        LongPrototype.ne = LongPrototype.notEquals;
+        LongPrototype.lessThan = /* @__PURE__ */ __name(function lessThan(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) < 0;
+        }, "lessThan");
+        LongPrototype.lt = LongPrototype.lessThan;
+        LongPrototype.lessThanOrEqual = /* @__PURE__ */ __name(function lessThanOrEqual(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) <= 0;
+        }, "lessThanOrEqual");
+        LongPrototype.lte = LongPrototype.lessThanOrEqual;
+        LongPrototype.le = LongPrototype.lessThanOrEqual;
+        LongPrototype.greaterThan = /* @__PURE__ */ __name(function greaterThan(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) > 0;
+        }, "greaterThan");
+        LongPrototype.gt = LongPrototype.greaterThan;
+        LongPrototype.greaterThanOrEqual = /* @__PURE__ */ __name(function greaterThanOrEqual(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) >= 0;
+        }, "greaterThanOrEqual");
+        LongPrototype.gte = LongPrototype.greaterThanOrEqual;
+        LongPrototype.ge = LongPrototype.greaterThanOrEqual;
+        LongPrototype.compare = /* @__PURE__ */ __name(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;
+        }, "compare");
+        LongPrototype.comp = LongPrototype.compare;
+        LongPrototype.negate = /* @__PURE__ */ __name(function negate() {
+          if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE;
+          return this.not().add(ONE);
+        }, "negate");
+        LongPrototype.neg = LongPrototype.negate;
+        LongPrototype.add = /* @__PURE__ */ __name(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);
+        }, "add");
+        LongPrototype.subtract = /* @__PURE__ */ __name(function subtract(subtrahend) {
+          if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend);
+          return this.add(subtrahend.neg());
+        }, "subtract");
+        LongPrototype.sub = LongPrototype.subtract;
+        LongPrototype.multiply = /* @__PURE__ */ __name(function multiply(multiplier) {
+          if (this.isZero()) return this;
+          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 this.unsigned ? UZERO : 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);
+        }, "multiply");
+        LongPrototype.mul = LongPrototype.multiply;
+        LongPrototype.divide = /* @__PURE__ */ __name(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;
+        }, "divide");
+        LongPrototype.div = LongPrototype.divide;
+        LongPrototype.modulo = /* @__PURE__ */ __name(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));
+        }, "modulo");
+        LongPrototype.mod = LongPrototype.modulo;
+        LongPrototype.rem = LongPrototype.modulo;
+        LongPrototype.not = /* @__PURE__ */ __name(function not() {
+          return fromBits(~this.low, ~this.high, this.unsigned);
+        }, "not");
+        LongPrototype.countLeadingZeros = /* @__PURE__ */ __name(function countLeadingZeros() {
+          return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
+        }, "countLeadingZeros");
+        LongPrototype.clz = LongPrototype.countLeadingZeros;
+        LongPrototype.countTrailingZeros = /* @__PURE__ */ __name(function countTrailingZeros() {
+          return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
+        }, "countTrailingZeros");
+        LongPrototype.ctz = LongPrototype.countTrailingZeros;
+        LongPrototype.and = /* @__PURE__ */ __name(function and(other) {
+          if (!isLong(other)) other = fromValue(other);
+          return fromBits(
+            this.low & other.low,
+            this.high & other.high,
+            this.unsigned
+          );
+        }, "and");
+        LongPrototype.or = /* @__PURE__ */ __name(function or(other) {
+          if (!isLong(other)) other = fromValue(other);
+          return fromBits(
+            this.low | other.low,
+            this.high | other.high,
+            this.unsigned
+          );
+        }, "or");
+        LongPrototype.xor = /* @__PURE__ */ __name(function xor(other) {
+          if (!isLong(other)) other = fromValue(other);
+          return fromBits(
+            this.low ^ other.low,
+            this.high ^ other.high,
+            this.unsigned
+          );
+        }, "xor");
+        LongPrototype.shiftLeft = /* @__PURE__ */ __name(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);
+        }, "shiftLeft");
+        LongPrototype.shl = LongPrototype.shiftLeft;
+        LongPrototype.shiftRight = /* @__PURE__ */ __name(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
+            );
+        }, "shiftRight");
+        LongPrototype.shr = LongPrototype.shiftRight;
+        LongPrototype.shiftRightUnsigned = /* @__PURE__ */ __name(function shiftRightUnsigned(numBits) {
+          if (isLong(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits < 32)
+            return fromBits(
+              this.low >>> numBits | this.high << 32 - numBits,
+              this.high >>> numBits,
+              this.unsigned
+            );
+          if (numBits === 32) return fromBits(this.high, 0, this.unsigned);
+          return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
+        }, "shiftRightUnsigned");
+        LongPrototype.shru = LongPrototype.shiftRightUnsigned;
+        LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
+        LongPrototype.rotateLeft = /* @__PURE__ */ __name(function rotateLeft(numBits) {
+          var b;
+          if (isLong(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
+          if (numBits < 32) {
+            b = 32 - numBits;
+            return fromBits(
+              this.low << numBits | this.high >>> b,
+              this.high << numBits | this.low >>> b,
+              this.unsigned
+            );
+          }
+          numBits -= 32;
+          b = 32 - numBits;
+          return fromBits(
+            this.high << numBits | this.low >>> b,
+            this.low << numBits | this.high >>> b,
+            this.unsigned
+          );
+        }, "rotateLeft");
+        LongPrototype.rotl = LongPrototype.rotateLeft;
+        LongPrototype.rotateRight = /* @__PURE__ */ __name(function rotateRight(numBits) {
+          var b;
+          if (isLong(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
+          if (numBits < 32) {
+            b = 32 - numBits;
+            return fromBits(
+              this.high << b | this.low >>> numBits,
+              this.low << b | this.high >>> numBits,
+              this.unsigned
+            );
+          }
+          numBits -= 32;
+          b = 32 - numBits;
+          return fromBits(
+            this.low << b | this.high >>> numBits,
+            this.high << b | this.low >>> numBits,
+            this.unsigned
+          );
+        }, "rotateRight");
+        LongPrototype.rotr = LongPrototype.rotateRight;
+        LongPrototype.toSigned = /* @__PURE__ */ __name(function toSigned() {
+          if (!this.unsigned) return this;
+          return fromBits(this.low, this.high, false);
+        }, "toSigned");
+        LongPrototype.toUnsigned = /* @__PURE__ */ __name(function toUnsigned() {
+          if (this.unsigned) return this;
+          return fromBits(this.low, this.high, true);
+        }, "toUnsigned");
+        LongPrototype.toBytes = /* @__PURE__ */ __name(function toBytes(le) {
+          return le ? this.toBytesLE() : this.toBytesBE();
+        }, "toBytes");
+        LongPrototype.toBytesLE = /* @__PURE__ */ __name(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
+          ];
+        }, "toBytesLE");
+        LongPrototype.toBytesBE = /* @__PURE__ */ __name(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
+          ];
+        }, "toBytesBE");
+        Long.fromBytes = /* @__PURE__ */ __name(function fromBytes(bytes, unsigned, le) {
+          return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
+        }, "fromBytes");
+        Long.fromBytesLE = /* @__PURE__ */ __name(function fromBytesLE(bytes, unsigned) {
+          return new Long(
+            bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
+            bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
+            unsigned
+          );
+        }, "fromBytesLE");
+        Long.fromBytesBE = /* @__PURE__ */ __name(function fromBytesBE(bytes, unsigned) {
+          return new Long(
+            bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
+            bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
+            unsigned
+          );
+        }, "fromBytesBE");
+        if (typeof BigInt === "function") {
+          Long.fromBigInt = /* @__PURE__ */ __name(function fromBigInt(value, unsigned) {
+            var lowBits = Number(BigInt.asIntN(32, value));
+            var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));
+            return fromBits(lowBits, highBits, unsigned);
+          }, "fromBigInt");
+          Long.fromValue = /* @__PURE__ */ __name(function fromValueWithBigInt(value, unsigned) {
+            if (typeof value === "bigint") return Long.fromBigInt(value, unsigned);
+            return fromValue(value, unsigned);
+          }, "fromValueWithBigInt");
+          LongPrototype.toBigInt = /* @__PURE__ */ __name(function toBigInt() {
+            var lowBigInt = BigInt(this.low >>> 0);
+            var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);
+            return highBigInt << BigInt(32) | lowBigInt;
+          }, "toBigInt");
+        }
+        var _default = _exports.default = Long;
+      }
+    );
+  }
+});
+
 // node_modules/protobufjs/src/util/minimal.js
 var require_minimal = __commonJS({
-  "node_modules/protobufjs/src/util/minimal.js"(exports2) {
+  "node_modules/protobufjs/src/util/minimal.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var util = exports2;
+    var util = exports;
     util.asPromise = require_aspromise();
     util.base64 = require_base64();
     util.EventEmitter = require_eventemitter();
@@ -650,8 +1644,13 @@ var require_minimal = __commonJS({
     util.utf8 = require_utf8();
     util.pool = require_pool();
     util.LongBits = require_longbits();
+    function isUnsafeProperty(key) {
+      return key === "__proto__" || key === "prototype" || key === "constructor";
+    }
+    __name(isUnsafeProperty, "isUnsafeProperty");
+    util.isUnsafeProperty = isUnsafeProperty;
     util.isNode = Boolean(typeof globalThis !== "undefined" && globalThis && globalThis.process && globalThis.process.versions && globalThis.process.versions.node);
-    util.global = util.isNode && globalThis || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
+    util.global = util.isNode && globalThis || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports;
     util.emptyArray = Object.freeze ? Object.freeze([]) : (
       /* istanbul ignore next */
       []
@@ -684,7 +1683,7 @@ var require_minimal = __commonJS({
     }, "isSet");
     util.Buffer = function() {
       try {
-        var Buffer = util.inquire("buffer").Buffer;
+        var Buffer = util.global.Buffer;
         return Buffer.prototype.utf8Write ? Buffer : (
           /* istanbul ignore next */
           null
@@ -702,7 +1701,14 @@ var require_minimal = __commonJS({
     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.global.Long || function() {
+      try {
+        var Long = require_umd();
+        return Long && Long.isLong ? Long : null;
+      } catch (e) {
+        return null;
+      }
+    }();
     util.key2Re = /^true|false|0|1$/;
     util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
     util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
@@ -715,14 +1721,30 @@ var require_minimal = __commonJS({
         return util.Long.fromBits(bits.lo, bits.hi, unsigned);
       return bits.toNumber(Boolean(unsigned));
     }, "longFromHash");
-    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]];
+    function merge(dst) {
+      var ifNotSet = typeof arguments[arguments.length - 1] === "boolean", limit = ifNotSet ? arguments.length - 1 : arguments.length;
+      ifNotSet = ifNotSet && arguments[arguments.length - 1];
+      for (var a = 1; a < limit; ++a) {
+        var src = arguments[a];
+        if (!src)
+          continue;
+        for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+          if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === void 0 || !ifNotSet))
+            dst[keys[i]] = src[keys[i]];
+      }
       return dst;
     }
     __name(merge, "merge");
     util.merge = merge;
+    util.nestingLimit = 32;
+    util.recursionLimit = 100;
+    util.makeProp = /* @__PURE__ */ __name(function makeProp(obj, key) {
+      Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }, "makeProp");
     util.lcFirst = /* @__PURE__ */ __name(function lcFirst(str) {
       return str.charAt(0).toLowerCase() + str.substring(1);
     }, "lcFirst");
@@ -817,10 +1839,10 @@ var require_minimal = __commonJS({
 
 // node_modules/protobufjs/src/writer.js
 var require_writer = __commonJS({
-  "node_modules/protobufjs/src/writer.js"(exports2, module2) {
+  "node_modules/protobufjs/src/writer.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = Writer;
+    module.exports = Writer;
     var util = require_minimal();
     var BufferWriter;
     var LongBits = util.LongBits;
@@ -898,22 +1920,23 @@ var require_writer = __commonJS({
       return this;
     }, "write_uint32");
     Writer.prototype.int32 = /* @__PURE__ */ __name(function write_int32(value) {
-      return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+      return (value |= 0) < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
     }, "write_int32");
     Writer.prototype.sint32 = /* @__PURE__ */ __name(function write_sint32(value) {
       return this.uint32((value << 1 ^ value >> 31) >>> 0);
     }, "write_sint32");
     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;
+      var lo = val.lo, hi = val.hi;
+      while (hi) {
+        buf[pos++] = lo & 127 | 128;
+        lo = (lo >>> 7 | hi << 25) >>> 0;
+        hi >>>= 7;
       }
-      while (val.lo > 127) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = val.lo >>> 7;
+      while (lo > 127) {
+        buf[pos++] = lo & 127 | 128;
+        lo = lo >>> 7;
       }
-      buf[pos++] = val.lo;
+      buf[pos++] = lo;
     }
     __name(writeVarint64, "writeVarint64");
     Writer.prototype.uint64 = /* @__PURE__ */ __name(function write_uint64(value) {
@@ -1018,10 +2041,10 @@ var require_writer = __commonJS({
 
 // node_modules/protobufjs/src/writer_buffer.js
 var require_writer_buffer = __commonJS({
-  "node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
+  "node_modules/protobufjs/src/writer_buffer.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = BufferWriter;
+    module.exports = BufferWriter;
     var Writer = require_writer();
     (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
     var util = require_minimal();
@@ -1071,10 +2094,10 @@ var require_writer_buffer = __commonJS({
 
 // node_modules/protobufjs/src/reader.js
 var require_reader = __commonJS({
-  "node_modules/protobufjs/src/reader.js"(exports2, module2) {
+  "node_modules/protobufjs/src/reader.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = Reader;
+    module.exports = Reader;
     var util = require_minimal();
     var BufferReader;
     var LongBits = util.LongBits;
@@ -1245,7 +2268,11 @@ var require_reader = __commonJS({
       }
       return this;
     }, "skip");
-    Reader.prototype.skipType = function(wireType) {
+    Reader.recursionLimit = util.recursionLimit;
+    Reader.prototype.skipType = function(wireType, depth) {
+      if (depth === void 0) depth = 0;
+      if (depth > Reader.recursionLimit)
+        throw Error("maximum nesting depth exceeded");
       switch (wireType) {
         case 0:
           this.skip();
@@ -1258,7 +2285,7 @@ var require_reader = __commonJS({
           break;
         case 3:
           while ((wireType = this.uint32() & 7) !== 4) {
-            this.skipType(wireType);
+            this.skipType(wireType, depth + 1);
           }
           break;
         case 5:
@@ -1301,10 +2328,10 @@ var require_reader = __commonJS({
 
 // node_modules/protobufjs/src/reader_buffer.js
 var require_reader_buffer = __commonJS({
-  "node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
+  "node_modules/protobufjs/src/reader_buffer.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = BufferReader;
+    module.exports = BufferReader;
     var Reader = require_reader();
     (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
     var util = require_minimal();
@@ -1326,10 +2353,10 @@ var require_reader_buffer = __commonJS({
 
 // node_modules/protobufjs/src/rpc/service.js
 var require_service = __commonJS({
-  "node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
+  "node_modules/protobufjs/src/rpc/service.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = Service;
+    module.exports = Service;
     var util = require_minimal();
     (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
     function Service(rpcImpl, requestDelimited, responseDelimited) {
@@ -1403,29 +2430,29 @@ var require_service = __commonJS({
 
 // node_modules/protobufjs/src/rpc.js
 var require_rpc = __commonJS({
-  "node_modules/protobufjs/src/rpc.js"(exports2) {
+  "node_modules/protobufjs/src/rpc.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var rpc = exports2;
+    var rpc = exports;
     rpc.Service = require_service();
   }
 });
 
 // node_modules/protobufjs/src/roots.js
 var require_roots = __commonJS({
-  "node_modules/protobufjs/src/roots.js"(exports2, module2) {
+  "node_modules/protobufjs/src/roots.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = {};
+    module.exports = {};
   }
 });
 
 // node_modules/protobufjs/src/index-minimal.js
 var require_index_minimal = __commonJS({
-  "node_modules/protobufjs/src/index-minimal.js"(exports2) {
+  "node_modules/protobufjs/src/index-minimal.js"(exports) {
     "use strict";
     init_esbuild_shims();
-    var protobuf = exports2;
+    var protobuf = exports;
     protobuf.build = "minimal";
     protobuf.Writer = require_writer();
     protobuf.BufferWriter = require_writer_buffer();
@@ -1447,16 +2474,16 @@ var require_index_minimal = __commonJS({
 
 // node_modules/protobufjs/minimal.js
 var require_minimal2 = __commonJS({
-  "node_modules/protobufjs/minimal.js"(exports2, module2) {
+  "node_modules/protobufjs/minimal.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    module2.exports = require_index_minimal();
+    module.exports = require_index_minimal();
   }
 });
 
 export {
   require_aspromise,
-  require_inquire,
+  require_umd,
   require_minimal,
   require_writer,
   require_reader,
@@ -1465,3 +2492,26 @@ export {
   require_index_minimal,
   require_minimal2
 };
+/*! Bundled license information:
+
+long/umd/index.js:
+  (**
+   * @license
+   * Copyright 2009 The Closure Library Authors
+   * Copyright 2020 Daniel Wirtz / The long.js Authors.
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *     http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   *
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/