@streamlayer/sdk-web-anonymous-auth 1.1.45 → 1.1.47

package/lib/cjs/index.js

@@ -3,15 +3,12 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("@streamlayer/sl-eslib/interactive/interactive.common_pb");
-require("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb");
-const sdkSettings_common_pb = require("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb");
-require("@streamlayer/sl-eslib/analytics/v1/invitations/invitations_pb");
-require("@streamlayer/sl-eslib/sports/events/events_pb");
-require("@streamlayer/sl-eslib/sdkSettings/client/client_pb");
-const users_pb = require("@streamlayer/sl-eslib/users/users_pb");
 const jose = require("jose");
-var process = {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var browser$1 = { exports: {} };
+var process = browser$1.exports = {};
 var cachedSetTimeout;
 var cachedClearTimeout;
 function defaultSetTimout() {
@@ -167,6 +164,8 @@ process.chdir = function(dir) {
 process.umask = function() {
   return 0;
 };
+var browserExports = browser$1.exports;
+const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
 var browser = { exports: {} };
 function tryStringify(o) {
   try {
@@ -699,24 +698,2768 @@ const logger = pino_1({
 });
 const createLogger = (name, options) => logger.child({ name }, options);
 createLogger("event-bus");
-var NotificationType;
-(function(NotificationType2) {
-  NotificationType2[NotificationType2["ONBOARDING"] = 1] = "ONBOARDING";
-  NotificationType2[NotificationType2["QUESTION"] = 2] = "QUESTION";
-  NotificationType2[NotificationType2["QUESTION_RESOLVED"] = 3] = "QUESTION_RESOLVED";
-})(NotificationType || (NotificationType = {}));
-window.slStore = /* @__PURE__ */ Object.create(null);
-var FeatureSource;
-(function(FeatureSource2) {
-  FeatureSource2["ORGANIZATION"] = "ORGANIZATION";
-  FeatureSource2["STREAM"] = "STREAM";
-})(FeatureSource || (FeatureSource = {}));
-({
-  [sdkSettings_common_pb.SdkOverlayType.BETTING]: "betting",
-  [sdkSettings_common_pb.SdkOverlayType.GAMES]: "games",
-  [sdkSettings_common_pb.SdkOverlayType.PUBLIC_CHAT]: "publicChat",
-  [sdkSettings_common_pb.SdkOverlayType.TWITTER]: "twitter"
-});
+function protoCamelCase(snakeCase) {
+  let capNext = false;
+  const b = [];
+  for (let i = 0; i < snakeCase.length; i++) {
+    let c = snakeCase.charAt(i);
+    switch (c) {
+      case "_":
+        capNext = true;
+        break;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        b.push(c);
+        capNext = false;
+        break;
+      default:
+        if (capNext) {
+          capNext = false;
+          c = c.toUpperCase();
+        }
+        b.push(c);
+        break;
+    }
+  }
+  return b.join("");
+}
+const reservedObjectProperties = /* @__PURE__ */ new Set([
+  // names reserved by JavaScript
+  "constructor",
+  "toString",
+  "toJSON",
+  "valueOf"
+]);
+function safeObjectProperty(name) {
+  return reservedObjectProperties.has(name) ? name + "$" : name;
+}
+function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  lowBits |= (middleByte & 15) << 28;
+  highBits = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+const TWO_PWR_32_DBL = 4294967296;
+function int64FromString(dec) {
+  const minus = dec[0] === "-";
+  if (minus) {
+    dec = dec.slice(1);
+  }
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+function int64ToString(lo, hi) {
+  let bits = newBits(lo, hi);
+  const negative = bits.hi & 2147483648;
+  if (negative) {
+    bits = negate(bits.lo, bits.hi);
+  }
+  const result = uInt64ToString(bits.lo, bits.hi);
+  return negative ? "-" + result : result;
+}
+function uInt64ToString(lo, hi) {
+  ({ lo, hi } = toUnsigned(lo, hi));
+  if (hi <= 2097151) {
+    return String(TWO_PWR_32_DBL * hi + lo);
+  }
+  const low = lo & 16777215;
+  const mid = (lo >>> 24 | hi << 8) & 16777215;
+  const high = hi >> 16 & 65535;
+  let digitA = low + mid * 6777216 + high * 6710656;
+  let digitB = mid + high * 8147497;
+  let digitC = high * 2;
+  const base = 1e7;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    digitC += Math.floor(digitB / base);
+    digitB %= base;
+  }
+  return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+  return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+  return { lo: lo | 0, hi: hi | 0 };
+}
+function negate(lowBits, highBits) {
+  highBits = ~highBits;
+  if (lowBits) {
+    lowBits = ~lowBits + 1;
+  } else {
+    highBits += 1;
+  }
+  return newBits(lowBits, highBits);
+}
+const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+  const partial = String(digit1e7);
+  return "0000000".slice(partial.length) + partial;
+};
+function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 127;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) != 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
+const protoInt64 = /* @__PURE__ */ makeInt64Support();
+function makeInt64Support() {
+  const dv = new DataView(new ArrayBuffer(8));
+  const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (typeof process$1 != "object" || typeof process$1.env != "object" || process$1.env.BUF_BIGINT_DISABLE !== "1");
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
+    return {
+      zero: BigInt(0),
+      supported: true,
+      parse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > MAX || bi < MIN) {
+          throw new Error(`invalid int64: ${value}`);
+        }
+        return bi;
+      },
+      uParse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > UMAX || bi < UMIN) {
+          throw new Error(`invalid uint64: ${value}`);
+        }
+        return bi;
+      },
+      enc(value) {
+        dv.setBigInt64(0, this.parse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      uEnc(value) {
+        dv.setBigInt64(0, this.uParse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      dec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigInt64(0, true);
+      },
+      uDec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigUint64(0, true);
+      }
+    };
+  }
+  return {
+    zero: "0",
+    supported: false,
+    parse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return value;
+    },
+    uParse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return value;
+    },
+    enc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return int64FromString(value);
+    },
+    uEnc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return int64FromString(value);
+    },
+    dec(lo, hi) {
+      return int64ToString(lo, hi);
+    },
+    uDec(lo, hi) {
+      return uInt64ToString(lo, hi);
+    }
+  };
+}
+function assertInt64String(value) {
+  if (!/^-?[0-9]+$/.test(value)) {
+    throw new Error("invalid int64: " + value);
+  }
+}
+function assertUInt64String(value) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new Error("invalid uint64: " + value);
+  }
+}
+var ScalarType;
+(function(ScalarType2) {
+  ScalarType2[ScalarType2["DOUBLE"] = 1] = "DOUBLE";
+  ScalarType2[ScalarType2["FLOAT"] = 2] = "FLOAT";
+  ScalarType2[ScalarType2["INT64"] = 3] = "INT64";
+  ScalarType2[ScalarType2["UINT64"] = 4] = "UINT64";
+  ScalarType2[ScalarType2["INT32"] = 5] = "INT32";
+  ScalarType2[ScalarType2["FIXED64"] = 6] = "FIXED64";
+  ScalarType2[ScalarType2["FIXED32"] = 7] = "FIXED32";
+  ScalarType2[ScalarType2["BOOL"] = 8] = "BOOL";
+  ScalarType2[ScalarType2["STRING"] = 9] = "STRING";
+  ScalarType2[ScalarType2["BYTES"] = 12] = "BYTES";
+  ScalarType2[ScalarType2["UINT32"] = 13] = "UINT32";
+  ScalarType2[ScalarType2["SFIXED32"] = 15] = "SFIXED32";
+  ScalarType2[ScalarType2["SFIXED64"] = 16] = "SFIXED64";
+  ScalarType2[ScalarType2["SINT32"] = 17] = "SINT32";
+  ScalarType2[ScalarType2["SINT64"] = 18] = "SINT64";
+})(ScalarType || (ScalarType = {}));
+function scalarZeroValue(type, longAsString) {
+  switch (type) {
+    case ScalarType.STRING:
+      return "";
+    case ScalarType.BOOL:
+      return false;
+    default:
+      return 0;
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      return 0;
+    case ScalarType.INT64:
+    case ScalarType.UINT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.FIXED64:
+    case ScalarType.SINT64:
+      return longAsString ? "0" : protoInt64.zero;
+    case ScalarType.BYTES:
+      return new Uint8Array(0);
+  }
+}
+function isScalarZeroValue(type, value) {
+  switch (type) {
+    case ScalarType.BOOL:
+      return value === false;
+    case ScalarType.STRING:
+      return value === "";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array && !value.byteLength;
+    default:
+      return value == 0;
+  }
+}
+const IMPLICIT$2 = 2;
+const unsafeLocal = Symbol.for("reflect unsafe local");
+function unsafeOneofCase(target, oneof) {
+  const c = target[oneof.localName].case;
+  if (c === void 0) {
+    return c;
+  }
+  return oneof.fields.find((f) => f.localName === c);
+}
+function unsafeIsSet(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    return target[field.oneof.localName].case === name;
+  }
+  if (field.presence != IMPLICIT$2) {
+    return target[name] !== void 0 && Object.prototype.hasOwnProperty.call(target, name);
+  }
+  switch (field.fieldKind) {
+    case "list":
+      return target[name].length > 0;
+    case "map":
+      return Object.keys(target[name]).length > 0;
+    case "scalar":
+      return !isScalarZeroValue(field.scalar, target[name]);
+    case "enum":
+      return target[name] !== field.enum.values[0].number;
+  }
+  throw new Error("message field with implicit presence");
+}
+function unsafeIsSetExplicit(target, localName) {
+  return Object.prototype.hasOwnProperty.call(target, localName) && target[localName] !== void 0;
+}
+function unsafeGet(target, field) {
+  if (field.oneof) {
+    const oneof = target[field.oneof.localName];
+    if (oneof.case === field.localName) {
+      return oneof.value;
+    }
+    return void 0;
+  }
+  return target[field.localName];
+}
+function unsafeSet(target, field, value) {
+  if (field.oneof) {
+    target[field.oneof.localName] = {
+      case: field.localName,
+      value
+    };
+  } else {
+    target[field.localName] = value;
+  }
+}
+function unsafeClear(target, field) {
+  const name = field.localName;
+  if (field.oneof) {
+    const oneofLocalName = field.oneof.localName;
+    if (target[oneofLocalName].case === name) {
+      target[oneofLocalName] = { case: void 0 };
+    }
+  } else if (field.presence != IMPLICIT$2) {
+    delete target[name];
+  } else {
+    switch (field.fieldKind) {
+      case "map":
+        target[name] = {};
+        break;
+      case "list":
+        target[name] = [];
+        break;
+      case "enum":
+        target[name] = field.enum.values[0].number;
+        break;
+      case "scalar":
+        target[name] = scalarZeroValue(field.scalar, field.longAsString);
+        break;
+    }
+  }
+}
+function restoreJsonNames(message) {
+  for (const f of message.field) {
+    if (!unsafeIsSetExplicit(f, "jsonName")) {
+      f.jsonName = protoCamelCase(f.name);
+    }
+  }
+  message.nestedType.forEach(restoreJsonNames);
+}
+function parseTextFormatEnumValue(descEnum, value) {
+  const enumValue = descEnum.values.find((v) => v.name === value);
+  if (!enumValue) {
+    throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+  }
+  return enumValue.number;
+}
+function parseTextFormatScalarValue(type, value) {
+  switch (type) {
+    case ScalarType.STRING:
+      return value;
+    case ScalarType.BYTES: {
+      const u = unescapeBytesDefaultValue(value);
+      if (u === false) {
+        throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`);
+      }
+      return u;
+    }
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      return protoInt64.parse(value);
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return protoInt64.uParse(value);
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      switch (value) {
+        case "inf":
+          return Number.POSITIVE_INFINITY;
+        case "-inf":
+          return Number.NEGATIVE_INFINITY;
+        case "nan":
+          return Number.NaN;
+        default:
+          return parseFloat(value);
+      }
+    case ScalarType.BOOL:
+      return value === "true";
+    case ScalarType.INT32:
+    case ScalarType.UINT32:
+    case ScalarType.SINT32:
+    case ScalarType.FIXED32:
+    case ScalarType.SFIXED32:
+      return parseInt(value, 10);
+  }
+}
+function unescapeBytesDefaultValue(str) {
+  const b = [];
+  const input = {
+    tail: str,
+    c: "",
+    next() {
+      if (this.tail.length == 0) {
+        return false;
+      }
+      this.c = this.tail[0];
+      this.tail = this.tail.substring(1);
+      return true;
+    },
+    take(n) {
+      if (this.tail.length >= n) {
+        const r = this.tail.substring(0, n);
+        this.tail = this.tail.substring(n);
+        return r;
+      }
+      return false;
+    }
+  };
+  while (input.next()) {
+    switch (input.c) {
+      case "\\":
+        if (input.next()) {
+          switch (input.c) {
+            case "\\":
+              b.push(input.c.charCodeAt(0));
+              break;
+            case "b":
+              b.push(8);
+              break;
+            case "f":
+              b.push(12);
+              break;
+            case "n":
+              b.push(10);
+              break;
+            case "r":
+              b.push(13);
+              break;
+            case "t":
+              b.push(9);
+              break;
+            case "v":
+              b.push(11);
+              break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 8);
+              if (isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "x": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "u": {
+              const s = input.c;
+              const t = input.take(4);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (isNaN(n)) {
+                return false;
+              }
+              const chunk = new Uint8Array(4);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, n, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+              break;
+            }
+            case "U": {
+              const s = input.c;
+              const t = input.take(8);
+              if (t === false) {
+                return false;
+              }
+              const tc = protoInt64.uEnc(s + t);
+              const chunk = new Uint8Array(8);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, tc.lo, true);
+              view.setInt32(4, tc.hi, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+              break;
+            }
+          }
+        }
+        break;
+      default:
+        b.push(input.c.charCodeAt(0));
+    }
+  }
+  return new Uint8Array(b);
+}
+function* nestedTypes(desc) {
+  switch (desc.kind) {
+    case "file":
+      for (const message of desc.messages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.enums;
+      yield* desc.services;
+      yield* desc.extensions;
+      break;
+    case "message":
+      for (const message of desc.nestedMessages) {
+        yield message;
+        yield* nestedTypes(message);
+      }
+      yield* desc.nestedEnums;
+      yield* desc.nestedExtensions;
+      break;
+  }
+}
+function createFileRegistry(...args) {
+  const registry = createBaseRegistry();
+  if (!args.length) {
+    return registry;
+  }
+  if ("$typeName" in args[0] && args[0].$typeName == "google.protobuf.FileDescriptorSet") {
+    for (const file of args[0].file) {
+      addFile(file, registry);
+    }
+    return registry;
+  }
+  if ("$typeName" in args[0]) {
+    let recurseDeps = function(file) {
+      const deps = [];
+      for (const protoFileName of file.dependency) {
+        if (registry.getFile(protoFileName) != void 0) {
+          continue;
+        }
+        if (seen.has(protoFileName)) {
+          continue;
+        }
+        const dep = resolve(protoFileName);
+        if (!dep) {
+          throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
+        }
+        if ("kind" in dep) {
+          registry.addFile(dep, false, true);
+        } else {
+          seen.add(dep.name);
+          deps.push(dep);
+        }
+      }
+      return deps.concat(...deps.map(recurseDeps));
+    };
+    const input = args[0];
+    const resolve = args[1];
+    const seen = /* @__PURE__ */ new Set();
+    for (const file of [input, ...recurseDeps(input)].reverse()) {
+      addFile(file, registry);
+    }
+  } else {
+    for (const fileReg of args) {
+      for (const file of fileReg.files) {
+        registry.addFile(file);
+      }
+    }
+  }
+  return registry;
+}
+function createBaseRegistry() {
+  const types = /* @__PURE__ */ new Map();
+  const extendees = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  return {
+    kind: "registry",
+    types,
+    extendees,
+    [Symbol.iterator]() {
+      return types.values();
+    },
+    get files() {
+      return files.values();
+    },
+    addFile(file, skipTypes, withDeps) {
+      files.set(file.proto.name, file);
+      if (!skipTypes) {
+        for (const type of nestedTypes(file)) {
+          this.add(type);
+        }
+      }
+      if (withDeps) {
+        for (const f of file.dependencies) {
+          this.addFile(f, skipTypes, withDeps);
+        }
+      }
+    },
+    add(desc) {
+      if (desc.kind == "extension") {
+        let numberToExt = extendees.get(desc.extendee.typeName);
+        if (!numberToExt) {
+          extendees.set(desc.extendee.typeName, numberToExt = /* @__PURE__ */ new Map());
+        }
+        numberToExt.set(desc.number, desc);
+      }
+      types.set(desc.typeName, desc);
+    },
+    get(typeName) {
+      return types.get(typeName);
+    },
+    getFile(fileName) {
+      return files.get(fileName);
+    },
+    getMessage(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : void 0;
+    },
+    getEnum(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : void 0;
+    },
+    getExtension(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : void 0;
+    },
+    getExtensionFor(extendee, no) {
+      var _a;
+      return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no);
+    },
+    getService(typeName) {
+      const t = types.get(typeName);
+      return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : void 0;
+    }
+  };
+}
+const EDITION_PROTO2$1 = 998;
+const EDITION_PROTO3$1 = 999;
+const TYPE_STRING = 9;
+const TYPE_GROUP = 10;
+const TYPE_MESSAGE = 11;
+const TYPE_BYTES = 12;
+const TYPE_ENUM = 14;
+const LABEL_REPEATED = 3;
+const LABEL_REQUIRED = 2;
+const JS_STRING = 1;
+const IDEMPOTENCY_UNKNOWN = 0;
+const EXPLICIT = 1;
+const IMPLICIT$1 = 2;
+const LEGACY_REQUIRED = 3;
+const PACKED = 1;
+const DELIMITED = 2;
+const OPEN = 1;
+const featureDefaults = {
+  // EDITION_PROTO2
+  998: {
+    fieldPresence: 1,
+    // EXPLICIT,
+    enumType: 2,
+    // CLOSED,
+    repeatedFieldEncoding: 2,
+    // EXPANDED,
+    utf8Validation: 3,
+    // NONE,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 2,
+    // LEGACY_BEST_EFFORT,
+    enforceNamingStyle: 2
+    // STYLE_LEGACY,
+  },
+  // EDITION_PROTO3
+  999: {
+    fieldPresence: 2,
+    // IMPLICIT,
+    enumType: 1,
+    // OPEN,
+    repeatedFieldEncoding: 1,
+    // PACKED,
+    utf8Validation: 2,
+    // VERIFY,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 1,
+    // ALLOW,
+    enforceNamingStyle: 2
+    // STYLE_LEGACY,
+  },
+  // EDITION_2023
+  1e3: {
+    fieldPresence: 1,
+    // EXPLICIT,
+    enumType: 1,
+    // OPEN,
+    repeatedFieldEncoding: 1,
+    // PACKED,
+    utf8Validation: 2,
+    // VERIFY,
+    messageEncoding: 1,
+    // LENGTH_PREFIXED,
+    jsonFormat: 1,
+    // ALLOW,
+    enforceNamingStyle: 2
+    // STYLE_LEGACY,
+  }
+};
+function addFile(proto, reg) {
+  var _a, _b;
+  const file = {
+    kind: "file",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    edition: getFileEdition(proto),
+    name: proto.name.replace(/\.proto$/, ""),
+    dependencies: findFileDependencies(proto, reg),
+    enums: [],
+    messages: [],
+    extensions: [],
+    services: [],
+    toString() {
+      return `file ${proto.name}`;
+    }
+  };
+  const mapEntriesStore = /* @__PURE__ */ new Map();
+  const mapEntries = {
+    get(typeName) {
+      return mapEntriesStore.get(typeName);
+    },
+    add(desc) {
+      var _a2;
+      assert(((_a2 = desc.proto.options) === null || _a2 === void 0 ? void 0 : _a2.mapEntry) === true);
+      mapEntriesStore.set(desc.typeName, desc);
+    }
+  };
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, void 0, reg);
+  }
+  for (const messageProto of proto.messageType) {
+    addMessage(messageProto, file, void 0, reg, mapEntries);
+  }
+  for (const serviceProto of proto.service) {
+    addService(serviceProto, file, reg);
+  }
+  addExtensions(file, reg);
+  for (const mapEntry of mapEntriesStore.values()) {
+    addFields(mapEntry, reg, mapEntries);
+  }
+  for (const message of file.messages) {
+    addFields(message, reg, mapEntries);
+    addExtensions(message, reg);
+  }
+  reg.addFile(file, true);
+}
+function addExtensions(desc, reg) {
+  switch (desc.kind) {
+    case "file":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.extensions.push(ext);
+        reg.add(ext);
+      }
+      break;
+    case "message":
+      for (const proto of desc.proto.extension) {
+        const ext = newField(proto, desc, reg);
+        desc.nestedExtensions.push(ext);
+        reg.add(ext);
+      }
+      for (const message of desc.nestedMessages) {
+        addExtensions(message, reg);
+      }
+      break;
+  }
+}
+function addFields(message, reg, mapEntries) {
+  const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+  const oneofsSeen = /* @__PURE__ */ new Set();
+  for (const proto of message.proto.field) {
+    const oneof = findOneof(proto, allOneofs);
+    const field = newField(proto, message, reg, oneof, mapEntries);
+    message.fields.push(field);
+    message.field[field.localName] = field;
+    if (oneof === void 0) {
+      message.members.push(field);
+    } else {
+      oneof.fields.push(field);
+      if (!oneofsSeen.has(oneof)) {
+        oneofsSeen.add(oneof);
+        message.members.push(oneof);
+      }
+    }
+  }
+  for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) {
+    message.oneofs.push(oneof);
+  }
+  for (const child of message.nestedMessages) {
+    addFields(child, reg, mapEntries);
+  }
+}
+function addEnum(proto, file, parent, reg) {
+  var _a, _b, _c;
+  const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value);
+  const desc = {
+    kind: "enum",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    parent,
+    open: true,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    value: {},
+    values: [],
+    sharedPrefix,
+    toString() {
+      return `enum ${this.typeName}`;
+    }
+  };
+  desc.open = isEnumOpen(desc);
+  reg.add(desc);
+  proto.value.forEach((proto2) => {
+    var _a2, _b2;
+    const name = proto2.name;
+    desc.values.push(desc.value[proto2.number] = {
+      kind: "enum_value",
+      proto: proto2,
+      deprecated: (_b2 = (_a2 = proto2.options) === null || _a2 === void 0 ? void 0 : _a2.deprecated) !== null && _b2 !== void 0 ? _b2 : false,
+      parent: desc,
+      name,
+      localName: safeObjectProperty(sharedPrefix == void 0 ? name : name.substring(sharedPrefix.length)),
+      number: proto2.number,
+      toString() {
+        return `enum value ${desc.typeName}.${name}`;
+      }
+    });
+  });
+  ((_c = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _c !== void 0 ? _c : file.enums).push(desc);
+}
+function addMessage(proto, file, parent, reg, mapEntries) {
+  var _a, _b, _c, _d;
+  const desc = {
+    kind: "message",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    parent,
+    name: proto.name,
+    typeName: makeTypeName(proto, parent, file),
+    fields: [],
+    field: {},
+    oneofs: [],
+    members: [],
+    nestedEnums: [],
+    nestedMessages: [],
+    nestedExtensions: [],
+    toString() {
+      return `message ${this.typeName}`;
+    }
+  };
+  if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
+    mapEntries.add(desc);
+  } else {
+    ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc);
+    reg.add(desc);
+  }
+  for (const enumProto of proto.enumType) {
+    addEnum(enumProto, file, desc, reg);
+  }
+  for (const messageProto of proto.nestedType) {
+    addMessage(messageProto, file, desc, reg, mapEntries);
+  }
+}
+function addService(proto, file, reg) {
+  var _a, _b;
+  const desc = {
+    kind: "service",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    file,
+    name: proto.name,
+    typeName: makeTypeName(proto, void 0, file),
+    methods: [],
+    method: {},
+    toString() {
+      return `service ${this.typeName}`;
+    }
+  };
+  file.services.push(desc);
+  reg.add(desc);
+  for (const methodProto of proto.method) {
+    const method = newMethod(methodProto, desc, reg);
+    desc.methods.push(method);
+    desc.method[method.localName] = method;
+  }
+}
+function newMethod(proto, parent, reg) {
+  var _a, _b, _c, _d;
+  let methodKind;
+  if (proto.clientStreaming && proto.serverStreaming) {
+    methodKind = "bidi_streaming";
+  } else if (proto.clientStreaming) {
+    methodKind = "client_streaming";
+  } else if (proto.serverStreaming) {
+    methodKind = "server_streaming";
+  } else {
+    methodKind = "unary";
+  }
+  const input = reg.getMessage(trimLeadingDot(proto.inputType));
+  const output = reg.getMessage(trimLeadingDot(proto.outputType));
+  assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+  assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
+  const name = proto.name;
+  return {
+    kind: "rpc",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    parent,
+    name,
+    localName: safeObjectProperty(name.length ? safeObjectProperty(name[0].toLowerCase() + name.substring(1)) : name),
+    methodKind,
+    input,
+    output,
+    idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN,
+    toString() {
+      return `rpc ${parent.typeName}.${name}`;
+    }
+  };
+}
+function newOneof(proto, parent) {
+  return {
+    kind: "oneof",
+    proto,
+    deprecated: false,
+    parent,
+    fields: [],
+    name: proto.name,
+    localName: safeObjectProperty(protoCamelCase(proto.name)),
+    toString() {
+      return `oneof ${parent.typeName}.${this.name}`;
+    }
+  };
+}
+function newField(proto, parentOrFile, reg, oneof, mapEntries) {
+  var _a, _b, _c;
+  const isExtension = mapEntries === void 0;
+  const field = {
+    kind: "field",
+    proto,
+    deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+    name: proto.name,
+    number: proto.number,
+    scalar: void 0,
+    message: void 0,
+    enum: void 0,
+    presence: getFieldPresence(proto, oneof, isExtension, parentOrFile),
+    listKind: void 0,
+    mapKind: void 0,
+    mapKey: void 0,
+    delimitedEncoding: void 0,
+    packed: void 0,
+    longAsString: false,
+    getDefaultValue: void 0
+  };
+  if (isExtension) {
+    const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
+    const parent = parentOrFile.kind == "file" ? void 0 : parentOrFile;
+    const typeName = makeTypeName(proto, parent, file);
+    field.kind = "extension";
+    field.file = file;
+    field.parent = parent;
+    field.oneof = void 0;
+    field.typeName = typeName;
+    field.jsonName = `[${typeName}]`;
+    field.toString = () => `extension ${typeName}`;
+    const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
+    assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+    field.extendee = extendee;
+  } else {
+    const parent = parentOrFile;
+    assert(parent.kind == "message");
+    field.parent = parent;
+    field.oneof = oneof;
+    field.localName = oneof ? protoCamelCase(proto.name) : safeObjectProperty(protoCamelCase(proto.name));
+    field.jsonName = proto.jsonName;
+    field.toString = () => `field ${parent.typeName}.${proto.name}`;
+  }
+  const label = proto.label;
+  const type = proto.type;
+  const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;
+  if (label === LABEL_REPEATED) {
+    const mapEntry = type == TYPE_MESSAGE ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName)) : void 0;
+    if (mapEntry) {
+      field.fieldKind = "map";
+      const { key, value } = findMapEntryFields(mapEntry);
+      field.mapKey = key.scalar;
+      field.mapKind = value.fieldKind;
+      field.message = value.message;
+      field.delimitedEncoding = false;
+      field.enum = value.enum;
+      field.scalar = value.scalar;
+      return field;
+    }
+    field.fieldKind = "list";
+    switch (type) {
+      case TYPE_MESSAGE:
+      case TYPE_GROUP:
+        field.listKind = "message";
+        field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+        assert(field.message);
+        field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+        break;
+      case TYPE_ENUM:
+        field.listKind = "enum";
+        field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+        assert(field.enum);
+        break;
+      default:
+        field.listKind = "scalar";
+        field.scalar = type;
+        field.longAsString = jstype == JS_STRING;
+        break;
+    }
+    field.packed = isPackedField(proto, parentOrFile);
+    return field;
+  }
+  switch (type) {
+    case TYPE_MESSAGE:
+    case TYPE_GROUP:
+      field.fieldKind = "message";
+      field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+      assert(
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        field.message,
+        `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`
+      );
+      field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+      field.getDefaultValue = () => void 0;
+      break;
+    case TYPE_ENUM: {
+      const enumeration = reg.getEnum(trimLeadingDot(proto.typeName));
+      assert(enumeration !== void 0, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+      field.fieldKind = "enum";
+      field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatEnumValue(enumeration, proto.defaultValue) : void 0;
+      };
+      break;
+    }
+    default: {
+      field.fieldKind = "scalar";
+      field.scalar = type;
+      field.longAsString = jstype == JS_STRING;
+      field.getDefaultValue = () => {
+        return unsafeIsSetExplicit(proto, "defaultValue") ? parseTextFormatScalarValue(type, proto.defaultValue) : void 0;
+      };
+      break;
+    }
+  }
+  return field;
+}
+function getFileEdition(proto) {
+  switch (proto.syntax) {
+    case "":
+    case "proto2":
+      return EDITION_PROTO2$1;
+    case "proto3":
+      return EDITION_PROTO3$1;
+    case "editions":
+      if (proto.edition in featureDefaults) {
+        return proto.edition;
+      }
+      throw new Error(`${proto.name}: unsupported edition`);
+    default:
+      throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`);
+  }
+}
+function findFileDependencies(proto, reg) {
+  return proto.dependency.map((wantName) => {
+    const dep = reg.getFile(wantName);
+    if (!dep) {
+      throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`);
+    }
+    return dep;
+  });
+}
+function findEnumSharedPrefix(enumName, values) {
+  const prefix = camelToSnakeCase(enumName) + "_";
+  for (const value of values) {
+    if (!value.name.toLowerCase().startsWith(prefix)) {
+      return void 0;
+    }
+    const shortName = value.name.substring(prefix.length);
+    if (shortName.length == 0) {
+      return void 0;
+    }
+    if (/^\d/.test(shortName)) {
+      return void 0;
+    }
+  }
+  return prefix;
+}
+function camelToSnakeCase(camel) {
+  return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+function makeTypeName(proto, parent, file) {
+  let typeName;
+  if (parent) {
+    typeName = `${parent.typeName}.${proto.name}`;
+  } else if (file.proto.package.length > 0) {
+    typeName = `${file.proto.package}.${proto.name}`;
+  } else {
+    typeName = `${proto.name}`;
+  }
+  return typeName;
+}
+function trimLeadingDot(typeName) {
+  return typeName.startsWith(".") ? typeName.substring(1) : typeName;
+}
+function findOneof(proto, allOneofs) {
+  if (!unsafeIsSetExplicit(proto, "oneofIndex")) {
+    return void 0;
+  }
+  if (proto.proto3Optional) {
+    return void 0;
+  }
+  const oneof = allOneofs[proto.oneofIndex];
+  assert(
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    oneof,
+    `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`
+  );
+  return oneof;
+}
+function getFieldPresence(proto, oneof, isExtension, parent) {
+  if (proto.label == LABEL_REQUIRED) {
+    return LEGACY_REQUIRED;
+  }
+  if (proto.label == LABEL_REPEATED) {
+    return IMPLICIT$1;
+  }
+  if (!!oneof || proto.proto3Optional) {
+    return EXPLICIT;
+  }
+  if (proto.type == TYPE_MESSAGE) {
+    return EXPLICIT;
+  }
+  if (isExtension) {
+    return EXPLICIT;
+  }
+  return resolveFeature("fieldPresence", { proto, parent });
+}
+function isPackedField(proto, parent) {
+  if (proto.label != LABEL_REPEATED) {
+    return false;
+  }
+  switch (proto.type) {
+    case TYPE_STRING:
+    case TYPE_BYTES:
+    case TYPE_GROUP:
+    case TYPE_MESSAGE:
+      return false;
+  }
+  const o = proto.options;
+  if (o && unsafeIsSetExplicit(o, "packed")) {
+    return o.packed;
+  }
+  return PACKED == resolveFeature("repeatedFieldEncoding", {
+    proto,
+    parent
+  });
+}
+function findMapEntryFields(mapEntry) {
+  const key = mapEntry.fields.find((f) => f.number === 1);
+  const value = mapEntry.fields.find((f) => f.number === 2);
+  assert(key && key.fieldKind == "scalar" && key.scalar != ScalarType.BYTES && key.scalar != ScalarType.FLOAT && key.scalar != ScalarType.DOUBLE && value && value.fieldKind != "list" && value.fieldKind != "map");
+  return { key, value };
+}
+function isEnumOpen(desc) {
+  var _a;
+  return OPEN == resolveFeature("enumType", {
+    proto: desc.proto,
+    parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file
+  });
+}
+function isDelimitedEncoding(proto, parent) {
+  if (proto.type == TYPE_GROUP) {
+    return true;
+  }
+  return DELIMITED == resolveFeature("messageEncoding", {
+    proto,
+    parent
+  });
+}
+function resolveFeature(name, ref) {
+  var _a, _b;
+  const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features;
+  if (featureSet) {
+    const val = featureSet[name];
+    if (val != 0) {
+      return val;
+    }
+  }
+  if ("kind" in ref) {
+    if (ref.kind == "message") {
+      return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file);
+    }
+    const editionDefaults = featureDefaults[ref.edition];
+    if (!editionDefaults) {
+      throw new Error(`feature default for edition ${ref.edition} not found`);
+    }
+    return editionDefaults[name];
+  }
+  return resolveFeature(name, ref.parent);
+}
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+function boot(boot2) {
+  const root = bootFileDescriptorProto(boot2);
+  root.messageType.forEach(restoreJsonNames);
+  const reg = createFileRegistry(root, () => void 0);
+  return reg.getFile(root.name);
+}
+function bootFileDescriptorProto(init) {
+  const proto = /* @__PURE__ */ Object.create({
+    syntax: "",
+    edition: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) }));
+}
+function bootDescriptorProto(init) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  return {
+    $typeName: "google.protobuf.DescriptorProto",
+    name: init.name,
+    field: (_b = (_a = init.field) === null || _a === void 0 ? void 0 : _a.map(bootFieldDescriptorProto)) !== null && _b !== void 0 ? _b : [],
+    extension: [],
+    nestedType: (_d = (_c = init.nestedType) === null || _c === void 0 ? void 0 : _c.map(bootDescriptorProto)) !== null && _d !== void 0 ? _d : [],
+    enumType: (_f = (_e = init.enumType) === null || _e === void 0 ? void 0 : _e.map(bootEnumDescriptorProto)) !== null && _f !== void 0 ? _f : [],
+    extensionRange: (_h = (_g = init.extensionRange) === null || _g === void 0 ? void 0 : _g.map((e) => Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e))) !== null && _h !== void 0 ? _h : [],
+    oneofDecl: [],
+    reservedRange: [],
+    reservedName: []
+  };
+}
+function bootFieldDescriptorProto(init) {
+  const proto = /* @__PURE__ */ Object.create({
+    label: 1,
+    typeName: "",
+    extendee: "",
+    defaultValue: "",
+    oneofIndex: 0,
+    jsonName: "",
+    proto3Optional: false
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : void 0 }));
+}
+function bootFieldOptions(init) {
+  var _a, _b, _c;
+  const proto = /* @__PURE__ */ Object.create({
+    ctype: 0,
+    packed: false,
+    jstype: 0,
+    lazy: false,
+    unverifiedLazy: false,
+    deprecated: false,
+    weak: false,
+    debugRedact: false,
+    retention: 0
+  });
+  return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== void 0 ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === void 0 ? void 0 : _b.map((e) => Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e))) !== null && _c !== void 0 ? _c : [], uninterpretedOption: [] }));
+}
+function bootEnumDescriptorProto(init) {
+  return {
+    $typeName: "google.protobuf.EnumDescriptorProto",
+    name: init.name,
+    reservedName: [],
+    reservedRange: [],
+    value: init.value.map((e) => Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))
+  };
+}
+function base64Decode(base64Str) {
+  const table = getDecodeTable();
+  let es = base64Str.length * 3 / 4;
+  if (base64Str[base64Str.length - 2] == "=")
+    es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=")
+    es -= 1;
+  let bytes = new Uint8Array(es), bytePos = 0, groupPos = 0, b, p = 0;
+  for (let i = 0; i < base64Str.length; i++) {
+    b = table[base64Str.charCodeAt(i)];
+    if (b === void 0) {
+      switch (base64Str[i]) {
+        case "=":
+          groupPos = 0;
+        case "\n":
+        case "\r":
+        case "	":
+        case " ":
+          continue;
+        default:
+          throw Error("invalid base64 string");
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = p << 2 | (b & 48) >> 4;
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2;
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = (p & 3) << 6 | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1)
+    throw Error("invalid base64 string");
+  return bytes.subarray(0, bytePos);
+}
+let encodeTableStd;
+let decodeTable;
+function getEncodeTable(encoding) {
+  if (!encodeTableStd) {
+    encodeTableStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    encodeTableStd.slice(0, -2).concat("-", "_");
+  }
+  return encodeTableStd;
+}
+function getDecodeTable() {
+  if (!decodeTable) {
+    decodeTable = [];
+    const encodeTable = getEncodeTable();
+    for (let i = 0; i < encodeTable.length; i++)
+      decodeTable[encodeTable[i].charCodeAt(0)] = i;
+    decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+");
+    decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/");
+  }
+  return decodeTable;
+}
+function isMessage(arg, schema) {
+  const isMessage2 = arg !== null && typeof arg == "object" && "$typeName" in arg && typeof arg.$typeName == "string";
+  if (!isMessage2) {
+    return false;
+  }
+  if (schema === void 0) {
+    return true;
+  }
+  return schema.typeName === arg.$typeName;
+}
+class FieldError extends Error {
+  constructor(fieldOrOneof, message, name = "FieldValueInvalidError") {
+    super(message);
+    this.name = name;
+    this.field = () => fieldOrOneof;
+  }
+}
+function isObject(arg) {
+  return arg !== null && typeof arg == "object" && !Array.isArray(arg);
+}
+function isReflectList(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "add" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== void 0) {
+      const a = field, b = arg.field();
+      return a.listKind == b.listKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMap(arg, field) {
+  var _a, _b, _c, _d;
+  if (isObject(arg) && unsafeLocal in arg && "has" in arg && "field" in arg && typeof arg.field == "function") {
+    if (field !== void 0) {
+      const a = field, b = arg.field();
+      return a.mapKey === b.mapKey && a.mapKind == b.mapKind && a.scalar === b.scalar && ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName);
+    }
+    return true;
+  }
+  return false;
+}
+function isReflectMessage(arg, messageDesc2) {
+  return isObject(arg) && unsafeLocal in arg && "desc" in arg && isObject(arg.desc) && arg.desc.kind === "message" && (messageDesc2 === void 0 || arg.desc.typeName == messageDesc2.typeName);
+}
+const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+function getTextEncoding() {
+  if (globalThis[symbol] == void 0) {
+    const te = new globalThis.TextEncoder();
+    const td = new globalThis.TextDecoder();
+    globalThis[symbol] = {
+      encodeUtf8(text) {
+        return te.encode(text);
+      },
+      decodeUtf8(bytes) {
+        return td.decode(bytes);
+      },
+      checkUtf8(text) {
+        try {
+          encodeURIComponent(text);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+    };
+  }
+  return globalThis[symbol];
+}
+var WireType;
+(function(WireType2) {
+  WireType2[WireType2["Varint"] = 0] = "Varint";
+  WireType2[WireType2["Bit64"] = 1] = "Bit64";
+  WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
+  WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
+  WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
+  WireType2[WireType2["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+const FLOAT32_MAX = 34028234663852886e22;
+const FLOAT32_MIN = -34028234663852886e22;
+const UINT32_MAX = 4294967295;
+const INT32_MAX = 2147483647;
+const INT32_MIN = -2147483648;
+class BinaryReader {
+  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
+    this.decodeUtf8 = decodeUtf8;
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    return [fieldNo, wireType];
+  }
+  /**
+   * Skip one element and return the skipped data.
+   *
+   * When skipping StartGroup, provide the tags field number to check for
+   * matching field number in the EndGroup tag.
+   */
+  skip(wireType, fieldNo) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        for (; ; ) {
+          const [fn, wt] = this.tag();
+          if (wt === WireType.EndGroup) {
+            if (fieldNo !== void 0 && fn !== fieldNo) {
+              throw new Error("invalid end group tag");
+            }
+            break;
+          }
+          this.skip(wt, fn);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return protoInt64.dec(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return protoInt64.uDec(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [lo, hi] = this.varint64();
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return protoInt64.dec(lo, hi);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+}
+function checkField(field, value) {
+  const check = field.fieldKind == "list" ? isReflectList(value, field) : field.fieldKind == "map" ? isReflectMap(value, field) : checkSingular(field, value);
+  if (check === true) {
+    return void 0;
+  }
+  let reason;
+  switch (field.fieldKind) {
+    case "list":
+      reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`;
+      break;
+    case "map":
+      reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`;
+      break;
+    default: {
+      reason = reasonSingular(field, value, check);
+    }
+  }
+  return new FieldError(field, reason);
+}
+function checkListItem(field, index, value) {
+  const check = checkSingular(field, value);
+  if (check !== true) {
+    return new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+  }
+  return void 0;
+}
+function checkMapEntry(field, key, value) {
+  const checkKey = checkScalarValue(key, field.mapKey);
+  if (checkKey !== true) {
+    return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+  }
+  const checkVal = checkSingular(field, value);
+  if (checkVal !== true) {
+    return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+  }
+  return void 0;
+}
+function checkSingular(field, value) {
+  if (field.scalar !== void 0) {
+    return checkScalarValue(value, field.scalar);
+  }
+  if (field.enum !== void 0) {
+    if (field.enum.open) {
+      return Number.isInteger(value);
+    }
+    return field.enum.values.some((v) => v.number === value);
+  }
+  return isReflectMessage(value, field.message);
+}
+function checkScalarValue(value, scalar) {
+  switch (scalar) {
+    case ScalarType.DOUBLE:
+      return typeof value == "number";
+    case ScalarType.FLOAT:
+      if (typeof value != "number") {
+        return false;
+      }
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        return true;
+      }
+      if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > INT32_MAX || value < INT32_MIN) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      if (value > UINT32_MAX || value < 0) {
+        return `${value.toFixed()} out of range`;
+      }
+      return true;
+    case ScalarType.BOOL:
+      return typeof value == "boolean";
+    case ScalarType.STRING:
+      if (typeof value != "string") {
+        return false;
+      }
+      return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+    case ScalarType.BYTES:
+      return value instanceof Uint8Array;
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.parse(value);
+          return true;
+        } catch (e) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if (typeof value == "bigint" || typeof value == "number" || typeof value == "string" && value.length > 0) {
+        try {
+          protoInt64.uParse(value);
+          return true;
+        } catch (e) {
+          return `${value} out of range`;
+        }
+      }
+      return false;
+  }
+}
+function reasonSingular(field, val, details) {
+  details = typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
+  if (field.scalar !== void 0) {
+    return `expected ${scalarTypeDescription(field.scalar)}` + details;
+  } else if (field.enum !== void 0) {
+    return `expected ${field.enum.toString()}` + details;
+  }
+  return `expected ${formatReflectMessage(field.message)}` + details;
+}
+function formatVal(val) {
+  switch (typeof val) {
+    case "object":
+      if (val === null) {
+        return "null";
+      }
+      if (val instanceof Uint8Array) {
+        return `Uint8Array(${val.length})`;
+      }
+      if (Array.isArray(val)) {
+        return `Array(${val.length})`;
+      }
+      if (isReflectList(val)) {
+        return formatReflectList(val.field());
+      }
+      if (isReflectMap(val)) {
+        return formatReflectMap(val.field());
+      }
+      if (isReflectMessage(val)) {
+        return formatReflectMessage(val.desc);
+      }
+      if (isMessage(val)) {
+        return `message ${val.$typeName}`;
+      }
+      return "object";
+    case "string":
+      return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`;
+    case "boolean":
+      return String(val);
+    case "number":
+      return String(val);
+    case "bigint":
+      return String(val) + "n";
+    default:
+      return typeof val;
+  }
+}
+function formatReflectMessage(desc) {
+  return `ReflectMessage (${desc.typeName})`;
+}
+function formatReflectList(field) {
+  switch (field.listKind) {
+    case "message":
+      return `ReflectList (${field.message.toString()})`;
+    case "enum":
+      return `ReflectList (${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectList (${ScalarType[field.scalar]})`;
+  }
+}
+function formatReflectMap(field) {
+  switch (field.mapKind) {
+    case "message":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.message.toString()})`;
+    case "enum":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${field.enum.toString()})`;
+    case "scalar":
+      return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`;
+  }
+}
+function scalarTypeDescription(scalar) {
+  switch (scalar) {
+    case ScalarType.STRING:
+      return "string";
+    case ScalarType.BOOL:
+      return "boolean";
+    case ScalarType.INT64:
+    case ScalarType.SINT64:
+    case ScalarType.SFIXED64:
+      return "bigint (int64)";
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      return "bigint (uint64)";
+    case ScalarType.BYTES:
+      return "Uint8Array";
+    case ScalarType.DOUBLE:
+      return "number (float64)";
+    case ScalarType.FLOAT:
+      return "number (float32)";
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      return "number (uint32)";
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+      return "number (int32)";
+  }
+}
+function isWrapper(arg) {
+  return isWrapperTypeName(arg.$typeName);
+}
+function isWrapperDesc(messageDesc2) {
+  const f = messageDesc2.fields[0];
+  return isWrapperTypeName(messageDesc2.typeName) && f !== void 0 && f.fieldKind == "scalar" && f.name == "value" && f.number == 1;
+}
+function isWrapperTypeName(name) {
+  return name.startsWith("google.protobuf.") && [
+    "DoubleValue",
+    "FloatValue",
+    "Int64Value",
+    "UInt64Value",
+    "Int32Value",
+    "UInt32Value",
+    "BoolValue",
+    "StringValue",
+    "BytesValue"
+  ].includes(name.substring(16));
+}
+const EDITION_PROTO3 = 999;
+const EDITION_PROTO2 = 998;
+const IMPLICIT = 2;
+function create(schema, init) {
+  if (isMessage(init, schema)) {
+    return init;
+  }
+  const message = createZeroMessage(schema);
+  return message;
+}
+const tokenZeroMessageField = Symbol();
+const messagePrototypes = /* @__PURE__ */ new WeakMap();
+function createZeroMessage(desc) {
+  let msg;
+  if (!needsPrototypeChain(desc)) {
+    msg = {
+      $typeName: desc.typeName
+    };
+    for (const member of desc.members) {
+      if (member.kind == "oneof" || member.presence == IMPLICIT) {
+        msg[member.localName] = createZeroField(member);
+      }
+    }
+  } else {
+    const cached = messagePrototypes.get(desc);
+    let prototype;
+    let members;
+    if (cached) {
+      ({ prototype, members } = cached);
+    } else {
+      prototype = {};
+      members = /* @__PURE__ */ new Set();
+      for (const member of desc.members) {
+        if (member.kind == "oneof") {
+          continue;
+        }
+        if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
+          continue;
+        }
+        if (member.presence == IMPLICIT) {
+          continue;
+        }
+        members.add(member);
+        prototype[member.localName] = createZeroField(member);
+      }
+      messagePrototypes.set(desc, { prototype, members });
+    }
+    msg = Object.create(prototype);
+    msg.$typeName = desc.typeName;
+    for (const member of desc.members) {
+      if (members.has(member)) {
+        continue;
+      }
+      if (member.kind == "field") {
+        if (member.fieldKind == "message") {
+          continue;
+        }
+        if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
+          if (member.presence != IMPLICIT) {
+            continue;
+          }
+        }
+      }
+      msg[member.localName] = createZeroField(member);
+    }
+  }
+  return msg;
+}
+function needsPrototypeChain(desc) {
+  switch (desc.file.edition) {
+    case EDITION_PROTO3:
+      return false;
+    case EDITION_PROTO2:
+      return true;
+    default:
+      return desc.fields.some((f) => f.presence != IMPLICIT && f.fieldKind != "message" && !f.oneof);
+  }
+}
+function createZeroField(field) {
+  if (field.kind == "oneof") {
+    return { case: void 0 };
+  }
+  if (field.fieldKind == "list") {
+    return [];
+  }
+  if (field.fieldKind == "map") {
+    return {};
+  }
+  if (field.fieldKind == "message") {
+    return tokenZeroMessageField;
+  }
+  const defaultValue = field.getDefaultValue();
+  if (defaultValue !== void 0) {
+    return field.fieldKind == "scalar" && field.longAsString ? defaultValue.toString() : defaultValue;
+  }
+  return field.fieldKind == "scalar" ? scalarZeroValue(field.scalar, field.longAsString) : field.enum.values[0].number;
+}
+function reflect(messageDesc2, message, check = true) {
+  return new ReflectMessageImpl(messageDesc2, message, check);
+}
+class ReflectMessageImpl {
+  get sortedFields() {
+    var _a;
+    return (_a = this._sortedFields) !== null && _a !== void 0 ? _a : this._sortedFields = this.desc.fields.concat().sort((a, b) => a.number - b.number);
+  }
+  constructor(messageDesc2, message, check = true) {
+    this.lists = /* @__PURE__ */ new Map();
+    this.maps = /* @__PURE__ */ new Map();
+    this.check = check;
+    this.desc = messageDesc2;
+    this.message = this[unsafeLocal] = message !== null && message !== void 0 ? message : create(messageDesc2);
+    this.fields = messageDesc2.fields;
+    this.oneofs = messageDesc2.oneofs;
+    this.members = messageDesc2.members;
+  }
+  findNumber(number) {
+    if (!this._fieldsByNumber) {
+      this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+    }
+    return this._fieldsByNumber.get(number);
+  }
+  oneofCase(oneof) {
+    assertOwn(this.message, oneof);
+    return unsafeOneofCase(this.message, oneof);
+  }
+  isSet(field) {
+    assertOwn(this.message, field);
+    return unsafeIsSet(this.message, field);
+  }
+  clear(field) {
+    assertOwn(this.message, field);
+    unsafeClear(this.message, field);
+  }
+  get(field) {
+    assertOwn(this.message, field);
+    const value = unsafeGet(this.message, field);
+    switch (field.fieldKind) {
+      case "list":
+        let list = this.lists.get(field);
+        if (!list || list[unsafeLocal] !== value) {
+          this.lists.set(field, list = new ReflectListImpl(field, value, this.check));
+        }
+        return list;
+      case "map":
+        let map = this.maps.get(field);
+        if (!map || map[unsafeLocal] !== value) {
+          this.maps.set(field, map = new ReflectMapImpl(field, value, this.check));
+        }
+        return map;
+      case "message":
+        return messageToReflect(field, value, this.check);
+      case "scalar":
+        return value === void 0 ? scalarZeroValue(field.scalar, false) : longToReflect(field, value);
+      case "enum":
+        return value !== null && value !== void 0 ? value : field.enum.values[0].number;
+    }
+  }
+  set(field, value) {
+    assertOwn(this.message, field);
+    if (this.check) {
+      const err = checkField(field, value);
+      if (err) {
+        throw err;
+      }
+    }
+    let local;
+    if (field.fieldKind == "message") {
+      local = messageToLocal(field, value);
+    } else if (isReflectMap(value) || isReflectList(value)) {
+      local = value[unsafeLocal];
+    } else {
+      local = longToLocal(field, value);
+    }
+    unsafeSet(this.message, field, local);
+  }
+  getUnknown() {
+    return this.message.$unknown;
+  }
+  setUnknown(value) {
+    this.message.$unknown = value;
+  }
+}
+function assertOwn(owner, member) {
+  if (member.parent.typeName !== owner.$typeName) {
+    throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+  }
+}
+class ReflectListImpl {
+  field() {
+    return this._field;
+  }
+  get size() {
+    return this._arr.length;
+  }
+  constructor(field, unsafeInput, check) {
+    this._field = field;
+    this._arr = this[unsafeLocal] = unsafeInput;
+    this.check = check;
+  }
+  get(index) {
+    const item = this._arr[index];
+    return item === void 0 ? void 0 : listItemToReflect(this._field, item, this.check);
+  }
+  set(index, item) {
+    if (index < 0 || index >= this._arr.length) {
+      throw new FieldError(this._field, `list item #${index + 1}: out of range`);
+    }
+    if (this.check) {
+      const err = checkListItem(this._field, index, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr[index] = listItemToLocal(this._field, item);
+  }
+  add(item) {
+    if (this.check) {
+      const err = checkListItem(this._field, this._arr.length, item);
+      if (err) {
+        throw err;
+      }
+    }
+    this._arr.push(listItemToLocal(this._field, item));
+    return void 0;
+  }
+  clear() {
+    this._arr.splice(0, this._arr.length);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  keys() {
+    return this._arr.keys();
+  }
+  *values() {
+    for (const item of this._arr) {
+      yield listItemToReflect(this._field, item, this.check);
+    }
+  }
+  *entries() {
+    for (let i = 0; i < this._arr.length; i++) {
+      yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+    }
+  }
+}
+class ReflectMapImpl {
+  constructor(field, unsafeInput, check = true) {
+    this.obj = this[unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+    this.check = check;
+    this._field = field;
+  }
+  field() {
+    return this._field;
+  }
+  set(key, value) {
+    if (this.check) {
+      const err = checkMapEntry(this._field, key, value);
+      if (err) {
+        throw err;
+      }
+    }
+    this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+    return this;
+  }
+  delete(key) {
+    const k = mapKeyToLocal(key);
+    const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+    if (has) {
+      delete this.obj[k];
+    }
+    return has;
+  }
+  clear() {
+    for (const key of Object.keys(this.obj)) {
+      delete this.obj[key];
+    }
+  }
+  get(key) {
+    let val = this.obj[mapKeyToLocal(key)];
+    if (val !== void 0) {
+      val = mapValueToReflect(this._field, val, this.check);
+    }
+    return val;
+  }
+  has(key) {
+    return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+  }
+  *keys() {
+    for (const objKey of Object.keys(this.obj)) {
+      yield mapKeyToReflect(objKey, this._field.mapKey);
+    }
+  }
+  *entries() {
+    for (const objEntry of Object.entries(this.obj)) {
+      yield [
+        mapKeyToReflect(objEntry[0], this._field.mapKey),
+        mapValueToReflect(this._field, objEntry[1], this.check)
+      ];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return Object.keys(this.obj).length;
+  }
+  *values() {
+    for (const val of Object.values(this.obj)) {
+      yield mapValueToReflect(this._field, val, this.check);
+    }
+  }
+  forEach(callbackfn, thisArg) {
+    for (const mapEntry of this.entries()) {
+      callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+    }
+  }
+}
+function messageToLocal(field, value) {
+  if (!isReflectMessage(value)) {
+    return value;
+  }
+  if (isWrapper(value.message) && !field.oneof && field.fieldKind == "message") {
+    return value.message.value;
+  }
+  if (value.desc.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value") {
+    return wktStructToLocal(value.message);
+  }
+  return value.message;
+}
+function messageToReflect(field, value, check) {
+  if (value !== void 0) {
+    if (isWrapperDesc(field.message) && !field.oneof && field.fieldKind == "message") {
+      value = {
+        $typeName: field.message.typeName,
+        value: longToReflect(field.message.fields[0], value)
+      };
+    } else if (field.message.typeName == "google.protobuf.Struct" && field.parent.typeName != "google.protobuf.Value" && isObject(value)) {
+      value = wktStructToReflect(value);
+    }
+  }
+  return new ReflectMessageImpl(field.message, value, check);
+}
+function listItemToLocal(field, value) {
+  if (field.listKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function listItemToReflect(field, value, check) {
+  if (field.listKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+  if (field.mapKind == "message") {
+    return messageToLocal(field, value);
+  }
+  return longToLocal(field, value);
+}
+function mapValueToReflect(field, value, check) {
+  if (field.mapKind == "message") {
+    return messageToReflect(field, value, check);
+  }
+  return value;
+}
+function mapKeyToLocal(key) {
+  return typeof key == "string" || typeof key == "number" ? key : String(key);
+}
+function mapKeyToReflect(key, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return key;
+    case ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32: {
+      const n = Number.parseInt(key);
+      if (Number.isFinite(n)) {
+        return n;
+      }
+      break;
+    }
+    case ScalarType.BOOL:
+      switch (key) {
+        case "true":
+          return true;
+        case "false":
+          return false;
+      }
+      break;
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+      try {
+        return protoInt64.uParse(key);
+      } catch (_a) {
+      }
+      break;
+    default:
+      try {
+        return protoInt64.parse(key);
+      } catch (_b) {
+      }
+      break;
+  }
+  return key;
+}
+function longToReflect(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString && typeof value == "string") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function longToLocal(field, value) {
+  switch (field.scalar) {
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.parse(value);
+      }
+      break;
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if ("longAsString" in field && field.longAsString) {
+        value = String(value);
+      } else if (typeof value == "string" || typeof value == "number") {
+        value = protoInt64.uParse(value);
+      }
+      break;
+  }
+  return value;
+}
+function wktStructToReflect(json) {
+  const struct = {
+    $typeName: "google.protobuf.Struct",
+    fields: {}
+  };
+  if (isObject(json)) {
+    for (const [k, v] of Object.entries(json)) {
+      struct.fields[k] = wktValueToReflect(v);
+    }
+  }
+  return struct;
+}
+function wktStructToLocal(val) {
+  const json = {};
+  for (const [k, v] of Object.entries(val.fields)) {
+    json[k] = wktValueToLocal(v);
+  }
+  return json;
+}
+function wktValueToLocal(val) {
+  switch (val.kind.case) {
+    case "structValue":
+      return wktStructToLocal(val.kind.value);
+    case "listValue":
+      return val.kind.value.values.map(wktValueToLocal);
+    case "nullValue":
+    case void 0:
+      return null;
+    default:
+      return val.kind.value;
+  }
+}
+function wktValueToReflect(json) {
+  const value = {
+    $typeName: "google.protobuf.Value",
+    kind: { case: void 0 }
+  };
+  switch (typeof json) {
+    case "number":
+      value.kind = { case: "numberValue", value: json };
+      break;
+    case "string":
+      value.kind = { case: "stringValue", value: json };
+      break;
+    case "boolean":
+      value.kind = { case: "boolValue", value: json };
+      break;
+    case "object":
+      if (json === null) {
+        const nullValue = 0;
+        value.kind = { case: "nullValue", value: nullValue };
+      } else if (Array.isArray(json)) {
+        const listValue = {
+          $typeName: "google.protobuf.ListValue",
+          values: []
+        };
+        if (Array.isArray(json)) {
+          for (const e of json) {
+            listValue.values.push(wktValueToReflect(e));
+          }
+        }
+        value.kind = {
+          case: "listValue",
+          value: listValue
+        };
+      } else {
+        value.kind = {
+          case: "structValue",
+          value: wktStructToReflect(json)
+        };
+      }
+      break;
+  }
+  return value;
+}
+function messageDesc(file, path, ...paths) {
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]);
+}
+const file_google_protobuf_descriptor = /* @__PURE__ */ boot({ "name": "google/protobuf/descriptor.proto", "package": "google.protobuf", "messageType": [{ "name": "FileDescriptorSet", "field": [{ "name": "file", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FileDescriptorProto" }], "extensionRange": [{ "start": 536e6, "end": 536000001 }] }, { "name": "FileDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "package", "number": 2, "type": 9, "label": 1 }, { "name": "dependency", "number": 3, "type": 9, "label": 3 }, { "name": "public_dependency", "number": 10, "type": 5, "label": 3 }, { "name": "weak_dependency", "number": 11, "type": 5, "label": 3 }, { "name": "message_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "service", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.ServiceDescriptorProto" }, { "name": "extension", "number": 7, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FileOptions" }, { "name": "source_code_info", "number": 9, "type": 11, "label": 1, "typeName": ".google.protobuf.SourceCodeInfo" }, { "name": "syntax", "number": 12, "type": 9, "label": 1 }, { "name": "edition", "number": 14, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }, { "name": "DescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "field", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "extension", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "nested_type", "number": 3, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "extension_range", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ExtensionRange" }, { "name": "oneof_decl", "number": 8, "type": 11, "label": 3, "typeName": ".google.protobuf.OneofDescriptorProto" }, { "name": "options", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.MessageOptions" }, { "name": "reserved_range", "number": 9, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ReservedRange" }, { "name": "reserved_name", "number": 10, "type": 9, "label": 3 }], "nestedType": [{ "name": "ExtensionRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions" }] }, { "name": "ReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "ExtensionRangeOptions", "field": [{ "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }, { "name": "declaration", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.ExtensionRangeOptions.Declaration", "options": { "retention": 2 } }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "verification", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions.VerificationState", "defaultValue": "UNVERIFIED", "options": { "retention": 2 } }], "nestedType": [{ "name": "Declaration", "field": [{ "name": "number", "number": 1, "type": 5, "label": 1 }, { "name": "full_name", "number": 2, "type": 9, "label": 1 }, { "name": "type", "number": 3, "type": 9, "label": 1 }, { "name": "reserved", "number": 5, "type": 8, "label": 1 }, { "name": "repeated", "number": 6, "type": 8, "label": 1 }] }], "enumType": [{ "name": "VerificationState", "value": [{ "name": "DECLARATION", "number": 0 }, { "name": "UNVERIFIED", "number": 1 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "FieldDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 3, "type": 5, "label": 1 }, { "name": "label", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Label" }, { "name": "type", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Type" }, { "name": "type_name", "number": 6, "type": 9, "label": 1 }, { "name": "extendee", "number": 2, "type": 9, "label": 1 }, { "name": "default_value", "number": 7, "type": 9, "label": 1 }, { "name": "oneof_index", "number": 9, "type": 5, "label": 1 }, { "name": "json_name", "number": 10, "type": 9, "label": 1 }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions" }, { "name": "proto3_optional", "number": 17, "type": 8, "label": 1 }], "enumType": [{ "name": "Type", "value": [{ "name": "TYPE_DOUBLE", "number": 1 }, { "name": "TYPE_FLOAT", "number": 2 }, { "name": "TYPE_INT64", "number": 3 }, { "name": "TYPE_UINT64", "number": 4 }, { "name": "TYPE_INT32", "number": 5 }, { "name": "TYPE_FIXED64", "number": 6 }, { "name": "TYPE_FIXED32", "number": 7 }, { "name": "TYPE_BOOL", "number": 8 }, { "name": "TYPE_STRING", "number": 9 }, { "name": "TYPE_GROUP", "number": 10 }, { "name": "TYPE_MESSAGE", "number": 11 }, { "name": "TYPE_BYTES", "number": 12 }, { "name": "TYPE_UINT32", "number": 13 }, { "name": "TYPE_ENUM", "number": 14 }, { "name": "TYPE_SFIXED32", "number": 15 }, { "name": "TYPE_SFIXED64", "number": 16 }, { "name": "TYPE_SINT32", "number": 17 }, { "name": "TYPE_SINT64", "number": 18 }] }, { "name": "Label", "value": [{ "name": "LABEL_OPTIONAL", "number": 1 }, { "name": "LABEL_REPEATED", "number": 3 }, { "name": "LABEL_REQUIRED", "number": 2 }] }] }, { "name": "OneofDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "options", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.OneofOptions" }] }, { "name": "EnumDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "value", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumValueDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumOptions" }, { "name": "reserved_range", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto.EnumReservedRange" }, { "name": "reserved_name", "number": 5, "type": 9, "label": 3 }], "nestedType": [{ "name": "EnumReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "EnumValueDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumValueOptions" }] }, { "name": "ServiceDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "method", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.MethodDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ServiceOptions" }] }, { "name": "MethodDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "input_type", "number": 2, "type": 9, "label": 1 }, { "name": "output_type", "number": 3, "type": 9, "label": 1 }, { "name": "options", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.MethodOptions" }, { "name": "client_streaming", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "server_streaming", "number": 6, "type": 8, "label": 1, "defaultValue": "false" }] }, { "name": "FileOptions", "field": [{ "name": "java_package", "number": 1, "type": 9, "label": 1 }, { "name": "java_outer_classname", "number": 8, "type": 9, "label": 1 }, { "name": "java_multiple_files", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generate_equals_and_hash", "number": 20, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "java_string_check_utf8", "number": 27, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "optimize_for", "number": 9, "type": 14, "label": 1, "typeName": ".google.protobuf.FileOptions.OptimizeMode", "defaultValue": "SPEED" }, { "name": "go_package", "number": 11, "type": 9, "label": 1 }, { "name": "cc_generic_services", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generic_services", "number": 17, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "py_generic_services", "number": 18, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 23, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "cc_enable_arenas", "number": 31, "type": 8, "label": 1, "defaultValue": "true" }, { "name": "objc_class_prefix", "number": 36, "type": 9, "label": 1 }, { "name": "csharp_namespace", "number": 37, "type": 9, "label": 1 }, { "name": "swift_prefix", "number": 39, "type": 9, "label": 1 }, { "name": "php_class_prefix", "number": 40, "type": 9, "label": 1 }, { "name": "php_namespace", "number": 41, "type": 9, "label": 1 }, { "name": "php_metadata_namespace", "number": 44, "type": 9, "label": 1 }, { "name": "ruby_package", "number": 45, "type": 9, "label": 1 }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "OptimizeMode", "value": [{ "name": "SPEED", "number": 1 }, { "name": "CODE_SIZE", "number": 2 }, { "name": "LITE_RUNTIME", "number": 3 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "MessageOptions", "field": [{ "name": "message_set_wire_format", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "no_standard_descriptor_accessor", "number": 2, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "map_entry", "number": 7, "type": 8, "label": 1 }, { "name": "deprecated_legacy_json_field_conflicts", "number": 11, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 12, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "FieldOptions", "field": [{ "name": "ctype", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.CType", "defaultValue": "STRING" }, { "name": "packed", "number": 2, "type": 8, "label": 1 }, { "name": "jstype", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.JSType", "defaultValue": "JS_NORMAL" }, { "name": "lazy", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "unverified_lazy", "number": 15, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "weak", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "debug_redact", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "retention", "number": 17, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.OptionRetention" }, { "name": "targets", "number": 19, "type": 14, "label": 3, "typeName": ".google.protobuf.FieldOptions.OptionTargetType" }, { "name": "edition_defaults", "number": 20, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldOptions.EditionDefault" }, { "name": "features", "number": 21, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "feature_support", "number": 22, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "nestedType": [{ "name": "EditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "value", "number": 2, "type": 9, "label": 1 }] }, { "name": "FeatureSupport", "field": [{ "name": "edition_introduced", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "edition_deprecated", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "deprecation_warning", "number": 3, "type": 9, "label": 1 }, { "name": "edition_removed", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }], "enumType": [{ "name": "CType", "value": [{ "name": "STRING", "number": 0 }, { "name": "CORD", "number": 1 }, { "name": "STRING_PIECE", "number": 2 }] }, { "name": "JSType", "value": [{ "name": "JS_NORMAL", "number": 0 }, { "name": "JS_STRING", "number": 1 }, { "name": "JS_NUMBER", "number": 2 }] }, { "name": "OptionRetention", "value": [{ "name": "RETENTION_UNKNOWN", "number": 0 }, { "name": "RETENTION_RUNTIME", "number": 1 }, { "name": "RETENTION_SOURCE", "number": 2 }] }, { "name": "OptionTargetType", "value": [{ "name": "TARGET_TYPE_UNKNOWN", "number": 0 }, { "name": "TARGET_TYPE_FILE", "number": 1 }, { "name": "TARGET_TYPE_EXTENSION_RANGE", "number": 2 }, { "name": "TARGET_TYPE_MESSAGE", "number": 3 }, { "name": "TARGET_TYPE_FIELD", "number": 4 }, { "name": "TARGET_TYPE_ONEOF", "number": 5 }, { "name": "TARGET_TYPE_ENUM", "number": 6 }, { "name": "TARGET_TYPE_ENUM_ENTRY", "number": 7 }, { "name": "TARGET_TYPE_SERVICE", "number": 8 }, { "name": "TARGET_TYPE_METHOD", "number": 9 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "OneofOptions", "field": [{ "name": "features", "number": 1, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "EnumOptions", "field": [{ "name": "allow_alias", "number": 2, "type": 8, "label": 1 }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated_legacy_json_field_conflicts", "number": 6, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "EnumValueOptions", "field": [{ "name": "deprecated", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "features", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "debug_redact", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "feature_support", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "ServiceOptions", "field": [{ "name": "features", "number": 34, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "MethodOptions", "field": [{ "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "idempotency_level", "number": 34, "type": 14, "label": 1, "typeName": ".google.protobuf.MethodOptions.IdempotencyLevel", "defaultValue": "IDEMPOTENCY_UNKNOWN" }, { "name": "features", "number": 35, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "IdempotencyLevel", "value": [{ "name": "IDEMPOTENCY_UNKNOWN", "number": 0 }, { "name": "NO_SIDE_EFFECTS", "number": 1 }, { "name": "IDEMPOTENT", "number": 2 }] }], "extensionRange": [{ "start": 1e3, "end": 536870912 }] }, { "name": "UninterpretedOption", "field": [{ "name": "name", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption.NamePart" }, { "name": "identifier_value", "number": 3, "type": 9, "label": 1 }, { "name": "positive_int_value", "number": 4, "type": 4, "label": 1 }, { "name": "negative_int_value", "number": 5, "type": 3, "label": 1 }, { "name": "double_value", "number": 6, "type": 1, "label": 1 }, { "name": "string_value", "number": 7, "type": 12, "label": 1 }, { "name": "aggregate_value", "number": 8, "type": 9, "label": 1 }], "nestedType": [{ "name": "NamePart", "field": [{ "name": "name_part", "number": 1, "type": 9, "label": 2 }, { "name": "is_extension", "number": 2, "type": 8, "label": 2 }] }] }, { "name": "FeatureSet", "field": [{ "name": "field_presence", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.FieldPresence", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPLICIT", "edition": 900 }, { "value": "IMPLICIT", "edition": 999 }, { "value": "EXPLICIT", "edition": 1e3 }] } }, { "name": "enum_type", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnumType", "options": { "retention": 1, "targets": [6, 1], "editionDefaults": [{ "value": "CLOSED", "edition": 900 }, { "value": "OPEN", "edition": 999 }] } }, { "name": "repeated_field_encoding", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.RepeatedFieldEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPANDED", "edition": 900 }, { "value": "PACKED", "edition": 999 }] } }, { "name": "utf8_validation", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.Utf8Validation", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "NONE", "edition": 900 }, { "value": "VERIFY", "edition": 999 }] } }, { "name": "message_encoding", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.MessageEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "LENGTH_PREFIXED", "edition": 900 }] } }, { "name": "json_format", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.JsonFormat", "options": { "retention": 1, "targets": [3, 6, 1], "editionDefaults": [{ "value": "LEGACY_BEST_EFFORT", "edition": 900 }, { "value": "ALLOW", "edition": 999 }] } }, { "name": "enforce_naming_style", "number": 7, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnforceNamingStyle", "options": { "retention": 2, "targets": [1, 2, 3, 4, 5, 6, 7, 8, 9], "editionDefaults": [{ "value": "STYLE_LEGACY", "edition": 900 }, { "value": "STYLE2024", "edition": 1001 }] } }], "enumType": [{ "name": "FieldPresence", "value": [{ "name": "FIELD_PRESENCE_UNKNOWN", "number": 0 }, { "name": "EXPLICIT", "number": 1 }, { "name": "IMPLICIT", "number": 2 }, { "name": "LEGACY_REQUIRED", "number": 3 }] }, { "name": "EnumType", "value": [{ "name": "ENUM_TYPE_UNKNOWN", "number": 0 }, { "name": "OPEN", "number": 1 }, { "name": "CLOSED", "number": 2 }] }, { "name": "RepeatedFieldEncoding", "value": [{ "name": "REPEATED_FIELD_ENCODING_UNKNOWN", "number": 0 }, { "name": "PACKED", "number": 1 }, { "name": "EXPANDED", "number": 2 }] }, { "name": "Utf8Validation", "value": [{ "name": "UTF8_VALIDATION_UNKNOWN", "number": 0 }, { "name": "VERIFY", "number": 2 }, { "name": "NONE", "number": 3 }] }, { "name": "MessageEncoding", "value": [{ "name": "MESSAGE_ENCODING_UNKNOWN", "number": 0 }, { "name": "LENGTH_PREFIXED", "number": 1 }, { "name": "DELIMITED", "number": 2 }] }, { "name": "JsonFormat", "value": [{ "name": "JSON_FORMAT_UNKNOWN", "number": 0 }, { "name": "ALLOW", "number": 1 }, { "name": "LEGACY_BEST_EFFORT", "number": 2 }] }, { "name": "EnforceNamingStyle", "value": [{ "name": "ENFORCE_NAMING_STYLE_UNKNOWN", "number": 0 }, { "name": "STYLE2024", "number": 1 }, { "name": "STYLE_LEGACY", "number": 2 }] }], "extensionRange": [{ "start": 1e3, "end": 9995 }, { "start": 9995, "end": 1e4 }, { "start": 1e4, "end": 10001 }] }, { "name": "FeatureSetDefaults", "field": [{ "name": "defaults", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" }, { "name": "minimum_edition", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "maximum_edition", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }], "nestedType": [{ "name": "FeatureSetEditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "overridable_features", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "fixed_features", "number": 5, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }] }] }, { "name": "SourceCodeInfo", "field": [{ "name": "location", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.SourceCodeInfo.Location" }], "nestedType": [{ "name": "Location", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "span", "number": 2, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "leading_comments", "number": 3, "type": 9, "label": 1 }, { "name": "trailing_comments", "number": 4, "type": 9, "label": 1 }, { "name": "leading_detached_comments", "number": 6, "type": 9, "label": 3 }] }], "extensionRange": [{ "start": 536e6, "end": 536000001 }] }, { "name": "GeneratedCodeInfo", "field": [{ "name": "annotation", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation" }], "nestedType": [{ "name": "Annotation", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "source_file", "number": 2, "type": 9, "label": 1 }, { "name": "begin", "number": 3, "type": 5, "label": 1 }, { "name": "end", "number": 4, "type": 5, "label": 1 }, { "name": "semantic", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic" }], "enumType": [{ "name": "Semantic", "value": [{ "name": "NONE", "number": 0 }, { "name": "SET", "number": 1 }, { "name": "ALIAS", "number": 2 }] }] }] }], "enumType": [{ "name": "Edition", "value": [{ "name": "EDITION_UNKNOWN", "number": 0 }, { "name": "EDITION_LEGACY", "number": 900 }, { "name": "EDITION_PROTO2", "number": 998 }, { "name": "EDITION_PROTO3", "number": 999 }, { "name": "EDITION_2023", "number": 1e3 }, { "name": "EDITION_2024", "number": 1001 }, { "name": "EDITION_1_TEST_ONLY", "number": 1 }, { "name": "EDITION_2_TEST_ONLY", "number": 2 }, { "name": "EDITION_99997_TEST_ONLY", "number": 99997 }, { "name": "EDITION_99998_TEST_ONLY", "number": 99998 }, { "name": "EDITION_99999_TEST_ONLY", "number": 99999 }, { "name": "EDITION_MAX", "number": 2147483647 }] }] });
+const FileDescriptorProtoSchema = /* @__PURE__ */ messageDesc(file_google_protobuf_descriptor, 1);
+var ExtensionRangeOptions_VerificationState;
+(function(ExtensionRangeOptions_VerificationState2) {
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["DECLARATION"] = 0] = "DECLARATION";
+  ExtensionRangeOptions_VerificationState2[ExtensionRangeOptions_VerificationState2["UNVERIFIED"] = 1] = "UNVERIFIED";
+})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {}));
+var FieldDescriptorProto_Type;
+(function(FieldDescriptorProto_Type2) {
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["DOUBLE"] = 1] = "DOUBLE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FLOAT"] = 2] = "FLOAT";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT64"] = 3] = "INT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT64"] = 4] = "UINT64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["INT32"] = 5] = "INT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED64"] = 6] = "FIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["FIXED32"] = 7] = "FIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BOOL"] = 8] = "BOOL";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["STRING"] = 9] = "STRING";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["GROUP"] = 10] = "GROUP";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["MESSAGE"] = 11] = "MESSAGE";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["BYTES"] = 12] = "BYTES";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["UINT32"] = 13] = "UINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["ENUM"] = 14] = "ENUM";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED32"] = 15] = "SFIXED32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SFIXED64"] = 16] = "SFIXED64";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT32"] = 17] = "SINT32";
+  FieldDescriptorProto_Type2[FieldDescriptorProto_Type2["SINT64"] = 18] = "SINT64";
+})(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {}));
+var FieldDescriptorProto_Label;
+(function(FieldDescriptorProto_Label2) {
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["OPTIONAL"] = 1] = "OPTIONAL";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REPEATED"] = 3] = "REPEATED";
+  FieldDescriptorProto_Label2[FieldDescriptorProto_Label2["REQUIRED"] = 2] = "REQUIRED";
+})(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
+var FileOptions_OptimizeMode;
+(function(FileOptions_OptimizeMode2) {
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["SPEED"] = 1] = "SPEED";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["CODE_SIZE"] = 2] = "CODE_SIZE";
+  FileOptions_OptimizeMode2[FileOptions_OptimizeMode2["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
+})(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {}));
+var FieldOptions_CType;
+(function(FieldOptions_CType2) {
+  FieldOptions_CType2[FieldOptions_CType2["STRING"] = 0] = "STRING";
+  FieldOptions_CType2[FieldOptions_CType2["CORD"] = 1] = "CORD";
+  FieldOptions_CType2[FieldOptions_CType2["STRING_PIECE"] = 2] = "STRING_PIECE";
+})(FieldOptions_CType || (FieldOptions_CType = {}));
+var FieldOptions_JSType;
+(function(FieldOptions_JSType2) {
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NORMAL"] = 0] = "JS_NORMAL";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_STRING"] = 1] = "JS_STRING";
+  FieldOptions_JSType2[FieldOptions_JSType2["JS_NUMBER"] = 2] = "JS_NUMBER";
+})(FieldOptions_JSType || (FieldOptions_JSType = {}));
+var FieldOptions_OptionRetention;
+(function(FieldOptions_OptionRetention2) {
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME";
+  FieldOptions_OptionRetention2[FieldOptions_OptionRetention2["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE";
+})(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {}));
+var FieldOptions_OptionTargetType;
+(function(FieldOptions_OptionTargetType2) {
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE";
+  FieldOptions_OptionTargetType2[FieldOptions_OptionTargetType2["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD";
+})(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {}));
+var MethodOptions_IdempotencyLevel;
+(function(MethodOptions_IdempotencyLevel2) {
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS";
+  MethodOptions_IdempotencyLevel2[MethodOptions_IdempotencyLevel2["IDEMPOTENT"] = 2] = "IDEMPOTENT";
+})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {}));
+var FeatureSet_FieldPresence;
+(function(FeatureSet_FieldPresence2) {
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["EXPLICIT"] = 1] = "EXPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["IMPLICIT"] = 2] = "IMPLICIT";
+  FeatureSet_FieldPresence2[FeatureSet_FieldPresence2["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED";
+})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {}));
+var FeatureSet_EnumType;
+(function(FeatureSet_EnumType2) {
+  FeatureSet_EnumType2[FeatureSet_EnumType2["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["OPEN"] = 1] = "OPEN";
+  FeatureSet_EnumType2[FeatureSet_EnumType2["CLOSED"] = 2] = "CLOSED";
+})(FeatureSet_EnumType || (FeatureSet_EnumType = {}));
+var FeatureSet_RepeatedFieldEncoding;
+(function(FeatureSet_RepeatedFieldEncoding2) {
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["PACKED"] = 1] = "PACKED";
+  FeatureSet_RepeatedFieldEncoding2[FeatureSet_RepeatedFieldEncoding2["EXPANDED"] = 2] = "EXPANDED";
+})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {}));
+var FeatureSet_Utf8Validation;
+(function(FeatureSet_Utf8Validation2) {
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["VERIFY"] = 2] = "VERIFY";
+  FeatureSet_Utf8Validation2[FeatureSet_Utf8Validation2["NONE"] = 3] = "NONE";
+})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
+var FeatureSet_MessageEncoding;
+(function(FeatureSet_MessageEncoding2) {
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED";
+  FeatureSet_MessageEncoding2[FeatureSet_MessageEncoding2["DELIMITED"] = 2] = "DELIMITED";
+})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {}));
+var FeatureSet_JsonFormat;
+(function(FeatureSet_JsonFormat2) {
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["ALLOW"] = 1] = "ALLOW";
+  FeatureSet_JsonFormat2[FeatureSet_JsonFormat2["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT";
+})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {}));
+var FeatureSet_EnforceNamingStyle;
+(function(FeatureSet_EnforceNamingStyle2) {
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE2024"] = 1] = "STYLE2024";
+  FeatureSet_EnforceNamingStyle2[FeatureSet_EnforceNamingStyle2["STYLE_LEGACY"] = 2] = "STYLE_LEGACY";
+})(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {}));
+var GeneratedCodeInfo_Annotation_Semantic;
+(function(GeneratedCodeInfo_Annotation_Semantic2) {
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["NONE"] = 0] = "NONE";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["SET"] = 1] = "SET";
+  GeneratedCodeInfo_Annotation_Semantic2[GeneratedCodeInfo_Annotation_Semantic2["ALIAS"] = 2] = "ALIAS";
+})(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {}));
+var Edition;
+(function(Edition2) {
+  Edition2[Edition2["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN";
+  Edition2[Edition2["EDITION_LEGACY"] = 900] = "EDITION_LEGACY";
+  Edition2[Edition2["EDITION_PROTO2"] = 998] = "EDITION_PROTO2";
+  Edition2[Edition2["EDITION_PROTO3"] = 999] = "EDITION_PROTO3";
+  Edition2[Edition2["EDITION_2023"] = 1e3] = "EDITION_2023";
+  Edition2[Edition2["EDITION_2024"] = 1001] = "EDITION_2024";
+  Edition2[Edition2["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY";
+  Edition2[Edition2["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY";
+  Edition2[Edition2["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY";
+  Edition2[Edition2["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY";
+  Edition2[Edition2["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
+  Edition2[Edition2["EDITION_MAX"] = 2147483647] = "EDITION_MAX";
+})(Edition || (Edition = {}));
+const readDefaults = {
+  readUnknownFields: true
+};
+function makeReadOptions(options) {
+  return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+}
+function fromBinary(schema, bytes, options) {
+  const msg = reflect(schema, void 0, false);
+  readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+  return msg.message;
+}
+function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+  var _a;
+  const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+  let fieldNo, wireType;
+  const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+  while (reader.pos < end) {
+    [fieldNo, wireType] = reader.tag();
+    if (delimited && wireType == WireType.EndGroup) {
+      break;
+    }
+    const field = message.findNumber(fieldNo);
+    if (!field) {
+      const data = reader.skip(wireType, fieldNo);
+      if (options.readUnknownFields) {
+        unknownFields.push({ no: fieldNo, wireType, data });
+      }
+      continue;
+    }
+    readField(message, reader, field, wireType, options);
+  }
+  if (delimited) {
+    if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+      throw new Error(`invalid end group tag`);
+    }
+  }
+  if (unknownFields.length > 0) {
+    message.setUnknown(unknownFields);
+  }
+}
+function readField(message, reader, field, wireType, options) {
+  switch (field.fieldKind) {
+    case "scalar":
+      message.set(field, readScalar(reader, field.scalar));
+      break;
+    case "enum":
+      message.set(field, readScalar(reader, ScalarType.INT32));
+      break;
+    case "message":
+      message.set(field, readMessageField(reader, options, field, message.get(field)));
+      break;
+    case "list":
+      readListField(reader, wireType, message.get(field), options);
+      break;
+    case "map":
+      readMapEntry(reader, message.get(field), options);
+      break;
+  }
+}
+function readMapEntry(reader, map, options) {
+  const field = map.field();
+  let key, val;
+  const end = reader.pos + reader.uint32();
+  while (reader.pos < end) {
+    const [fieldNo] = reader.tag();
+    switch (fieldNo) {
+      case 1:
+        key = readScalar(reader, field.mapKey);
+        break;
+      case 2:
+        switch (field.mapKind) {
+          case "scalar":
+            val = readScalar(reader, field.scalar);
+            break;
+          case "enum":
+            val = reader.int32();
+            break;
+          case "message":
+            val = readMessageField(reader, options, field);
+            break;
+        }
+        break;
+    }
+  }
+  if (key === void 0) {
+    key = scalarZeroValue(field.mapKey, false);
+  }
+  if (val === void 0) {
+    switch (field.mapKind) {
+      case "scalar":
+        val = scalarZeroValue(field.scalar, false);
+        break;
+      case "enum":
+        val = field.enum.values[0].number;
+        break;
+      case "message":
+        val = reflect(field.message, void 0, false);
+        break;
+    }
+  }
+  map.set(key, val);
+}
+function readListField(reader, wireType, list, options) {
+  var _a;
+  const field = list.field();
+  if (field.listKind === "message") {
+    list.add(readMessageField(reader, options, field));
+    return;
+  }
+  const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+  const packed = wireType == WireType.LengthDelimited && scalarType != ScalarType.STRING && scalarType != ScalarType.BYTES;
+  if (!packed) {
+    list.add(readScalar(reader, scalarType));
+    return;
+  }
+  const e = reader.uint32() + reader.pos;
+  while (reader.pos < e) {
+    list.add(readScalar(reader, scalarType));
+  }
+}
+function readMessageField(reader, options, field, mergeMessage) {
+  const delimited = field.delimitedEncoding;
+  const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, void 0, false);
+  readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+  return message;
+}
+function readScalar(reader, type) {
+  switch (type) {
+    case ScalarType.STRING:
+      return reader.string();
+    case ScalarType.BOOL:
+      return reader.bool();
+    case ScalarType.DOUBLE:
+      return reader.double();
+    case ScalarType.FLOAT:
+      return reader.float();
+    case ScalarType.INT32:
+      return reader.int32();
+    case ScalarType.INT64:
+      return reader.int64();
+    case ScalarType.UINT64:
+      return reader.uint64();
+    case ScalarType.FIXED64:
+      return reader.fixed64();
+    case ScalarType.BYTES:
+      return reader.bytes();
+    case ScalarType.FIXED32:
+      return reader.fixed32();
+    case ScalarType.SFIXED32:
+      return reader.sfixed32();
+    case ScalarType.SFIXED64:
+      return reader.sfixed64();
+    case ScalarType.SINT64:
+      return reader.sint64();
+    case ScalarType.UINT32:
+      return reader.uint32();
+    case ScalarType.SINT32:
+      return reader.sint32();
+  }
+}
+function fileDesc(b64, imports) {
+  var _a;
+  const root = fromBinary(FileDescriptorProtoSchema, base64Decode(b64));
+  root.messageType.forEach(restoreJsonNames);
+  root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : [];
+  const reg = createFileRegistry(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName));
+  return reg.getFile(root.name);
+}
+function serviceDesc(file, path, ...paths) {
+  if (paths.length > 0) {
+    throw new Error();
+  }
+  return file.services[path];
+}
+const file_streamlayer_common_streamlayer_common = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_descriptor]);
+var NotificationType;
+(function(NotificationType2) {
+  NotificationType2[NotificationType2["ONBOARDING"] = 1] = "ONBOARDING";
+  NotificationType2[NotificationType2["QUESTION"] = 2] = "QUESTION";
+  NotificationType2[NotificationType2["QUESTION_RESOLVED"] = 3] = "QUESTION_RESOLVED";
+})(NotificationType || (NotificationType = {}));
+window.slStore = /* @__PURE__ */ Object.create(null);
+var FeatureSource;
+(function(FeatureSource2) {
+  FeatureSource2["ORGANIZATION"] = "ORGANIZATION";
+  FeatureSource2["STREAM"] = "STREAM";
+})(FeatureSource || (FeatureSource = {}));
 var FeatureStatus;
 (function(FeatureStatus2) {
   FeatureStatus2["Ready"] = "ready";
@@ -815,8 +3558,11 @@ createLogger("grpc:retry");
   retryAttempts: createContextKey(10, { description: "Number of attempts to retry" }),
   retryDelay: createContextKey(3e4, { description: "Max delay between retries in milliseconds" })
 });
+const file_streamlayer_users_users_common = /* @__PURE__ */ fileDesc("CiRzdHJlYW1sYXllci91c2Vycy91c2Vyc19jb21tb24ucHJvdG8SEXN0cmVhbWxheWVyLnVzZXJzIh4KDlB1YmxpY0NoYXRVc2VyEgwKBG5hbWUYASABKAkioAEKDlVzZXJBdHRyaWJ1dGVzEhAKCHVzZXJuYW1lGAEgASgJEgwKBG5hbWUYAiABKAkSDQoFYWxpYXMYAyABKAkSDgoGYXZhdGFyGAUgASgJEjoKC3B1YmxpY19jaGF0GAYgASgLMiEuc3RyZWFtbGF5ZXIudXNlcnMuUHVibGljQ2hhdFVzZXJCAhgBEhMKC3B1YmxpY19uYW1lGAcgASgJIjMKEFVzZXJPcmdhbml6YXRpb24SCgoCaWQYASABKAkSEwoLcGVybWlzc2lvbnMYAiADKAki/wEKDFVzZXJNZXRhZGF0YRIOCgZhdmF0YXIYAiABKAkSIAoYYXZhdGFyX2JhY2tncm91bmRfY29sb3VyGAMgASgJEhAKCHRpbWV6b25lGAQgASgJEk4KF25vdGlmaWNhdGlvbl9wcmVmZXJlbmNlGAUgASgOMi0uc3RyZWFtbGF5ZXIudXNlcnMuVXNlck5vdGlmaWNhdGlvblByZWZlcmVuY2USDgoGYWN0aXZlGAYgASgIEhIKCmZpcnN0X25hbWUYByABKAkSEQoJbGFzdF9uYW1lGAggASgJEg0KBXJvbGVzGAkgAygJEhUKDWF1ZGllbmNlX3RhZ3MYCiADKAkiegoWRXh0ZW5kZWRVc2VyQXR0cmlidXRlcxIQCgh1c2VybmFtZRgBIAEoCRIMCgRuYW1lGAIgASgJEg0KBWFsaWFzGAMgASgJEjEKCG1ldGFkYXRhGAQgASgLMh8uc3RyZWFtbGF5ZXIudXNlcnMuVXNlck1ldGFkYXRhIlcKBFVzZXISCgoCaWQYASABKAkSDAoEdHlwZRgCIAEoCRI1CgphdHRyaWJ1dGVzGAMgASgLMiEuc3RyZWFtbGF5ZXIudXNlcnMuVXNlckF0dHJpYnV0ZXMiZwoMRXh0ZW5kZWRVc2VyEgoKAmlkGAEgASgJEgwKBHR5cGUYAiABKAkSPQoKYXR0cmlidXRlcxgDIAEoCzIpLnN0cmVhbWxheWVyLnVzZXJzLkV4dGVuZGVkVXNlckF0dHJpYnV0ZXMq5gEKGlVzZXJOb3RpZmljYXRpb25QcmVmZXJlbmNlEiYKIlVTRVJfTk9USUZJQ0FUSU9OX1BSRUZFUkVOQ0VfVU5TRVQQABIrCidVU0VSX05PVElGSUNBVElPTl9QUkVGRVJFTkNFX0FMTF9FVkVOVFMQARI2CjJVU0VSX05PVElGSUNBVElPTl9QUkVGRVJFTkNFX0lNUE9SVEFOVF9FVkVOVFNfT05MWRACEjsKN1VTRVJfTk9USUZJQ0FUSU9OX1BSRUZFUkVOQ0VfREFJTFlfU1VNTUFSWV9BTkRfTUVOVElPTlMQA0KKAQoVY29tLnN0cmVhbWxheWVyLnVzZXJzQhtTdHJlYW1MYXllclVzZXJzQ29tbW9uUHJvdG9QAVpJZ2l0aHViLmNvbS9zdHJlYW1sYXllci9zbC1wcm90b2ZpbGVzLy5idWlsZC9nby9zdHJlYW1sYXllci91c2VycztzbF91c2Vyc6ICBlNMX0FQSWIGcHJvdG8z");
+const file_streamlayer_users_users = /* @__PURE__ */ fileDesc("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", [file_streamlayer_common_streamlayer_common, file_streamlayer_users_users_common]);
+const Users = /* @__PURE__ */ serviceDesc(file_streamlayer_users_users, 0);
 const bypassAuth = (transport, params) => {
-  const { client, createRequestOptions } = transport.createPromiseClient(users_pb.Users, { method: "bypassAuth" });
+  const { client, createRequestOptions } = transport.createPromiseClient(Users, { method: "bypassAuth" });
   const contextValues = createRequestOptions({ retryAttempts: 0 });
   return client.bypassAuth(params, { contextValues });
 };