@openfeature/flagd-provider 0.13.0 → 0.13.2

package/index.esm.js

@@ -1,25 +1,56 @@
-import { GeneralError, FlagNotFoundError, TypeMismatchError, ParseError, StandardResolutionReasons, ProviderStatus, OpenFeatureEventEmitter, ProviderEvents } from '@openfeature/server-sdk';
+import { GeneralError, FlagNotFoundError, TypeMismatchError, ParseError, StandardResolutionReasons, OpenFeatureError, OpenFeatureEventEmitter, ProviderEvents } from '@openfeature/server-sdk';
 import { makeGenericClientConstructor, status, credentials } from '@grpc/grpc-js';
 import { ConnectivityState } from '@grpc/grpc-js/build/src/connectivity-state';
 import { LRUCache } from 'lru-cache';
-import { promisify } from 'util';
+import { promisify } from 'node:util';
 import { FlagdCore } from '@openfeature/flagd-core';
-import { OpenFeatureError, GeneralError as GeneralError$1 } from '@openfeature/core';
 import { promises, watchFile, unwatchFile } from 'fs';
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 const EVENT_CONFIGURATION_CHANGE = 'configuration_change';
 const EVENT_PROVIDER_READY = 'provider_ready';
 const DEFAULT_MAX_CACHE_SIZE = 1000;
 
 const DEFAULT_CONFIG = {
     host: 'localhost',
-    port: 8013,
     tls: false,
-    resolverType: 'rpc',
     selector: '',
     cache: 'lru',
     maxCacheSize: DEFAULT_MAX_CACHE_SIZE,
 };
+const DEFAULT_RPC_CONFIG = Object.assign(Object.assign({}, DEFAULT_CONFIG), { resolverType: 'rpc', port: 8013 });
+const DEFAULT_IN_PROCESS_CONFIG = Object.assign(Object.assign({}, DEFAULT_CONFIG), { resolverType: 'in-process', port: 8015 });
 var ENV_VAR;
 (function (ENV_VAR) {
     ENV_VAR["FLAGD_HOST"] = "FLAGD_HOST";
@@ -39,7 +70,7 @@ const getEnvVarConfig = () => {
     })), (Number(process.env[ENV_VAR.FLAGD_PORT]) && {
         port: Number(process.env[ENV_VAR.FLAGD_PORT]),
     })), (process.env[ENV_VAR.FLAGD_TLS] && {
-        tls: ((_a = process.env[ENV_VAR.FLAGD_TLS]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'true',
+        tls: ((_a = process.env[ENV_VAR.FLAGD_TLS]) === null || _a === undefined ? undefined : _a.toLowerCase()) === 'true',
     })), (process.env[ENV_VAR.FLAGD_SOCKET_PATH] && {
         socketPath: process.env[ENV_VAR.FLAGD_SOCKET_PATH],
     })), ((process.env[ENV_VAR.FLAGD_CACHE] === 'lru' || process.env[ENV_VAR.FLAGD_CACHE] === 'disabled') && {
@@ -55,39 +86,13 @@ const getEnvVarConfig = () => {
     })));
 };
 function getConfig(options = {}) {
-    return Object.assign(Object.assign(Object.assign({}, DEFAULT_CONFIG), getEnvVarConfig()), options);
+    const envVarConfig = getEnvVarConfig();
+    const defaultConfig = options.resolverType == 'in-process' || envVarConfig.resolverType == 'in-process'
+        ? DEFAULT_IN_PROCESS_CONFIG
+        : DEFAULT_RPC_CONFIG;
+    return Object.assign(Object.assign(Object.assign({}, defaultConfig), envVarConfig), options);
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /**
  * @license
  * Copyright 2009 The Closure Library Authors
@@ -276,7 +281,7 @@ function fromNumber(value, unsigned) {
     if (value >= TWO_PWR_64_DBL)
       return MAX_UNSIGNED_VALUE;
   } else {
-    if (value <= -TWO_PWR_63_DBL)
+    if (value <= -9223372036854776e3)
       return MIN_VALUE;
     if (value + 1 >= TWO_PWR_63_DBL)
       return MAX_VALUE;
@@ -1075,7 +1080,7 @@ LongPrototype.divide = function divide(divisor) {
     // negative number / -1 would be 1 larger than the largest
     // positive number, due to two's complement.
     if (!this.unsigned &&
-      this.high === -0x80000000 &&
+      this.high === -2147483648 &&
       divisor.low === -1 && divisor.high === -1) {
       // be consistent with non-wasm code path
       return this;
@@ -1556,1432 +1561,1506 @@ Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var indexMinimal = {};
 
 var minimal$1 = {};
 
-var aspromise = asPromise;
+var aspromise;
+var hasRequiredAspromise;
+
+function requireAspromise () {
+	if (hasRequiredAspromise) return aspromise;
+	hasRequiredAspromise = 1;
+	aspromise = asPromise;
 
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
+	/**
+	 * Callback as used by {@link util.asPromise}.
+	 * @typedef asPromiseCallback
+	 * @type {function}
+	 * @param {Error|null} error Error, if any
+	 * @param {...*} params Additional arguments
+	 * @returns {undefined}
+	 */
 
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
+	/**
+	 * Returns a promise from a node-style callback function.
+	 * @memberof util
+	 * @param {asPromiseCallback} fn Function to call
+	 * @param {*} ctx Function context
+	 * @param {...*} params Function arguments
+	 * @returns {Promise<*>} Promisified function
+	 */
+	function asPromise(fn, ctx/*, varargs */) {
+	    var params  = new Array(arguments.length - 1),
+	        offset  = 0,
+	        index   = 2,
+	        pending = true;
+	    while (index < arguments.length)
+	        params[offset++] = arguments[index++];
+	    return new Promise(function executor(resolve, reject) {
+	        params[offset] = function callback(err/*, varargs */) {
+	            if (pending) {
+	                pending = false;
+	                if (err)
+	                    reject(err);
+	                else {
+	                    var params = new Array(arguments.length - 1),
+	                        offset = 0;
+	                    while (offset < params.length)
+	                        params[offset++] = arguments[offset];
+	                    resolve.apply(null, params);
+	                }
+	            }
+	        };
+	        try {
+	            fn.apply(ctx || null, params);
+	        } catch (err) {
+	            if (pending) {
+	                pending = false;
+	                reject(err);
+	            }
+	        }
+	    });
+	}
+	return aspromise;
 }
 
 var base64$1 = {};
 
-(function (exports) {
+var hasRequiredBase64;
+
+function requireBase64 () {
+	if (hasRequiredBase64) return base64$1;
+	hasRequiredBase64 = 1;
+	(function (exports) {
 
-/**
- * A minimal base64 implementation for number arrays.
- * @memberof util
- * @namespace
- */
-var base64 = exports;
+		/**
+		 * A minimal base64 implementation for number arrays.
+		 * @memberof util
+		 * @namespace
+		 */
+		var base64 = exports;
 
-/**
- * Calculates the byte length of a base64 encoded string.
- * @param {string} string Base64 encoded string
- * @returns {number} Byte length
- */
-base64.length = function length(string) {
-    var p = string.length;
-    if (!p)
-        return 0;
-    var n = 0;
-    while (--p % 4 > 1 && string.charAt(p) === "=")
-        ++n;
-    return Math.ceil(string.length * 3) / 4 - n;
-};
+		/**
+		 * Calculates the byte length of a base64 encoded string.
+		 * @param {string} string Base64 encoded string
+		 * @returns {number} Byte length
+		 */
+		base64.length = function length(string) {
+		    var p = string.length;
+		    if (!p)
+		        return 0;
+		    var n = 0;
+		    while (--p % 4 > 1 && string.charAt(p) === "=")
+		        ++n;
+		    return Math.ceil(string.length * 3) / 4 - n;
+		};
 
-// Base64 encoding table
-var b64 = new Array(64);
+		// Base64 encoding table
+		var b64 = new Array(64);
 
-// Base64 decoding table
-var s64 = new Array(123);
+		// Base64 decoding table
+		var s64 = new Array(123);
 
-// 65..90, 97..122, 48..57, 43, 47
-for (var i = 0; i < 64;)
-    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+		// 65..90, 97..122, 48..57, 43, 47
+		for (var i = 0; i < 64;)
+		    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
 
-/**
- * Encodes a buffer to a base64 encoded string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} Base64 encoded string
- */
-base64.encode = function encode(buffer, start, end) {
-    var parts = null,
-        chunk = [];
-    var i = 0, // output index
-        j = 0, // goto index
-        t;     // temporary
-    while (start < end) {
-        var b = buffer[start++];
-        switch (j) {
-            case 0:
-                chunk[i++] = b64[b >> 2];
-                t = (b & 3) << 4;
-                j = 1;
-                break;
-            case 1:
-                chunk[i++] = b64[t | b >> 4];
-                t = (b & 15) << 2;
-                j = 2;
-                break;
-            case 2:
-                chunk[i++] = b64[t | b >> 6];
-                chunk[i++] = b64[b & 63];
-                j = 0;
-                break;
-        }
-        if (i > 8191) {
-            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-            i = 0;
-        }
-    }
-    if (j) {
-        chunk[i++] = b64[t];
-        chunk[i++] = 61;
-        if (j === 1)
-            chunk[i++] = 61;
-    }
-    if (parts) {
-        if (i)
-            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-        return parts.join("");
-    }
-    return String.fromCharCode.apply(String, chunk.slice(0, i));
-};
+		/**
+		 * Encodes a buffer to a base64 encoded string.
+		 * @param {Uint8Array} buffer Source buffer
+		 * @param {number} start Source start
+		 * @param {number} end Source end
+		 * @returns {string} Base64 encoded string
+		 */
+		base64.encode = function encode(buffer, start, end) {
+		    var parts = null,
+		        chunk = [];
+		    var i = 0, // output index
+		        j = 0, // goto index
+		        t;     // temporary
+		    while (start < end) {
+		        var b = buffer[start++];
+		        switch (j) {
+		            case 0:
+		                chunk[i++] = b64[b >> 2];
+		                t = (b & 3) << 4;
+		                j = 1;
+		                break;
+		            case 1:
+		                chunk[i++] = b64[t | b >> 4];
+		                t = (b & 15) << 2;
+		                j = 2;
+		                break;
+		            case 2:
+		                chunk[i++] = b64[t | b >> 6];
+		                chunk[i++] = b64[b & 63];
+		                j = 0;
+		                break;
+		        }
+		        if (i > 8191) {
+		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+		            i = 0;
+		        }
+		    }
+		    if (j) {
+		        chunk[i++] = b64[t];
+		        chunk[i++] = 61;
+		        if (j === 1)
+		            chunk[i++] = 61;
+		    }
+		    if (parts) {
+		        if (i)
+		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		        return parts.join("");
+		    }
+		    return String.fromCharCode.apply(String, chunk.slice(0, i));
+		};
 
-var invalidEncoding = "invalid encoding";
+		var invalidEncoding = "invalid encoding";
 
-/**
- * Decodes a base64 encoded string to a buffer.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Number of bytes written
- * @throws {Error} If encoding is invalid
- */
-base64.decode = function decode(string, buffer, offset) {
-    var start = offset;
-    var j = 0, // goto index
-        t;     // temporary
-    for (var i = 0; i < string.length;) {
-        var c = string.charCodeAt(i++);
-        if (c === 61 && j > 1)
-            break;
-        if ((c = s64[c]) === undefined)
-            throw Error(invalidEncoding);
-        switch (j) {
-            case 0:
-                t = c;
-                j = 1;
-                break;
-            case 1:
-                buffer[offset++] = t << 2 | (c & 48) >> 4;
-                t = c;
-                j = 2;
-                break;
-            case 2:
-                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-                t = c;
-                j = 3;
-                break;
-            case 3:
-                buffer[offset++] = (t & 3) << 6 | c;
-                j = 0;
-                break;
-        }
-    }
-    if (j === 1)
-        throw Error(invalidEncoding);
-    return offset - start;
-};
+		/**
+		 * Decodes a base64 encoded string to a buffer.
+		 * @param {string} string Source string
+		 * @param {Uint8Array} buffer Destination buffer
+		 * @param {number} offset Destination offset
+		 * @returns {number} Number of bytes written
+		 * @throws {Error} If encoding is invalid
+		 */
+		base64.decode = function decode(string, buffer, offset) {
+		    var start = offset;
+		    var j = 0, // goto index
+		        t;     // temporary
+		    for (var i = 0; i < string.length;) {
+		        var c = string.charCodeAt(i++);
+		        if (c === 61 && j > 1)
+		            break;
+		        if ((c = s64[c]) === undefined)
+		            throw Error(invalidEncoding);
+		        switch (j) {
+		            case 0:
+		                t = c;
+		                j = 1;
+		                break;
+		            case 1:
+		                buffer[offset++] = t << 2 | (c & 48) >> 4;
+		                t = c;
+		                j = 2;
+		                break;
+		            case 2:
+		                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+		                t = c;
+		                j = 3;
+		                break;
+		            case 3:
+		                buffer[offset++] = (t & 3) << 6 | c;
+		                j = 0;
+		                break;
+		        }
+		    }
+		    if (j === 1)
+		        throw Error(invalidEncoding);
+		    return offset - start;
+		};
 
-/**
- * Tests if the specified string appears to be base64 encoded.
- * @param {string} string String to test
- * @returns {boolean} `true` if probably base64 encoded, otherwise false
- */
-base64.test = function test(string) {
-    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-};
-}(base64$1));
+		/**
+		 * Tests if the specified string appears to be base64 encoded.
+		 * @param {string} string String to test
+		 * @returns {boolean} `true` if probably base64 encoded, otherwise false
+		 */
+		base64.test = function test(string) {
+		    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+		}; 
+	} (base64$1));
+	return base64$1;
+}
 
-var eventemitter = EventEmitter;
+var eventemitter;
+var hasRequiredEventemitter;
+
+function requireEventemitter () {
+	if (hasRequiredEventemitter) return eventemitter;
+	hasRequiredEventemitter = 1;
+	eventemitter = EventEmitter;
 
-/**
- * Constructs a new event emitter instance.
- * @classdesc A minimal event emitter.
- * @memberof util
- * @constructor
- */
-function EventEmitter() {
+	/**
+	 * Constructs a new event emitter instance.
+	 * @classdesc A minimal event emitter.
+	 * @memberof util
+	 * @constructor
+	 */
+	function EventEmitter() {
 
-    /**
-     * Registered listeners.
-     * @type {Object.<string,*>}
-     * @private
-     */
-    this._listeners = {};
-}
+	    /**
+	     * Registered listeners.
+	     * @type {Object.<string,*>}
+	     * @private
+	     */
+	    this._listeners = {};
+	}
 
-/**
- * Registers an event listener.
- * @param {string} evt Event name
- * @param {function} fn Listener
- * @param {*} [ctx] Listener context
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.on = function on(evt, fn, ctx) {
-    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-        fn  : fn,
-        ctx : ctx || this
-    });
-    return this;
-};
+	/**
+	 * Registers an event listener.
+	 * @param {string} evt Event name
+	 * @param {function} fn Listener
+	 * @param {*} [ctx] Listener context
+	 * @returns {util.EventEmitter} `this`
+	 */
+	EventEmitter.prototype.on = function on(evt, fn, ctx) {
+	    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+	        fn  : fn,
+	        ctx : ctx || this
+	    });
+	    return this;
+	};
 
-/**
- * Removes an event listener or any matching listeners if arguments are omitted.
- * @param {string} [evt] Event name. Removes all listeners if omitted.
- * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.off = function off(evt, fn) {
-    if (evt === undefined)
-        this._listeners = {};
-    else {
-        if (fn === undefined)
-            this._listeners[evt] = [];
-        else {
-            var listeners = this._listeners[evt];
-            for (var i = 0; i < listeners.length;)
-                if (listeners[i].fn === fn)
-                    listeners.splice(i, 1);
-                else
-                    ++i;
-        }
-    }
-    return this;
-};
+	/**
+	 * Removes an event listener or any matching listeners if arguments are omitted.
+	 * @param {string} [evt] Event name. Removes all listeners if omitted.
+	 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+	 * @returns {util.EventEmitter} `this`
+	 */
+	EventEmitter.prototype.off = function off(evt, fn) {
+	    if (evt === undefined)
+	        this._listeners = {};
+	    else {
+	        if (fn === undefined)
+	            this._listeners[evt] = [];
+	        else {
+	            var listeners = this._listeners[evt];
+	            for (var i = 0; i < listeners.length;)
+	                if (listeners[i].fn === fn)
+	                    listeners.splice(i, 1);
+	                else
+	                    ++i;
+	        }
+	    }
+	    return this;
+	};
 
-/**
- * Emits an event by calling its listeners with the specified arguments.
- * @param {string} evt Event name
- * @param {...*} args Arguments
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.emit = function emit(evt) {
-    var listeners = this._listeners[evt];
-    if (listeners) {
-        var args = [],
-            i = 1;
-        for (; i < arguments.length;)
-            args.push(arguments[i++]);
-        for (i = 0; i < listeners.length;)
-            listeners[i].fn.apply(listeners[i++].ctx, args);
-    }
-    return this;
-};
+	/**
+	 * Emits an event by calling its listeners with the specified arguments.
+	 * @param {string} evt Event name
+	 * @param {...*} args Arguments
+	 * @returns {util.EventEmitter} `this`
+	 */
+	EventEmitter.prototype.emit = function emit(evt) {
+	    var listeners = this._listeners[evt];
+	    if (listeners) {
+	        var args = [],
+	            i = 1;
+	        for (; i < arguments.length;)
+	            args.push(arguments[i++]);
+	        for (i = 0; i < listeners.length;)
+	            listeners[i].fn.apply(listeners[i++].ctx, args);
+	    }
+	    return this;
+	};
+	return eventemitter;
+}
 
-var float = factory(factory);
+var float;
+var hasRequiredFloat;
+
+function requireFloat () {
+	if (hasRequiredFloat) return float;
+	hasRequiredFloat = 1;
 
-/**
- * Reads / writes floats / doubles from / to buffers.
- * @name util.float
- * @namespace
- */
+	float = factory(factory);
 
-/**
- * Writes a 32 bit float to a buffer using little endian byte order.
- * @name util.float.writeFloatLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Reads / writes floats / doubles from / to buffers.
+	 * @name util.float
+	 * @namespace
+	 */
 
-/**
- * Writes a 32 bit float to a buffer using big endian byte order.
- * @name util.float.writeFloatBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Writes a 32 bit float to a buffer using little endian byte order.
+	 * @name util.float.writeFloatLE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 32 bit float from a buffer using little endian byte order.
- * @name util.float.readFloatLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Writes a 32 bit float to a buffer using big endian byte order.
+	 * @name util.float.writeFloatBE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 32 bit float from a buffer using big endian byte order.
- * @name util.float.readFloatBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 32 bit float from a buffer using little endian byte order.
+	 * @name util.float.readFloatLE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-/**
- * Writes a 64 bit double to a buffer using little endian byte order.
- * @name util.float.writeDoubleLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Reads a 32 bit float from a buffer using big endian byte order.
+	 * @name util.float.readFloatBE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-/**
- * Writes a 64 bit double to a buffer using big endian byte order.
- * @name util.float.writeDoubleBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+	/**
+	 * Writes a 64 bit double to a buffer using little endian byte order.
+	 * @name util.float.writeDoubleLE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 64 bit double from a buffer using little endian byte order.
- * @name util.float.readDoubleLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Writes a 64 bit double to a buffer using big endian byte order.
+	 * @name util.float.writeDoubleBE
+	 * @function
+	 * @param {number} val Value to write
+	 * @param {Uint8Array} buf Target buffer
+	 * @param {number} pos Target buffer offset
+	 * @returns {undefined}
+	 */
 
-/**
- * Reads a 64 bit double from a buffer using big endian byte order.
- * @name util.float.readDoubleBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+	/**
+	 * Reads a 64 bit double from a buffer using little endian byte order.
+	 * @name util.float.readDoubleLE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-// Factory function for the purpose of node-based testing in modified global environments
-function factory(exports) {
+	/**
+	 * Reads a 64 bit double from a buffer using big endian byte order.
+	 * @name util.float.readDoubleBE
+	 * @function
+	 * @param {Uint8Array} buf Source buffer
+	 * @param {number} pos Source buffer offset
+	 * @returns {number} Value read
+	 */
 
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
+	// Factory function for the purpose of node-based testing in modified global environments
+	function factory(exports) {
 
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
+	    // float: typed array
+	    if (typeof Float32Array !== "undefined") (function() {
 
-        function writeFloat_f32_cpy(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-        }
+	        var f32 = new Float32Array([ -0 ]),
+	            f8b = new Uint8Array(f32.buffer),
+	            le  = f8b[3] === 128;
 
-        function writeFloat_f32_rev(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[3];
-            buf[pos + 1] = f8b[2];
-            buf[pos + 2] = f8b[1];
-            buf[pos + 3] = f8b[0];
-        }
+	        function writeFloat_f32_cpy(val, buf, pos) {
+	            f32[0] = val;
+	            buf[pos    ] = f8b[0];
+	            buf[pos + 1] = f8b[1];
+	            buf[pos + 2] = f8b[2];
+	            buf[pos + 3] = f8b[3];
+	        }
 
-        /* istanbul ignore next */
-        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+	        function writeFloat_f32_rev(val, buf, pos) {
+	            f32[0] = val;
+	            buf[pos    ] = f8b[3];
+	            buf[pos + 1] = f8b[2];
+	            buf[pos + 2] = f8b[1];
+	            buf[pos + 3] = f8b[0];
+	        }
 
-        function readFloat_f32_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            return f32[0];
-        }
+	        /* istanbul ignore next */
+	        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+	        /* istanbul ignore next */
+	        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
 
-        function readFloat_f32_rev(buf, pos) {
-            f8b[3] = buf[pos    ];
-            f8b[2] = buf[pos + 1];
-            f8b[1] = buf[pos + 2];
-            f8b[0] = buf[pos + 3];
-            return f32[0];
-        }
+	        function readFloat_f32_cpy(buf, pos) {
+	            f8b[0] = buf[pos    ];
+	            f8b[1] = buf[pos + 1];
+	            f8b[2] = buf[pos + 2];
+	            f8b[3] = buf[pos + 3];
+	            return f32[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+	        function readFloat_f32_rev(buf, pos) {
+	            f8b[3] = buf[pos    ];
+	            f8b[2] = buf[pos + 1];
+	            f8b[1] = buf[pos + 2];
+	            f8b[0] = buf[pos + 3];
+	            return f32[0];
+	        }
 
-    // float: ieee754
-    })(); else (function() {
+	        /* istanbul ignore next */
+	        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+	        /* istanbul ignore next */
+	        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
 
-        function writeFloat_ieee754(writeUint, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0)
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-            else if (isNaN(val))
-                writeUint(2143289344, buf, pos);
-            else if (val > 3.4028234663852886e+38) // +-Infinity
-                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-            else if (val < 1.1754943508222875e-38) // denormal
-                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-            else {
-                var exponent = Math.floor(Math.log(val) / Math.LN2),
-                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-            }
-        }
+	    // float: ieee754
+	    })(); else (function() {
 
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+	        function writeFloat_ieee754(writeUint, val, buf, pos) {
+	            var sign = val < 0 ? 1 : 0;
+	            if (sign)
+	                val = -val;
+	            if (val === 0)
+	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
+	            else if (isNaN(val))
+	                writeUint(2143289344, buf, pos);
+	            else if (val > 3.4028234663852886e+38) // +-Infinity
+	                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+	            else if (val < 1.1754943508222875e-38) // denormal
+	                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
+	            else {
+	                var exponent = Math.floor(Math.log(val) / Math.LN2),
+	                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+	                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+	            }
+	        }
 
-        function readFloat_ieee754(readUint, buf, pos) {
-            var uint = readUint(buf, pos),
-                sign = (uint >> 31) * 2 + 1,
-                exponent = uint >>> 23 & 255,
-                mantissa = uint & 8388607;
-            return exponent === 255
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 1.401298464324817e-45 * mantissa
-                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
-        }
+	        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+	        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+	        function readFloat_ieee754(readUint, buf, pos) {
+	            var uint = readUint(buf, pos),
+	                sign = (uint >> 31) * 2 + 1,
+	                exponent = uint >>> 23 & 255,
+	                mantissa = uint & 8388607;
+	            return exponent === 255
+	                ? mantissa
+	                ? NaN
+	                : sign * Infinity
+	                : exponent === 0 // denormal
+	                ? sign * 1.401298464324817e-45 * mantissa
+	                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+	        }
 
-    })();
+	        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+	        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
 
-    // double: typed array
-    if (typeof Float64Array !== "undefined") (function() {
+	    })();
 
-        var f64 = new Float64Array([-0]),
-            f8b = new Uint8Array(f64.buffer),
-            le  = f8b[7] === 128;
+	    // double: typed array
+	    if (typeof Float64Array !== "undefined") (function() {
 
-        function writeDouble_f64_cpy(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-            buf[pos + 4] = f8b[4];
-            buf[pos + 5] = f8b[5];
-            buf[pos + 6] = f8b[6];
-            buf[pos + 7] = f8b[7];
-        }
+	        var f64 = new Float64Array([-0]),
+	            f8b = new Uint8Array(f64.buffer),
+	            le  = f8b[7] === 128;
 
-        function writeDouble_f64_rev(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[7];
-            buf[pos + 1] = f8b[6];
-            buf[pos + 2] = f8b[5];
-            buf[pos + 3] = f8b[4];
-            buf[pos + 4] = f8b[3];
-            buf[pos + 5] = f8b[2];
-            buf[pos + 6] = f8b[1];
-            buf[pos + 7] = f8b[0];
-        }
+	        function writeDouble_f64_cpy(val, buf, pos) {
+	            f64[0] = val;
+	            buf[pos    ] = f8b[0];
+	            buf[pos + 1] = f8b[1];
+	            buf[pos + 2] = f8b[2];
+	            buf[pos + 3] = f8b[3];
+	            buf[pos + 4] = f8b[4];
+	            buf[pos + 5] = f8b[5];
+	            buf[pos + 6] = f8b[6];
+	            buf[pos + 7] = f8b[7];
+	        }
 
-        /* istanbul ignore next */
-        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+	        function writeDouble_f64_rev(val, buf, pos) {
+	            f64[0] = val;
+	            buf[pos    ] = f8b[7];
+	            buf[pos + 1] = f8b[6];
+	            buf[pos + 2] = f8b[5];
+	            buf[pos + 3] = f8b[4];
+	            buf[pos + 4] = f8b[3];
+	            buf[pos + 5] = f8b[2];
+	            buf[pos + 6] = f8b[1];
+	            buf[pos + 7] = f8b[0];
+	        }
 
-        function readDouble_f64_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            f8b[4] = buf[pos + 4];
-            f8b[5] = buf[pos + 5];
-            f8b[6] = buf[pos + 6];
-            f8b[7] = buf[pos + 7];
-            return f64[0];
-        }
+	        /* istanbul ignore next */
+	        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
 
-        function readDouble_f64_rev(buf, pos) {
-            f8b[7] = buf[pos    ];
-            f8b[6] = buf[pos + 1];
-            f8b[5] = buf[pos + 2];
-            f8b[4] = buf[pos + 3];
-            f8b[3] = buf[pos + 4];
-            f8b[2] = buf[pos + 5];
-            f8b[1] = buf[pos + 6];
-            f8b[0] = buf[pos + 7];
-            return f64[0];
-        }
+	        function readDouble_f64_cpy(buf, pos) {
+	            f8b[0] = buf[pos    ];
+	            f8b[1] = buf[pos + 1];
+	            f8b[2] = buf[pos + 2];
+	            f8b[3] = buf[pos + 3];
+	            f8b[4] = buf[pos + 4];
+	            f8b[5] = buf[pos + 5];
+	            f8b[6] = buf[pos + 6];
+	            f8b[7] = buf[pos + 7];
+	            return f64[0];
+	        }
 
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+	        function readDouble_f64_rev(buf, pos) {
+	            f8b[7] = buf[pos    ];
+	            f8b[6] = buf[pos + 1];
+	            f8b[5] = buf[pos + 2];
+	            f8b[4] = buf[pos + 3];
+	            f8b[3] = buf[pos + 4];
+	            f8b[2] = buf[pos + 5];
+	            f8b[1] = buf[pos + 6];
+	            f8b[0] = buf[pos + 7];
+	            return f64[0];
+	        }
 
-    // double: ieee754
-    })(); else (function() {
+	        /* istanbul ignore next */
+	        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+	        /* istanbul ignore next */
+	        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 
-        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0) {
-                writeUint(0, buf, pos + off0);
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-            } else if (isNaN(val)) {
-                writeUint(0, buf, pos + off0);
-                writeUint(2146959360, buf, pos + off1);
-            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-                writeUint(0, buf, pos + off0);
-                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-            } else {
-                var mantissa;
-                if (val < 2.2250738585072014e-308) { // denormal
-                    mantissa = val / 5e-324;
-                    writeUint(mantissa >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-                } else {
-                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-                    if (exponent === 1024)
-                        exponent = 1023;
-                    mantissa = val * Math.pow(2, -exponent);
-                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-                }
-            }
-        }
+	    // double: ieee754
+	    })(); else (function() {
 
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+	        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+	            var sign = val < 0 ? 1 : 0;
+	            if (sign)
+	                val = -val;
+	            if (val === 0) {
+	                writeUint(0, buf, pos + off0);
+	                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
+	            } else if (isNaN(val)) {
+	                writeUint(0, buf, pos + off0);
+	                writeUint(2146959360, buf, pos + off1);
+	            } else if (val > 1.7976931348623157e+308) { // +-Infinity
+	                writeUint(0, buf, pos + off0);
+	                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+	            } else {
+	                var mantissa;
+	                if (val < 2.2250738585072014e-308) { // denormal
+	                    mantissa = val / 5e-324;
+	                    writeUint(mantissa >>> 0, buf, pos + off0);
+	                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+	                } else {
+	                    var exponent = Math.floor(Math.log(val) / Math.LN2);
+	                    if (exponent === 1024)
+	                        exponent = 1023;
+	                    mantissa = val * Math.pow(2, -exponent);
+	                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+	                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+	                }
+	            }
+	        }
 
-        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
-            var lo = readUint(buf, pos + off0),
-                hi = readUint(buf, pos + off1);
-            var sign = (hi >> 31) * 2 + 1,
-                exponent = hi >>> 20 & 2047,
-                mantissa = 4294967296 * (hi & 1048575) + lo;
-            return exponent === 2047
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 5e-324 * mantissa
-                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
-        }
+	        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+	        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+	        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+	            var lo = readUint(buf, pos + off0),
+	                hi = readUint(buf, pos + off1);
+	            var sign = (hi >> 31) * 2 + 1,
+	                exponent = hi >>> 20 & 2047,
+	                mantissa = 4294967296 * (hi & 1048575) + lo;
+	            return exponent === 2047
+	                ? mantissa
+	                ? NaN
+	                : sign * Infinity
+	                : exponent === 0 // denormal
+	                ? sign * 5e-324 * mantissa
+	                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+	        }
 
-    })();
+	        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+	        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
 
-    return exports;
-}
+	    })();
 
-// uint helpers
+	    return exports;
+	}
 
-function writeUintLE(val, buf, pos) {
-    buf[pos    ] =  val        & 255;
-    buf[pos + 1] =  val >>> 8  & 255;
-    buf[pos + 2] =  val >>> 16 & 255;
-    buf[pos + 3] =  val >>> 24;
-}
+	// uint helpers
 
-function writeUintBE(val, buf, pos) {
-    buf[pos    ] =  val >>> 24;
-    buf[pos + 1] =  val >>> 16 & 255;
-    buf[pos + 2] =  val >>> 8  & 255;
-    buf[pos + 3] =  val        & 255;
-}
+	function writeUintLE(val, buf, pos) {
+	    buf[pos    ] =  val        & 255;
+	    buf[pos + 1] =  val >>> 8  & 255;
+	    buf[pos + 2] =  val >>> 16 & 255;
+	    buf[pos + 3] =  val >>> 24;
+	}
 
-function readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
+	function writeUintBE(val, buf, pos) {
+	    buf[pos    ] =  val >>> 24;
+	    buf[pos + 1] =  val >>> 16 & 255;
+	    buf[pos + 2] =  val >>> 8  & 255;
+	    buf[pos + 3] =  val        & 255;
+	}
 
-function readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
+	function readUintLE(buf, pos) {
+	    return (buf[pos    ]
+	          | buf[pos + 1] << 8
+	          | buf[pos + 2] << 16
+	          | buf[pos + 3] << 24) >>> 0;
+	}
+
+	function readUintBE(buf, pos) {
+	    return (buf[pos    ] << 24
+	          | buf[pos + 1] << 16
+	          | buf[pos + 2] << 8
+	          | buf[pos + 3]) >>> 0;
+	}
+	return float;
 }
 
-var inquire_1 = inquire;
+var inquire_1;
+var hasRequiredInquire;
+
+function requireInquire () {
+	if (hasRequiredInquire) return inquire_1;
+	hasRequiredInquire = 1;
+	inquire_1 = inquire;
 
-/**
- * Requires a module only if available.
- * @memberof util
- * @param {string} moduleName Module to require
- * @returns {?Object} Required module if available and not empty, otherwise `null`
- */
-function inquire(moduleName) {
-    try {
-        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-        if (mod && (mod.length || Object.keys(mod).length))
-            return mod;
-    } catch (e) {} // eslint-disable-line no-empty
-    return null;
+	/**
+	 * Requires a module only if available.
+	 * @memberof util
+	 * @param {string} moduleName Module to require
+	 * @returns {?Object} Required module if available and not empty, otherwise `null`
+	 */
+	function inquire(moduleName) {
+	    try {
+	        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
+	        if (mod && (mod.length || Object.keys(mod).length))
+	            return mod;
+	    } catch (e) {} // eslint-disable-line no-empty
+	    return null;
+	}
+	return inquire_1;
 }
 
 var utf8$2 = {};
 
-(function (exports) {
+var hasRequiredUtf8;
+
+function requireUtf8 () {
+	if (hasRequiredUtf8) return utf8$2;
+	hasRequiredUtf8 = 1;
+	(function (exports) {
 
-/**
- * A minimal UTF8 implementation for number arrays.
- * @memberof util
- * @namespace
- */
-var utf8 = exports;
+		/**
+		 * A minimal UTF8 implementation for number arrays.
+		 * @memberof util
+		 * @namespace
+		 */
+		var utf8 = exports;
 
-/**
- * Calculates the UTF8 byte length of a string.
- * @param {string} string String
- * @returns {number} Byte length
- */
-utf8.length = function utf8_length(string) {
-    var len = 0,
-        c = 0;
-    for (var i = 0; i < string.length; ++i) {
-        c = string.charCodeAt(i);
-        if (c < 128)
-            len += 1;
-        else if (c < 2048)
-            len += 2;
-        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-            ++i;
-            len += 4;
-        } else
-            len += 3;
-    }
-    return len;
-};
+		/**
+		 * Calculates the UTF8 byte length of a string.
+		 * @param {string} string String
+		 * @returns {number} Byte length
+		 */
+		utf8.length = function utf8_length(string) {
+		    var len = 0,
+		        c = 0;
+		    for (var i = 0; i < string.length; ++i) {
+		        c = string.charCodeAt(i);
+		        if (c < 128)
+		            len += 1;
+		        else if (c < 2048)
+		            len += 2;
+		        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+		            ++i;
+		            len += 4;
+		        } else
+		            len += 3;
+		    }
+		    return len;
+		};
 
-/**
- * Reads UTF8 bytes as a string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} String read
- */
-utf8.read = function utf8_read(buffer, start, end) {
-    var len = end - start;
-    if (len < 1)
-        return "";
-    var parts = null,
-        chunk = [],
-        i = 0, // char offset
-        t;     // temporary
-    while (start < end) {
-        t = buffer[start++];
-        if (t < 128)
-            chunk[i++] = t;
-        else if (t > 191 && t < 224)
-            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
-        else if (t > 239 && t < 365) {
-            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
-            chunk[i++] = 0xD800 + (t >> 10);
-            chunk[i++] = 0xDC00 + (t & 1023);
-        } else
-            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
-        if (i > 8191) {
-            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-            i = 0;
-        }
-    }
-    if (parts) {
-        if (i)
-            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-        return parts.join("");
-    }
-    return String.fromCharCode.apply(String, chunk.slice(0, i));
-};
+		/**
+		 * Reads UTF8 bytes as a string.
+		 * @param {Uint8Array} buffer Source buffer
+		 * @param {number} start Source start
+		 * @param {number} end Source end
+		 * @returns {string} String read
+		 */
+		utf8.read = function utf8_read(buffer, start, end) {
+		    var len = end - start;
+		    if (len < 1)
+		        return "";
+		    var parts = null,
+		        chunk = [],
+		        i = 0, // char offset
+		        t;     // temporary
+		    while (start < end) {
+		        t = buffer[start++];
+		        if (t < 128)
+		            chunk[i++] = t;
+		        else if (t > 191 && t < 224)
+		            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+		        else if (t > 239 && t < 365) {
+		            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+		            chunk[i++] = 0xD800 + (t >> 10);
+		            chunk[i++] = 0xDC00 + (t & 1023);
+		        } else
+		            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+		        if (i > 8191) {
+		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+		            i = 0;
+		        }
+		    }
+		    if (parts) {
+		        if (i)
+		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		        return parts.join("");
+		    }
+		    return String.fromCharCode.apply(String, chunk.slice(0, i));
+		};
 
-/**
- * Writes a string as UTF8 bytes.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Bytes written
- */
-utf8.write = function utf8_write(string, buffer, offset) {
-    var start = offset,
-        c1, // character 1
-        c2; // character 2
-    for (var i = 0; i < string.length; ++i) {
-        c1 = string.charCodeAt(i);
-        if (c1 < 128) {
-            buffer[offset++] = c1;
-        } else if (c1 < 2048) {
-            buffer[offset++] = c1 >> 6       | 192;
-            buffer[offset++] = c1       & 63 | 128;
-        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-            ++i;
-            buffer[offset++] = c1 >> 18      | 240;
-            buffer[offset++] = c1 >> 12 & 63 | 128;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        } else {
-            buffer[offset++] = c1 >> 12      | 224;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        }
-    }
-    return offset - start;
-};
-}(utf8$2));
+		/**
+		 * Writes a string as UTF8 bytes.
+		 * @param {string} string Source string
+		 * @param {Uint8Array} buffer Destination buffer
+		 * @param {number} offset Destination offset
+		 * @returns {number} Bytes written
+		 */
+		utf8.write = function utf8_write(string, buffer, offset) {
+		    var start = offset,
+		        c1, // character 1
+		        c2; // character 2
+		    for (var i = 0; i < string.length; ++i) {
+		        c1 = string.charCodeAt(i);
+		        if (c1 < 128) {
+		            buffer[offset++] = c1;
+		        } else if (c1 < 2048) {
+		            buffer[offset++] = c1 >> 6       | 192;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+		            ++i;
+		            buffer[offset++] = c1 >> 18      | 240;
+		            buffer[offset++] = c1 >> 12 & 63 | 128;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        } else {
+		            buffer[offset++] = c1 >> 12      | 224;
+		            buffer[offset++] = c1 >> 6  & 63 | 128;
+		            buffer[offset++] = c1       & 63 | 128;
+		        }
+		    }
+		    return offset - start;
+		}; 
+	} (utf8$2));
+	return utf8$2;
+}
+
+var pool_1;
+var hasRequiredPool;
 
-var pool_1 = pool;
+function requirePool () {
+	if (hasRequiredPool) return pool_1;
+	hasRequiredPool = 1;
+	pool_1 = pool;
 
-/**
- * An allocator as used by {@link util.pool}.
- * @typedef PoolAllocator
- * @type {function}
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
+	/**
+	 * An allocator as used by {@link util.pool}.
+	 * @typedef PoolAllocator
+	 * @type {function}
+	 * @param {number} size Buffer size
+	 * @returns {Uint8Array} Buffer
+	 */
 
-/**
- * A slicer as used by {@link util.pool}.
- * @typedef PoolSlicer
- * @type {function}
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Uint8Array} Buffer slice
- * @this {Uint8Array}
- */
+	/**
+	 * A slicer as used by {@link util.pool}.
+	 * @typedef PoolSlicer
+	 * @type {function}
+	 * @param {number} start Start offset
+	 * @param {number} end End offset
+	 * @returns {Uint8Array} Buffer slice
+	 * @this {Uint8Array}
+	 */
 
-/**
- * A general purpose buffer pool.
- * @memberof util
- * @function
- * @param {PoolAllocator} alloc Allocator
- * @param {PoolSlicer} slice Slicer
- * @param {number} [size=8192] Slab size
- * @returns {PoolAllocator} Pooled allocator
- */
-function pool(alloc, slice, size) {
-    var SIZE   = size || 8192;
-    var MAX    = SIZE >>> 1;
-    var slab   = null;
-    var offset = SIZE;
-    return function pool_alloc(size) {
-        if (size < 1 || size > MAX)
-            return alloc(size);
-        if (offset + size > SIZE) {
-            slab = alloc(SIZE);
-            offset = 0;
-        }
-        var buf = slice.call(slab, offset, offset += size);
-        if (offset & 7) // align to 32 bit
-            offset = (offset | 7) + 1;
-        return buf;
-    };
+	/**
+	 * A general purpose buffer pool.
+	 * @memberof util
+	 * @function
+	 * @param {PoolAllocator} alloc Allocator
+	 * @param {PoolSlicer} slice Slicer
+	 * @param {number} [size=8192] Slab size
+	 * @returns {PoolAllocator} Pooled allocator
+	 */
+	function pool(alloc, slice, size) {
+	    var SIZE   = size || 8192;
+	    var MAX    = SIZE >>> 1;
+	    var slab   = null;
+	    var offset = SIZE;
+	    return function pool_alloc(size) {
+	        if (size < 1 || size > MAX)
+	            return alloc(size);
+	        if (offset + size > SIZE) {
+	            slab = alloc(SIZE);
+	            offset = 0;
+	        }
+	        var buf = slice.call(slab, offset, offset += size);
+	        if (offset & 7) // align to 32 bit
+	            offset = (offset | 7) + 1;
+	        return buf;
+	    };
+	}
+	return pool_1;
 }
 
-var longbits = LongBits$2;
-
-var util$5 = minimal$1;
-
-/**
- * Constructs new long bits.
- * @classdesc Helper class for working with the low and high bits of a 64 bit value.
- * @memberof util
- * @constructor
- * @param {number} lo Low 32 bits, unsigned
- * @param {number} hi High 32 bits, unsigned
- */
-function LongBits$2(lo, hi) {
-
-    // note that the casts below are theoretically unnecessary as of today, but older statically
-    // generated converter code might still call the ctor with signed 32bits. kept for compat.
-
-    /**
-     * Low bits.
-     * @type {number}
-     */
-    this.lo = lo >>> 0;
-
-    /**
-     * High bits.
-     * @type {number}
-     */
-    this.hi = hi >>> 0;
+var longbits;
+var hasRequiredLongbits;
+
+function requireLongbits () {
+	if (hasRequiredLongbits) return longbits;
+	hasRequiredLongbits = 1;
+	longbits = LongBits;
+
+	var util = requireMinimal();
+
+	/**
+	 * Constructs new long bits.
+	 * @classdesc Helper class for working with the low and high bits of a 64 bit value.
+	 * @memberof util
+	 * @constructor
+	 * @param {number} lo Low 32 bits, unsigned
+	 * @param {number} hi High 32 bits, unsigned
+	 */
+	function LongBits(lo, hi) {
+
+	    // note that the casts below are theoretically unnecessary as of today, but older statically
+	    // generated converter code might still call the ctor with signed 32bits. kept for compat.
+
+	    /**
+	     * Low bits.
+	     * @type {number}
+	     */
+	    this.lo = lo >>> 0;
+
+	    /**
+	     * High bits.
+	     * @type {number}
+	     */
+	    this.hi = hi >>> 0;
+	}
+
+	/**
+	 * Zero bits.
+	 * @memberof util.LongBits
+	 * @type {util.LongBits}
+	 */
+	var zero = LongBits.zero = new LongBits(0, 0);
+
+	zero.toNumber = function() { return 0; };
+	zero.zzEncode = zero.zzDecode = function() { return this; };
+	zero.length = function() { return 1; };
+
+	/**
+	 * Zero hash.
+	 * @memberof util.LongBits
+	 * @type {string}
+	 */
+	var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
+
+	/**
+	 * Constructs new long bits from the specified number.
+	 * @param {number} value Value
+	 * @returns {util.LongBits} Instance
+	 */
+	LongBits.fromNumber = function fromNumber(value) {
+	    if (value === 0)
+	        return zero;
+	    var sign = value < 0;
+	    if (sign)
+	        value = -value;
+	    var lo = value >>> 0,
+	        hi = (value - lo) / 4294967296 >>> 0;
+	    if (sign) {
+	        hi = ~hi >>> 0;
+	        lo = ~lo >>> 0;
+	        if (++lo > 4294967295) {
+	            lo = 0;
+	            if (++hi > 4294967295)
+	                hi = 0;
+	        }
+	    }
+	    return new LongBits(lo, hi);
+	};
+
+	/**
+	 * Constructs new long bits from a number, long or string.
+	 * @param {Long|number|string} value Value
+	 * @returns {util.LongBits} Instance
+	 */
+	LongBits.from = function from(value) {
+	    if (typeof value === "number")
+	        return LongBits.fromNumber(value);
+	    if (util.isString(value)) {
+	        /* istanbul ignore else */
+	        if (util.Long)
+	            value = util.Long.fromString(value);
+	        else
+	            return LongBits.fromNumber(parseInt(value, 10));
+	    }
+	    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+	};
+
+	/**
+	 * Converts this long bits to a possibly unsafe JavaScript number.
+	 * @param {boolean} [unsigned=false] Whether unsigned or not
+	 * @returns {number} Possibly unsafe number
+	 */
+	LongBits.prototype.toNumber = function toNumber(unsigned) {
+	    if (!unsigned && this.hi >>> 31) {
+	        var lo = ~this.lo + 1 >>> 0,
+	            hi = ~this.hi     >>> 0;
+	        if (!lo)
+	            hi = hi + 1 >>> 0;
+	        return -(lo + hi * 4294967296);
+	    }
+	    return this.lo + this.hi * 4294967296;
+	};
+
+	/**
+	 * Converts this long bits to a long.
+	 * @param {boolean} [unsigned=false] Whether unsigned or not
+	 * @returns {Long} Long
+	 */
+	LongBits.prototype.toLong = function toLong(unsigned) {
+	    return util.Long
+	        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
+	        /* istanbul ignore next */
+	        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
+	};
+
+	var charCodeAt = String.prototype.charCodeAt;
+
+	/**
+	 * Constructs new long bits from the specified 8 characters long hash.
+	 * @param {string} hash Hash
+	 * @returns {util.LongBits} Bits
+	 */
+	LongBits.fromHash = function fromHash(hash) {
+	    if (hash === zeroHash)
+	        return zero;
+	    return new LongBits(
+	        ( charCodeAt.call(hash, 0)
+	        | charCodeAt.call(hash, 1) << 8
+	        | charCodeAt.call(hash, 2) << 16
+	        | charCodeAt.call(hash, 3) << 24) >>> 0
+	    ,
+	        ( charCodeAt.call(hash, 4)
+	        | charCodeAt.call(hash, 5) << 8
+	        | charCodeAt.call(hash, 6) << 16
+	        | charCodeAt.call(hash, 7) << 24) >>> 0
+	    );
+	};
+
+	/**
+	 * Converts this long bits to a 8 characters long hash.
+	 * @returns {string} Hash
+	 */
+	LongBits.prototype.toHash = function toHash() {
+	    return String.fromCharCode(
+	        this.lo        & 255,
+	        this.lo >>> 8  & 255,
+	        this.lo >>> 16 & 255,
+	        this.lo >>> 24      ,
+	        this.hi        & 255,
+	        this.hi >>> 8  & 255,
+	        this.hi >>> 16 & 255,
+	        this.hi >>> 24
+	    );
+	};
+
+	/**
+	 * Zig-zag encodes this long bits.
+	 * @returns {util.LongBits} `this`
+	 */
+	LongBits.prototype.zzEncode = function zzEncode() {
+	    var mask =   this.hi >> 31;
+	    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+	    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;
+	    return this;
+	};
+
+	/**
+	 * Zig-zag decodes this long bits.
+	 * @returns {util.LongBits} `this`
+	 */
+	LongBits.prototype.zzDecode = function zzDecode() {
+	    var mask = -(this.lo & 1);
+	    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+	    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;
+	    return this;
+	};
+
+	/**
+	 * Calculates the length of this longbits when encoded as a varint.
+	 * @returns {number} Length
+	 */
+	LongBits.prototype.length = function length() {
+	    var part0 =  this.lo,
+	        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
+	        part2 =  this.hi >>> 24;
+	    return part2 === 0
+	         ? part1 === 0
+	           ? part0 < 16384
+	             ? part0 < 128 ? 1 : 2
+	             : part0 < 2097152 ? 3 : 4
+	           : part1 < 16384
+	             ? part1 < 128 ? 5 : 6
+	             : part1 < 2097152 ? 7 : 8
+	         : part2 < 128 ? 9 : 10;
+	};
+	return longbits;
 }
 
-/**
- * Zero bits.
- * @memberof util.LongBits
- * @type {util.LongBits}
- */
-var zero = LongBits$2.zero = new LongBits$2(0, 0);
-
-zero.toNumber = function() { return 0; };
-zero.zzEncode = zero.zzDecode = function() { return this; };
-zero.length = function() { return 1; };
-
-/**
- * Zero hash.
- * @memberof util.LongBits
- * @type {string}
- */
-var zeroHash = LongBits$2.zeroHash = "\0\0\0\0\0\0\0\0";
-
-/**
- * Constructs new long bits from the specified number.
- * @param {number} value Value
- * @returns {util.LongBits} Instance
- */
-LongBits$2.fromNumber = function fromNumber(value) {
-    if (value === 0)
-        return zero;
-    var sign = value < 0;
-    if (sign)
-        value = -value;
-    var lo = value >>> 0,
-        hi = (value - lo) / 4294967296 >>> 0;
-    if (sign) {
-        hi = ~hi >>> 0;
-        lo = ~lo >>> 0;
-        if (++lo > 4294967295) {
-            lo = 0;
-            if (++hi > 4294967295)
-                hi = 0;
-        }
-    }
-    return new LongBits$2(lo, hi);
-};
-
-/**
- * Constructs new long bits from a number, long or string.
- * @param {Long|number|string} value Value
- * @returns {util.LongBits} Instance
- */
-LongBits$2.from = function from(value) {
-    if (typeof value === "number")
-        return LongBits$2.fromNumber(value);
-    if (util$5.isString(value)) {
-        /* istanbul ignore else */
-        if (util$5.Long)
-            value = util$5.Long.fromString(value);
-        else
-            return LongBits$2.fromNumber(parseInt(value, 10));
-    }
-    return value.low || value.high ? new LongBits$2(value.low >>> 0, value.high >>> 0) : zero;
-};
-
-/**
- * Converts this long bits to a possibly unsafe JavaScript number.
- * @param {boolean} [unsigned=false] Whether unsigned or not
- * @returns {number} Possibly unsafe number
- */
-LongBits$2.prototype.toNumber = function toNumber(unsigned) {
-    if (!unsigned && this.hi >>> 31) {
-        var lo = ~this.lo + 1 >>> 0,
-            hi = ~this.hi     >>> 0;
-        if (!lo)
-            hi = hi + 1 >>> 0;
-        return -(lo + hi * 4294967296);
-    }
-    return this.lo + this.hi * 4294967296;
-};
-
-/**
- * Converts this long bits to a long.
- * @param {boolean} [unsigned=false] Whether unsigned or not
- * @returns {Long} Long
- */
-LongBits$2.prototype.toLong = function toLong(unsigned) {
-    return util$5.Long
-        ? new util$5.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
-        /* istanbul ignore next */
-        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
-};
-
-var charCodeAt = String.prototype.charCodeAt;
-
-/**
- * Constructs new long bits from the specified 8 characters long hash.
- * @param {string} hash Hash
- * @returns {util.LongBits} Bits
- */
-LongBits$2.fromHash = function fromHash(hash) {
-    if (hash === zeroHash)
-        return zero;
-    return new LongBits$2(
-        ( charCodeAt.call(hash, 0)
-        | charCodeAt.call(hash, 1) << 8
-        | charCodeAt.call(hash, 2) << 16
-        | charCodeAt.call(hash, 3) << 24) >>> 0
-    ,
-        ( charCodeAt.call(hash, 4)
-        | charCodeAt.call(hash, 5) << 8
-        | charCodeAt.call(hash, 6) << 16
-        | charCodeAt.call(hash, 7) << 24) >>> 0
-    );
-};
-
-/**
- * Converts this long bits to a 8 characters long hash.
- * @returns {string} Hash
- */
-LongBits$2.prototype.toHash = function toHash() {
-    return String.fromCharCode(
-        this.lo        & 255,
-        this.lo >>> 8  & 255,
-        this.lo >>> 16 & 255,
-        this.lo >>> 24      ,
-        this.hi        & 255,
-        this.hi >>> 8  & 255,
-        this.hi >>> 16 & 255,
-        this.hi >>> 24
-    );
-};
-
-/**
- * Zig-zag encodes this long bits.
- * @returns {util.LongBits} `this`
- */
-LongBits$2.prototype.zzEncode = function zzEncode() {
-    var mask =   this.hi >> 31;
-    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
-    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;
-    return this;
-};
-
-/**
- * Zig-zag decodes this long bits.
- * @returns {util.LongBits} `this`
- */
-LongBits$2.prototype.zzDecode = function zzDecode() {
-    var mask = -(this.lo & 1);
-    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
-    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;
-    return this;
-};
-
-/**
- * Calculates the length of this longbits when encoded as a varint.
- * @returns {number} Length
- */
-LongBits$2.prototype.length = function length() {
-    var part0 =  this.lo,
-        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
-        part2 =  this.hi >>> 24;
-    return part2 === 0
-         ? part1 === 0
-           ? part0 < 16384
-             ? part0 < 128 ? 1 : 2
-             : part0 < 2097152 ? 3 : 4
-           : part1 < 16384
-             ? part1 < 128 ? 5 : 6
-             : part1 < 2097152 ? 7 : 8
-         : part2 < 128 ? 9 : 10;
-};
-
-(function (exports) {
-var util = exports;
-
-// used to return a Promise where callback is omitted
-util.asPromise = aspromise;
-
-// converts to / from base64 encoded strings
-util.base64 = base64$1;
-
-// base class of rpc.Service
-util.EventEmitter = eventemitter;
-
-// float handling accross browsers
-util.float = float;
-
-// requires modules optionally and hides the call from bundlers
-util.inquire = inquire_1;
-
-// converts to / from utf8 encoded strings
-util.utf8 = utf8$2;
-
-// provides a node-like buffer pool in the browser
-util.pool = pool_1;
-
-// utility to work with the low and high bits of a 64 bit value
-util.LongBits = longbits;
-
-/**
- * Whether running within node or not.
- * @memberof util
- * @type {boolean}
- */
-util.isNode = Boolean(typeof commonjsGlobal !== "undefined"
-                   && commonjsGlobal
-                   && commonjsGlobal.process
-                   && commonjsGlobal.process.versions
-                   && commonjsGlobal.process.versions.node);
-
-/**
- * Global object reference.
- * @memberof util
- * @type {Object}
- */
-util.global = util.isNode && commonjsGlobal
-           || typeof window !== "undefined" && window
-           || typeof self   !== "undefined" && self
-           || commonjsGlobal; // eslint-disable-line no-invalid-this
-
-/**
- * An immuable empty array.
- * @memberof util
- * @type {Array.<*>}
- * @const
- */
-util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes
-
-/**
- * An immutable empty object.
- * @type {Object}
- * @const
- */
-util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes
-
-/**
- * Tests if the specified value is an integer.
- * @function
- * @param {*} value Value to test
- * @returns {boolean} `true` if the value is an integer
- */
-util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
-    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
-};
-
-/**
- * Tests if the specified value is a string.
- * @param {*} value Value to test
- * @returns {boolean} `true` if the value is a string
- */
-util.isString = function isString(value) {
-    return typeof value === "string" || value instanceof String;
-};
-
-/**
- * Tests if the specified value is a non-null object.
- * @param {*} value Value to test
- * @returns {boolean} `true` if the value is a non-null object
- */
-util.isObject = function isObject(value) {
-    return value && typeof value === "object";
-};
-
-/**
- * Checks if a property on a message is considered to be present.
- * This is an alias of {@link util.isSet}.
- * @function
- * @param {Object} obj Plain object or message instance
- * @param {string} prop Property name
- * @returns {boolean} `true` if considered to be present, otherwise `false`
- */
-util.isset =
-
-/**
- * Checks if a property on a message is considered to be present.
- * @param {Object} obj Plain object or message instance
- * @param {string} prop Property name
- * @returns {boolean} `true` if considered to be present, otherwise `false`
- */
-util.isSet = function isSet(obj, prop) {
-    var value = obj[prop];
-    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
-        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
-    return false;
-};
-
-/**
- * Any compatible Buffer instance.
- * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
- * @interface Buffer
- * @extends Uint8Array
- */
-
-/**
- * Node's Buffer class if available.
- * @type {Constructor<Buffer>}
- */
-util.Buffer = (function() {
-    try {
-        var Buffer = util.inquire("buffer").Buffer;
-        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
-        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
-    } catch (e) {
-        /* istanbul ignore next */
-        return null;
-    }
-})();
-
-// Internal alias of or polyfull for Buffer.from.
-util._Buffer_from = null;
-
-// Internal alias of or polyfill for Buffer.allocUnsafe.
-util._Buffer_allocUnsafe = null;
-
-/**
- * Creates a new buffer of whatever type supported by the environment.
- * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
- * @returns {Uint8Array|Buffer} Buffer
- */
-util.newBuffer = function newBuffer(sizeOrArray) {
-    /* istanbul ignore next */
-    return typeof sizeOrArray === "number"
-        ? util.Buffer
-            ? util._Buffer_allocUnsafe(sizeOrArray)
-            : new util.Array(sizeOrArray)
-        : util.Buffer
-            ? util._Buffer_from(sizeOrArray)
-            : typeof Uint8Array === "undefined"
-                ? sizeOrArray
-                : new Uint8Array(sizeOrArray);
-};
-
-/**
- * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
- * @type {Constructor<Uint8Array>}
- */
-util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
-
-/**
- * Any compatible Long instance.
- * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
- * @interface Long
- * @property {number} low Low bits
- * @property {number} high High bits
- * @property {boolean} unsigned Whether unsigned or not
- */
-
-/**
- * Long.js's Long class if available.
- * @type {Constructor<Long>}
- */
-util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long
-         || /* istanbul ignore next */ util.global.Long
-         || util.inquire("long");
-
-/**
- * Regular expression used to verify 2 bit (`bool`) map keys.
- * @type {RegExp}
- * @const
- */
-util.key2Re = /^true|false|0|1$/;
-
-/**
- * Regular expression used to verify 32 bit (`int32` etc.) map keys.
- * @type {RegExp}
- * @const
- */
-util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
-
-/**
- * Regular expression used to verify 64 bit (`int64` etc.) map keys.
- * @type {RegExp}
- * @const
- */
-util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
-
-/**
- * Converts a number or long to an 8 characters long hash string.
- * @param {Long|number} value Value to convert
- * @returns {string} Hash
- */
-util.longToHash = function longToHash(value) {
-    return value
-        ? util.LongBits.from(value).toHash()
-        : util.LongBits.zeroHash;
-};
-
-/**
- * Converts an 8 characters long hash string to a long or number.
- * @param {string} hash Hash
- * @param {boolean} [unsigned=false] Whether unsigned or not
- * @returns {Long|number} Original value
- */
-util.longFromHash = function longFromHash(hash, unsigned) {
-    var bits = util.LongBits.fromHash(hash);
-    if (util.Long)
-        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
-    return bits.toNumber(Boolean(unsigned));
-};
-
-/**
- * Merges the properties of the source object into the destination object.
- * @memberof util
- * @param {Object.<string,*>} dst Destination object
- * @param {Object.<string,*>} src Source object
- * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
- * @returns {Object.<string,*>} Destination object
- */
-function merge(dst, src, ifNotSet) { // used by converters
-    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
-        if (dst[keys[i]] === undefined || !ifNotSet)
-            dst[keys[i]] = src[keys[i]];
-    return dst;
+var hasRequiredMinimal;
+
+function requireMinimal () {
+	if (hasRequiredMinimal) return minimal$1;
+	hasRequiredMinimal = 1;
+	(function (exports) {
+		var util = exports;
+
+		// used to return a Promise where callback is omitted
+		util.asPromise = requireAspromise();
+
+		// converts to / from base64 encoded strings
+		util.base64 = requireBase64();
+
+		// base class of rpc.Service
+		util.EventEmitter = requireEventemitter();
+
+		// float handling accross browsers
+		util.float = requireFloat();
+
+		// requires modules optionally and hides the call from bundlers
+		util.inquire = requireInquire();
+
+		// converts to / from utf8 encoded strings
+		util.utf8 = requireUtf8();
+
+		// provides a node-like buffer pool in the browser
+		util.pool = requirePool();
+
+		// utility to work with the low and high bits of a 64 bit value
+		util.LongBits = requireLongbits();
+
+		/**
+		 * Whether running within node or not.
+		 * @memberof util
+		 * @type {boolean}
+		 */
+		util.isNode = Boolean(typeof commonjsGlobal !== "undefined"
+		                   && commonjsGlobal
+		                   && commonjsGlobal.process
+		                   && commonjsGlobal.process.versions
+		                   && commonjsGlobal.process.versions.node);
+
+		/**
+		 * Global object reference.
+		 * @memberof util
+		 * @type {Object}
+		 */
+		util.global = util.isNode && commonjsGlobal
+		           || typeof window !== "undefined" && window
+		           || typeof self   !== "undefined" && self
+		           || commonjsGlobal; // eslint-disable-line no-invalid-this
+
+		/**
+		 * An immuable empty array.
+		 * @memberof util
+		 * @type {Array.<*>}
+		 * @const
+		 */
+		util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes
+
+		/**
+		 * An immutable empty object.
+		 * @type {Object}
+		 * @const
+		 */
+		util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes
+
+		/**
+		 * Tests if the specified value is an integer.
+		 * @function
+		 * @param {*} value Value to test
+		 * @returns {boolean} `true` if the value is an integer
+		 */
+		util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
+		    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+		};
+
+		/**
+		 * Tests if the specified value is a string.
+		 * @param {*} value Value to test
+		 * @returns {boolean} `true` if the value is a string
+		 */
+		util.isString = function isString(value) {
+		    return typeof value === "string" || value instanceof String;
+		};
+
+		/**
+		 * Tests if the specified value is a non-null object.
+		 * @param {*} value Value to test
+		 * @returns {boolean} `true` if the value is a non-null object
+		 */
+		util.isObject = function isObject(value) {
+		    return value && typeof value === "object";
+		};
+
+		/**
+		 * Checks if a property on a message is considered to be present.
+		 * This is an alias of {@link util.isSet}.
+		 * @function
+		 * @param {Object} obj Plain object or message instance
+		 * @param {string} prop Property name
+		 * @returns {boolean} `true` if considered to be present, otherwise `false`
+		 */
+		util.isset =
+
+		/**
+		 * Checks if a property on a message is considered to be present.
+		 * @param {Object} obj Plain object or message instance
+		 * @param {string} prop Property name
+		 * @returns {boolean} `true` if considered to be present, otherwise `false`
+		 */
+		util.isSet = function isSet(obj, prop) {
+		    var value = obj[prop];
+		    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
+		        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+		    return false;
+		};
+
+		/**
+		 * Any compatible Buffer instance.
+		 * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
+		 * @interface Buffer
+		 * @extends Uint8Array
+		 */
+
+		/**
+		 * Node's Buffer class if available.
+		 * @type {Constructor<Buffer>}
+		 */
+		util.Buffer = (function() {
+		    try {
+		        var Buffer = util.inquire("buffer").Buffer;
+		        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
+		        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
+		    } catch (e) {
+		        /* istanbul ignore next */
+		        return null;
+		    }
+		})();
+
+		// Internal alias of or polyfull for Buffer.from.
+		util._Buffer_from = null;
+
+		// Internal alias of or polyfill for Buffer.allocUnsafe.
+		util._Buffer_allocUnsafe = null;
+
+		/**
+		 * Creates a new buffer of whatever type supported by the environment.
+		 * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
+		 * @returns {Uint8Array|Buffer} Buffer
+		 */
+		util.newBuffer = function newBuffer(sizeOrArray) {
+		    /* istanbul ignore next */
+		    return typeof sizeOrArray === "number"
+		        ? util.Buffer
+		            ? util._Buffer_allocUnsafe(sizeOrArray)
+		            : new util.Array(sizeOrArray)
+		        : util.Buffer
+		            ? util._Buffer_from(sizeOrArray)
+		            : typeof Uint8Array === "undefined"
+		                ? sizeOrArray
+		                : new Uint8Array(sizeOrArray);
+		};
+
+		/**
+		 * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
+		 * @type {Constructor<Uint8Array>}
+		 */
+		util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
+
+		/**
+		 * Any compatible Long instance.
+		 * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
+		 * @interface Long
+		 * @property {number} low Low bits
+		 * @property {number} high High bits
+		 * @property {boolean} unsigned Whether unsigned or not
+		 */
+
+		/**
+		 * Long.js's Long class if available.
+		 * @type {Constructor<Long>}
+		 */
+		util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long
+		         || /* istanbul ignore next */ util.global.Long
+		         || util.inquire("long");
+
+		/**
+		 * Regular expression used to verify 2 bit (`bool`) map keys.
+		 * @type {RegExp}
+		 * @const
+		 */
+		util.key2Re = /^true|false|0|1$/;
+
+		/**
+		 * Regular expression used to verify 32 bit (`int32` etc.) map keys.
+		 * @type {RegExp}
+		 * @const
+		 */
+		util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
+
+		/**
+		 * Regular expression used to verify 64 bit (`int64` etc.) map keys.
+		 * @type {RegExp}
+		 * @const
+		 */
+		util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
+
+		/**
+		 * Converts a number or long to an 8 characters long hash string.
+		 * @param {Long|number} value Value to convert
+		 * @returns {string} Hash
+		 */
+		util.longToHash = function longToHash(value) {
+		    return value
+		        ? util.LongBits.from(value).toHash()
+		        : util.LongBits.zeroHash;
+		};
+
+		/**
+		 * Converts an 8 characters long hash string to a long or number.
+		 * @param {string} hash Hash
+		 * @param {boolean} [unsigned=false] Whether unsigned or not
+		 * @returns {Long|number} Original value
+		 */
+		util.longFromHash = function longFromHash(hash, unsigned) {
+		    var bits = util.LongBits.fromHash(hash);
+		    if (util.Long)
+		        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
+		    return bits.toNumber(Boolean(unsigned));
+		};
+
+		/**
+		 * Merges the properties of the source object into the destination object.
+		 * @memberof util
+		 * @param {Object.<string,*>} dst Destination object
+		 * @param {Object.<string,*>} src Source object
+		 * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
+		 * @returns {Object.<string,*>} Destination object
+		 */
+		function merge(dst, src, ifNotSet) { // used by converters
+		    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+		        if (dst[keys[i]] === undefined || !ifNotSet)
+		            dst[keys[i]] = src[keys[i]];
+		    return dst;
+		}
+
+		util.merge = merge;
+
+		/**
+		 * Converts the first character of a string to lower case.
+		 * @param {string} str String to convert
+		 * @returns {string} Converted string
+		 */
+		util.lcFirst = function lcFirst(str) {
+		    return str.charAt(0).toLowerCase() + str.substring(1);
+		};
+
+		/**
+		 * Creates a custom error constructor.
+		 * @memberof util
+		 * @param {string} name Error name
+		 * @returns {Constructor<Error>} Custom error constructor
+		 */
+		function newError(name) {
+
+		    function CustomError(message, properties) {
+
+		        if (!(this instanceof CustomError))
+		            return new CustomError(message, properties);
+
+		        // Error.call(this, message);
+		        // ^ just returns a new error instance because the ctor can be called as a function
+
+		        Object.defineProperty(this, "message", { get: function() { return message; } });
+
+		        /* istanbul ignore next */
+		        if (Error.captureStackTrace) // node
+		            Error.captureStackTrace(this, CustomError);
+		        else
+		            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
+
+		        if (properties)
+		            merge(this, properties);
+		    }
+
+		    CustomError.prototype = Object.create(Error.prototype, {
+		        constructor: {
+		            value: CustomError,
+		            writable: true,
+		            enumerable: false,
+		            configurable: true,
+		        },
+		        name: {
+		            get: function get() { return name; },
+		            set: undefined,
+		            enumerable: false,
+		            // configurable: false would accurately preserve the behavior of
+		            // the original, but I'm guessing that was not intentional.
+		            // For an actual error subclass, this property would
+		            // be configurable.
+		            configurable: true,
+		        },
+		        toString: {
+		            value: function value() { return this.name + ": " + this.message; },
+		            writable: true,
+		            enumerable: false,
+		            configurable: true,
+		        },
+		    });
+
+		    return CustomError;
+		}
+
+		util.newError = newError;
+
+		/**
+		 * Constructs a new protocol error.
+		 * @classdesc Error subclass indicating a protocol specifc error.
+		 * @memberof util
+		 * @extends Error
+		 * @template T extends Message<T>
+		 * @constructor
+		 * @param {string} message Error message
+		 * @param {Object.<string,*>} [properties] Additional properties
+		 * @example
+		 * try {
+		 *     MyMessage.decode(someBuffer); // throws if required fields are missing
+		 * } catch (e) {
+		 *     if (e instanceof ProtocolError && e.instance)
+		 *         console.log("decoded so far: " + JSON.stringify(e.instance));
+		 * }
+		 */
+		util.ProtocolError = newError("ProtocolError");
+
+		/**
+		 * So far decoded message instance.
+		 * @name util.ProtocolError#instance
+		 * @type {Message<T>}
+		 */
+
+		/**
+		 * A OneOf getter as returned by {@link util.oneOfGetter}.
+		 * @typedef OneOfGetter
+		 * @type {function}
+		 * @returns {string|undefined} Set field name, if any
+		 */
+
+		/**
+		 * Builds a getter for a oneof's present field name.
+		 * @param {string[]} fieldNames Field names
+		 * @returns {OneOfGetter} Unbound getter
+		 */
+		util.oneOfGetter = function getOneOf(fieldNames) {
+		    var fieldMap = {};
+		    for (var i = 0; i < fieldNames.length; ++i)
+		        fieldMap[fieldNames[i]] = 1;
+
+		    /**
+		     * @returns {string|undefined} Set field name, if any
+		     * @this Object
+		     * @ignore
+		     */
+		    return function() { // eslint-disable-line consistent-return
+		        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
+		            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
+		                return keys[i];
+		    };
+		};
+
+		/**
+		 * A OneOf setter as returned by {@link util.oneOfSetter}.
+		 * @typedef OneOfSetter
+		 * @type {function}
+		 * @param {string|undefined} value Field name
+		 * @returns {undefined}
+		 */
+
+		/**
+		 * Builds a setter for a oneof's present field name.
+		 * @param {string[]} fieldNames Field names
+		 * @returns {OneOfSetter} Unbound setter
+		 */
+		util.oneOfSetter = function setOneOf(fieldNames) {
+
+		    /**
+		     * @param {string} name Field name
+		     * @returns {undefined}
+		     * @this Object
+		     * @ignore
+		     */
+		    return function(name) {
+		        for (var i = 0; i < fieldNames.length; ++i)
+		            if (fieldNames[i] !== name)
+		                delete this[fieldNames[i]];
+		    };
+		};
+
+		/**
+		 * Default conversion options used for {@link Message#toJSON} implementations.
+		 *
+		 * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
+		 *
+		 * - Longs become strings
+		 * - Enums become string keys
+		 * - Bytes become base64 encoded strings
+		 * - (Sub-)Messages become plain objects
+		 * - Maps become plain objects with all string keys
+		 * - Repeated fields become arrays
+		 * - NaN and Infinity for float and double fields become strings
+		 *
+		 * @type {IConversionOptions}
+		 * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
+		 */
+		util.toJSONOptions = {
+		    longs: String,
+		    enums: String,
+		    bytes: String,
+		    json: true
+		};
+
+		// Sets up buffer utility according to the environment (called in index-minimal)
+		util._configure = function() {
+		    var Buffer = util.Buffer;
+		    /* istanbul ignore if */
+		    if (!Buffer) {
+		        util._Buffer_from = util._Buffer_allocUnsafe = null;
+		        return;
+		    }
+		    // because node 4.x buffers are incompatible & immutable
+		    // see: https://github.com/dcodeIO/protobuf.js/pull/665
+		    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
+		        /* istanbul ignore next */
+		        function Buffer_from(value, encoding) {
+		            return new Buffer(value, encoding);
+		        };
+		    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
+		        /* istanbul ignore next */
+		        function Buffer_allocUnsafe(size) {
+		            return new Buffer(size);
+		        };
+		}; 
+	} (minimal$1));
+	return minimal$1;
 }
 
-util.merge = merge;
-
-/**
- * Converts the first character of a string to lower case.
- * @param {string} str String to convert
- * @returns {string} Converted string
- */
-util.lcFirst = function lcFirst(str) {
-    return str.charAt(0).toLowerCase() + str.substring(1);
-};
-
-/**
- * Creates a custom error constructor.
- * @memberof util
- * @param {string} name Error name
- * @returns {Constructor<Error>} Custom error constructor
- */
-function newError(name) {
-
-    function CustomError(message, properties) {
-
-        if (!(this instanceof CustomError))
-            return new CustomError(message, properties);
-
-        // Error.call(this, message);
-        // ^ just returns a new error instance because the ctor can be called as a function
-
-        Object.defineProperty(this, "message", { get: function() { return message; } });
-
-        /* istanbul ignore next */
-        if (Error.captureStackTrace) // node
-            Error.captureStackTrace(this, CustomError);
-        else
-            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
-
-        if (properties)
-            merge(this, properties);
-    }
-
-    CustomError.prototype = Object.create(Error.prototype, {
-        constructor: {
-            value: CustomError,
-            writable: true,
-            enumerable: false,
-            configurable: true,
-        },
-        name: {
-            get: function get() { return name; },
-            set: undefined,
-            enumerable: false,
-            // configurable: false would accurately preserve the behavior of
-            // the original, but I'm guessing that was not intentional.
-            // For an actual error subclass, this property would
-            // be configurable.
-            configurable: true,
-        },
-        toString: {
-            value: function value() { return this.name + ": " + this.message; },
-            writable: true,
-            enumerable: false,
-            configurable: true,
-        },
-    });
-
-    return CustomError;
-}
-
-util.newError = newError;
-
-/**
- * Constructs a new protocol error.
- * @classdesc Error subclass indicating a protocol specifc error.
- * @memberof util
- * @extends Error
- * @template T extends Message<T>
- * @constructor
- * @param {string} message Error message
- * @param {Object.<string,*>} [properties] Additional properties
- * @example
- * try {
- *     MyMessage.decode(someBuffer); // throws if required fields are missing
- * } catch (e) {
- *     if (e instanceof ProtocolError && e.instance)
- *         console.log("decoded so far: " + JSON.stringify(e.instance));
- * }
- */
-util.ProtocolError = newError("ProtocolError");
-
-/**
- * So far decoded message instance.
- * @name util.ProtocolError#instance
- * @type {Message<T>}
- */
-
-/**
- * A OneOf getter as returned by {@link util.oneOfGetter}.
- * @typedef OneOfGetter
- * @type {function}
- * @returns {string|undefined} Set field name, if any
- */
-
-/**
- * Builds a getter for a oneof's present field name.
- * @param {string[]} fieldNames Field names
- * @returns {OneOfGetter} Unbound getter
- */
-util.oneOfGetter = function getOneOf(fieldNames) {
-    var fieldMap = {};
-    for (var i = 0; i < fieldNames.length; ++i)
-        fieldMap[fieldNames[i]] = 1;
-
-    /**
-     * @returns {string|undefined} Set field name, if any
-     * @this Object
-     * @ignore
-     */
-    return function() { // eslint-disable-line consistent-return
-        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
-            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
-                return keys[i];
-    };
-};
-
-/**
- * A OneOf setter as returned by {@link util.oneOfSetter}.
- * @typedef OneOfSetter
- * @type {function}
- * @param {string|undefined} value Field name
- * @returns {undefined}
- */
-
-/**
- * Builds a setter for a oneof's present field name.
- * @param {string[]} fieldNames Field names
- * @returns {OneOfSetter} Unbound setter
- */
-util.oneOfSetter = function setOneOf(fieldNames) {
-
-    /**
-     * @param {string} name Field name
-     * @returns {undefined}
-     * @this Object
-     * @ignore
-     */
-    return function(name) {
-        for (var i = 0; i < fieldNames.length; ++i)
-            if (fieldNames[i] !== name)
-                delete this[fieldNames[i]];
-    };
-};
-
-/**
- * Default conversion options used for {@link Message#toJSON} implementations.
- *
- * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
- *
- * - Longs become strings
- * - Enums become string keys
- * - Bytes become base64 encoded strings
- * - (Sub-)Messages become plain objects
- * - Maps become plain objects with all string keys
- * - Repeated fields become arrays
- * - NaN and Infinity for float and double fields become strings
- *
- * @type {IConversionOptions}
- * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
- */
-util.toJSONOptions = {
-    longs: String,
-    enums: String,
-    bytes: String,
-    json: true
-};
-
-// Sets up buffer utility according to the environment (called in index-minimal)
-util._configure = function() {
-    var Buffer = util.Buffer;
-    /* istanbul ignore if */
-    if (!Buffer) {
-        util._Buffer_from = util._Buffer_allocUnsafe = null;
-        return;
-    }
-    // because node 4.x buffers are incompatible & immutable
-    // see: https://github.com/dcodeIO/protobuf.js/pull/665
-    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
-        /* istanbul ignore next */
-        function Buffer_from(value, encoding) {
-            return new Buffer(value, encoding);
-        };
-    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
-        /* istanbul ignore next */
-        function Buffer_allocUnsafe(size) {
-            return new Buffer(size);
-        };
-};
-}(minimal$1));
-
 var writer = Writer$1;
 
-var util$4      = minimal$1;
+var util$4      = requireMinimal();
 
 var BufferWriter$1; // cyclic
 
@@ -3450,7 +3529,7 @@ var writer_buffer = BufferWriter;
 var Writer = writer;
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 
-var util$3 = minimal$1;
+var util$3 = requireMinimal();
 
 /**
  * Constructs a new buffer writer instance.
@@ -3531,7 +3610,7 @@ BufferWriter._configure();
 
 var reader = Reader$1;
 
-var util$2      = minimal$1;
+var util$2      = requireMinimal();
 
 var BufferReader$1; // cyclic
 
@@ -3951,7 +4030,7 @@ var reader_buffer = BufferReader;
 var Reader = reader;
 (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 
-var util$1 = minimal$1;
+var util$1 = requireMinimal();
 
 /**
  * Constructs a new buffer reader instance.
@@ -4000,7 +4079,7 @@ var rpc = {};
 
 var service = Service;
 
-var util = minimal$1;
+var util = requireMinimal();
 
 // Extends EventEmitter
 (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
@@ -4142,84 +4221,86 @@ Service.prototype.end = function end(endedByRPC) {
 
 (function (exports) {
 
-/**
- * Streaming RPC helpers.
- * @namespace
- */
-var rpc = exports;
-
-/**
- * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
- * @typedef RPCImpl
- * @type {function}
- * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
- * @param {Uint8Array} requestData Request data
- * @param {RPCImplCallback} callback Callback function
- * @returns {undefined}
- * @example
- * function rpcImpl(method, requestData, callback) {
- *     if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
- *         throw Error("no such method");
- *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {
- *         callback(err, responseData);
- *     });
- * }
- */
-
-/**
- * Node-style callback as used by {@link RPCImpl}.
- * @typedef RPCImplCallback
- * @type {function}
- * @param {Error|null} error Error, if any, otherwise `null`
- * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
- * @returns {undefined}
- */
-
-rpc.Service = service;
-}(rpc));
+	/**
+	 * Streaming RPC helpers.
+	 * @namespace
+	 */
+	var rpc = exports;
+
+	/**
+	 * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
+	 * @typedef RPCImpl
+	 * @type {function}
+	 * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
+	 * @param {Uint8Array} requestData Request data
+	 * @param {RPCImplCallback} callback Callback function
+	 * @returns {undefined}
+	 * @example
+	 * function rpcImpl(method, requestData, callback) {
+	 *     if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
+	 *         throw Error("no such method");
+	 *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {
+	 *         callback(err, responseData);
+	 *     });
+	 * }
+	 */
+
+	/**
+	 * Node-style callback as used by {@link RPCImpl}.
+	 * @typedef RPCImplCallback
+	 * @type {function}
+	 * @param {Error|null} error Error, if any, otherwise `null`
+	 * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
+	 * @returns {undefined}
+	 */
+
+	rpc.Service = service; 
+} (rpc));
 
 var roots = {};
 
 (function (exports) {
-var protobuf = exports;
-
-/**
- * Build type, one of `"full"`, `"light"` or `"minimal"`.
- * @name build
- * @type {string}
- * @const
- */
-protobuf.build = "minimal";
-
-// Serialization
-protobuf.Writer       = writer;
-protobuf.BufferWriter = writer_buffer;
-protobuf.Reader       = reader;
-protobuf.BufferReader = reader_buffer;
-
-// Utility
-protobuf.util         = minimal$1;
-protobuf.rpc          = rpc;
-protobuf.roots        = roots;
-protobuf.configure    = configure;
-
-/* istanbul ignore next */
-/**
- * Reconfigures the library according to the environment.
- * @returns {undefined}
- */
-function configure() {
-    protobuf.util._configure();
-    protobuf.Writer._configure(protobuf.BufferWriter);
-    protobuf.Reader._configure(protobuf.BufferReader);
-}
-
-// Set up buffer utility according to the environment
-configure();
-}(indexMinimal));
+	var protobuf = exports;
+
+	/**
+	 * Build type, one of `"full"`, `"light"` or `"minimal"`.
+	 * @name build
+	 * @type {string}
+	 * @const
+	 */
+	protobuf.build = "minimal";
+
+	// Serialization
+	protobuf.Writer       = writer;
+	protobuf.BufferWriter = writer_buffer;
+	protobuf.Reader       = reader;
+	protobuf.BufferReader = reader_buffer;
+
+	// Utility
+	protobuf.util         = requireMinimal();
+	protobuf.rpc          = rpc;
+	protobuf.roots        = roots;
+	protobuf.configure    = configure;
+
+	/* istanbul ignore next */
+	/**
+	 * Reconfigures the library according to the environment.
+	 * @returns {undefined}
+	 */
+	function configure() {
+	    protobuf.util._configure();
+	    protobuf.Writer._configure(protobuf.BufferWriter);
+	    protobuf.Reader._configure(protobuf.BufferReader);
+	}
+
+	// Set up buffer utility according to the environment
+	configure(); 
+} (indexMinimal));
 
 var minimal = indexMinimal;
 
+var _m0 = /*@__PURE__*/getDefaultExportFromCjs(minimal);
+
 /* eslint-disable */
 /**
  * `NullValue` is a singleton enumeration to represent the null value for the
@@ -4257,7 +4338,7 @@ function createBaseStruct() {
     return { fields: {} };
 }
 const Struct = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         Object.entries(message.fields).forEach(([key, value]) => {
             if (value !== undefined) {
                 Struct_FieldsEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
@@ -4266,7 +4347,7 @@ const Struct = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStruct();
         while (reader.pos < end) {
@@ -4313,12 +4394,12 @@ const Struct = {
         return obj;
     },
     create(base) {
-        return Struct.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Struct.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseStruct();
-        message.fields = Object.entries((_a = object.fields) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
+        message.fields = Object.entries((_a = object.fields) !== null && _a !== undefined ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
                 acc[key] = value;
             }
@@ -4349,7 +4430,7 @@ function createBaseStruct_FieldsEntry() {
     return { key: "", value: undefined };
 }
 const Struct_FieldsEntry = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.key !== "") {
             writer.uint32(10).string(message.key);
         }
@@ -4359,7 +4440,7 @@ const Struct_FieldsEntry = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStruct_FieldsEntry();
         while (reader.pos < end) {
@@ -4386,7 +4467,7 @@ const Struct_FieldsEntry = {
         return message;
     },
     fromJSON(object) {
-        return { key: isSet$2(object.key) ? String(object.key) : "", value: isSet$2(object === null || object === void 0 ? void 0 : object.value) ? object.value : undefined };
+        return { key: isSet$2(object.key) ? String(object.key) : "", value: isSet$2(object === null || object === undefined ? undefined : object.value) ? object.value : undefined };
     },
     toJSON(message) {
         const obj = {};
@@ -4399,13 +4480,13 @@ const Struct_FieldsEntry = {
         return obj;
     },
     create(base) {
-        return Struct_FieldsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Struct_FieldsEntry.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseStruct_FieldsEntry();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
-        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : undefined;
+        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
+        message.value = (_b = object.value) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -4420,7 +4501,7 @@ function createBaseValue() {
     };
 }
 const Value = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.nullValue !== undefined) {
             writer.uint32(8).int32(message.nullValue);
         }
@@ -4442,7 +4523,7 @@ const Value = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseValue();
         while (reader.pos < end) {
@@ -4525,17 +4606,17 @@ const Value = {
         return obj;
     },
     create(base) {
-        return Value.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Value.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d, _e, _f;
         const message = createBaseValue();
-        message.nullValue = (_a = object.nullValue) !== null && _a !== void 0 ? _a : undefined;
-        message.numberValue = (_b = object.numberValue) !== null && _b !== void 0 ? _b : undefined;
-        message.stringValue = (_c = object.stringValue) !== null && _c !== void 0 ? _c : undefined;
-        message.boolValue = (_d = object.boolValue) !== null && _d !== void 0 ? _d : undefined;
-        message.structValue = (_e = object.structValue) !== null && _e !== void 0 ? _e : undefined;
-        message.listValue = (_f = object.listValue) !== null && _f !== void 0 ? _f : undefined;
+        message.nullValue = (_a = object.nullValue) !== null && _a !== undefined ? _a : undefined;
+        message.numberValue = (_b = object.numberValue) !== null && _b !== undefined ? _b : undefined;
+        message.stringValue = (_c = object.stringValue) !== null && _c !== undefined ? _c : undefined;
+        message.boolValue = (_d = object.boolValue) !== null && _d !== undefined ? _d : undefined;
+        message.structValue = (_e = object.structValue) !== null && _e !== undefined ? _e : undefined;
+        message.listValue = (_f = object.listValue) !== null && _f !== undefined ? _f : undefined;
         return message;
     },
     wrap(value) {
@@ -4567,19 +4648,19 @@ const Value = {
         if (message.stringValue !== undefined) {
             return message.stringValue;
         }
-        else if ((message === null || message === void 0 ? void 0 : message.numberValue) !== undefined) {
+        else if ((message === null || message === undefined ? undefined : message.numberValue) !== undefined) {
             return message.numberValue;
         }
-        else if ((message === null || message === void 0 ? void 0 : message.boolValue) !== undefined) {
+        else if ((message === null || message === undefined ? undefined : message.boolValue) !== undefined) {
             return message.boolValue;
         }
-        else if ((message === null || message === void 0 ? void 0 : message.structValue) !== undefined) {
+        else if ((message === null || message === undefined ? undefined : message.structValue) !== undefined) {
             return message.structValue;
         }
-        else if ((message === null || message === void 0 ? void 0 : message.listValue) !== undefined) {
+        else if ((message === null || message === undefined ? undefined : message.listValue) !== undefined) {
             return message.listValue;
         }
-        else if ((message === null || message === void 0 ? void 0 : message.nullValue) !== undefined) {
+        else if ((message === null || message === undefined ? undefined : message.nullValue) !== undefined) {
             return null;
         }
         return undefined;
@@ -4589,14 +4670,14 @@ function createBaseListValue() {
     return { values: [] };
 }
 const ListValue = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         for (const v of message.values) {
             Value.encode(Value.wrap(v), writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseListValue();
         while (reader.pos < end) {
@@ -4617,32 +4698,32 @@ const ListValue = {
         return message;
     },
     fromJSON(object) {
-        return { values: Array.isArray(object === null || object === void 0 ? void 0 : object.values) ? [...object.values] : [] };
+        return { values: Array.isArray(object === null || object === undefined ? undefined : object.values) ? [...object.values] : [] };
     },
     toJSON(message) {
         var _a;
         const obj = {};
-        if ((_a = message.values) === null || _a === void 0 ? void 0 : _a.length) {
+        if ((_a = message.values) === null || _a === undefined ? undefined : _a.length) {
             obj.values = message.values;
         }
         return obj;
     },
     create(base) {
-        return ListValue.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ListValue.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseListValue();
-        message.values = ((_a = object.values) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
+        message.values = ((_a = object.values) === null || _a === undefined ? undefined : _a.map((e) => e)) || [];
         return message;
     },
     wrap(array) {
         const result = createBaseListValue();
-        result.values = array !== null && array !== void 0 ? array : [];
+        result.values = array !== null && array !== undefined ? array : [];
         return result;
     },
     unwrap(message) {
-        if ((message === null || message === void 0 ? void 0 : message.hasOwnProperty("values")) && Array.isArray(message.values)) {
+        if ((message === null || message === undefined ? undefined : message.hasOwnProperty("values")) && Array.isArray(message.values)) {
             return message.values;
         }
         else {
@@ -4662,14 +4743,14 @@ function createBaseResolveAllRequest() {
     return { context: undefined };
 }
 const ResolveAllRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.context !== undefined) {
             Struct.encode(Struct.wrap(message.context), writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveAllRequest();
         while (reader.pos < end) {
@@ -4700,12 +4781,12 @@ const ResolveAllRequest = {
         return obj;
     },
     create(base) {
-        return ResolveAllRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveAllRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseResolveAllRequest();
-        message.context = (_a = object.context) !== null && _a !== void 0 ? _a : undefined;
+        message.context = (_a = object.context) !== null && _a !== undefined ? _a : undefined;
         return message;
     },
 };
@@ -4713,14 +4794,14 @@ function createBaseResolveAllResponse() {
     return { flags: {} };
 }
 const ResolveAllResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         Object.entries(message.flags).forEach(([key, value]) => {
             ResolveAllResponse_FlagsEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
         });
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveAllResponse();
         while (reader.pos < end) {
@@ -4767,12 +4848,12 @@ const ResolveAllResponse = {
         return obj;
     },
     create(base) {
-        return ResolveAllResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveAllResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseResolveAllResponse();
-        message.flags = Object.entries((_a = object.flags) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
+        message.flags = Object.entries((_a = object.flags) !== null && _a !== undefined ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
                 acc[key] = AnyFlag.fromPartial(value);
             }
@@ -4785,7 +4866,7 @@ function createBaseResolveAllResponse_FlagsEntry() {
     return { key: "", value: undefined };
 }
 const ResolveAllResponse_FlagsEntry = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.key !== "") {
             writer.uint32(10).string(message.key);
         }
@@ -4795,7 +4876,7 @@ const ResolveAllResponse_FlagsEntry = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveAllResponse_FlagsEntry();
         while (reader.pos < end) {
@@ -4838,12 +4919,12 @@ const ResolveAllResponse_FlagsEntry = {
         return obj;
     },
     create(base) {
-        return ResolveAllResponse_FlagsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveAllResponse_FlagsEntry.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseResolveAllResponse_FlagsEntry();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
         message.value = (object.value !== undefined && object.value !== null)
             ? AnyFlag.fromPartial(object.value)
             : undefined;
@@ -4858,10 +4939,11 @@ function createBaseAnyFlag() {
         stringValue: undefined,
         doubleValue: undefined,
         objectValue: undefined,
+        metadata: undefined,
     };
 }
 const AnyFlag = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.reason !== "") {
             writer.uint32(10).string(message.reason);
         }
@@ -4880,10 +4962,13 @@ const AnyFlag = {
         if (message.objectValue !== undefined) {
             Struct.encode(Struct.wrap(message.objectValue), writer.uint32(50).fork()).ldelim();
         }
+        if (message.metadata !== undefined) {
+            Struct.encode(Struct.wrap(message.metadata), writer.uint32(58).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseAnyFlag();
         while (reader.pos < end) {
@@ -4925,6 +5010,12 @@ const AnyFlag = {
                     }
                     message.objectValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
                     continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -4941,6 +5032,7 @@ const AnyFlag = {
             stringValue: isSet$1(object.stringValue) ? String(object.stringValue) : undefined,
             doubleValue: isSet$1(object.doubleValue) ? Number(object.doubleValue) : undefined,
             objectValue: isObject$1(object.objectValue) ? object.objectValue : undefined,
+            metadata: isObject$1(object.metadata) ? object.metadata : undefined,
         };
     },
     toJSON(message) {
@@ -4963,20 +5055,24 @@ const AnyFlag = {
         if (message.objectValue !== undefined) {
             obj.objectValue = message.objectValue;
         }
+        if (message.metadata !== undefined) {
+            obj.metadata = message.metadata;
+        }
         return obj;
     },
     create(base) {
-        return AnyFlag.fromPartial(base !== null && base !== void 0 ? base : {});
+        return AnyFlag.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         const message = createBaseAnyFlag();
-        message.reason = (_a = object.reason) !== null && _a !== void 0 ? _a : "";
-        message.variant = (_b = object.variant) !== null && _b !== void 0 ? _b : "";
-        message.boolValue = (_c = object.boolValue) !== null && _c !== void 0 ? _c : undefined;
-        message.stringValue = (_d = object.stringValue) !== null && _d !== void 0 ? _d : undefined;
-        message.doubleValue = (_e = object.doubleValue) !== null && _e !== void 0 ? _e : undefined;
-        message.objectValue = (_f = object.objectValue) !== null && _f !== void 0 ? _f : undefined;
+        message.reason = (_a = object.reason) !== null && _a !== undefined ? _a : "";
+        message.variant = (_b = object.variant) !== null && _b !== undefined ? _b : "";
+        message.boolValue = (_c = object.boolValue) !== null && _c !== undefined ? _c : undefined;
+        message.stringValue = (_d = object.stringValue) !== null && _d !== undefined ? _d : undefined;
+        message.doubleValue = (_e = object.doubleValue) !== null && _e !== undefined ? _e : undefined;
+        message.objectValue = (_f = object.objectValue) !== null && _f !== undefined ? _f : undefined;
+        message.metadata = (_g = object.metadata) !== null && _g !== undefined ? _g : undefined;
         return message;
     },
 };
@@ -4984,7 +5080,7 @@ function createBaseResolveBooleanRequest() {
     return { flagKey: "", context: undefined };
 }
 const ResolveBooleanRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagKey !== "") {
             writer.uint32(10).string(message.flagKey);
         }
@@ -4994,7 +5090,7 @@ const ResolveBooleanRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveBooleanRequest();
         while (reader.pos < end) {
@@ -5037,13 +5133,13 @@ const ResolveBooleanRequest = {
         return obj;
     },
     create(base) {
-        return ResolveBooleanRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveBooleanRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseResolveBooleanRequest();
-        message.flagKey = (_a = object.flagKey) !== null && _a !== void 0 ? _a : "";
-        message.context = (_b = object.context) !== null && _b !== void 0 ? _b : undefined;
+        message.flagKey = (_a = object.flagKey) !== null && _a !== undefined ? _a : "";
+        message.context = (_b = object.context) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5051,7 +5147,7 @@ function createBaseResolveBooleanResponse() {
     return { value: false, reason: "", variant: "", metadata: undefined };
 }
 const ResolveBooleanResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.value === true) {
             writer.uint32(8).bool(message.value);
         }
@@ -5067,7 +5163,7 @@ const ResolveBooleanResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveBooleanResponse();
         while (reader.pos < end) {
@@ -5130,15 +5226,15 @@ const ResolveBooleanResponse = {
         return obj;
     },
     create(base) {
-        return ResolveBooleanResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveBooleanResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseResolveBooleanResponse();
-        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : false;
-        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : "";
-        message.variant = (_c = object.variant) !== null && _c !== void 0 ? _c : "";
-        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : undefined;
+        message.value = (_a = object.value) !== null && _a !== undefined ? _a : false;
+        message.reason = (_b = object.reason) !== null && _b !== undefined ? _b : "";
+        message.variant = (_c = object.variant) !== null && _c !== undefined ? _c : "";
+        message.metadata = (_d = object.metadata) !== null && _d !== undefined ? _d : undefined;
         return message;
     },
 };
@@ -5146,7 +5242,7 @@ function createBaseResolveStringRequest() {
     return { flagKey: "", context: undefined };
 }
 const ResolveStringRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagKey !== "") {
             writer.uint32(10).string(message.flagKey);
         }
@@ -5156,7 +5252,7 @@ const ResolveStringRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveStringRequest();
         while (reader.pos < end) {
@@ -5199,13 +5295,13 @@ const ResolveStringRequest = {
         return obj;
     },
     create(base) {
-        return ResolveStringRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveStringRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseResolveStringRequest();
-        message.flagKey = (_a = object.flagKey) !== null && _a !== void 0 ? _a : "";
-        message.context = (_b = object.context) !== null && _b !== void 0 ? _b : undefined;
+        message.flagKey = (_a = object.flagKey) !== null && _a !== undefined ? _a : "";
+        message.context = (_b = object.context) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5213,7 +5309,7 @@ function createBaseResolveStringResponse() {
     return { value: "", reason: "", variant: "", metadata: undefined };
 }
 const ResolveStringResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.value !== "") {
             writer.uint32(10).string(message.value);
         }
@@ -5229,7 +5325,7 @@ const ResolveStringResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveStringResponse();
         while (reader.pos < end) {
@@ -5292,15 +5388,15 @@ const ResolveStringResponse = {
         return obj;
     },
     create(base) {
-        return ResolveStringResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveStringResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseResolveStringResponse();
-        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : "";
-        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : "";
-        message.variant = (_c = object.variant) !== null && _c !== void 0 ? _c : "";
-        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : undefined;
+        message.value = (_a = object.value) !== null && _a !== undefined ? _a : "";
+        message.reason = (_b = object.reason) !== null && _b !== undefined ? _b : "";
+        message.variant = (_c = object.variant) !== null && _c !== undefined ? _c : "";
+        message.metadata = (_d = object.metadata) !== null && _d !== undefined ? _d : undefined;
         return message;
     },
 };
@@ -5308,7 +5404,7 @@ function createBaseResolveFloatRequest() {
     return { flagKey: "", context: undefined };
 }
 const ResolveFloatRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagKey !== "") {
             writer.uint32(10).string(message.flagKey);
         }
@@ -5318,7 +5414,7 @@ const ResolveFloatRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveFloatRequest();
         while (reader.pos < end) {
@@ -5361,13 +5457,13 @@ const ResolveFloatRequest = {
         return obj;
     },
     create(base) {
-        return ResolveFloatRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveFloatRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseResolveFloatRequest();
-        message.flagKey = (_a = object.flagKey) !== null && _a !== void 0 ? _a : "";
-        message.context = (_b = object.context) !== null && _b !== void 0 ? _b : undefined;
+        message.flagKey = (_a = object.flagKey) !== null && _a !== undefined ? _a : "";
+        message.context = (_b = object.context) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5375,7 +5471,7 @@ function createBaseResolveFloatResponse() {
     return { value: 0, reason: "", variant: "", metadata: undefined };
 }
 const ResolveFloatResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.value !== 0) {
             writer.uint32(9).double(message.value);
         }
@@ -5391,7 +5487,7 @@ const ResolveFloatResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveFloatResponse();
         while (reader.pos < end) {
@@ -5454,15 +5550,15 @@ const ResolveFloatResponse = {
         return obj;
     },
     create(base) {
-        return ResolveFloatResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveFloatResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseResolveFloatResponse();
-        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : 0;
-        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : "";
-        message.variant = (_c = object.variant) !== null && _c !== void 0 ? _c : "";
-        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : undefined;
+        message.value = (_a = object.value) !== null && _a !== undefined ? _a : 0;
+        message.reason = (_b = object.reason) !== null && _b !== undefined ? _b : "";
+        message.variant = (_c = object.variant) !== null && _c !== undefined ? _c : "";
+        message.metadata = (_d = object.metadata) !== null && _d !== undefined ? _d : undefined;
         return message;
     },
 };
@@ -5470,7 +5566,7 @@ function createBaseResolveIntRequest() {
     return { flagKey: "", context: undefined };
 }
 const ResolveIntRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagKey !== "") {
             writer.uint32(10).string(message.flagKey);
         }
@@ -5480,7 +5576,7 @@ const ResolveIntRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveIntRequest();
         while (reader.pos < end) {
@@ -5523,13 +5619,13 @@ const ResolveIntRequest = {
         return obj;
     },
     create(base) {
-        return ResolveIntRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveIntRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseResolveIntRequest();
-        message.flagKey = (_a = object.flagKey) !== null && _a !== void 0 ? _a : "";
-        message.context = (_b = object.context) !== null && _b !== void 0 ? _b : undefined;
+        message.flagKey = (_a = object.flagKey) !== null && _a !== undefined ? _a : "";
+        message.context = (_b = object.context) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5537,7 +5633,7 @@ function createBaseResolveIntResponse() {
     return { value: "0", reason: "", variant: "", metadata: undefined };
 }
 const ResolveIntResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.value !== "0") {
             writer.uint32(8).int64(message.value);
         }
@@ -5553,7 +5649,7 @@ const ResolveIntResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveIntResponse();
         while (reader.pos < end) {
@@ -5616,15 +5712,15 @@ const ResolveIntResponse = {
         return obj;
     },
     create(base) {
-        return ResolveIntResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveIntResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseResolveIntResponse();
-        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : "0";
-        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : "";
-        message.variant = (_c = object.variant) !== null && _c !== void 0 ? _c : "";
-        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : undefined;
+        message.value = (_a = object.value) !== null && _a !== undefined ? _a : "0";
+        message.reason = (_b = object.reason) !== null && _b !== undefined ? _b : "";
+        message.variant = (_c = object.variant) !== null && _c !== undefined ? _c : "";
+        message.metadata = (_d = object.metadata) !== null && _d !== undefined ? _d : undefined;
         return message;
     },
 };
@@ -5632,7 +5728,7 @@ function createBaseResolveObjectRequest() {
     return { flagKey: "", context: undefined };
 }
 const ResolveObjectRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagKey !== "") {
             writer.uint32(10).string(message.flagKey);
         }
@@ -5642,7 +5738,7 @@ const ResolveObjectRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveObjectRequest();
         while (reader.pos < end) {
@@ -5685,13 +5781,13 @@ const ResolveObjectRequest = {
         return obj;
     },
     create(base) {
-        return ResolveObjectRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveObjectRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseResolveObjectRequest();
-        message.flagKey = (_a = object.flagKey) !== null && _a !== void 0 ? _a : "";
-        message.context = (_b = object.context) !== null && _b !== void 0 ? _b : undefined;
+        message.flagKey = (_a = object.flagKey) !== null && _a !== undefined ? _a : "";
+        message.context = (_b = object.context) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5699,7 +5795,7 @@ function createBaseResolveObjectResponse() {
     return { value: undefined, reason: "", variant: "", metadata: undefined };
 }
 const ResolveObjectResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.value !== undefined) {
             Struct.encode(Struct.wrap(message.value), writer.uint32(10).fork()).ldelim();
         }
@@ -5715,7 +5811,7 @@ const ResolveObjectResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseResolveObjectResponse();
         while (reader.pos < end) {
@@ -5778,15 +5874,15 @@ const ResolveObjectResponse = {
         return obj;
     },
     create(base) {
-        return ResolveObjectResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ResolveObjectResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseResolveObjectResponse();
-        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : undefined;
-        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : "";
-        message.variant = (_c = object.variant) !== null && _c !== void 0 ? _c : "";
-        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : undefined;
+        message.value = (_a = object.value) !== null && _a !== undefined ? _a : undefined;
+        message.reason = (_b = object.reason) !== null && _b !== undefined ? _b : "";
+        message.variant = (_c = object.variant) !== null && _c !== undefined ? _c : "";
+        message.metadata = (_d = object.metadata) !== null && _d !== undefined ? _d : undefined;
         return message;
     },
 };
@@ -5794,7 +5890,7 @@ function createBaseEventStreamResponse() {
     return { type: "", data: undefined };
 }
 const EventStreamResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.type !== "") {
             writer.uint32(10).string(message.type);
         }
@@ -5804,7 +5900,7 @@ const EventStreamResponse = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseEventStreamResponse();
         while (reader.pos < end) {
@@ -5847,13 +5943,13 @@ const EventStreamResponse = {
         return obj;
     },
     create(base) {
-        return EventStreamResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return EventStreamResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseEventStreamResponse();
-        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
-        message.data = (_b = object.data) !== null && _b !== void 0 ? _b : undefined;
+        message.type = (_a = object.type) !== null && _a !== undefined ? _a : "";
+        message.data = (_b = object.data) !== null && _b !== undefined ? _b : undefined;
         return message;
     },
 };
@@ -5861,11 +5957,11 @@ function createBaseEventStreamRequest() {
     return {};
 }
 const EventStreamRequest = {
-    encode(_, writer = minimal.Writer.create()) {
+    encode(_, writer = _m0.Writer.create()) {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseEventStreamRequest();
         while (reader.pos < end) {
@@ -5885,7 +5981,7 @@ const EventStreamRequest = {
         return obj;
     },
     create(base) {
-        return EventStreamRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return EventStreamRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(_) {
         const message = createBaseEventStreamRequest();
@@ -5961,9 +6057,9 @@ const ServiceClient = makeGenericClientConstructor(ServiceService, "flagd.evalua
 function longToString(long) {
     return long.toString();
 }
-if (minimal.util.Long !== Long) {
-    minimal.util.Long = Long;
-    minimal.configure();
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
 }
 function isObject$1(value) {
     return typeof value === "object" && value !== null;
@@ -5998,7 +6094,7 @@ class GRPCService {
         this._eventStream = undefined;
         this.onRejected = (err) => {
             // map the errors
-            switch (err === null || err === void 0 ? void 0 : err.code) {
+            switch (err === null || err === undefined ? undefined : err.code) {
                 case status.DATA_LOSS:
                     throw new ParseError(err.details);
                 case status.INVALID_ARGUMENT:
@@ -6008,7 +6104,7 @@ class GRPCService {
                 case status.UNAVAILABLE:
                     throw new FlagNotFoundError(err.details);
                 default:
-                    throw new GeneralError(err === null || err === void 0 ? void 0 : err.details);
+                    throw new GeneralError(err === null || err === undefined ? undefined : err.details);
             }
         };
         const { host, port, tls, socketPath } = config;
@@ -6024,45 +6120,45 @@ class GRPCService {
         return new Promise((resolve, reject) => this.listen(reconnectCallback, changedCallback, disconnectCallback, resolve, reject));
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             closeStreamIfDefined(this._eventStream);
             this._client.close();
         });
     }
     resolveBoolean(flagKey, _, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.resolve(this._client.resolveBoolean, flagKey, context, logger);
         });
     }
     resolveString(flagKey, _, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.resolve(this._client.resolveString, flagKey, context, logger);
         });
     }
     resolveNumber(flagKey, _, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.resolve(this._client.resolveFloat, flagKey, context, logger);
         });
     }
     resolveObject(flagKey, _, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.resolve(this._client.resolveObject, flagKey, context, logger);
         });
     }
     listen(reconnectCallback, changedCallback, disconnectCallback, resolveConnect, rejectConnect) {
         var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: connecting stream...`);
+        (_a = this.logger) === null || _a === undefined ? undefined : _a.debug(`${FlagdProvider.name}: connecting stream...`);
         // close the previous stream if we're reconnecting
         closeStreamIfDefined(this._eventStream);
         const stream = this._client.eventStream({}, {});
         stream.on('error', (err) => {
-            rejectConnect === null || rejectConnect === void 0 ? void 0 : rejectConnect(err);
+            rejectConnect === null || rejectConnect === undefined ? undefined : rejectConnect(err);
             this.handleError(reconnectCallback, changedCallback, disconnectCallback);
         });
         stream.on('data', (message) => {
             var _a;
             if (message.type === EVENT_PROVIDER_READY) {
-                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: streaming connection established with flagd`);
+                (_a = this.logger) === null || _a === undefined ? undefined : _a.debug(`${FlagdProvider.name}: streaming connection established with flagd`);
                 // if resolveConnect is undefined, this is a reconnection; we only want to fire the reconnect callback in that case
                 if (resolveConnect) {
                     resolveConnect();
@@ -6081,16 +6177,16 @@ class GRPCService {
         var _a;
         if (message.data) {
             const data = message.data;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${FlagdProvider.name}: got message: ${JSON.stringify(data, undefined, 2)}`);
-            if (data && typeof data === 'object' && 'flags' in data && (data === null || data === void 0 ? void 0 : data['flags'])) {
+            (_a = this.logger) === null || _a === undefined ? undefined : _a.debug(`${FlagdProvider.name}: got message: ${JSON.stringify(data, undefined, 2)}`);
+            if (data && typeof data === 'object' && 'flags' in data && (data === null || data === undefined ? undefined : data['flags'])) {
                 const flagChangeMessage = data;
                 const flagsChanged = Object.keys(flagChangeMessage.flags || []);
                 if (this._cacheEnabled) {
                     // remove each changed key from cache
                     flagsChanged.forEach((key) => {
                         var _a, _b;
-                        if ((_a = this._cache) === null || _a === void 0 ? void 0 : _a.delete(key)) {
-                            (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`${FlagdProvider.name}: evicted key: ${key} from cache.`);
+                        if ((_a = this._cache) === null || _a === undefined ? undefined : _a.delete(key)) {
+                            (_b = this.logger) === null || _b === undefined ? undefined : _b.debug(`${FlagdProvider.name}: evicted key: ${key} from cache.`);
                         }
                     });
                 }
@@ -6107,16 +6203,16 @@ class GRPCService {
     handleError(reconnectCallback, changedCallback, disconnectCallback) {
         var _a, _b;
         disconnectCallback('streaming connection error, will attempt reconnect...');
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`${FlagdProvider.name}: streaming connection error, will attempt reconnect...`);
-        (_b = this._cache) === null || _b === void 0 ? void 0 : _b.clear();
+        (_a = this.logger) === null || _a === undefined ? undefined : _a.error(`${FlagdProvider.name}: streaming connection error, will attempt reconnect...`);
+        (_b = this._cache) === null || _b === undefined ? undefined : _b.clear();
         this.reconnect(reconnectCallback, changedCallback, disconnectCallback);
     }
     resolve(promise, flagKey, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             var _a, _b;
             const resolver = promisify(promise);
             if (this._cacheActive) {
-                const cached = (_a = this._cache) === null || _a === void 0 ? void 0 : _a.get(flagKey);
+                const cached = (_a = this._cache) === null || _a === undefined ? undefined : _a.get(flagKey);
                 if (cached) {
                     return Object.assign(Object.assign({}, cached), { reason: StandardResolutionReasons.CACHED });
                 }
@@ -6134,19 +6230,73 @@ class GRPCService {
             logger.debug(`${FlagdProvider.name}: resolved flag with key: ${resolved.value}, variant: ${response.variant}, reason: ${response.reason}`);
             if (this._cacheActive && response.reason === StandardResolutionReasons.STATIC) {
                 // cache this static value
-                (_b = this._cache) === null || _b === void 0 ? void 0 : _b.set(flagKey, resolved);
+                (_b = this._cache) === null || _b === undefined ? undefined : _b.set(flagKey, resolved);
             }
             return resolved;
         });
     }
 }
 
+const encoding = 'utf8';
+class FileFetch {
+    constructor(filename, logger) {
+        this._filename = filename;
+        this._logger = logger;
+    }
+    connect(dataFillCallback, _, changedCallback) {
+        return __awaiter(this, undefined, undefined, function* () {
+            var _a, _b;
+            (_a = this._logger) === null || _a === undefined ? undefined : _a.debug('Starting file sync connection');
+            try {
+                const output = yield promises.readFile(this._filename, encoding);
+                // Don't emit the change event for the initial read
+                dataFillCallback(output);
+                // Using watchFile instead of watch to support virtualized host file systems.
+                watchFile(this._filename, () => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    try {
+                        const data = yield promises.readFile(this._filename, encoding);
+                        const changes = dataFillCallback(data);
+                        if (changes.length > 0) {
+                            changedCallback(changes);
+                        }
+                    }
+                    catch (err) {
+                        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.error(`Error reading file: ${err}`);
+                    }
+                }));
+            }
+            catch (err) {
+                if (err instanceof OpenFeatureError) {
+                    throw err;
+                }
+                else {
+                    switch (err === null || err === undefined ? undefined : err.code) {
+                        case 'ENOENT':
+                            throw new GeneralError(`File not found: ${this._filename}`);
+                        case 'EACCES':
+                            throw new GeneralError(`File not accessible: ${this._filename}`);
+                        default:
+                            (_b = this._logger) === null || _b === undefined ? undefined : _b.debug(`Error reading file: ${err}`);
+                            throw new GeneralError();
+                    }
+                }
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, undefined, undefined, function* () {
+            unwatchFile(this._filename);
+        });
+    }
+}
+
 /* eslint-disable */
 function createBaseSyncFlagsRequest() {
     return { providerId: "", selector: "" };
 }
 const SyncFlagsRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.providerId !== "") {
             writer.uint32(10).string(message.providerId);
         }
@@ -6156,7 +6306,7 @@ const SyncFlagsRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseSyncFlagsRequest();
         while (reader.pos < end) {
@@ -6199,13 +6349,13 @@ const SyncFlagsRequest = {
         return obj;
     },
     create(base) {
-        return SyncFlagsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return SyncFlagsRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseSyncFlagsRequest();
-        message.providerId = (_a = object.providerId) !== null && _a !== void 0 ? _a : "";
-        message.selector = (_b = object.selector) !== null && _b !== void 0 ? _b : "";
+        message.providerId = (_a = object.providerId) !== null && _a !== undefined ? _a : "";
+        message.selector = (_b = object.selector) !== null && _b !== undefined ? _b : "";
         return message;
     },
 };
@@ -6213,14 +6363,14 @@ function createBaseSyncFlagsResponse() {
     return { flagConfiguration: "" };
 }
 const SyncFlagsResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagConfiguration !== "") {
             writer.uint32(10).string(message.flagConfiguration);
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseSyncFlagsResponse();
         while (reader.pos < end) {
@@ -6251,12 +6401,12 @@ const SyncFlagsResponse = {
         return obj;
     },
     create(base) {
-        return SyncFlagsResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return SyncFlagsResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseSyncFlagsResponse();
-        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== void 0 ? _a : "";
+        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== undefined ? _a : "";
         return message;
     },
 };
@@ -6264,7 +6414,7 @@ function createBaseFetchAllFlagsRequest() {
     return { providerId: "", selector: "" };
 }
 const FetchAllFlagsRequest = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.providerId !== "") {
             writer.uint32(10).string(message.providerId);
         }
@@ -6274,7 +6424,7 @@ const FetchAllFlagsRequest = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseFetchAllFlagsRequest();
         while (reader.pos < end) {
@@ -6317,13 +6467,13 @@ const FetchAllFlagsRequest = {
         return obj;
     },
     create(base) {
-        return FetchAllFlagsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return FetchAllFlagsRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseFetchAllFlagsRequest();
-        message.providerId = (_a = object.providerId) !== null && _a !== void 0 ? _a : "";
-        message.selector = (_b = object.selector) !== null && _b !== void 0 ? _b : "";
+        message.providerId = (_a = object.providerId) !== null && _a !== undefined ? _a : "";
+        message.selector = (_b = object.selector) !== null && _b !== undefined ? _b : "";
         return message;
     },
 };
@@ -6331,14 +6481,14 @@ function createBaseFetchAllFlagsResponse() {
     return { flagConfiguration: "" };
 }
 const FetchAllFlagsResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.flagConfiguration !== "") {
             writer.uint32(10).string(message.flagConfiguration);
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseFetchAllFlagsResponse();
         while (reader.pos < end) {
@@ -6369,12 +6519,12 @@ const FetchAllFlagsResponse = {
         return obj;
     },
     create(base) {
-        return FetchAllFlagsResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return FetchAllFlagsResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseFetchAllFlagsResponse();
-        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== void 0 ? _a : "";
+        message.flagConfiguration = (_a = object.flagConfiguration) !== null && _a !== undefined ? _a : "";
         return message;
     },
 };
@@ -6382,11 +6532,11 @@ function createBaseGetMetadataRequest() {
     return {};
 }
 const GetMetadataRequest = {
-    encode(_, writer = minimal.Writer.create()) {
+    encode(_, writer = _m0.Writer.create()) {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseGetMetadataRequest();
         while (reader.pos < end) {
@@ -6406,7 +6556,7 @@ const GetMetadataRequest = {
         return obj;
     },
     create(base) {
-        return GetMetadataRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+        return GetMetadataRequest.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(_) {
         const message = createBaseGetMetadataRequest();
@@ -6417,14 +6567,14 @@ function createBaseGetMetadataResponse() {
     return { metadata: undefined };
 }
 const GetMetadataResponse = {
-    encode(message, writer = minimal.Writer.create()) {
+    encode(message, writer = _m0.Writer.create()) {
         if (message.metadata !== undefined) {
             Struct.encode(Struct.wrap(message.metadata), writer.uint32(18).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof minimal.Reader ? input : minimal.Reader.create(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseGetMetadataResponse();
         while (reader.pos < end) {
@@ -6455,12 +6605,12 @@ const GetMetadataResponse = {
         return obj;
     },
     create(base) {
-        return GetMetadataResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+        return GetMetadataResponse.fromPartial(base !== null && base !== undefined ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseGetMetadataResponse();
-        message.metadata = (_a = object.metadata) !== null && _a !== void 0 ? _a : undefined;
+        message.metadata = (_a = object.metadata) !== null && _a !== undefined ? _a : undefined;
         return message;
     },
 };
@@ -6526,21 +6676,22 @@ class GrpcFetch {
         this._request = { providerId: '', selector: selector ? selector : '' };
     }
     connect(dataCallback, reconnectCallback, changedCallback, disconnectCallback) {
-        return new Promise((resolve, reject) => this.listen(dataCallback, reconnectCallback, changedCallback, disconnectCallback, resolve, reject)).then(() => {
+        return __awaiter(this, undefined, undefined, function* () {
+            yield new Promise((resolve, reject) => this.listen(dataCallback, reconnectCallback, changedCallback, disconnectCallback, resolve, reject));
             this._initialized = true;
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             var _a;
-            (_a = this._logger) === null || _a === void 0 ? void 0 : _a.debug('Disconnecting gRPC sync connection');
+            (_a = this._logger) === null || _a === undefined ? undefined : _a.debug('Disconnecting gRPC sync connection');
             closeStreamIfDefined(this._syncStream);
             this._syncClient.close();
         });
     }
     listen(dataCallback, reconnectCallback, changedCallback, disconnectCallback, resolveConnect, rejectConnect) {
         var _a;
-        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.debug('Starting gRPC sync connection');
+        (_a = this._logger) === null || _a === undefined ? undefined : _a.debug('Starting gRPC sync connection');
         closeStreamIfDefined(this._syncStream);
         try {
             this._syncStream = this._syncClient.syncFlags(this._request);
@@ -6576,12 +6727,12 @@ class GrpcFetch {
     }
     handleError(err, dataCallback, reconnectCallback, changedCallback, disconnectCallback, rejectConnect) {
         var _a, _b, _c;
-        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.error('Connection error, attempting to reconnect');
-        (_b = this._logger) === null || _b === void 0 ? void 0 : _b.debug(err);
+        (_a = this._logger) === null || _a === undefined ? undefined : _a.error('Connection error, attempting to reconnect');
+        (_b = this._logger) === null || _b === undefined ? undefined : _b.debug(err);
         this._isConnected = false;
-        const errorMessage = (_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : 'Failed to connect to syncFlags stream';
+        const errorMessage = (_c = err === null || err === undefined ? undefined : err.message) !== null && _c !== undefined ? _c : 'Failed to connect to syncFlags stream';
         disconnectCallback(errorMessage);
-        rejectConnect === null || rejectConnect === void 0 ? void 0 : rejectConnect(new GeneralError(errorMessage));
+        rejectConnect === null || rejectConnect === undefined ? undefined : rejectConnect(new GeneralError(errorMessage));
         this.reconnect(dataCallback, reconnectCallback, changedCallback, disconnectCallback);
     }
     reconnect(dataCallback, reconnectCallback, changedCallback, disconnectCallback) {
@@ -6592,60 +6743,6 @@ class GrpcFetch {
     }
 }
 
-const encoding = 'utf8';
-class FileFetch {
-    constructor(filename, logger) {
-        this._filename = filename;
-        this._logger = logger;
-    }
-    connect(dataFillCallback, _, changedCallback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            (_a = this._logger) === null || _a === void 0 ? void 0 : _a.debug('Starting file sync connection');
-            try {
-                const output = yield promises.readFile(this._filename, encoding);
-                // Don't emit the change event for the initial read
-                dataFillCallback(output);
-                // Using watchFile instead of watch to support virtualized host file systems.
-                watchFile(this._filename, () => __awaiter(this, void 0, void 0, function* () {
-                    var _c;
-                    try {
-                        const data = yield promises.readFile(this._filename, encoding);
-                        const changes = dataFillCallback(data);
-                        if (changes.length > 0) {
-                            changedCallback(changes);
-                        }
-                    }
-                    catch (err) {
-                        (_c = this._logger) === null || _c === void 0 ? void 0 : _c.error(`Error reading file: ${err}`);
-                    }
-                }));
-            }
-            catch (err) {
-                if (err instanceof OpenFeatureError) {
-                    throw err;
-                }
-                else {
-                    switch (err === null || err === void 0 ? void 0 : err.code) {
-                        case 'ENOENT':
-                            throw new GeneralError$1(`File not found: ${this._filename}`);
-                        case 'EACCES':
-                            throw new GeneralError$1(`File not accessible: ${this._filename}`);
-                        default:
-                            (_b = this._logger) === null || _b === void 0 ? void 0 : _b.debug(`Error reading file: ${err}`);
-                            throw new GeneralError$1();
-                    }
-                }
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            unwatchFile(this._filename);
-        });
-    }
-}
-
 class InProcessService {
     constructor(config, dataFetcher, logger) {
         this.config = config;
@@ -6660,39 +6757,37 @@ class InProcessService {
         return this._dataFetcher.connect(this.setFlagConfiguration.bind(this), reconnectCallback, changedCallback, disconnectCallback);
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             this._dataFetcher.disconnect();
         });
     }
     resolveBoolean(flagKey, defaultValue, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.evaluate('boolean', flagKey, defaultValue, context, logger);
         });
     }
     resolveNumber(flagKey, defaultValue, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.evaluate('number', flagKey, defaultValue, context, logger);
         });
     }
     resolveString(flagKey, defaultValue, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.evaluate('string', flagKey, defaultValue, context, logger);
         });
     }
     resolveObject(flagKey, defaultValue, context, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             return this.evaluate('object', flagKey, defaultValue, context, logger);
         });
     }
     evaluate(type, flagKey, defaultValue, context, logger) {
-        const details = this._flagdCore.resolve(type, flagKey, defaultValue, context, logger);
-        return Object.assign(Object.assign({}, details), { flagMetadata: this.addFlagMetadata() });
-    }
-    /**
-     * Adds the flag metadata to the resolution details
-     */
-    addFlagMetadata() {
-        return Object.assign({}, (this.config.selector ? { scope: this.config.selector } : {}));
+        const resolution = this._flagdCore.resolve(type, flagKey, defaultValue, context, logger);
+        // Add selector as scope if not already present in flag metadata
+        if (this.config.selector && !resolution.flagMetadata['scope']) {
+            return Object.assign(Object.assign({}, resolution), { flagMetadata: Object.assign(Object.assign({}, resolution.flagMetadata), { scope: this.config.selector }) });
+        }
+        return resolution;
     }
     /**
      * Sets the flag configuration
@@ -6706,12 +6801,6 @@ class InProcessService {
 }
 
 class FlagdProvider {
-    get status() {
-        return this._status;
-    }
-    get events() {
-        return this._events;
-    }
     /**
      * Construct a new flagd provider.
      *
@@ -6722,16 +6811,10 @@ class FlagdProvider {
     constructor(options, logger, service) {
         this.logger = logger;
         this.metadata = {
-            name: 'flagd Provider',
+            name: 'flagd',
         };
         this.runsOn = 'server';
-        this._status = ProviderStatus.NOT_READY;
-        this._events = new OpenFeatureEventEmitter();
-        this.logRejected = (err, flagKey, logger) => {
-            logger.error(`Error resolving flag ${flagKey}: ${err === null || err === void 0 ? void 0 : err.message}`);
-            logger.error(err === null || err === void 0 ? void 0 : err.stack);
-            throw err;
-        };
+        this.events = new OpenFeatureEventEmitter();
         const config = getConfig(options);
         this._service = service
             ? service
@@ -6740,56 +6823,44 @@ class FlagdProvider {
                 : new GRPCService(config, undefined, logger);
     }
     initialize() {
-        return this._service
-            .connect(this.handleReconnect.bind(this), this.handleChanged.bind(this), this.handleError.bind(this))
-            .then(() => {
-            var _a;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${this.metadata.name}: ready`);
-            this._status = ProviderStatus.READY;
-        })
-            .catch((err) => {
-            var _a, _b;
-            this._status = ProviderStatus.ERROR;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`${this.metadata.name}: error during initialization: ${err.message}`);
-            (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(err);
-            throw err;
+        return __awaiter(this, undefined, undefined, function* () {
+            var _a, _b, _c;
+            try {
+                yield this._service.connect(this.handleReconnect.bind(this), this.handleChanged.bind(this), this.handleError.bind(this));
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${this.metadata.name}: ready`);
+            }
+            catch (err) {
+                (_b = this.logger) === null || _b === undefined ? undefined : _b.error(`${this.metadata.name}: error during initialization: ${err === null || err === undefined ? undefined : err.message}`);
+                (_c = this.logger) === null || _c === undefined ? undefined : _c.debug(err);
+                throw err;
+            }
         });
     }
     onClose() {
         var _a;
-        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`${this.metadata.name}: shutting down`);
+        (_a = this.logger) === null || _a === undefined ? undefined : _a.debug(`${this.metadata.name}: shutting down`);
         return this._service.disconnect();
     }
     resolveBooleanEvaluation(flagKey, defaultValue, transformedContext, logger) {
-        return this._service
-            .resolveBoolean(flagKey, defaultValue, transformedContext, logger)
-            .catch((err) => this.logRejected(err, flagKey, logger));
+        return this._service.resolveBoolean(flagKey, defaultValue, transformedContext, logger);
     }
     resolveStringEvaluation(flagKey, defaultValue, transformedContext, logger) {
-        return this._service
-            .resolveString(flagKey, defaultValue, transformedContext, logger)
-            .catch((err) => this.logRejected(err, flagKey, logger));
+        return this._service.resolveString(flagKey, defaultValue, transformedContext, logger);
     }
     resolveNumberEvaluation(flagKey, defaultValue, transformedContext, logger) {
-        return this._service
-            .resolveNumber(flagKey, defaultValue, transformedContext, logger)
-            .catch((err) => this.logRejected(err, flagKey, logger));
+        return this._service.resolveNumber(flagKey, defaultValue, transformedContext, logger);
     }
     resolveObjectEvaluation(flagKey, defaultValue, transformedContext, logger) {
-        return this._service
-            .resolveObject(flagKey, defaultValue, transformedContext, logger)
-            .catch((err) => this.logRejected(err, flagKey, logger));
+        return this._service.resolveObject(flagKey, defaultValue, transformedContext, logger);
     }
     handleReconnect() {
-        this._status = ProviderStatus.READY;
-        this._events.emit(ProviderEvents.Ready);
+        this.events.emit(ProviderEvents.Ready);
     }
     handleError(message) {
-        this._status = ProviderStatus.ERROR;
-        this._events.emit(ProviderEvents.Error, { message });
+        this.events.emit(ProviderEvents.Error, { message });
     }
     handleChanged(flagsChanged) {
-        this._events.emit(ProviderEvents.ConfigurationChanged, { flagsChanged });
+        this.events.emit(ProviderEvents.ConfigurationChanged, { flagsChanged });
     }
 }