@bite-ninja/zenu-sdk 0.2.3

package/dist/index.js

@@ -0,0 +1,3713 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node_modules/nice-grpc-common/lib/Metadata.js
+var require_Metadata = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Metadata = undefined;
+  exports.Metadata = function Metadata(init) {
+    const data = new Map;
+    const metadata = {
+      set(key, value) {
+        key = normalizeKey(key);
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            data.delete(key);
+          } else {
+            for (const item of value) {
+              validate(key, item);
+            }
+            data.set(key, key.endsWith("-bin") ? value : [value.join(", ")]);
+          }
+        } else {
+          validate(key, value);
+          data.set(key, [value]);
+        }
+        return metadata;
+      },
+      append(key, value) {
+        key = normalizeKey(key);
+        validate(key, value);
+        let values = data.get(key);
+        if (values == null) {
+          values = [];
+          data.set(key, values);
+        }
+        values.push(value);
+        if (!key.endsWith("-bin")) {
+          data.set(key, [values.join(", ")]);
+        }
+        return metadata;
+      },
+      delete(key) {
+        key = normalizeKey(key);
+        data.delete(key);
+      },
+      get(key) {
+        var _a;
+        key = normalizeKey(key);
+        return (_a = data.get(key)) === null || _a === undefined ? undefined : _a[0];
+      },
+      getAll(key) {
+        var _a;
+        key = normalizeKey(key);
+        return (_a = data.get(key)) !== null && _a !== undefined ? _a : [];
+      },
+      has(key) {
+        key = normalizeKey(key);
+        return data.has(key);
+      },
+      [Symbol.iterator]() {
+        return data[Symbol.iterator]();
+      }
+    };
+    if (init != null) {
+      const entries = isIterable(init) ? init : Object.entries(init);
+      for (const [key, value] of entries) {
+        metadata.set(key, value);
+      }
+    }
+    return metadata;
+  };
+  function normalizeKey(key) {
+    return key.toLowerCase();
+  }
+  function validate(key, value) {
+    if (!/^[0-9a-z_.-]+$/.test(key)) {
+      throw new Error(`Metadata key '${key}' contains illegal characters`);
+    }
+    if (key.endsWith("-bin")) {
+      if (!(value instanceof Uint8Array)) {
+        throw new Error(`Metadata key '${key}' ends with '-bin', thus it must have binary value`);
+      }
+    } else {
+      if (typeof value !== "string") {
+        throw new Error(`Metadata key '${key}' doesn't end with '-bin', thus it must have string value`);
+      }
+      if (!/^[ -~]*$/.test(value)) {
+        throw new Error(`Metadata value '${value}' of key '${key}' contains illegal characters`);
+      }
+    }
+  }
+  function isIterable(value) {
+    return Symbol.iterator in value;
+  }
+});
+
+// node_modules/nice-grpc-common/lib/Status.js
+var require_Status = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Status = undefined;
+  var Status;
+  (function(Status2) {
+    Status2[Status2["OK"] = 0] = "OK";
+    Status2[Status2["CANCELLED"] = 1] = "CANCELLED";
+    Status2[Status2["UNKNOWN"] = 2] = "UNKNOWN";
+    Status2[Status2["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+    Status2[Status2["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+    Status2[Status2["NOT_FOUND"] = 5] = "NOT_FOUND";
+    Status2[Status2["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
+    Status2[Status2["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+    Status2[Status2["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+    Status2[Status2["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
+    Status2[Status2["ABORTED"] = 10] = "ABORTED";
+    Status2[Status2["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
+    Status2[Status2["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+    Status2[Status2["INTERNAL"] = 13] = "INTERNAL";
+    Status2[Status2["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+    Status2[Status2["DATA_LOSS"] = 15] = "DATA_LOSS";
+    Status2[Status2["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+  })(Status = exports.Status || (exports.Status = {}));
+});
+
+// node_modules/nice-grpc-common/lib/MethodDescriptor.js
+var require_MethodDescriptor = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/nice-grpc-common/lib/client/CallOptions.js
+var require_CallOptions = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/nice-grpc-common/lib/client/ClientMiddleware.js
+var require_ClientMiddleware = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/nice-grpc-common/lib/client/composeClientMiddleware.js
+var require_composeClientMiddleware = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.composeClientMiddleware = undefined;
+  function composeClientMiddleware(middleware1, middleware2) {
+    return (call, options) => {
+      return middleware2(Object.assign(Object.assign({}, call), { next: (request, options2) => {
+        return middleware1(Object.assign(Object.assign({}, call), { request }), options2);
+      } }), options);
+    };
+  }
+  exports.composeClientMiddleware = composeClientMiddleware;
+});
+
+// node_modules/ts-error/lib/helpers.js
+var require_helpers = __commonJS((exports) => {
+  exports.__esModule = undefined;
+  exports.__esModule = true;
+  var objectSetPrototypeOfIsDefined = typeof Object.setPrototypeOf === "function";
+  var objectGetPrototypeOfIsDefined = typeof Object.getPrototypeOf === "function";
+  var objectDefinePropertyIsDefined = typeof Object.defineProperty === "function";
+  var objectCreateIsDefined = typeof Object.create === "function";
+  var objectHasOwnPropertyIsDefined = typeof Object.prototype.hasOwnProperty === "function";
+  var setPrototypeOf = function setPrototypeOf(target, prototype) {
+    if (objectSetPrototypeOfIsDefined) {
+      Object.setPrototypeOf(target, prototype);
+    } else {
+      target.__proto__ = prototype;
+    }
+  };
+  exports.setPrototypeOf = setPrototypeOf;
+  var getPrototypeOf = function getPrototypeOf(target) {
+    if (objectGetPrototypeOfIsDefined) {
+      return Object.getPrototypeOf(target);
+    } else {
+      return target.__proto__ || target.prototype;
+    }
+  };
+  exports.getPrototypeOf = getPrototypeOf;
+  var ie8ObjectDefinePropertyBug = false;
+  var defineProperty = function defineProperty(target, name, propertyDescriptor) {
+    if (objectDefinePropertyIsDefined && !ie8ObjectDefinePropertyBug) {
+      try {
+        Object.defineProperty(target, name, propertyDescriptor);
+      } catch (e) {
+        ie8ObjectDefinePropertyBug = true;
+        defineProperty(target, name, propertyDescriptor);
+      }
+    } else {
+      target[name] = propertyDescriptor.value;
+    }
+  };
+  exports.defineProperty = defineProperty;
+  var hasOwnProperty = function hasOwnProperty(target, name) {
+    if (objectHasOwnPropertyIsDefined) {
+      return target.hasOwnProperty(target, name);
+    } else {
+      return target[name] === undefined;
+    }
+  };
+  exports.hasOwnProperty = hasOwnProperty;
+  var objectCreate = function objectCreate(prototype, propertyDescriptors) {
+    if (objectCreateIsDefined) {
+      return Object.create(prototype, propertyDescriptors);
+    } else {
+      var F = function F() {};
+      F.prototype = prototype;
+      var result = new F;
+      if (typeof propertyDescriptors === "undefined") {
+        return result;
+      }
+      if (typeof propertyDescriptors === "null") {
+        throw new Error("PropertyDescriptors must not be null.");
+      }
+      if (typeof propertyDescriptors === "object") {
+        for (var key in propertyDescriptors) {
+          if (hasOwnProperty(propertyDescriptors, key)) {
+            result[key] = propertyDescriptors[key].value;
+          }
+        }
+      }
+      return result;
+    }
+  };
+  exports.objectCreate = objectCreate;
+});
+
+// node_modules/ts-error/lib/cjs.js
+var require_cjs = __commonJS((exports) => {
+  exports.__esModule = undefined;
+  exports.__esModule = true;
+  var helpers = require_helpers();
+  var setPrototypeOf = helpers.setPrototypeOf;
+  var getPrototypeOf = helpers.getPrototypeOf;
+  var defineProperty = helpers.defineProperty;
+  var objectCreate = helpers.objectCreate;
+  var uglyErrorPrinting = new Error().toString() === "[object Error]";
+  var extendableErrorName = "";
+  function ExtendableError(message) {
+    var originalConstructor = this.constructor;
+    var constructorName = originalConstructor.name || function() {
+      var constructorNameMatch = originalConstructor.toString().match(/^function\s*([^\s(]+)/);
+      return constructorNameMatch === null ? extendableErrorName ? extendableErrorName : "Error" : constructorNameMatch[1];
+    }();
+    var constructorNameIsError = constructorName === "Error";
+    var name = constructorNameIsError ? extendableErrorName : constructorName;
+    var instance = Error.apply(this, arguments);
+    setPrototypeOf(instance, getPrototypeOf(this));
+    if (!(instance instanceof originalConstructor) || !(instance instanceof ExtendableError)) {
+      var instance = this;
+      Error.apply(this, arguments);
+      defineProperty(instance, "message", {
+        configurable: true,
+        enumerable: false,
+        value: message,
+        writable: true
+      });
+    }
+    defineProperty(instance, "name", {
+      configurable: true,
+      enumerable: false,
+      value: name,
+      writable: true
+    });
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(instance, constructorNameIsError ? ExtendableError : originalConstructor);
+    }
+    if (instance.stack === undefined) {
+      var err = new Error(message);
+      err.name = instance.name;
+      instance.stack = err.stack;
+    }
+    if (uglyErrorPrinting) {
+      defineProperty(instance, "toString", {
+        configurable: true,
+        enumerable: false,
+        value: function toString() {
+          return (this.name || "Error") + (typeof this.message === "undefined" ? "" : ": " + this.message);
+        },
+        writable: true
+      });
+    }
+    return instance;
+  }
+  extendableErrorName = ExtendableError.name || "ExtendableError";
+  ExtendableError.prototype = objectCreate(Error.prototype, {
+    constructor: {
+      value: Error,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  exports.ExtendableError = ExtendableError;
+  exports.default = exports.ExtendableError;
+});
+
+// node_modules/nice-grpc-common/lib/client/ClientError.js
+var require_ClientError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ClientError = undefined;
+  var ts_error_1 = require_cjs();
+  var Status_1 = require_Status();
+
+  class ClientError extends ts_error_1.ExtendableError {
+    constructor(path, code, details) {
+      super(`${path} ${Status_1.Status[code]}: ${details}`);
+      this.path = path;
+      this.code = code;
+      this.details = details;
+      this.name = "ClientError";
+      Object.defineProperty(this, "@@nice-grpc", {
+        value: true
+      });
+      Object.defineProperty(this, "@@nice-grpc:ClientError", {
+        value: true
+      });
+    }
+    static [Symbol.hasInstance](instance) {
+      if (this !== ClientError) {
+        return this.prototype.isPrototypeOf(instance);
+      }
+      return typeof instance === "object" && instance !== null && (instance.constructor === ClientError || instance["@@nice-grpc:ClientError"] === true || instance.name === "ClientError" && instance["@@nice-grpc"] === true);
+    }
+  }
+  exports.ClientError = ClientError;
+});
+
+// node_modules/nice-grpc-common/lib/server/CallContext.js
+var require_CallContext = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/nice-grpc-common/lib/server/ServerMiddleware.js
+var require_ServerMiddleware = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/nice-grpc-common/lib/server/composeServerMiddleware.js
+var require_composeServerMiddleware = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.composeServerMiddleware = undefined;
+  function composeServerMiddleware(middleware1, middleware2) {
+    return (call, context) => {
+      return middleware1(Object.assign(Object.assign({}, call), { next: (request, context1) => {
+        return middleware2(Object.assign(Object.assign({}, call), { request }), context1);
+      } }), context);
+    };
+  }
+  exports.composeServerMiddleware = composeServerMiddleware;
+});
+
+// node_modules/nice-grpc-common/lib/server/ServerError.js
+var require_ServerError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ServerError = undefined;
+  var ts_error_1 = require_cjs();
+  var Status_1 = require_Status();
+
+  class ServerError extends ts_error_1.ExtendableError {
+    constructor(code, details) {
+      super(`${Status_1.Status[code]}: ${details}`);
+      this.code = code;
+      this.details = details;
+      this.name = "ServerError";
+      Object.defineProperty(this, "@@nice-grpc", {
+        value: true
+      });
+      Object.defineProperty(this, "@@nice-grpc:ServerError", {
+        value: true
+      });
+    }
+    static [Symbol.hasInstance](instance) {
+      if (this !== ServerError) {
+        return this.prototype.isPrototypeOf(instance);
+      }
+      return typeof instance === "object" && instance !== null && (instance.constructor === ServerError || instance["@@nice-grpc:ServerError"] === true || instance.name === "ServerError" && instance["@@nice-grpc"] === true);
+    }
+  }
+  exports.ServerError = ServerError;
+});
+
+// node_modules/nice-grpc-common/lib/index.js
+var require_lib = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_Metadata(), exports);
+  __exportStar(require_Status(), exports);
+  __exportStar(require_MethodDescriptor(), exports);
+  __exportStar(require_CallOptions(), exports);
+  __exportStar(require_ClientMiddleware(), exports);
+  __exportStar(require_composeClientMiddleware(), exports);
+  __exportStar(require_ClientError(), exports);
+  __exportStar(require_CallContext(), exports);
+  __exportStar(require_ServerMiddleware(), exports);
+  __exportStar(require_composeServerMiddleware(), exports);
+  __exportStar(require_ServerError(), exports);
+});
+
+// node_modules/nice-grpc-web/lib/service-definitions/grpc-web.js
+var require_grpc_web = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromGrpcWebServiceDefinition = fromGrpcWebServiceDefinition;
+  exports.isGrpcWebServiceDefinition = isGrpcWebServiceDefinition;
+  function fromGrpcWebServiceDefinition(definition) {
+    const result = {};
+    for (const [key, value] of Object.entries(definition)) {
+      if (key === "serviceName") {
+        continue;
+      }
+      const method = value;
+      result[uncapitalize(key)] = {
+        path: `/${definition.serviceName}/${key}`,
+        requestStream: method.requestStream,
+        responseStream: method.responseStream,
+        requestDeserialize: method.requestType.deserializeBinary,
+        requestSerialize: (value2) => value2.serializeBinary(),
+        responseDeserialize: method.responseType.deserializeBinary,
+        responseSerialize: (value2) => value2.serializeBinary(),
+        options: {}
+      };
+    }
+    return result;
+  }
+  function isGrpcWebServiceDefinition(definition) {
+    return "prototype" in definition;
+  }
+  function uncapitalize(value) {
+    if (value.length === 0) {
+      return value;
+    }
+    return value[0].toLowerCase() + value.slice(1);
+  }
+});
+
+// node_modules/nice-grpc-web/lib/service-definitions/ts-proto.js
+var require_ts_proto = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromTsProtoServiceDefinition = fromTsProtoServiceDefinition;
+  exports.isTsProtoServiceDefinition = isTsProtoServiceDefinition;
+  function fromTsProtoServiceDefinition(definition) {
+    const result = {};
+    for (const [key, method] of Object.entries(definition.methods)) {
+      const requestEncode = method.requestType.encode;
+      const requestFromPartial = method.requestType.fromPartial;
+      const responseEncode = method.responseType.encode;
+      const responseFromPartial = method.responseType.fromPartial;
+      result[key] = {
+        path: `/${definition.fullName}/${method.name}`,
+        requestStream: method.requestStream,
+        responseStream: method.responseStream,
+        requestDeserialize: method.requestType.decode,
+        requestSerialize: requestFromPartial != null ? (value) => requestEncode(requestFromPartial(value)).finish() : (value) => requestEncode(value).finish(),
+        responseDeserialize: method.responseType.decode,
+        responseSerialize: responseFromPartial != null ? (value) => responseEncode(responseFromPartial(value)).finish() : (value) => responseEncode(value).finish(),
+        options: method.options
+      };
+    }
+    return result;
+  }
+  function isTsProtoServiceDefinition(definition) {
+    return "name" in definition && "fullName" in definition && "methods" in definition;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/service-definitions/index.js
+var require_service_definitions = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.normalizeServiceDefinition = normalizeServiceDefinition;
+  var grpc_web_1 = require_grpc_web();
+  var ts_proto_1 = require_ts_proto();
+  function normalizeServiceDefinition(definition) {
+    if ((0, grpc_web_1.isGrpcWebServiceDefinition)(definition)) {
+      return (0, grpc_web_1.fromGrpcWebServiceDefinition)(definition);
+    } else if ((0, ts_proto_1.isTsProtoServiceDefinition)(definition)) {
+      return (0, ts_proto_1.fromTsProtoServiceDefinition)(definition);
+    } else {
+      return definition;
+    }
+  }
+});
+
+// node_modules/abort-controller-x/lib/AbortError.js
+var require_AbortError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.catchAbortError = exports.rethrowAbortError = exports.throwIfAborted = exports.isAbortError = exports.AbortError = undefined;
+
+  class AbortError extends Error {
+    constructor() {
+      super("The operation has been aborted");
+      this.message = "The operation has been aborted";
+      this.name = "AbortError";
+      if (typeof Error.captureStackTrace === "function") {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+  }
+  exports.AbortError = AbortError;
+  function isAbortError(error) {
+    return typeof error === "object" && error !== null && error.name === "AbortError";
+  }
+  exports.isAbortError = isAbortError;
+  function throwIfAborted(signal) {
+    if (signal.aborted) {
+      throw new AbortError;
+    }
+  }
+  exports.throwIfAborted = throwIfAborted;
+  function rethrowAbortError(error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    return;
+  }
+  exports.rethrowAbortError = rethrowAbortError;
+  function catchAbortError(error) {
+    if (isAbortError(error)) {
+      return;
+    }
+    throw error;
+  }
+  exports.catchAbortError = catchAbortError;
+});
+
+// node_modules/abort-controller-x/lib/execute.js
+var require_execute = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.execute = undefined;
+  var AbortError_1 = require_AbortError();
+  function execute(signal, executor) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new AbortError_1.AbortError);
+        return;
+      }
+      let removeAbortListener;
+      let finished = false;
+      function finish() {
+        if (!finished) {
+          finished = true;
+          if (removeAbortListener != null) {
+            removeAbortListener();
+          }
+        }
+      }
+      const callback = executor((value) => {
+        resolve(value);
+        finish();
+      }, (reason) => {
+        reject(reason);
+        finish();
+      });
+      if (!finished) {
+        const listener = () => {
+          const callbackResult = callback();
+          if (callbackResult == null) {
+            reject(new AbortError_1.AbortError);
+          } else {
+            callbackResult.then(() => {
+              reject(new AbortError_1.AbortError);
+            }, (reason) => {
+              reject(reason);
+            });
+          }
+          finish();
+        };
+        signal.addEventListener("abort", listener);
+        removeAbortListener = () => {
+          signal.removeEventListener("abort", listener);
+        };
+      }
+    });
+  }
+  exports.execute = execute;
+});
+
+// node_modules/abort-controller-x/lib/abortable.js
+var require_abortable = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.abortable = undefined;
+  var execute_1 = require_execute();
+  function abortable(signal, promise) {
+    if (signal.aborted) {
+      const noop = () => {};
+      promise.then(noop, noop);
+    }
+    return (0, execute_1.execute)(signal, (resolve, reject) => {
+      promise.then(resolve, reject);
+      return () => {};
+    });
+  }
+  exports.abortable = abortable;
+});
+
+// node_modules/abort-controller-x/lib/delay.js
+var require_delay = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.delay = undefined;
+  var execute_1 = require_execute();
+  function delay(signal, dueTime) {
+    return (0, execute_1.execute)(signal, (resolve) => {
+      const ms = typeof dueTime === "number" ? dueTime : dueTime.getTime() - Date.now();
+      const timer = setTimeout(resolve, ms);
+      return () => {
+        clearTimeout(timer);
+      };
+    });
+  }
+  exports.delay = delay;
+});
+
+// node_modules/abort-controller-x/lib/forever.js
+var require_forever = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.forever = undefined;
+  var execute_1 = require_execute();
+  function forever(signal) {
+    return (0, execute_1.execute)(signal, () => () => {});
+  }
+  exports.forever = forever;
+});
+
+// node_modules/abort-controller-x/lib/waitForEvent.js
+var require_waitForEvent = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.waitForEvent = undefined;
+  var execute_1 = require_execute();
+  function waitForEvent(signal, target, eventName, options) {
+    return (0, execute_1.execute)(signal, (resolve) => {
+      let unlisten;
+      let finished = false;
+      const handler = (...args) => {
+        resolve(args.length > 1 ? args : args[0]);
+        finished = true;
+        if (unlisten != null) {
+          unlisten();
+        }
+      };
+      unlisten = listen(target, eventName, handler, options);
+      if (finished) {
+        unlisten();
+      }
+      return () => {
+        finished = true;
+        if (unlisten != null) {
+          unlisten();
+        }
+      };
+    });
+  }
+  exports.waitForEvent = waitForEvent;
+  function listen(target, eventName, handler, options) {
+    if (isEventTarget(target)) {
+      target.addEventListener(eventName, handler, options);
+      return () => target.removeEventListener(eventName, handler, options);
+    }
+    if (isJQueryStyleEventEmitter(target)) {
+      target.on(eventName, handler);
+      return () => target.off(eventName, handler);
+    }
+    if (isNodeStyleEventEmitter(target)) {
+      target.addListener(eventName, handler);
+      return () => target.removeListener(eventName, handler);
+    }
+    throw new Error("Invalid event target");
+  }
+  function isNodeStyleEventEmitter(sourceObj) {
+    return isFunction(sourceObj.addListener) && isFunction(sourceObj.removeListener);
+  }
+  function isJQueryStyleEventEmitter(sourceObj) {
+    return isFunction(sourceObj.on) && isFunction(sourceObj.off);
+  }
+  function isEventTarget(sourceObj) {
+    return isFunction(sourceObj.addEventListener) && isFunction(sourceObj.removeEventListener);
+  }
+  var isFunction = (obj) => typeof obj === "function";
+});
+
+// node_modules/abort-controller-x/lib/all.js
+var require_all = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.all = undefined;
+  var AbortError_1 = require_AbortError();
+  function all(signal, executor) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new AbortError_1.AbortError);
+        return;
+      }
+      const innerAbortController = new AbortController;
+      const promises = executor(innerAbortController.signal);
+      if (promises.length === 0) {
+        resolve([]);
+        return;
+      }
+      const abortListener = () => {
+        innerAbortController.abort();
+      };
+      signal.addEventListener("abort", abortListener);
+      let rejection;
+      const results = new Array(promises.length);
+      let settledCount = 0;
+      function settled() {
+        settledCount += 1;
+        if (settledCount === promises.length) {
+          signal.removeEventListener("abort", abortListener);
+          if (rejection != null) {
+            reject(rejection.reason);
+          } else {
+            resolve(results);
+          }
+        }
+      }
+      for (const [i, promise] of promises.entries()) {
+        promise.then((value) => {
+          results[i] = value;
+          settled();
+        }, (reason) => {
+          innerAbortController.abort();
+          if (rejection == null || !(0, AbortError_1.isAbortError)(reason) && (0, AbortError_1.isAbortError)(rejection.reason)) {
+            rejection = { reason };
+          }
+          settled();
+        });
+      }
+    });
+  }
+  exports.all = all;
+});
+
+// node_modules/abort-controller-x/lib/race.js
+var require_race = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.race = undefined;
+  var AbortError_1 = require_AbortError();
+  function race(signal, executor) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new AbortError_1.AbortError);
+        return;
+      }
+      const innerAbortController = new AbortController;
+      const promises = executor(innerAbortController.signal);
+      const abortListener = () => {
+        innerAbortController.abort();
+      };
+      signal.addEventListener("abort", abortListener);
+      let settledCount = 0;
+      function settled(result2) {
+        innerAbortController.abort();
+        settledCount += 1;
+        if (settledCount === promises.length) {
+          signal.removeEventListener("abort", abortListener);
+          if (result2.status === "fulfilled") {
+            resolve(result2.value);
+          } else {
+            reject(result2.reason);
+          }
+        }
+      }
+      let result;
+      for (const promise of promises) {
+        promise.then((value) => {
+          if (result == null) {
+            result = { status: "fulfilled", value };
+          }
+          settled(result);
+        }, (reason) => {
+          if (result == null || !(0, AbortError_1.isAbortError)(reason) && (result.status === "fulfilled" || (0, AbortError_1.isAbortError)(result.reason))) {
+            result = { status: "rejected", reason };
+          }
+          settled(result);
+        });
+      }
+    });
+  }
+  exports.race = race;
+});
+
+// node_modules/abort-controller-x/lib/retry.js
+var require_retry = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.retry = undefined;
+  var delay_1 = require_delay();
+  var AbortError_1 = require_AbortError();
+  async function retry(signal, fn, options = {}) {
+    const { baseMs = 1000, maxDelayMs = 30000, onError, maxAttempts = Infinity } = options;
+    let attempt = 0;
+    const reset = () => {
+      attempt = -1;
+    };
+    while (true) {
+      try {
+        return await fn(signal, attempt, reset);
+      } catch (error) {
+        (0, AbortError_1.rethrowAbortError)(error);
+        if (attempt >= maxAttempts) {
+          throw error;
+        }
+        let delayMs;
+        if (attempt === -1) {
+          delayMs = 0;
+        } else {
+          const backoff = Math.min(maxDelayMs, Math.pow(2, attempt) * baseMs);
+          delayMs = Math.round(backoff * (1 + Math.random()) / 2);
+        }
+        if (onError) {
+          onError(error, attempt, delayMs);
+        }
+        if (delayMs !== 0) {
+          await (0, delay_1.delay)(signal, delayMs);
+        }
+        attempt += 1;
+      }
+    }
+  }
+  exports.retry = retry;
+});
+
+// node_modules/abort-controller-x/lib/spawn.js
+var require_spawn = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.spawn = undefined;
+  var AbortError_1 = require_AbortError();
+  function spawn(signal, fn) {
+    if (signal.aborted) {
+      return Promise.reject(new AbortError_1.AbortError);
+    }
+    const deferredFunctions = [];
+    const spawnAbortController = new AbortController;
+    const spawnSignal = spawnAbortController.signal;
+    const abortSpawn = () => {
+      spawnAbortController.abort();
+    };
+    signal.addEventListener("abort", abortSpawn);
+    const removeAbortListener = () => {
+      signal.removeEventListener("abort", abortSpawn);
+    };
+    const tasks = new Set;
+    const abortTasks = () => {
+      for (const task of tasks) {
+        task.abort();
+      }
+    };
+    spawnSignal.addEventListener("abort", abortTasks);
+    const removeSpawnAbortListener = () => {
+      spawnSignal.removeEventListener("abort", abortTasks);
+    };
+    let promise = new Promise((resolve, reject) => {
+      let result;
+      let failure;
+      fork((signal2) => fn(signal2, {
+        defer(fn2) {
+          deferredFunctions.push(fn2);
+        },
+        fork
+      })).join().then((value) => {
+        spawnAbortController.abort();
+        result = { value };
+      }, (error) => {
+        spawnAbortController.abort();
+        if (!(0, AbortError_1.isAbortError)(error) || failure == null) {
+          failure = { error };
+        }
+      });
+      function fork(forkFn) {
+        if (spawnSignal.aborted) {
+          return {
+            abort() {},
+            async join() {
+              throw new AbortError_1.AbortError;
+            }
+          };
+        }
+        const taskAbortController = new AbortController;
+        const taskSignal = taskAbortController.signal;
+        const taskPromise = forkFn(taskSignal);
+        const task = {
+          abort() {
+            taskAbortController.abort();
+          },
+          join: () => taskPromise
+        };
+        tasks.add(task);
+        taskPromise.catch(AbortError_1.catchAbortError).catch((error) => {
+          failure = { error };
+          spawnAbortController.abort();
+        }).finally(() => {
+          tasks.delete(task);
+          if (tasks.size === 0) {
+            if (failure != null) {
+              reject(failure.error);
+            } else {
+              resolve(result.value);
+            }
+          }
+        });
+        return task;
+      }
+    });
+    promise = promise.finally(() => {
+      removeAbortListener();
+      removeSpawnAbortListener();
+      let deferPromise = Promise.resolve();
+      for (let i = deferredFunctions.length - 1;i >= 0; i--) {
+        deferPromise = deferPromise.finally(deferredFunctions[i]);
+      }
+      return deferPromise;
+    });
+    return promise;
+  }
+  exports.spawn = spawn;
+});
+
+// node_modules/abort-controller-x/lib/run.js
+var require_run = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.run = undefined;
+  var AbortError_1 = require_AbortError();
+  function run(fn) {
+    const abortController = new AbortController;
+    const promise = fn(abortController.signal).catch(AbortError_1.catchAbortError);
+    return () => {
+      abortController.abort();
+      return promise;
+    };
+  }
+  exports.run = run;
+});
+
+// node_modules/abort-controller-x/lib/proactiveRetry.js
+var require_proactiveRetry = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.proactiveRetry = undefined;
+  var AbortError_1 = require_AbortError();
+  var delay_1 = require_delay();
+  var execute_1 = require_execute();
+  function proactiveRetry(signal, fn, options = {}) {
+    const { baseMs = 1000, onError, maxAttempts = Infinity } = options;
+    return (0, execute_1.execute)(signal, (resolve, reject) => {
+      const innerAbortController = new AbortController;
+      let attemptsExhausted = false;
+      const promises = new Map;
+      function handleFulfilled(value) {
+        innerAbortController.abort();
+        promises.clear();
+        resolve(value);
+      }
+      function handleRejected(err, attempt) {
+        promises.delete(attempt);
+        if (attemptsExhausted && promises.size === 0) {
+          reject(err);
+          return;
+        }
+        if ((0, AbortError_1.isAbortError)(err)) {
+          return;
+        }
+        if (onError) {
+          try {
+            onError(err, attempt);
+          } catch (err2) {
+            innerAbortController.abort();
+            promises.clear();
+            reject(err2);
+          }
+        }
+      }
+      async function makeAttempts(signal2) {
+        for (let attempt = 0;; attempt++) {
+          const promise = fn(signal2, attempt);
+          promises.set(attempt, promise);
+          promise.then(handleFulfilled, (err) => handleRejected(err, attempt));
+          if (attempt + 1 >= maxAttempts) {
+            break;
+          }
+          const backoff = Math.pow(2, attempt) * baseMs;
+          const delayMs = Math.round(backoff * (1 + Math.random()) / 2);
+          await (0, delay_1.delay)(signal2, delayMs);
+        }
+        attemptsExhausted = true;
+      }
+      makeAttempts(innerAbortController.signal).catch(AbortError_1.catchAbortError);
+      return () => {
+        innerAbortController.abort();
+      };
+    });
+  }
+  exports.proactiveRetry = proactiveRetry;
+});
+
+// node_modules/abort-controller-x/lib/index.js
+var require_lib2 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(require_abortable(), exports);
+  __exportStar(require_AbortError(), exports);
+  __exportStar(require_delay(), exports);
+  __exportStar(require_execute(), exports);
+  __exportStar(require_forever(), exports);
+  __exportStar(require_waitForEvent(), exports);
+  __exportStar(require_all(), exports);
+  __exportStar(require_race(), exports);
+  __exportStar(require_retry(), exports);
+  __exportStar(require_spawn(), exports);
+  __exportStar(require_run(), exports);
+  __exportStar(require_proactiveRetry(), exports);
+});
+
+// node_modules/js-base64/base64.js
+var require_base64 = __commonJS((exports, module) => {
+  (function(global2, factory) {
+    typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : function() {
+      var _Base64 = global2.Base64;
+      var gBase64 = factory();
+      gBase64.noConflict = function() {
+        global2.Base64 = _Base64;
+        return gBase64;
+      };
+      if (global2.Meteor) {
+        Base64 = gBase64;
+      }
+      global2.Base64 = gBase64;
+    }();
+  })(typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : exports, function() {
+    var version = "3.7.8";
+    var VERSION = version;
+    var _hasBuffer = typeof Buffer === "function";
+    var _TD = typeof TextDecoder === "function" ? new TextDecoder : undefined;
+    var _TE = typeof TextEncoder === "function" ? new TextEncoder : undefined;
+    var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    var b64chs = Array.prototype.slice.call(b64ch);
+    var b64tab = function(a) {
+      var tab = {};
+      a.forEach(function(c, i) {
+        return tab[c] = i;
+      });
+      return tab;
+    }(b64chs);
+    var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+    var _fromCC = String.fromCharCode.bind(String);
+    var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : function(it) {
+      return new Uint8Array(Array.prototype.slice.call(it, 0));
+    };
+    var _mkUriSafe = function(src) {
+      return src.replace(/=/g, "").replace(/[+\/]/g, function(m0) {
+        return m0 == "+" ? "-" : "_";
+      });
+    };
+    var _tidyB64 = function(s) {
+      return s.replace(/[^A-Za-z0-9\+\/]/g, "");
+    };
+    var btoaPolyfill = function(bin) {
+      var u32, c0, c1, c2, asc = "";
+      var pad = bin.length % 3;
+      for (var i = 0;i < bin.length; ) {
+        if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
+          throw new TypeError("invalid character found");
+        u32 = c0 << 16 | c1 << 8 | c2;
+        asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
+      }
+      return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+    };
+    var _btoa = typeof btoa === "function" ? function(bin) {
+      return btoa(bin);
+    } : _hasBuffer ? function(bin) {
+      return Buffer.from(bin, "binary").toString("base64");
+    } : btoaPolyfill;
+    var _fromUint8Array = _hasBuffer ? function(u8a) {
+      return Buffer.from(u8a).toString("base64");
+    } : function(u8a) {
+      var maxargs = 4096;
+      var strs = [];
+      for (var i = 0, l = u8a.length;i < l; i += maxargs) {
+        strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+      }
+      return _btoa(strs.join(""));
+    };
+    var fromUint8Array = function(u8a, urlsafe) {
+      if (urlsafe === undefined) {
+        urlsafe = false;
+      }
+      return urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
+    };
+    var cb_utob = function(c) {
+      if (c.length < 2) {
+        var cc = c.charCodeAt(0);
+        return cc < 128 ? c : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+      } else {
+        var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320);
+        return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+      }
+    };
+    var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
+    var utob = function(u) {
+      return u.replace(re_utob, cb_utob);
+    };
+    var _encode = _hasBuffer ? function(s) {
+      return Buffer.from(s, "utf8").toString("base64");
+    } : _TE ? function(s) {
+      return _fromUint8Array(_TE.encode(s));
+    } : function(s) {
+      return _btoa(utob(s));
+    };
+    var encode = function(src, urlsafe) {
+      if (urlsafe === undefined) {
+        urlsafe = false;
+      }
+      return urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
+    };
+    var encodeURI = function(src) {
+      return encode(src, true);
+    };
+    var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
+    var cb_btou = function(cccc) {
+      switch (cccc.length) {
+        case 4:
+          var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
+          return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
+        case 3:
+          return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
+        default:
+          return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
+      }
+    };
+    var btou = function(b) {
+      return b.replace(re_btou, cb_btou);
+    };
+    var atobPolyfill = function(asc) {
+      asc = asc.replace(/\s+/g, "");
+      if (!b64re.test(asc))
+        throw new TypeError("malformed base64.");
+      asc += "==".slice(2 - (asc.length & 3));
+      var u24, r1, r2;
+      var binArray = [];
+      for (var i = 0;i < asc.length; ) {
+        u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
+        if (r1 === 64) {
+          binArray.push(_fromCC(u24 >> 16 & 255));
+        } else if (r2 === 64) {
+          binArray.push(_fromCC(u24 >> 16 & 255, u24 >> 8 & 255));
+        } else {
+          binArray.push(_fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255));
+        }
+      }
+      return binArray.join("");
+    };
+    var _atob = typeof atob === "function" ? function(asc) {
+      return atob(_tidyB64(asc));
+    } : _hasBuffer ? function(asc) {
+      return Buffer.from(asc, "base64").toString("binary");
+    } : atobPolyfill;
+    var _toUint8Array = _hasBuffer ? function(a) {
+      return _U8Afrom(Buffer.from(a, "base64"));
+    } : function(a) {
+      return _U8Afrom(_atob(a).split("").map(function(c) {
+        return c.charCodeAt(0);
+      }));
+    };
+    var toUint8Array = function(a) {
+      return _toUint8Array(_unURI(a));
+    };
+    var _decode = _hasBuffer ? function(a) {
+      return Buffer.from(a, "base64").toString("utf8");
+    } : _TD ? function(a) {
+      return _TD.decode(_toUint8Array(a));
+    } : function(a) {
+      return btou(_atob(a));
+    };
+    var _unURI = function(a) {
+      return _tidyB64(a.replace(/[-_]/g, function(m0) {
+        return m0 == "-" ? "+" : "/";
+      }));
+    };
+    var decode = function(src) {
+      return _decode(_unURI(src));
+    };
+    var isValid = function(src) {
+      if (typeof src !== "string")
+        return false;
+      var s = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
+      return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
+    };
+    var _noEnum = function(v) {
+      return {
+        value: v,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      };
+    };
+    var extendString = function() {
+      var _add = function(name, body) {
+        return Object.defineProperty(String.prototype, name, _noEnum(body));
+      };
+      _add("fromBase64", function() {
+        return decode(this);
+      });
+      _add("toBase64", function(urlsafe) {
+        return encode(this, urlsafe);
+      });
+      _add("toBase64URI", function() {
+        return encode(this, true);
+      });
+      _add("toBase64URL", function() {
+        return encode(this, true);
+      });
+      _add("toUint8Array", function() {
+        return toUint8Array(this);
+      });
+    };
+    var extendUint8Array = function() {
+      var _add = function(name, body) {
+        return Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
+      };
+      _add("toBase64", function(urlsafe) {
+        return fromUint8Array(this, urlsafe);
+      });
+      _add("toBase64URI", function() {
+        return fromUint8Array(this, true);
+      });
+      _add("toBase64URL", function() {
+        return fromUint8Array(this, true);
+      });
+    };
+    var extendBuiltins = function() {
+      extendString();
+      extendUint8Array();
+    };
+    var gBase64 = {
+      version,
+      VERSION,
+      atob: _atob,
+      atobPolyfill,
+      btoa: _btoa,
+      btoaPolyfill,
+      fromBase64: decode,
+      toBase64: encode,
+      encode,
+      encodeURI,
+      encodeURL: encodeURI,
+      utob,
+      btou,
+      decode,
+      isValid,
+      fromUint8Array,
+      toUint8Array,
+      extendString,
+      extendUint8Array,
+      extendBuiltins
+    };
+    gBase64.Base64 = {};
+    Object.keys(gBase64).forEach(function(k) {
+      return gBase64.Base64[k] = gBase64[k];
+    });
+    return gBase64;
+  });
+});
+
+// node_modules/nice-grpc-web/lib/client/transports/fetch.js
+var require_fetch = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.FetchTransport = FetchTransport;
+  var abort_controller_x_1 = require_lib2();
+  var js_base64_1 = require_base64();
+  var nice_grpc_common_1 = require_lib();
+  function FetchTransport(config) {
+    return async function* fetchTransport({ url, body, metadata, signal, method }) {
+      let requestBody;
+      if (!method.requestStream) {
+        let bodyBuffer;
+        for await (const chunk of body) {
+          bodyBuffer = chunk;
+          break;
+        }
+        requestBody = bodyBuffer;
+      } else {
+        let iterator;
+        requestBody = new ReadableStream({
+          type: "bytes",
+          start() {
+            iterator = body[Symbol.asyncIterator]();
+          },
+          async pull(controller) {
+            const { done, value } = await iterator.next();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          },
+          async cancel() {
+            var _a, _b;
+            await ((_b = (_a = iterator).return) === null || _b === undefined ? undefined : _b.call(_a));
+          }
+        });
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        body: requestBody,
+        headers: metadataToHeaders(metadata),
+        signal,
+        cache: config === null || config === undefined ? undefined : config.cache,
+        ["duplex"]: "half",
+        credentials: config === null || config === undefined ? undefined : config.credentials
+      });
+      yield {
+        type: "header",
+        header: headersToMetadata(response.headers)
+      };
+      if (!response.ok) {
+        const responseText = await response.text();
+        throw new nice_grpc_common_1.ClientError(method.path, getStatusFromHttpCode(response.status), getErrorDetailsFromHttpResponse(response.status, responseText));
+      }
+      (0, abort_controller_x_1.throwIfAborted)(signal);
+      const reader = response.body.getReader();
+      const abortListener = () => {
+        reader.cancel().catch(() => {});
+      };
+      signal.addEventListener("abort", abortListener);
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (value != null) {
+            yield {
+              type: "data",
+              data: value
+            };
+          }
+          if (done) {
+            break;
+          }
+        }
+      } finally {
+        signal.removeEventListener("abort", abortListener);
+        (0, abort_controller_x_1.throwIfAborted)(signal);
+      }
+    };
+  }
+  function metadataToHeaders(metadata) {
+    const headers = new Headers;
+    for (const [key, values] of metadata) {
+      for (const value of values) {
+        headers.append(key, typeof value === "string" ? value : js_base64_1.Base64.fromUint8Array(value));
+      }
+    }
+    return headers;
+  }
+  function headersToMetadata(headers) {
+    const metadata = new nice_grpc_common_1.Metadata;
+    for (const [key, value] of headers) {
+      if (key.endsWith("-bin")) {
+        for (const item of value.split(/,\s?/)) {
+          metadata.append(key, js_base64_1.Base64.toUint8Array(item));
+        }
+      } else {
+        metadata.set(key, value);
+      }
+    }
+    return metadata;
+  }
+  function getStatusFromHttpCode(statusCode) {
+    switch (statusCode) {
+      case 400:
+        return nice_grpc_common_1.Status.INTERNAL;
+      case 401:
+        return nice_grpc_common_1.Status.UNAUTHENTICATED;
+      case 403:
+        return nice_grpc_common_1.Status.PERMISSION_DENIED;
+      case 404:
+        return nice_grpc_common_1.Status.UNIMPLEMENTED;
+      case 429:
+      case 502:
+      case 503:
+      case 504:
+        return nice_grpc_common_1.Status.UNAVAILABLE;
+      default:
+        return nice_grpc_common_1.Status.UNKNOWN;
+    }
+  }
+  function getErrorDetailsFromHttpResponse(statusCode, responseText) {
+    return `Received HTTP ${statusCode} response: ` + (responseText.length > 1000 ? responseText.slice(0, 1000) + "... (truncated)" : responseText);
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/channel.js
+var require_channel = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createChannel = createChannel;
+  var fetch_1 = require_fetch();
+  function createChannel(address, transport = (0, fetch_1.FetchTransport)()) {
+    return { address, transport };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/utils/isAsyncIterable.js
+var require_isAsyncIterable = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isAsyncIterable = isAsyncIterable;
+  function isAsyncIterable(value) {
+    return value != null && Symbol.asyncIterator in value;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/utils/concatBuffers.js
+var require_concatBuffers = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.concatBuffers = concatBuffers;
+  function concatBuffers(buffers, totalLength) {
+    if (buffers.length === 1) {
+      return buffers[0];
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buffer of buffers) {
+      result.set(buffer, offset);
+      offset += buffer.length;
+    }
+    return result;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/decodeMetadata.js
+var require_decodeMetadata = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decodeMetadata = decodeMetadata;
+  var nice_grpc_common_1 = require_lib();
+  var js_base64_1 = require_base64();
+  function decodeMetadata(data) {
+    const metadata = (0, nice_grpc_common_1.Metadata)();
+    const text = new TextDecoder().decode(data);
+    for (const line of text.split(`\r
+`)) {
+      if (!line) {
+        continue;
+      }
+      const splitIndex = line.indexOf(":");
+      if (splitIndex === -1) {
+        throw new Error(`Invalid metadata line: ${line}`);
+      }
+      const key = line.slice(0, splitIndex).trim().toLowerCase();
+      const value = line.slice(splitIndex + 1).trim();
+      if (key.endsWith("-bin")) {
+        for (const item of value.split(/,\s?/)) {
+          metadata.append(key, js_base64_1.Base64.toUint8Array(item));
+        }
+      } else {
+        metadata.append(key, value);
+      }
+    }
+    return metadata;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/framing.js
+var require_framing = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LPM_HEADER_LENGTH = undefined;
+  exports.parseLpmHeader = parseLpmHeader;
+  exports.encodeFrame = encodeFrame;
+  exports.LPM_HEADER_LENGTH = 5;
+  function parseLpmHeader(data) {
+    if (data.length !== exports.LPM_HEADER_LENGTH) {
+      throw new Error(`Invalid LPM header length: ${data.length}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const compressed = (view.getUint8(0) & 1) !== 0;
+    const isMetadata = (view.getUint8(0) & 128) !== 0;
+    const length = view.getUint32(1);
+    return {
+      compressed,
+      isMetadata,
+      length
+    };
+  }
+  function encodeFrame(data) {
+    const messageBytes = new Uint8Array(exports.LPM_HEADER_LENGTH + data.length);
+    new DataView(messageBytes.buffer, 1, 4).setUint32(0, data.length, false);
+    messageBytes.set(data, exports.LPM_HEADER_LENGTH);
+    return messageBytes;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/decodeResponse.js
+var require_decodeResponse = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decodeResponse = decodeResponse;
+  var concatBuffers_1 = require_concatBuffers();
+  var decodeMetadata_1 = require_decodeMetadata();
+  var framing_1 = require_framing();
+  async function* decodeResponse({ response, decode, onHeader, onTrailer }) {
+    let receivedHeader = false;
+    let receivedTrailer = false;
+    let receivedData = false;
+    let buffer = createChunkBuffer(framing_1.LPM_HEADER_LENGTH);
+    let lpmHeader;
+    for await (const frame of response) {
+      if (frame.type === "header") {
+        handleHeader(frame.header);
+      } else if (frame.type === "trailer") {
+        handleTrailer(frame.trailer);
+      } else if (frame.type === "data") {
+        if (receivedTrailer) {
+          throw new Error("Received data after trailer");
+        }
+        let { data } = frame;
+        while (data.length > 0 || (lpmHeader === null || lpmHeader === undefined ? undefined : lpmHeader.length) === 0) {
+          const position = Math.min(data.length, buffer.targetLength - buffer.totalLength);
+          const chunk = data.subarray(0, position);
+          data = data.subarray(position);
+          buffer.chunks.push(chunk);
+          buffer.totalLength += chunk.length;
+          if (buffer.totalLength === buffer.targetLength) {
+            const messageBytes = (0, concatBuffers_1.concatBuffers)(buffer.chunks, buffer.totalLength);
+            if (lpmHeader == null) {
+              lpmHeader = (0, framing_1.parseLpmHeader)(messageBytes);
+              buffer = createChunkBuffer(lpmHeader.length);
+            } else {
+              if (lpmHeader.compressed) {
+                throw new Error("Compressed messages not supported");
+              }
+              if (lpmHeader.isMetadata) {
+                if (!receivedHeader) {
+                  handleHeader((0, decodeMetadata_1.decodeMetadata)(messageBytes));
+                } else {
+                  handleTrailer((0, decodeMetadata_1.decodeMetadata)(messageBytes));
+                }
+              } else {
+                if (!receivedHeader) {
+                  throw new Error("Received data before header");
+                }
+                yield decode(messageBytes);
+                receivedData = true;
+              }
+              lpmHeader = undefined;
+              buffer = createChunkBuffer(framing_1.LPM_HEADER_LENGTH);
+            }
+          }
+        }
+      }
+    }
+    function handleHeader(header) {
+      if (receivedHeader) {
+        throw new Error("Received multiple headers");
+      }
+      if (receivedData) {
+        throw new Error("Received header after data");
+      }
+      if (receivedTrailer) {
+        throw new Error("Received header after trailer");
+      }
+      receivedHeader = true;
+      onHeader(header);
+    }
+    function handleTrailer(trailer) {
+      if (receivedTrailer) {
+        throw new Error("Received multiple trailers");
+      }
+      receivedTrailer = true;
+      onTrailer(trailer);
+    }
+    function createChunkBuffer(targetLength) {
+      return {
+        chunks: [],
+        totalLength: 0,
+        targetLength
+      };
+    }
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/encodeRequest.js
+var require_encodeRequest = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.encodeRequest = encodeRequest;
+  var framing_1 = require_framing();
+  async function* encodeRequest({ request, encode }) {
+    for await (const data of request) {
+      const bytes = encode(data);
+      yield (0, framing_1.encodeFrame)(bytes);
+    }
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/makeInternalErrorMessage.js
+var require_makeInternalErrorMessage = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.makeInternalErrorMessage = makeInternalErrorMessage;
+  function makeInternalErrorMessage(err) {
+    if (err == null || typeof err !== "object") {
+      return String(err);
+    } else if (typeof err.message === "string") {
+      return err.message;
+    } else {
+      return JSON.stringify(err);
+    }
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/parseTrailer.js
+var require_parseTrailer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.parseTrailer = parseTrailer;
+  var nice_grpc_common_1 = require_lib();
+  function parseTrailer(trailer) {
+    let status;
+    const statusValue = trailer.get("grpc-status");
+    if (statusValue != null) {
+      const statusNum = +statusValue;
+      if (statusNum in nice_grpc_common_1.Status) {
+        status = statusNum;
+      } else {
+        throw new Error(`Received invalid status code from server: ${statusValue}`);
+      }
+    } else {
+      throw new Error("Received no status code from server");
+    }
+    let message = trailer.get("grpc-message");
+    if (message != null) {
+      try {
+        message = decodeURIComponent(message);
+      } catch (_a) {}
+    }
+    const trailerCopy = (0, nice_grpc_common_1.Metadata)(trailer);
+    trailerCopy.delete("grpc-status");
+    trailerCopy.delete("grpc-message");
+    return {
+      status,
+      message,
+      trailer: trailerCopy
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/makeCall.js
+var require_makeCall = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.makeCall = makeCall;
+  var abort_controller_x_1 = require_lib2();
+  var nice_grpc_common_1 = require_lib();
+  var decodeResponse_1 = require_decodeResponse();
+  var encodeRequest_1 = require_encodeRequest();
+  var makeInternalErrorMessage_1 = require_makeInternalErrorMessage();
+  var parseTrailer_1 = require_parseTrailer();
+  async function* makeCall(definition, channel, request, options) {
+    const { metadata, signal = new AbortController().signal, onHeader, onTrailer } = options;
+    (0, abort_controller_x_1.throwIfAborted)(signal);
+    let receivedTrailersOnly = false;
+    let status;
+    let message;
+    function handleTrailer(trailer) {
+      if (receivedTrailersOnly) {
+        if (new Map(trailer).size > 0) {
+          throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, "Received non-empty trailer after trailers-only response");
+        } else {
+          return;
+        }
+      }
+      const parsedTrailer = (0, parseTrailer_1.parseTrailer)(trailer);
+      ({ status, message } = parsedTrailer);
+      onTrailer === null || onTrailer === undefined || onTrailer(parsedTrailer.trailer);
+    }
+    const finalMetadata = (0, nice_grpc_common_1.Metadata)(metadata);
+    finalMetadata.set("content-type", "application/grpc-web+proto");
+    finalMetadata.set("x-grpc-web", "1");
+    const innerAbortController = new AbortController;
+    const abortListener = () => {
+      innerAbortController.abort();
+    };
+    signal.addEventListener("abort", abortListener);
+    let finished = false;
+    let requestError;
+    async function* interceptRequestError() {
+      try {
+        for await (const item of request) {
+          if (finished) {
+            throw new Error("Request finished");
+          }
+          yield item;
+        }
+      } catch (err) {
+        requestError = { err };
+        innerAbortController.abort();
+        throw err;
+      }
+    }
+    async function* handleTransportErrors() {
+      try {
+        return yield* channel.transport({
+          url: channel.address + definition.path,
+          metadata: finalMetadata,
+          body: (0, encodeRequest_1.encodeRequest)({
+            request: interceptRequestError(),
+            encode: definition.requestSerialize
+          }),
+          signal: innerAbortController.signal,
+          method: definition
+        });
+      } catch (err) {
+        (0, abort_controller_x_1.rethrowAbortError)(err);
+        throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.UNKNOWN, `Transport error: ${(0, makeInternalErrorMessage_1.makeInternalErrorMessage)(err)}`);
+      }
+    }
+    const response = (0, decodeResponse_1.decodeResponse)({
+      response: handleTransportErrors(),
+      decode: definition.responseDeserialize,
+      onHeader(header) {
+        const isTrailersOnly = header.has("grpc-status");
+        if (isTrailersOnly) {
+          handleTrailer(header);
+          receivedTrailersOnly = true;
+        } else {
+          onHeader === null || onHeader === undefined || onHeader(header);
+        }
+      },
+      onTrailer(trailer) {
+        handleTrailer(trailer);
+      }
+    });
+    try {
+      yield* response;
+    } catch (err) {
+      if (requestError !== undefined) {
+        throw requestError.err;
+      } else if (err instanceof nice_grpc_common_1.ClientError || (0, abort_controller_x_1.isAbortError)(err)) {
+        throw err;
+      } else {
+        throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, (0, makeInternalErrorMessage_1.makeInternalErrorMessage)(err));
+      }
+    } finally {
+      finished = true;
+      signal.removeEventListener("abort", abortListener);
+      if (status != null && status !== nice_grpc_common_1.Status.OK) {
+        throw new nice_grpc_common_1.ClientError(definition.path, status, message !== null && message !== undefined ? message : "");
+      }
+    }
+    if (status == null) {
+      throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.UNKNOWN, 'Response stream closed without gRPC status. This may indicate a misconfigured CORS policy on the server: Access-Control-Expose-Headers must include "grpc-status" and "grpc-message".');
+    }
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/createBidiStreamingMethod.js
+var require_createBidiStreamingMethod = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createBidiStreamingMethod = createBidiStreamingMethod;
+  var isAsyncIterable_1 = require_isAsyncIterable();
+  var makeCall_1 = require_makeCall();
+  function createBidiStreamingMethod(definition, channel, middleware, defaultOptions) {
+    const methodDescriptor = {
+      path: definition.path,
+      requestStream: definition.requestStream,
+      responseStream: definition.responseStream,
+      options: definition.options
+    };
+    async function* bidiStreamingMethod(request, options) {
+      if (!(0, isAsyncIterable_1.isAsyncIterable)(request)) {
+        throw new Error("A middleware passed invalid request to next(): expected a single message for bidirectional streaming method");
+      }
+      const response = (0, makeCall_1.makeCall)(definition, channel, request, options);
+      yield* response;
+    }
+    const method = middleware == null ? bidiStreamingMethod : (request, options) => middleware({
+      method: methodDescriptor,
+      requestStream: true,
+      request,
+      responseStream: true,
+      next: bidiStreamingMethod
+    }, options);
+    return (request, options) => {
+      const iterable = method(request, {
+        ...defaultOptions,
+        ...options
+      });
+      const iterator = iterable[Symbol.asyncIterator]();
+      return {
+        [Symbol.asyncIterator]() {
+          return {
+            async next() {
+              const result = await iterator.next();
+              if (result.done && result.value != null) {
+                return await iterator.throw(new Error("A middleware returned a message, but expected to return void for bidirectional streaming method"));
+              }
+              return result;
+            },
+            return() {
+              return iterator.return();
+            },
+            throw(err) {
+              return iterator.throw(err);
+            }
+          };
+        }
+      };
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/createClientStreamingMethod.js
+var require_createClientStreamingMethod = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createClientStreamingMethod = createClientStreamingMethod;
+  var nice_grpc_common_1 = require_lib();
+  var isAsyncIterable_1 = require_isAsyncIterable();
+  var makeCall_1 = require_makeCall();
+  function createClientStreamingMethod(definition, channel, middleware, defaultOptions) {
+    const methodDescriptor = {
+      path: definition.path,
+      requestStream: definition.requestStream,
+      responseStream: definition.responseStream,
+      options: definition.options
+    };
+    async function* clientStreamingMethod(request, options) {
+      if (!(0, isAsyncIterable_1.isAsyncIterable)(request)) {
+        throw Error("A middleware passed invalid request to next(): expected a single message for client streaming method");
+      }
+      const response = (0, makeCall_1.makeCall)(definition, channel, request, options);
+      let unaryResponse;
+      for await (const message of response) {
+        if (unaryResponse != null) {
+          throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, "Received more than one message from server for client streaming method");
+        }
+        unaryResponse = message;
+      }
+      if (unaryResponse == null) {
+        throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, "Server did not return a response");
+      }
+      return unaryResponse;
+    }
+    const method = middleware == null ? clientStreamingMethod : (request, options) => middleware({
+      method: methodDescriptor,
+      requestStream: true,
+      request,
+      responseStream: false,
+      next: clientStreamingMethod
+    }, options);
+    return async (request, options) => {
+      const iterable = method(request, {
+        ...defaultOptions,
+        ...options
+      });
+      const iterator = iterable[Symbol.asyncIterator]();
+      let result = await iterator.next();
+      while (true) {
+        if (!result.done) {
+          result = await iterator.throw(new Error("A middleware yielded a message, but expected to only return a message for client streaming method"));
+          continue;
+        }
+        if (result.value == null) {
+          result = await iterator.throw(new Error("A middleware returned void, but expected to return a message for client streaming method"));
+          continue;
+        }
+        return result.value;
+      }
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/utils/asyncIterableOf.js
+var require_asyncIterableOf = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.asyncIterableOf = asyncIterableOf;
+  async function* asyncIterableOf(item) {
+    yield item;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/createServerStreamingMethod.js
+var require_createServerStreamingMethod = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createServerStreamingMethod = createServerStreamingMethod;
+  var asyncIterableOf_1 = require_asyncIterableOf();
+  var isAsyncIterable_1 = require_isAsyncIterable();
+  var makeCall_1 = require_makeCall();
+  function createServerStreamingMethod(definition, channel, middleware, defaultOptions) {
+    const methodDescriptor = {
+      path: definition.path,
+      requestStream: definition.requestStream,
+      responseStream: definition.responseStream,
+      options: definition.options
+    };
+    async function* serverStreamingMethod(request, options) {
+      if ((0, isAsyncIterable_1.isAsyncIterable)(request)) {
+        throw new Error("A middleware passed invalid request to next(): expected a single message for server streaming method");
+      }
+      const response = (0, makeCall_1.makeCall)(definition, channel, (0, asyncIterableOf_1.asyncIterableOf)(request), options);
+      yield* response;
+    }
+    const method = middleware == null ? serverStreamingMethod : (request, options) => middleware({
+      method: methodDescriptor,
+      requestStream: false,
+      request,
+      responseStream: true,
+      next: serverStreamingMethod
+    }, options);
+    return (request, options) => {
+      const iterable = method(request, {
+        ...defaultOptions,
+        ...options
+      });
+      const iterator = iterable[Symbol.asyncIterator]();
+      return {
+        [Symbol.asyncIterator]() {
+          return {
+            async next() {
+              const result = await iterator.next();
+              if (result.done && result.value != null) {
+                return await iterator.throw(new Error("A middleware returned a message, but expected to return void for server streaming method"));
+              }
+              return result;
+            },
+            return() {
+              return iterator.return();
+            },
+            throw(err) {
+              return iterator.throw(err);
+            }
+          };
+        }
+      };
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/createUnaryMethod.js
+var require_createUnaryMethod = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createUnaryMethod = createUnaryMethod;
+  var nice_grpc_common_1 = require_lib();
+  var asyncIterableOf_1 = require_asyncIterableOf();
+  var isAsyncIterable_1 = require_isAsyncIterable();
+  var makeCall_1 = require_makeCall();
+  function createUnaryMethod(definition, channel, middleware, defaultOptions) {
+    const methodDescriptor = {
+      path: definition.path,
+      requestStream: definition.requestStream,
+      responseStream: definition.responseStream,
+      options: definition.options
+    };
+    async function* unaryMethod(request, options) {
+      if ((0, isAsyncIterable_1.isAsyncIterable)(request)) {
+        throw new Error("A middleware passed invalid request to next(): expected a single message for unary method");
+      }
+      const response = (0, makeCall_1.makeCall)(definition, channel, (0, asyncIterableOf_1.asyncIterableOf)(request), options);
+      let unaryResponse;
+      for await (const message of response) {
+        if (unaryResponse != null) {
+          throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, "Received more than one message from server for unary method");
+        }
+        unaryResponse = message;
+      }
+      if (unaryResponse == null) {
+        throw new nice_grpc_common_1.ClientError(definition.path, nice_grpc_common_1.Status.INTERNAL, "Server did not return a response");
+      }
+      return unaryResponse;
+    }
+    const method = middleware == null ? unaryMethod : (request, options) => middleware({
+      method: methodDescriptor,
+      requestStream: false,
+      request,
+      responseStream: false,
+      next: unaryMethod
+    }, options);
+    return async (request, options) => {
+      const iterable = method(request, {
+        ...defaultOptions,
+        ...options
+      });
+      const iterator = iterable[Symbol.asyncIterator]();
+      let result = await iterator.next();
+      while (true) {
+        if (!result.done) {
+          result = await iterator.throw(new Error("A middleware yielded a message, but expected to only return a message for unary method"));
+          continue;
+        }
+        if (result.value == null) {
+          result = await iterator.throw(new Error("A middleware returned void, but expected to return a message for unary method"));
+          continue;
+        }
+        return result.value;
+      }
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/ClientFactory.js
+var require_ClientFactory = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createClientFactory = createClientFactory;
+  exports.createClient = createClient;
+  var nice_grpc_common_1 = require_lib();
+  var service_definitions_1 = require_service_definitions();
+  var createBidiStreamingMethod_1 = require_createBidiStreamingMethod();
+  var createClientStreamingMethod_1 = require_createClientStreamingMethod();
+  var createServerStreamingMethod_1 = require_createServerStreamingMethod();
+  var createUnaryMethod_1 = require_createUnaryMethod();
+  function createClientFactory() {
+    return createClientFactoryWithMiddleware();
+  }
+  function createClient(definition, channel, defaultCallOptions) {
+    return createClientFactory().create(definition, channel, defaultCallOptions);
+  }
+  function createClientFactoryWithMiddleware(middleware) {
+    return {
+      use(newMiddleware) {
+        return createClientFactoryWithMiddleware(middleware == null ? newMiddleware : (0, nice_grpc_common_1.composeClientMiddleware)(middleware, newMiddleware));
+      },
+      create(definition, channel, defaultCallOptions = {}) {
+        const client = {};
+        const methodEntries = Object.entries((0, service_definitions_1.normalizeServiceDefinition)(definition));
+        for (const [methodName, methodDefinition] of methodEntries) {
+          const defaultOptions = {
+            ...defaultCallOptions["*"],
+            ...defaultCallOptions[methodName]
+          };
+          if (!methodDefinition.requestStream) {
+            if (!methodDefinition.responseStream) {
+              client[methodName] = (0, createUnaryMethod_1.createUnaryMethod)(methodDefinition, channel, middleware, defaultOptions);
+            } else {
+              client[methodName] = (0, createServerStreamingMethod_1.createServerStreamingMethod)(methodDefinition, channel, middleware, defaultOptions);
+            }
+          } else {
+            if (!methodDefinition.responseStream) {
+              client[methodName] = (0, createClientStreamingMethod_1.createClientStreamingMethod)(methodDefinition, channel, middleware, defaultOptions);
+            } else {
+              client[methodName] = (0, createBidiStreamingMethod_1.createBidiStreamingMethod)(methodDefinition, channel, middleware, defaultOptions);
+            }
+          }
+        }
+        return client;
+      }
+    };
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/Client.js
+var require_Client = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/isomorphic-ws/browser.js
+var exports_browser = {};
+__export(exports_browser, {
+  default: () => browser_default
+});
+var ws = null, browser_default;
+var init_browser = __esm(() => {
+  if (typeof WebSocket !== "undefined") {
+    ws = WebSocket;
+  } else if (typeof MozWebSocket !== "undefined") {
+    ws = MozWebSocket;
+  } else if (typeof global !== "undefined") {
+    ws = global.WebSocket || global.MozWebSocket;
+  } else if (typeof window !== "undefined") {
+    ws = window.WebSocket || window.MozWebSocket;
+  } else if (typeof self !== "undefined") {
+    ws = self.WebSocket || self.MozWebSocket;
+  }
+  browser_default = ws;
+});
+
+// node_modules/nice-grpc-web/lib/utils/AsyncSink.js
+var require_AsyncSink = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AsyncSink = undefined;
+  var ARRAY_VALUE = "value";
+  var ARRAY_ERROR = "error";
+
+  class AsyncSink {
+    constructor() {
+      this._ended = false;
+      this._values = [];
+      this._resolvers = [];
+    }
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+    write(value) {
+      this._push({ type: ARRAY_VALUE, value });
+    }
+    error(error) {
+      this._push({ type: ARRAY_ERROR, error });
+    }
+    _push(item) {
+      if (this._ended) {
+        return;
+      }
+      if (this._resolvers.length > 0) {
+        const { resolve, reject } = this._resolvers.shift();
+        if (item.type === ARRAY_ERROR) {
+          reject(item.error);
+        } else {
+          resolve({ done: false, value: item.value });
+        }
+      } else {
+        this._values.push(item);
+      }
+    }
+    next() {
+      if (this._values.length > 0) {
+        const { type, value, error } = this._values.shift();
+        if (type === ARRAY_ERROR) {
+          return Promise.reject(error);
+        } else {
+          return Promise.resolve({ done: false, value });
+        }
+      }
+      if (this._ended) {
+        return Promise.resolve({ done: true });
+      }
+      return new Promise((resolve, reject) => {
+        this._resolvers.push({ resolve, reject });
+      });
+    }
+    end() {
+      while (this._resolvers.length > 0) {
+        this._resolvers.shift().resolve({ done: true });
+      }
+      this._ended = true;
+    }
+  }
+  exports.AsyncSink = AsyncSink;
+});
+
+// node_modules/nice-grpc-web/lib/client/transports/websocket.js
+var require_websocket = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.WebsocketTransport = WebsocketTransport;
+  var abort_controller_x_1 = require_lib2();
+  var isomorphic_ws_1 = __importDefault((init_browser(), __toCommonJS(exports_browser)));
+  var js_base64_1 = require_base64();
+  var AsyncSink_1 = require_AsyncSink();
+  function WebsocketTransport() {
+    return async function* ({ url, body, metadata, signal }) {
+      if (signal.aborted) {
+        throw new abort_controller_x_1.AbortError;
+      }
+      const frames = new AsyncSink_1.AsyncSink;
+      signal.addEventListener("abort", () => {
+        frames.error(new abort_controller_x_1.AbortError);
+      });
+      const websocketUrl = new URL(url);
+      websocketUrl.protocol = websocketUrl.protocol.replace("http", "ws");
+      const webSocket = new isomorphic_ws_1.default(websocketUrl, ["grpc-websockets"]);
+      webSocket.binaryType = "arraybuffer";
+      webSocket.addEventListener("message", (event) => {
+        if (event.data instanceof ArrayBuffer) {
+          frames.write({
+            type: "data",
+            data: new Uint8Array(event.data)
+          });
+        } else {
+          frames.error(new Error(`Unexpected message type: ${typeof event.data}`));
+        }
+      });
+      webSocket.addEventListener("close", (event) => {
+        if (event.wasClean) {
+          frames.end();
+        } else {
+          frames.error(new Error(`WebSocket closed with code ${event.code}` + (event.reason && `: ${event.reason}`)));
+        }
+      });
+      const pipeAbortController = new AbortController;
+      pipeBody(pipeAbortController.signal, metadata, body, webSocket).catch((err) => {
+        if (!(0, abort_controller_x_1.isAbortError)(err)) {
+          frames.error(err);
+        }
+      });
+      try {
+        return yield* frames;
+      } finally {
+        pipeAbortController.abort();
+        webSocket.close();
+      }
+    };
+  }
+  async function pipeBody(signal, metadata, body, webSocket) {
+    if (webSocket.readyState == isomorphic_ws_1.default.CONNECTING) {
+      await (0, abort_controller_x_1.waitForEvent)(signal, webSocket, "open");
+    }
+    webSocket.send(encodeMetadata(metadata));
+    for await (const chunk of body) {
+      (0, abort_controller_x_1.throwIfAborted)(signal);
+      const data = new Uint8Array(chunk.length + 1);
+      data.set([0], 0);
+      data.set(chunk, 1);
+      webSocket.send(data);
+    }
+    webSocket.send(new Uint8Array([1]));
+  }
+  function encodeMetadata(metadata) {
+    let result = "";
+    for (const [key, values] of metadata) {
+      for (const value of values) {
+        const valueString = typeof value === "string" ? value : js_base64_1.Base64.fromUint8Array(value);
+        const pairString = `${key}: ${valueString}\r
+`;
+        for (let i = 0;i < pairString.length; i++) {
+          const charCode = pairString.charCodeAt(i);
+          if (!isValidCharCode(charCode)) {
+            throw new Error(`Metadata contains invalid characters: '${pairString}'`);
+          }
+        }
+        result += pairString;
+      }
+    }
+    return new TextEncoder().encode(result);
+  }
+  function isValidCharCode(val) {
+    return val === 9 || val === 10 || val === 13 || val >= 32 && val <= 126;
+  }
+});
+
+// node_modules/nice-grpc-web/lib/client/transports/nodeHttp/browser.js
+var require_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NodeHttpTransport = NodeHttpTransport;
+  function NodeHttpTransport() {
+    throw new Error("NodeHttpTransport is not supported in the browser");
+  }
+});
+
+// node_modules/nice-grpc-web/lib/index.js
+var require_lib3 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NodeHttpTransport = exports.WebsocketTransport = exports.FetchTransport = exports.Status = exports.Metadata = exports.composeClientMiddleware = exports.ClientError = undefined;
+  var nice_grpc_common_1 = require_lib();
+  Object.defineProperty(exports, "ClientError", { enumerable: true, get: function() {
+    return nice_grpc_common_1.ClientError;
+  } });
+  Object.defineProperty(exports, "composeClientMiddleware", { enumerable: true, get: function() {
+    return nice_grpc_common_1.composeClientMiddleware;
+  } });
+  Object.defineProperty(exports, "Metadata", { enumerable: true, get: function() {
+    return nice_grpc_common_1.Metadata;
+  } });
+  Object.defineProperty(exports, "Status", { enumerable: true, get: function() {
+    return nice_grpc_common_1.Status;
+  } });
+  __exportStar(require_service_definitions(), exports);
+  __exportStar(require_channel(), exports);
+  __exportStar(require_ClientFactory(), exports);
+  __exportStar(require_Client(), exports);
+  var fetch_1 = require_fetch();
+  Object.defineProperty(exports, "FetchTransport", { enumerable: true, get: function() {
+    return fetch_1.FetchTransport;
+  } });
+  var websocket_1 = require_websocket();
+  Object.defineProperty(exports, "WebsocketTransport", { enumerable: true, get: function() {
+    return websocket_1.WebsocketTransport;
+  } });
+  var nodeHttp_1 = require_browser();
+  Object.defineProperty(exports, "NodeHttpTransport", { enumerable: true, get: function() {
+    return nodeHttp_1.NodeHttpTransport;
+  } });
+});
+
+// src/client.ts
+var import_nice_grpc_web = __toESM(require_lib3(), 1);
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
+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");
+}
+function varint64write(lo, hi, bytes) {
+  for (let i = 0;i < 28; i = i + 7) {
+    const shift = lo >>> i;
+    const hasNext = !(shift >>> 7 == 0 && hi == 0);
+    const byte = (hasNext ? shift | 128 : shift) & 255;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
+  const hasMoreBits = !(hi >> 3 == 0);
+  bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
+  if (!hasMoreBits) {
+    return;
+  }
+  for (let i = 3;i < 31; i = i + 7) {
+    const shift = hi >>> i;
+    const hasNext = !(shift >>> 7 == 0);
+    const byte = (hasNext ? shift | 128 : shift) & 255;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  bytes.push(hi >>> 31 & 1);
+}
+var 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);
+}
+var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+  const partial = String(digit1e7);
+  return "0000000".slice(partial.length) + partial;
+};
+function varint32write(value, bytes) {
+  if (value >= 0) {
+    while (value > 127) {
+      bytes.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    bytes.push(value);
+  } else {
+    for (let i = 0;i < 9; i++) {
+      bytes.push(value & 127 | 128);
+      value = value >> 7;
+    }
+    bytes.push(1);
+  }
+}
+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;
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
+var 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" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808");
+    const MAX = BigInt("9223372036854775807");
+    const UMIN = BigInt("0");
+    const 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);
+  }
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
+var symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+function getTextEncoding() {
+  if (globalThis[symbol] == undefined) {
+    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 (_) {
+          return false;
+        }
+      }
+    };
+  }
+  return globalThis[symbol];
+}
+
+// node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
+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 = {}));
+var FLOAT32_MAX = 340282346638528860000000000000000000000;
+var FLOAT32_MIN = -340282346638528860000000000000000000000;
+var UINT32_MAX = 4294967295;
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
+
+class BinaryWriter {
+  constructor(encodeUtf8 = getTextEncoding().encodeUtf8) {
+    this.encodeUtf8 = encodeUtf8;
+    this.stack = [];
+    this.chunks = [];
+    this.buf = [];
+  }
+  finish() {
+    if (this.buf.length) {
+      this.chunks.push(new Uint8Array(this.buf));
+      this.buf = [];
+    }
+    let len = 0;
+    for (let i = 0;i < this.chunks.length; i++)
+      len += this.chunks[i].length;
+    let bytes = new Uint8Array(len);
+    let offset = 0;
+    for (let i = 0;i < this.chunks.length; i++) {
+      bytes.set(this.chunks[i], offset);
+      offset += this.chunks[i].length;
+    }
+    this.chunks = [];
+    return bytes;
+  }
+  fork() {
+    this.stack.push({ chunks: this.chunks, buf: this.buf });
+    this.chunks = [];
+    this.buf = [];
+    return this;
+  }
+  join() {
+    let chunk = this.finish();
+    let prev = this.stack.pop();
+    if (!prev)
+      throw new Error("invalid state, fork stack empty");
+    this.chunks = prev.chunks;
+    this.buf = prev.buf;
+    this.uint32(chunk.byteLength);
+    return this.raw(chunk);
+  }
+  tag(fieldNo, type) {
+    return this.uint32((fieldNo << 3 | type) >>> 0);
+  }
+  raw(chunk) {
+    if (this.buf.length) {
+      this.chunks.push(new Uint8Array(this.buf));
+      this.buf = [];
+    }
+    this.chunks.push(chunk);
+    return this;
+  }
+  uint32(value) {
+    assertUInt32(value);
+    while (value > 127) {
+      this.buf.push(value & 127 | 128);
+      value = value >>> 7;
+    }
+    this.buf.push(value);
+    return this;
+  }
+  int32(value) {
+    assertInt32(value);
+    varint32write(value, this.buf);
+    return this;
+  }
+  bool(value) {
+    this.buf.push(value ? 1 : 0);
+    return this;
+  }
+  bytes(value) {
+    this.uint32(value.byteLength);
+    return this.raw(value);
+  }
+  string(value) {
+    let chunk = this.encodeUtf8(value);
+    this.uint32(chunk.byteLength);
+    return this.raw(chunk);
+  }
+  float(value) {
+    assertFloat32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setFloat32(0, value, true);
+    return this.raw(chunk);
+  }
+  double(value) {
+    let chunk = new Uint8Array(8);
+    new DataView(chunk.buffer).setFloat64(0, value, true);
+    return this.raw(chunk);
+  }
+  fixed32(value) {
+    assertUInt32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setUint32(0, value, true);
+    return this.raw(chunk);
+  }
+  sfixed32(value) {
+    assertInt32(value);
+    let chunk = new Uint8Array(4);
+    new DataView(chunk.buffer).setInt32(0, value, true);
+    return this.raw(chunk);
+  }
+  sint32(value) {
+    assertInt32(value);
+    value = (value << 1 ^ value >> 31) >>> 0;
+    varint32write(value, this.buf);
+    return this;
+  }
+  sfixed64(value) {
+    let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
+    view.setInt32(0, tc.lo, true);
+    view.setInt32(4, tc.hi, true);
+    return this.raw(chunk);
+  }
+  fixed64(value) {
+    let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
+    view.setInt32(0, tc.lo, true);
+    view.setInt32(4, tc.hi, true);
+    return this.raw(chunk);
+  }
+  int64(value) {
+    let tc = protoInt64.enc(value);
+    varint64write(tc.lo, tc.hi, this.buf);
+    return this;
+  }
+  sint64(value) {
+    const tc = protoInt64.enc(value), sign = tc.hi >> 31, lo = tc.lo << 1 ^ sign, hi = (tc.hi << 1 | tc.lo >>> 31) ^ sign;
+    varint64write(lo, hi, this.buf);
+    return this;
+  }
+  uint64(value) {
+    const tc = protoInt64.uEnc(value);
+    varint64write(tc.lo, tc.hi, this.buf);
+    return this;
+  }
+}
+
+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);
+  }
+  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(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 !== undefined && 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);
+  }
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  int32() {
+    return this.uint32() | 0;
+  }
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  int64() {
+    return protoInt64.dec(...this.varint64());
+  }
+  uint64() {
+    return protoInt64.uDec(...this.varint64());
+  }
+  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);
+  }
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+}
+function assertInt32(arg) {
+  if (typeof arg == "string") {
+    arg = Number(arg);
+  } else if (typeof arg != "number") {
+    throw new Error("invalid int32: " + typeof arg);
+  }
+  if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
+    throw new Error("invalid int32: " + arg);
+}
+function assertUInt32(arg) {
+  if (typeof arg == "string") {
+    arg = Number(arg);
+  } else if (typeof arg != "number") {
+    throw new Error("invalid uint32: " + typeof arg);
+  }
+  if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
+    throw new Error("invalid uint32: " + arg);
+}
+function assertFloat32(arg) {
+  if (typeof arg == "string") {
+    const o = arg;
+    arg = Number(arg);
+    if (Number.isNaN(arg) && o !== "NaN") {
+      throw new Error("invalid float32: " + o);
+    }
+  } else if (typeof arg != "number") {
+    throw new Error("invalid float32: " + typeof arg);
+  }
+  if (Number.isFinite(arg) && (arg > FLOAT32_MAX || arg < FLOAT32_MIN))
+    throw new Error("invalid float32: " + arg);
+}
+
+// src/gen/google/protobuf/timestamp.ts
+function createBaseTimestamp() {
+  return { seconds: 0, nanos: 0 };
+}
+var Timestamp = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.seconds !== 0) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.seconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.seconds !== 0) {
+      obj.seconds = Math.round(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+  create(base) {
+    return Timestamp.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTimestamp();
+    message.seconds = object.seconds ?? 0;
+    message.nanos = object.nanos ?? 0;
+    return message;
+  }
+};
+function longToNumber(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+function isSet(value) {
+  return value !== null && value !== undefined;
+}
+
+// src/gen/zenu/users/v1/users_service.ts
+var protobufPackage = "zenu.users.v1";
+var RoleScope;
+((RoleScope2) => {
+  RoleScope2[RoleScope2["ROLE_SCOPE_UNSPECIFIED"] = 0] = "ROLE_SCOPE_UNSPECIFIED";
+  RoleScope2[RoleScope2["ROLE_SCOPE_GLOBAL"] = 1] = "ROLE_SCOPE_GLOBAL";
+  RoleScope2[RoleScope2["ROLE_SCOPE_ORGANIZATION"] = 2] = "ROLE_SCOPE_ORGANIZATION";
+  RoleScope2[RoleScope2["ROLE_SCOPE_LOCATION"] = 3] = "ROLE_SCOPE_LOCATION";
+  RoleScope2[RoleScope2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(RoleScope ||= {});
+function roleScopeFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "ROLE_SCOPE_UNSPECIFIED":
+      return 0 /* ROLE_SCOPE_UNSPECIFIED */;
+    case 1:
+    case "ROLE_SCOPE_GLOBAL":
+      return 1 /* ROLE_SCOPE_GLOBAL */;
+    case 2:
+    case "ROLE_SCOPE_ORGANIZATION":
+      return 2 /* ROLE_SCOPE_ORGANIZATION */;
+    case 3:
+    case "ROLE_SCOPE_LOCATION":
+      return 3 /* ROLE_SCOPE_LOCATION */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function roleScopeToJSON(object) {
+  switch (object) {
+    case 0 /* ROLE_SCOPE_UNSPECIFIED */:
+      return "ROLE_SCOPE_UNSPECIFIED";
+    case 1 /* ROLE_SCOPE_GLOBAL */:
+      return "ROLE_SCOPE_GLOBAL";
+    case 2 /* ROLE_SCOPE_ORGANIZATION */:
+      return "ROLE_SCOPE_ORGANIZATION";
+    case 3 /* ROLE_SCOPE_LOCATION */:
+      return "ROLE_SCOPE_LOCATION";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+var Role;
+((Role2) => {
+  Role2[Role2["ROLE_UNSPECIFIED"] = 0] = "ROLE_UNSPECIFIED";
+  Role2[Role2["ROLE_ADMINISTRATOR"] = 1] = "ROLE_ADMINISTRATOR";
+  Role2[Role2["ROLE_DEVELOPER"] = 2] = "ROLE_DEVELOPER";
+  Role2[Role2["ROLE_MANAGER"] = 3] = "ROLE_MANAGER";
+  Role2[Role2["ROLE_NINJA"] = 4] = "ROLE_NINJA";
+  Role2[Role2["ROLE_INSTORE"] = 5] = "ROLE_INSTORE";
+  Role2[Role2["ROLE_EMPLOYEE"] = 6] = "ROLE_EMPLOYEE";
+  Role2[Role2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Role ||= {});
+function roleFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "ROLE_UNSPECIFIED":
+      return 0 /* ROLE_UNSPECIFIED */;
+    case 1:
+    case "ROLE_ADMINISTRATOR":
+      return 1 /* ROLE_ADMINISTRATOR */;
+    case 2:
+    case "ROLE_DEVELOPER":
+      return 2 /* ROLE_DEVELOPER */;
+    case 3:
+    case "ROLE_MANAGER":
+      return 3 /* ROLE_MANAGER */;
+    case 4:
+    case "ROLE_NINJA":
+      return 4 /* ROLE_NINJA */;
+    case 5:
+    case "ROLE_INSTORE":
+      return 5 /* ROLE_INSTORE */;
+    case 6:
+    case "ROLE_EMPLOYEE":
+      return 6 /* ROLE_EMPLOYEE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function roleToJSON(object) {
+  switch (object) {
+    case 0 /* ROLE_UNSPECIFIED */:
+      return "ROLE_UNSPECIFIED";
+    case 1 /* ROLE_ADMINISTRATOR */:
+      return "ROLE_ADMINISTRATOR";
+    case 2 /* ROLE_DEVELOPER */:
+      return "ROLE_DEVELOPER";
+    case 3 /* ROLE_MANAGER */:
+      return "ROLE_MANAGER";
+    case 4 /* ROLE_NINJA */:
+      return "ROLE_NINJA";
+    case 5 /* ROLE_INSTORE */:
+      return "ROLE_INSTORE";
+    case 6 /* ROLE_EMPLOYEE */:
+      return "ROLE_EMPLOYEE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseSayHelloRequest() {
+  return { name: "" };
+}
+var SayHelloRequest = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSayHelloRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { name: isSet2(object.name) ? globalThis.String(object.name) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+  create(base) {
+    return SayHelloRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSayHelloRequest();
+    message.name = object.name ?? "";
+    return message;
+  }
+};
+function createBaseSayHelloResponse() {
+  return { message: "", currentTime: undefined };
+}
+var SayHelloResponse = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    if (message.currentTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.currentTime), writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSayHelloResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.message = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.currentTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      message: isSet2(object.message) ? globalThis.String(object.message) : "",
+      currentTime: isSet2(object.currentTime) ? fromJsonTimestamp(object.currentTime) : isSet2(object.current_time) ? fromJsonTimestamp(object.current_time) : undefined
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    if (message.currentTime !== undefined) {
+      obj.currentTime = message.currentTime.toISOString();
+    }
+    return obj;
+  },
+  create(base) {
+    return SayHelloResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSayHelloResponse();
+    message.message = object.message ?? "";
+    message.currentTime = object.currentTime ?? undefined;
+    return message;
+  }
+};
+function createBaseWhoAmIRequest() {
+  return {};
+}
+var WhoAmIRequest = {
+  encode(_, writer = new BinaryWriter) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWhoAmIRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return WhoAmIRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseWhoAmIRequest();
+    return message;
+  }
+};
+function createBaseWhoAmIResponse() {
+  return { user: undefined };
+}
+var WhoAmIResponse = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.user !== undefined) {
+      User.encode(message.user, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWhoAmIResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.user = User.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { user: isSet2(object.user) ? User.fromJSON(object.user) : undefined };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.user !== undefined) {
+      obj.user = User.toJSON(message.user);
+    }
+    return obj;
+  },
+  create(base) {
+    return WhoAmIResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseWhoAmIResponse();
+    message.user = object.user !== undefined && object.user !== null ? User.fromPartial(object.user) : undefined;
+    return message;
+  }
+};
+function createBaseUser() {
+  return {
+    id: "",
+    email: "",
+    givenName: "",
+    familyName: "",
+    telephone: "",
+    image: "",
+    createdAt: undefined,
+    updatedAt: undefined,
+    roles: []
+  };
+}
+var User = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.email !== "") {
+      writer.uint32(18).string(message.email);
+    }
+    if (message.givenName !== "") {
+      writer.uint32(26).string(message.givenName);
+    }
+    if (message.familyName !== "") {
+      writer.uint32(34).string(message.familyName);
+    }
+    if (message.telephone !== "") {
+      writer.uint32(42).string(message.telephone);
+    }
+    if (message.image !== "") {
+      writer.uint32(50).string(message.image);
+    }
+    if (message.createdAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(58).fork()).join();
+    }
+    if (message.updatedAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(66).fork()).join();
+    }
+    for (const v of message.roles) {
+      UserRole.encode(v, writer.uint32(74).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUser();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.email = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.givenName = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.familyName = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.telephone = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.image = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.roles.push(UserRole.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet2(object.id) ? globalThis.String(object.id) : "",
+      email: isSet2(object.email) ? globalThis.String(object.email) : "",
+      givenName: isSet2(object.givenName) ? globalThis.String(object.givenName) : isSet2(object.given_name) ? globalThis.String(object.given_name) : "",
+      familyName: isSet2(object.familyName) ? globalThis.String(object.familyName) : isSet2(object.family_name) ? globalThis.String(object.family_name) : "",
+      telephone: isSet2(object.telephone) ? globalThis.String(object.telephone) : "",
+      image: isSet2(object.image) ? globalThis.String(object.image) : "",
+      createdAt: isSet2(object.createdAt) ? fromJsonTimestamp(object.createdAt) : isSet2(object.created_at) ? fromJsonTimestamp(object.created_at) : undefined,
+      updatedAt: isSet2(object.updatedAt) ? fromJsonTimestamp(object.updatedAt) : isSet2(object.updated_at) ? fromJsonTimestamp(object.updated_at) : undefined,
+      roles: globalThis.Array.isArray(object?.roles) ? object.roles.map((e) => UserRole.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.email !== "") {
+      obj.email = message.email;
+    }
+    if (message.givenName !== "") {
+      obj.givenName = message.givenName;
+    }
+    if (message.familyName !== "") {
+      obj.familyName = message.familyName;
+    }
+    if (message.telephone !== "") {
+      obj.telephone = message.telephone;
+    }
+    if (message.image !== "") {
+      obj.image = message.image;
+    }
+    if (message.createdAt !== undefined) {
+      obj.createdAt = message.createdAt.toISOString();
+    }
+    if (message.updatedAt !== undefined) {
+      obj.updatedAt = message.updatedAt.toISOString();
+    }
+    if (message.roles?.length) {
+      obj.roles = message.roles.map((e) => UserRole.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return User.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUser();
+    message.id = object.id ?? "";
+    message.email = object.email ?? "";
+    message.givenName = object.givenName ?? "";
+    message.familyName = object.familyName ?? "";
+    message.telephone = object.telephone ?? "";
+    message.image = object.image ?? "";
+    message.createdAt = object.createdAt ?? undefined;
+    message.updatedAt = object.updatedAt ?? undefined;
+    message.roles = object.roles?.map((e) => UserRole.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseUserRole() {
+  return { role: 0, scope: 0, organizationId: undefined, locationId: undefined };
+}
+var UserRole = {
+  encode(message, writer = new BinaryWriter) {
+    if (message.role !== 0) {
+      writer.uint32(8).int32(message.role);
+    }
+    if (message.scope !== 0) {
+      writer.uint32(16).int32(message.scope);
+    }
+    if (message.organizationId !== undefined) {
+      writer.uint32(26).string(message.organizationId);
+    }
+    if (message.locationId !== undefined) {
+      writer.uint32(34).string(message.locationId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUserRole();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.role = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.scope = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.organizationId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.locationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      role: isSet2(object.role) ? roleFromJSON(object.role) : 0,
+      scope: isSet2(object.scope) ? roleScopeFromJSON(object.scope) : 0,
+      organizationId: isSet2(object.organizationId) ? globalThis.String(object.organizationId) : isSet2(object.organization_id) ? globalThis.String(object.organization_id) : undefined,
+      locationId: isSet2(object.locationId) ? globalThis.String(object.locationId) : isSet2(object.location_id) ? globalThis.String(object.location_id) : undefined
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.role !== 0) {
+      obj.role = roleToJSON(message.role);
+    }
+    if (message.scope !== 0) {
+      obj.scope = roleScopeToJSON(message.scope);
+    }
+    if (message.organizationId !== undefined) {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.locationId !== undefined) {
+      obj.locationId = message.locationId;
+    }
+    return obj;
+  },
+  create(base) {
+    return UserRole.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUserRole();
+    message.role = object.role ?? 0;
+    message.scope = object.scope ?? 0;
+    message.organizationId = object.organizationId ?? undefined;
+    message.locationId = object.locationId ?? undefined;
+    return message;
+  }
+};
+var UsersServiceDefinition = {
+  name: "UsersService",
+  fullName: "zenu.users.v1.UsersService",
+  methods: {
+    sayHello: {
+      name: "SayHello",
+      requestType: SayHelloRequest,
+      requestStream: false,
+      responseType: SayHelloResponse,
+      responseStream: false,
+      options: {}
+    },
+    whoAmI: {
+      name: "WhoAmI",
+      requestType: WhoAmIRequest,
+      requestStream: false,
+      responseType: WhoAmIResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function toTimestamp(date) {
+  const seconds = Math.trunc(date.getTime() / 1000);
+  const nanos = date.getTime() % 1000 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp(t) {
+  let millis = (t.seconds || 0) * 1000;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+function isSet2(value) {
+  return value !== null && value !== undefined;
+}
+
+// src/client.ts
+function createZenuClient({
+  baseUrl,
+  getToken
+}) {
+  const channel = import_nice_grpc_web.createChannel(baseUrl);
+  const clientFactory = import_nice_grpc_web.createClientFactory().use(async function* (call, options) {
+    const token = await getToken();
+    const metadata = import_nice_grpc_web.Metadata(options.metadata);
+    metadata.set("Authorization", `Bearer ${token}`);
+    return yield* call.next(call.request, {
+      ...options,
+      metadata
+    });
+  });
+  return {
+    users: clientFactory.create(UsersServiceDefinition, channel)
+  };
+}
+export {
+  roleToJSON,
+  roleScopeToJSON,
+  roleScopeFromJSON,
+  roleFromJSON,
+  protobufPackage,
+  createZenuClient,
+  WhoAmIResponse,
+  WhoAmIRequest,
+  UsersServiceDefinition,
+  UserRole,
+  User,
+  SayHelloResponse,
+  SayHelloRequest,
+  RoleScope,
+  Role
+};