@azure/web-pubsub-client-protobuf 1.0.0-alpha.20240823.1 → 1.0.0-alpha.20240827.1

package/dist/index.js

@@ -791,204 +791,204 @@ 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;
+	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;
 }
@@ -999,1683 +999,1683 @@ 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 = 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 = 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);
-		        };
+		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 = 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;
 }
 
-var writer = Writer$1;
-
-var util$4      = requireMinimal();
-
-var BufferWriter$1; // cyclic
-
-var LongBits$1  = util$4.LongBits,
-    base64    = util$4.base64,
-    utf8$1      = util$4.utf8;
-
-/**
- * Constructs a new writer operation instance.
- * @classdesc Scheduled writer operation.
- * @constructor
- * @param {function(*, Uint8Array, number)} fn Function to call
- * @param {number} len Value byte length
- * @param {*} val Value to write
- * @ignore
- */
-function Op(fn, len, val) {
-
-    /**
-     * Function to call.
-     * @type {function(Uint8Array, number, *)}
-     */
-    this.fn = fn;
-
-    /**
-     * Value byte length.
-     * @type {number}
-     */
-    this.len = len;
-
-    /**
-     * Next operation.
-     * @type {Writer.Op|undefined}
-     */
-    this.next = undefined;
-
-    /**
-     * Value to write.
-     * @type {*}
-     */
-    this.val = val; // type varies
-}
-
-/* istanbul ignore next */
-function noop() {} // eslint-disable-line no-empty-function
-
-/**
- * Constructs a new writer state instance.
- * @classdesc Copied writer state.
- * @memberof Writer
- * @constructor
- * @param {Writer} writer Writer to copy state from
- * @ignore
- */
-function State(writer) {
-
-    /**
-     * Current head.
-     * @type {Writer.Op}
-     */
-    this.head = writer.head;
-
-    /**
-     * Current tail.
-     * @type {Writer.Op}
-     */
-    this.tail = writer.tail;
-
-    /**
-     * Current buffer length.
-     * @type {number}
-     */
-    this.len = writer.len;
-
-    /**
-     * Next state.
-     * @type {State|null}
-     */
-    this.next = writer.states;
-}
-
-/**
- * Constructs a new writer instance.
- * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
- * @constructor
- */
-function Writer$1() {
-
-    /**
-     * Current length.
-     * @type {number}
-     */
-    this.len = 0;
-
-    /**
-     * Operations head.
-     * @type {Object}
-     */
-    this.head = new Op(noop, 0, 0);
-
-    /**
-     * Operations tail
-     * @type {Object}
-     */
-    this.tail = this.head;
-
-    /**
-     * Linked forked states.
-     * @type {Object|null}
-     */
-    this.states = null;
-
-    // When a value is written, the writer calculates its byte length and puts it into a linked
-    // list of operations to perform when finish() is called. This both allows us to allocate
-    // buffers of the exact required size and reduces the amount of work we have to do compared
-    // to first calculating over objects and then encoding over objects. In our case, the encoding
-    // part is just a linked list walk calling operations with already prepared values.
-}
-
-var create$1 = function create() {
-    return util$4.Buffer
-        ? function create_buffer_setup() {
-            return (Writer$1.create = function create_buffer() {
-                return new BufferWriter$1();
-            })();
-        }
-        /* istanbul ignore next */
-        : function create_array() {
-            return new Writer$1();
-        };
-};
-
-/**
- * Creates a new writer.
- * @function
- * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
- */
-Writer$1.create = create$1();
-
-/**
- * Allocates a buffer of the specified size.
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
-Writer$1.alloc = function alloc(size) {
-    return new util$4.Array(size);
-};
-
-// Use Uint8Array buffer pool in the browser, just like node does with buffers
-/* istanbul ignore else */
-if (util$4.Array !== Array)
-    Writer$1.alloc = util$4.pool(Writer$1.alloc, util$4.Array.prototype.subarray);
-
-/**
- * Pushes a new operation to the queue.
- * @param {function(Uint8Array, number, *)} fn Function to call
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @returns {Writer} `this`
- * @private
- */
-Writer$1.prototype._push = function push(fn, len, val) {
-    this.tail = this.tail.next = new Op(fn, len, val);
-    this.len += len;
-    return this;
-};
-
-function writeByte(val, buf, pos) {
-    buf[pos] = val & 255;
-}
-
-function writeVarint32(val, buf, pos) {
-    while (val > 127) {
-        buf[pos++] = val & 127 | 128;
-        val >>>= 7;
-    }
-    buf[pos] = val;
-}
-
-/**
- * Constructs a new varint writer operation instance.
- * @classdesc Scheduled varint writer operation.
- * @extends Op
- * @constructor
- * @param {number} len Value byte length
- * @param {number} val Value to write
- * @ignore
- */
-function VarintOp(len, val) {
-    this.len = len;
-    this.next = undefined;
-    this.val = val;
-}
-
-VarintOp.prototype = Object.create(Op.prototype);
-VarintOp.prototype.fn = writeVarint32;
-
-/**
- * Writes an unsigned 32 bit value as a varint.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.uint32 = function write_uint32(value) {
-    // here, the call to this.push has been inlined and a varint specific Op subclass is used.
-    // uint32 is by far the most frequently used operation and benefits significantly from this.
-    this.len += (this.tail = this.tail.next = new VarintOp(
-        (value = value >>> 0)
-                < 128       ? 1
-        : value < 16384     ? 2
-        : value < 2097152   ? 3
-        : value < 268435456 ? 4
-        :                     5,
-    value)).len;
-    return this;
-};
-
-/**
- * Writes a signed 32 bit value as a varint.
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.int32 = function write_int32(value) {
-    return value < 0
-        ? this._push(writeVarint64, 10, LongBits$1.fromNumber(value)) // 10 bytes per spec
-        : this.uint32(value);
-};
-
-/**
- * Writes a 32 bit value as a varint, zig-zag encoded.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.sint32 = function write_sint32(value) {
-    return this.uint32((value << 1 ^ value >> 31) >>> 0);
-};
-
-function writeVarint64(val, buf, pos) {
-    while (val.hi) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
-        val.hi >>>= 7;
-    }
-    while (val.lo > 127) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = val.lo >>> 7;
-    }
-    buf[pos++] = val.lo;
-}
-
-/**
- * Writes an unsigned 64 bit value as a varint.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.uint64 = function write_uint64(value) {
-    var bits = LongBits$1.from(value);
-    return this._push(writeVarint64, bits.length(), bits);
-};
-
-/**
- * Writes a signed 64 bit value as a varint.
- * @function
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.int64 = Writer$1.prototype.uint64;
-
-/**
- * Writes a signed 64 bit value as a varint, zig-zag encoded.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.sint64 = function write_sint64(value) {
-    var bits = LongBits$1.from(value).zzEncode();
-    return this._push(writeVarint64, bits.length(), bits);
-};
-
-/**
- * Writes a boolish value as a varint.
- * @param {boolean} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.bool = function write_bool(value) {
-    return this._push(writeByte, 1, value ? 1 : 0);
-};
-
-function writeFixed32(val, buf, pos) {
-    buf[pos    ] =  val         & 255;
-    buf[pos + 1] =  val >>> 8   & 255;
-    buf[pos + 2] =  val >>> 16  & 255;
-    buf[pos + 3] =  val >>> 24;
-}
-
-/**
- * Writes an unsigned 32 bit value as fixed 32 bits.
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.fixed32 = function write_fixed32(value) {
-    return this._push(writeFixed32, 4, value >>> 0);
-};
-
-/**
- * Writes a signed 32 bit value as fixed 32 bits.
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.sfixed32 = Writer$1.prototype.fixed32;
-
-/**
- * Writes an unsigned 64 bit value as fixed 64 bits.
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.fixed64 = function write_fixed64(value) {
-    var bits = LongBits$1.from(value);
-    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
-};
-
-/**
- * Writes a signed 64 bit value as fixed 64 bits.
- * @function
- * @param {Long|number|string} value Value to write
- * @returns {Writer} `this`
- * @throws {TypeError} If `value` is a string and no long library is present.
- */
-Writer$1.prototype.sfixed64 = Writer$1.prototype.fixed64;
-
-/**
- * Writes a float (32 bit).
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.float = function write_float(value) {
-    return this._push(util$4.float.writeFloatLE, 4, value);
-};
-
-/**
- * Writes a double (64 bit float).
- * @function
- * @param {number} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.double = function write_double(value) {
-    return this._push(util$4.float.writeDoubleLE, 8, value);
-};
-
-var writeBytes = util$4.Array.prototype.set
-    ? function writeBytes_set(val, buf, pos) {
-        buf.set(val, pos); // also works for plain array values
-    }
-    /* istanbul ignore next */
-    : function writeBytes_for(val, buf, pos) {
-        for (var i = 0; i < val.length; ++i)
-            buf[pos + i] = val[i];
-    };
-
-/**
- * Writes a sequence of bytes.
- * @param {Uint8Array|string} value Buffer or base64 encoded string to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.bytes = function write_bytes(value) {
-    var len = value.length >>> 0;
-    if (!len)
-        return this._push(writeByte, 1, 0);
-    if (util$4.isString(value)) {
-        var buf = Writer$1.alloc(len = base64.length(value));
-        base64.decode(value, buf, 0);
-        value = buf;
-    }
-    return this.uint32(len)._push(writeBytes, len, value);
-};
-
-/**
- * Writes a string.
- * @param {string} value Value to write
- * @returns {Writer} `this`
- */
-Writer$1.prototype.string = function write_string(value) {
-    var len = utf8$1.length(value);
-    return len
-        ? this.uint32(len)._push(utf8$1.write, len, value)
-        : this._push(writeByte, 1, 0);
-};
-
-/**
- * Forks this writer's state by pushing it to a stack.
- * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.fork = function fork() {
-    this.states = new State(this);
-    this.head = this.tail = new Op(noop, 0, 0);
-    this.len = 0;
-    return this;
-};
-
-/**
- * Resets this instance to the last state.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.reset = function reset() {
-    if (this.states) {
-        this.head   = this.states.head;
-        this.tail   = this.states.tail;
-        this.len    = this.states.len;
-        this.states = this.states.next;
-    } else {
-        this.head = this.tail = new Op(noop, 0, 0);
-        this.len  = 0;
-    }
-    return this;
-};
-
-/**
- * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
- * @returns {Writer} `this`
- */
-Writer$1.prototype.ldelim = function ldelim() {
-    var head = this.head,
-        tail = this.tail,
-        len  = this.len;
-    this.reset().uint32(len);
-    if (len) {
-        this.tail.next = head.next; // skip noop
-        this.tail = tail;
-        this.len += len;
-    }
-    return this;
-};
-
-/**
- * Finishes the write operation.
- * @returns {Uint8Array} Finished buffer
- */
-Writer$1.prototype.finish = function finish() {
-    var head = this.head.next, // skip noop
-        buf  = this.constructor.alloc(this.len),
-        pos  = 0;
-    while (head) {
-        head.fn(head.val, buf, pos);
-        pos += head.len;
-        head = head.next;
-    }
-    // this.head = this.tail = null;
-    return buf;
-};
-
-Writer$1._configure = function(BufferWriter_) {
-    BufferWriter$1 = BufferWriter_;
-    Writer$1.create = create$1();
-    BufferWriter$1._configure();
+var writer = Writer$1;
+
+var util$4      = requireMinimal();
+
+var BufferWriter$1; // cyclic
+
+var LongBits$1  = util$4.LongBits,
+    base64    = util$4.base64,
+    utf8$1      = util$4.utf8;
+
+/**
+ * Constructs a new writer operation instance.
+ * @classdesc Scheduled writer operation.
+ * @constructor
+ * @param {function(*, Uint8Array, number)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {*} val Value to write
+ * @ignore
+ */
+function Op(fn, len, val) {
+
+    /**
+     * Function to call.
+     * @type {function(Uint8Array, number, *)}
+     */
+    this.fn = fn;
+
+    /**
+     * Value byte length.
+     * @type {number}
+     */
+    this.len = len;
+
+    /**
+     * Next operation.
+     * @type {Writer.Op|undefined}
+     */
+    this.next = undefined;
+
+    /**
+     * Value to write.
+     * @type {*}
+     */
+    this.val = val; // type varies
+}
+
+/* istanbul ignore next */
+function noop() {} // eslint-disable-line no-empty-function
+
+/**
+ * Constructs a new writer state instance.
+ * @classdesc Copied writer state.
+ * @memberof Writer
+ * @constructor
+ * @param {Writer} writer Writer to copy state from
+ * @ignore
+ */
+function State(writer) {
+
+    /**
+     * Current head.
+     * @type {Writer.Op}
+     */
+    this.head = writer.head;
+
+    /**
+     * Current tail.
+     * @type {Writer.Op}
+     */
+    this.tail = writer.tail;
+
+    /**
+     * Current buffer length.
+     * @type {number}
+     */
+    this.len = writer.len;
+
+    /**
+     * Next state.
+     * @type {State|null}
+     */
+    this.next = writer.states;
+}
+
+/**
+ * Constructs a new writer instance.
+ * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ */
+function Writer$1() {
+
+    /**
+     * Current length.
+     * @type {number}
+     */
+    this.len = 0;
+
+    /**
+     * Operations head.
+     * @type {Object}
+     */
+    this.head = new Op(noop, 0, 0);
+
+    /**
+     * Operations tail
+     * @type {Object}
+     */
+    this.tail = this.head;
+
+    /**
+     * Linked forked states.
+     * @type {Object|null}
+     */
+    this.states = null;
+
+    // When a value is written, the writer calculates its byte length and puts it into a linked
+    // list of operations to perform when finish() is called. This both allows us to allocate
+    // buffers of the exact required size and reduces the amount of work we have to do compared
+    // to first calculating over objects and then encoding over objects. In our case, the encoding
+    // part is just a linked list walk calling operations with already prepared values.
+}
+
+var create$1 = function create() {
+    return util$4.Buffer
+        ? function create_buffer_setup() {
+            return (Writer$1.create = function create_buffer() {
+                return new BufferWriter$1();
+            })();
+        }
+        /* istanbul ignore next */
+        : function create_array() {
+            return new Writer$1();
+        };
+};
+
+/**
+ * Creates a new writer.
+ * @function
+ * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
+ */
+Writer$1.create = create$1();
+
+/**
+ * Allocates a buffer of the specified size.
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+Writer$1.alloc = function alloc(size) {
+    return new util$4.Array(size);
+};
+
+// Use Uint8Array buffer pool in the browser, just like node does with buffers
+/* istanbul ignore else */
+if (util$4.Array !== Array)
+    Writer$1.alloc = util$4.pool(Writer$1.alloc, util$4.Array.prototype.subarray);
+
+/**
+ * Pushes a new operation to the queue.
+ * @param {function(Uint8Array, number, *)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @returns {Writer} `this`
+ * @private
+ */
+Writer$1.prototype._push = function push(fn, len, val) {
+    this.tail = this.tail.next = new Op(fn, len, val);
+    this.len += len;
+    return this;
+};
+
+function writeByte(val, buf, pos) {
+    buf[pos] = val & 255;
+}
+
+function writeVarint32(val, buf, pos) {
+    while (val > 127) {
+        buf[pos++] = val & 127 | 128;
+        val >>>= 7;
+    }
+    buf[pos] = val;
+}
+
+/**
+ * Constructs a new varint writer operation instance.
+ * @classdesc Scheduled varint writer operation.
+ * @extends Op
+ * @constructor
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @ignore
+ */
+function VarintOp(len, val) {
+    this.len = len;
+    this.next = undefined;
+    this.val = val;
+}
+
+VarintOp.prototype = Object.create(Op.prototype);
+VarintOp.prototype.fn = writeVarint32;
+
+/**
+ * Writes an unsigned 32 bit value as a varint.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.uint32 = function write_uint32(value) {
+    // here, the call to this.push has been inlined and a varint specific Op subclass is used.
+    // uint32 is by far the most frequently used operation and benefits significantly from this.
+    this.len += (this.tail = this.tail.next = new VarintOp(
+        (value = value >>> 0)
+                < 128       ? 1
+        : value < 16384     ? 2
+        : value < 2097152   ? 3
+        : value < 268435456 ? 4
+        :                     5,
+    value)).len;
+    return this;
+};
+
+/**
+ * Writes a signed 32 bit value as a varint.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.int32 = function write_int32(value) {
+    return value < 0
+        ? this._push(writeVarint64, 10, LongBits$1.fromNumber(value)) // 10 bytes per spec
+        : this.uint32(value);
+};
+
+/**
+ * Writes a 32 bit value as a varint, zig-zag encoded.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.sint32 = function write_sint32(value) {
+    return this.uint32((value << 1 ^ value >> 31) >>> 0);
+};
+
+function writeVarint64(val, buf, pos) {
+    while (val.hi) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+        val.hi >>>= 7;
+    }
+    while (val.lo > 127) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = val.lo >>> 7;
+    }
+    buf[pos++] = val.lo;
+}
+
+/**
+ * Writes an unsigned 64 bit value as a varint.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer$1.prototype.uint64 = function write_uint64(value) {
+    var bits = LongBits$1.from(value);
+    return this._push(writeVarint64, bits.length(), bits);
+};
+
+/**
+ * Writes a signed 64 bit value as a varint.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer$1.prototype.int64 = Writer$1.prototype.uint64;
+
+/**
+ * Writes a signed 64 bit value as a varint, zig-zag encoded.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer$1.prototype.sint64 = function write_sint64(value) {
+    var bits = LongBits$1.from(value).zzEncode();
+    return this._push(writeVarint64, bits.length(), bits);
+};
+
+/**
+ * Writes a boolish value as a varint.
+ * @param {boolean} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.bool = function write_bool(value) {
+    return this._push(writeByte, 1, value ? 1 : 0);
+};
+
+function writeFixed32(val, buf, pos) {
+    buf[pos    ] =  val         & 255;
+    buf[pos + 1] =  val >>> 8   & 255;
+    buf[pos + 2] =  val >>> 16  & 255;
+    buf[pos + 3] =  val >>> 24;
+}
+
+/**
+ * Writes an unsigned 32 bit value as fixed 32 bits.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.fixed32 = function write_fixed32(value) {
+    return this._push(writeFixed32, 4, value >>> 0);
+};
+
+/**
+ * Writes a signed 32 bit value as fixed 32 bits.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.sfixed32 = Writer$1.prototype.fixed32;
+
+/**
+ * Writes an unsigned 64 bit value as fixed 64 bits.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer$1.prototype.fixed64 = function write_fixed64(value) {
+    var bits = LongBits$1.from(value);
+    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+};
+
+/**
+ * Writes a signed 64 bit value as fixed 64 bits.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer$1.prototype.sfixed64 = Writer$1.prototype.fixed64;
+
+/**
+ * Writes a float (32 bit).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.float = function write_float(value) {
+    return this._push(util$4.float.writeFloatLE, 4, value);
+};
+
+/**
+ * Writes a double (64 bit float).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.double = function write_double(value) {
+    return this._push(util$4.float.writeDoubleLE, 8, value);
+};
+
+var writeBytes = util$4.Array.prototype.set
+    ? function writeBytes_set(val, buf, pos) {
+        buf.set(val, pos); // also works for plain array values
+    }
+    /* istanbul ignore next */
+    : function writeBytes_for(val, buf, pos) {
+        for (var i = 0; i < val.length; ++i)
+            buf[pos + i] = val[i];
+    };
+
+/**
+ * Writes a sequence of bytes.
+ * @param {Uint8Array|string} value Buffer or base64 encoded string to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.bytes = function write_bytes(value) {
+    var len = value.length >>> 0;
+    if (!len)
+        return this._push(writeByte, 1, 0);
+    if (util$4.isString(value)) {
+        var buf = Writer$1.alloc(len = base64.length(value));
+        base64.decode(value, buf, 0);
+        value = buf;
+    }
+    return this.uint32(len)._push(writeBytes, len, value);
+};
+
+/**
+ * Writes a string.
+ * @param {string} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.string = function write_string(value) {
+    var len = utf8$1.length(value);
+    return len
+        ? this.uint32(len)._push(utf8$1.write, len, value)
+        : this._push(writeByte, 1, 0);
+};
+
+/**
+ * Forks this writer's state by pushing it to a stack.
+ * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.fork = function fork() {
+    this.states = new State(this);
+    this.head = this.tail = new Op(noop, 0, 0);
+    this.len = 0;
+    return this;
+};
+
+/**
+ * Resets this instance to the last state.
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.reset = function reset() {
+    if (this.states) {
+        this.head   = this.states.head;
+        this.tail   = this.states.tail;
+        this.len    = this.states.len;
+        this.states = this.states.next;
+    } else {
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len  = 0;
+    }
+    return this;
+};
+
+/**
+ * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+ * @returns {Writer} `this`
+ */
+Writer$1.prototype.ldelim = function ldelim() {
+    var head = this.head,
+        tail = this.tail,
+        len  = this.len;
+    this.reset().uint32(len);
+    if (len) {
+        this.tail.next = head.next; // skip noop
+        this.tail = tail;
+        this.len += len;
+    }
+    return this;
+};
+
+/**
+ * Finishes the write operation.
+ * @returns {Uint8Array} Finished buffer
+ */
+Writer$1.prototype.finish = function finish() {
+    var head = this.head.next, // skip noop
+        buf  = this.constructor.alloc(this.len),
+        pos  = 0;
+    while (head) {
+        head.fn(head.val, buf, pos);
+        pos += head.len;
+        head = head.next;
+    }
+    // this.head = this.tail = null;
+    return buf;
+};
+
+Writer$1._configure = function(BufferWriter_) {
+    BufferWriter$1 = BufferWriter_;
+    Writer$1.create = create$1();
+    BufferWriter$1._configure();
+};
+
+var writer_buffer = BufferWriter;
+
+// extends Writer
+var Writer = writer;
+(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+
+var util$3 = requireMinimal();
+
+/**
+ * Constructs a new buffer writer instance.
+ * @classdesc Wire format writer using node buffers.
+ * @extends Writer
+ * @constructor
+ */
+function BufferWriter() {
+    Writer.call(this);
+}
+
+BufferWriter._configure = function () {
+    /**
+     * Allocates a buffer of the specified size.
+     * @function
+     * @param {number} size Buffer size
+     * @returns {Buffer} Buffer
+     */
+    BufferWriter.alloc = util$3._Buffer_allocUnsafe;
+
+    BufferWriter.writeBytesBuffer = util$3.Buffer && util$3.Buffer.prototype instanceof Uint8Array && util$3.Buffer.prototype.set.name === "set"
+        ? function writeBytesBuffer_set(val, buf, pos) {
+          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
+          // also works for plain array values
+        }
+        /* istanbul ignore next */
+        : function writeBytesBuffer_copy(val, buf, pos) {
+          if (val.copy) // Buffer values
+            val.copy(buf, pos, 0, val.length);
+          else for (var i = 0; i < val.length;) // plain array values
+            buf[pos++] = val[i++];
+        };
+};
+
+
+/**
+ * @override
+ */
+BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
+    if (util$3.isString(value))
+        value = util$3._Buffer_from(value, "base64");
+    var len = value.length >>> 0;
+    this.uint32(len);
+    if (len)
+        this._push(BufferWriter.writeBytesBuffer, len, value);
+    return this;
+};
+
+function writeStringBuffer(val, buf, pos) {
+    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
+        util$3.utf8.write(val, buf, pos);
+    else if (buf.utf8Write)
+        buf.utf8Write(val, pos);
+    else
+        buf.write(val, pos);
+}
+
+/**
+ * @override
+ */
+BufferWriter.prototype.string = function write_string_buffer(value) {
+    var len = util$3.Buffer.byteLength(value);
+    this.uint32(len);
+    if (len)
+        this._push(writeStringBuffer, len, value);
+    return this;
+};
+
+
+/**
+ * Finishes the write operation.
+ * @name BufferWriter#finish
+ * @function
+ * @returns {Buffer} Finished buffer
+ */
+
+BufferWriter._configure();
+
+var reader = Reader$1;
+
+var util$2      = requireMinimal();
+
+var BufferReader$1; // cyclic
+
+var LongBits  = util$2.LongBits,
+    utf8      = util$2.utf8;
+
+/* istanbul ignore next */
+function indexOutOfRange(reader, writeLength) {
+    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+}
+
+/**
+ * Constructs a new reader instance using the specified buffer.
+ * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ * @param {Uint8Array} buffer Buffer to read from
+ */
+function Reader$1(buffer) {
+
+    /**
+     * Read buffer.
+     * @type {Uint8Array}
+     */
+    this.buf = buffer;
+
+    /**
+     * Read buffer position.
+     * @type {number}
+     */
+    this.pos = 0;
+
+    /**
+     * Read buffer length.
+     * @type {number}
+     */
+    this.len = buffer.length;
+}
+
+var create_array = typeof Uint8Array !== "undefined"
+    ? function create_typed_array(buffer) {
+        if (buffer instanceof Uint8Array || Array.isArray(buffer))
+            return new Reader$1(buffer);
+        throw Error("illegal buffer");
+    }
+    /* istanbul ignore next */
+    : function create_array(buffer) {
+        if (Array.isArray(buffer))
+            return new Reader$1(buffer);
+        throw Error("illegal buffer");
+    };
+
+var create = function create() {
+    return util$2.Buffer
+        ? function create_buffer_setup(buffer) {
+            return (Reader$1.create = function create_buffer(buffer) {
+                return util$2.Buffer.isBuffer(buffer)
+                    ? new BufferReader$1(buffer)
+                    /* istanbul ignore next */
+                    : create_array(buffer);
+            })(buffer);
+        }
+        /* istanbul ignore next */
+        : create_array;
 };
 
-var writer_buffer = BufferWriter;
-
-// extends Writer
-var Writer = writer;
-(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
-
-var util$3 = requireMinimal();
-
-/**
- * Constructs a new buffer writer instance.
- * @classdesc Wire format writer using node buffers.
- * @extends Writer
- * @constructor
- */
-function BufferWriter() {
-    Writer.call(this);
-}
-
-BufferWriter._configure = function () {
-    /**
-     * Allocates a buffer of the specified size.
-     * @function
-     * @param {number} size Buffer size
-     * @returns {Buffer} Buffer
-     */
-    BufferWriter.alloc = util$3._Buffer_allocUnsafe;
-
-    BufferWriter.writeBytesBuffer = util$3.Buffer && util$3.Buffer.prototype instanceof Uint8Array && util$3.Buffer.prototype.set.name === "set"
-        ? function writeBytesBuffer_set(val, buf, pos) {
-          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
-          // also works for plain array values
-        }
-        /* istanbul ignore next */
-        : function writeBytesBuffer_copy(val, buf, pos) {
-          if (val.copy) // Buffer values
-            val.copy(buf, pos, 0, val.length);
-          else for (var i = 0; i < val.length;) // plain array values
-            buf[pos++] = val[i++];
-        };
-};
-
-
-/**
- * @override
- */
-BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
-    if (util$3.isString(value))
-        value = util$3._Buffer_from(value, "base64");
-    var len = value.length >>> 0;
-    this.uint32(len);
-    if (len)
-        this._push(BufferWriter.writeBytesBuffer, len, value);
-    return this;
-};
-
-function writeStringBuffer(val, buf, pos) {
-    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
-        util$3.utf8.write(val, buf, pos);
-    else if (buf.utf8Write)
-        buf.utf8Write(val, pos);
-    else
-        buf.write(val, pos);
-}
-
-/**
- * @override
- */
-BufferWriter.prototype.string = function write_string_buffer(value) {
-    var len = util$3.Buffer.byteLength(value);
-    this.uint32(len);
-    if (len)
-        this._push(writeStringBuffer, len, value);
-    return this;
-};
-
-
-/**
- * Finishes the write operation.
- * @name BufferWriter#finish
- * @function
- * @returns {Buffer} Finished buffer
- */
-
-BufferWriter._configure();
+/**
+ * Creates a new reader using the specified buffer.
+ * @function
+ * @param {Uint8Array|Buffer} buffer Buffer to read from
+ * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
+ * @throws {Error} If `buffer` is not a valid buffer
+ */
+Reader$1.create = create();
 
-var reader = Reader$1;
-
-var util$2      = requireMinimal();
-
-var BufferReader$1; // cyclic
-
-var LongBits  = util$2.LongBits,
-    utf8      = util$2.utf8;
-
-/* istanbul ignore next */
-function indexOutOfRange(reader, writeLength) {
-    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
-}
-
-/**
- * Constructs a new reader instance using the specified buffer.
- * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
- * @constructor
- * @param {Uint8Array} buffer Buffer to read from
- */
-function Reader$1(buffer) {
-
-    /**
-     * Read buffer.
-     * @type {Uint8Array}
-     */
-    this.buf = buffer;
-
-    /**
-     * Read buffer position.
-     * @type {number}
-     */
-    this.pos = 0;
-
-    /**
-     * Read buffer length.
-     * @type {number}
-     */
-    this.len = buffer.length;
-}
-
-var create_array = typeof Uint8Array !== "undefined"
-    ? function create_typed_array(buffer) {
-        if (buffer instanceof Uint8Array || Array.isArray(buffer))
-            return new Reader$1(buffer);
-        throw Error("illegal buffer");
-    }
-    /* istanbul ignore next */
-    : function create_array(buffer) {
-        if (Array.isArray(buffer))
-            return new Reader$1(buffer);
-        throw Error("illegal buffer");
-    };
-
-var create = function create() {
-    return util$2.Buffer
-        ? function create_buffer_setup(buffer) {
-            return (Reader$1.create = function create_buffer(buffer) {
-                return util$2.Buffer.isBuffer(buffer)
-                    ? new BufferReader$1(buffer)
-                    /* istanbul ignore next */
-                    : create_array(buffer);
-            })(buffer);
-        }
-        /* istanbul ignore next */
-        : create_array;
-};
-
-/**
- * Creates a new reader using the specified buffer.
- * @function
- * @param {Uint8Array|Buffer} buffer Buffer to read from
- * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
- * @throws {Error} If `buffer` is not a valid buffer
- */
-Reader$1.create = create();
-
-Reader$1.prototype._slice = util$2.Array.prototype.subarray || /* istanbul ignore next */ util$2.Array.prototype.slice;
-
-/**
- * Reads a varint as an unsigned 32 bit value.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.uint32 = (function read_uint32_setup() {
-    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
-    return function read_uint32() {
-        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
-        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;
-
-        /* istanbul ignore if */
-        if ((this.pos += 5) > this.len) {
-            this.pos = this.len;
-            throw indexOutOfRange(this, 10);
-        }
-        return value;
-    };
-})();
-
-/**
- * Reads a varint as a signed 32 bit value.
- * @returns {number} Value read
- */
-Reader$1.prototype.int32 = function read_int32() {
-    return this.uint32() | 0;
-};
-
-/**
- * Reads a zig-zag encoded varint as a signed 32 bit value.
- * @returns {number} Value read
- */
-Reader$1.prototype.sint32 = function read_sint32() {
-    var value = this.uint32();
-    return value >>> 1 ^ -(value & 1) | 0;
-};
-
-/* eslint-disable no-invalid-this */
-
-function readLongVarint() {
-    // tends to deopt with local vars for octet etc.
-    var bits = new LongBits(0, 0);
-    var i = 0;
-    if (this.len - this.pos > 4) { // fast route (lo)
-        for (; i < 4; ++i) {
-            // 1st..4th
-            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
-        }
-        // 5th
-        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
-        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;
-        if (this.buf[this.pos++] < 128)
-            return bits;
-        i = 0;
-    } else {
-        for (; i < 3; ++i) {
-            /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-            // 1st..3th
-            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
-        }
-        // 4th
-        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
-        return bits;
-    }
-    if (this.len - this.pos > 4) { // fast route (hi)
-        for (; i < 5; ++i) {
-            // 6th..10th
-            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
-        }
-    } else {
-        for (; i < 5; ++i) {
-            /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-            // 6th..10th
-            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
-            if (this.buf[this.pos++] < 128)
-                return bits;
-        }
-    }
-    /* istanbul ignore next */
-    throw Error("invalid varint encoding");
-}
-
-/* eslint-enable no-invalid-this */
-
-/**
- * Reads a varint as a signed 64 bit value.
- * @name Reader#int64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a varint as an unsigned 64 bit value.
- * @name Reader#uint64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a zig-zag encoded varint as a signed 64 bit value.
- * @name Reader#sint64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a varint as a boolean.
- * @returns {boolean} Value read
- */
-Reader$1.prototype.bool = function read_bool() {
-    return this.uint32() !== 0;
-};
-
-function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
-    return (buf[end - 4]
-          | buf[end - 3] << 8
-          | buf[end - 2] << 16
-          | buf[end - 1] << 24) >>> 0;
-}
-
-/**
- * Reads fixed 32 bits as an unsigned 32 bit integer.
- * @returns {number} Value read
- */
-Reader$1.prototype.fixed32 = function read_fixed32() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    return readFixed32_end(this.buf, this.pos += 4);
-};
-
-/**
- * Reads fixed 32 bits as a signed 32 bit integer.
- * @returns {number} Value read
- */
-Reader$1.prototype.sfixed32 = function read_sfixed32() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    return readFixed32_end(this.buf, this.pos += 4) | 0;
-};
-
-/* eslint-disable no-invalid-this */
-
-function readFixed64(/* this: Reader */) {
-
-    /* istanbul ignore if */
-    if (this.pos + 8 > this.len)
-        throw indexOutOfRange(this, 8);
-
-    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
-}
-
-/* eslint-enable no-invalid-this */
-
-/**
- * Reads fixed 64 bits.
- * @name Reader#fixed64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads zig-zag encoded fixed 64 bits.
- * @name Reader#sfixed64
- * @function
- * @returns {Long} Value read
- */
-
-/**
- * Reads a float (32 bit) as a number.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.float = function read_float() {
-
-    /* istanbul ignore if */
-    if (this.pos + 4 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    var value = util$2.float.readFloatLE(this.buf, this.pos);
-    this.pos += 4;
-    return value;
-};
-
-/**
- * Reads a double (64 bit float) as a number.
- * @function
- * @returns {number} Value read
- */
-Reader$1.prototype.double = function read_double() {
-
-    /* istanbul ignore if */
-    if (this.pos + 8 > this.len)
-        throw indexOutOfRange(this, 4);
-
-    var value = util$2.float.readDoubleLE(this.buf, this.pos);
-    this.pos += 8;
-    return value;
-};
-
-/**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @returns {Uint8Array} Value read
- */
-Reader$1.prototype.bytes = function read_bytes() {
-    var length = this.uint32(),
-        start  = this.pos,
-        end    = this.pos + length;
-
-    /* istanbul ignore if */
-    if (end > this.len)
-        throw indexOutOfRange(this, length);
-
-    this.pos += length;
-    if (Array.isArray(this.buf)) // plain array
-        return this.buf.slice(start, end);
-
-    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1
-        var nativeBuffer = util$2.Buffer;
-        return nativeBuffer
-            ? nativeBuffer.alloc(0)
-            : new this.buf.constructor(0);
-    }
-    return this._slice.call(this.buf, start, end);
-};
-
-/**
- * Reads a string preceeded by its byte length as a varint.
- * @returns {string} Value read
- */
-Reader$1.prototype.string = function read_string() {
-    var bytes = this.bytes();
-    return utf8.read(bytes, 0, bytes.length);
-};
-
-/**
- * Skips the specified number of bytes if specified, otherwise skips a varint.
- * @param {number} [length] Length if known, otherwise a varint is assumed
- * @returns {Reader} `this`
- */
-Reader$1.prototype.skip = function skip(length) {
-    if (typeof length === "number") {
-        /* istanbul ignore if */
-        if (this.pos + length > this.len)
-            throw indexOutOfRange(this, length);
-        this.pos += length;
-    } else {
-        do {
-            /* istanbul ignore if */
-            if (this.pos >= this.len)
-                throw indexOutOfRange(this);
-        } while (this.buf[this.pos++] & 128);
-    }
-    return this;
-};
-
-/**
- * Skips the next element of the specified wire type.
- * @param {number} wireType Wire type received
- * @returns {Reader} `this`
- */
-Reader$1.prototype.skipType = function(wireType) {
-    switch (wireType) {
-        case 0:
-            this.skip();
-            break;
-        case 1:
-            this.skip(8);
-            break;
-        case 2:
-            this.skip(this.uint32());
-            break;
-        case 3:
-            while ((wireType = this.uint32() & 7) !== 4) {
-                this.skipType(wireType);
-            }
-            break;
-        case 5:
-            this.skip(4);
-            break;
-
-        /* istanbul ignore next */
-        default:
-            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
-    }
-    return this;
-};
-
-Reader$1._configure = function(BufferReader_) {
-    BufferReader$1 = BufferReader_;
-    Reader$1.create = create();
-    BufferReader$1._configure();
-
-    var fn = util$2.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
-    util$2.merge(Reader$1.prototype, {
-
-        int64: function read_int64() {
-            return readLongVarint.call(this)[fn](false);
-        },
-
-        uint64: function read_uint64() {
-            return readLongVarint.call(this)[fn](true);
-        },
-
-        sint64: function read_sint64() {
-            return readLongVarint.call(this).zzDecode()[fn](false);
-        },
-
-        fixed64: function read_fixed64() {
-            return readFixed64.call(this)[fn](true);
-        },
-
-        sfixed64: function read_sfixed64() {
-            return readFixed64.call(this)[fn](false);
-        }
-
-    });
+Reader$1.prototype._slice = util$2.Array.prototype.subarray || /* istanbul ignore next */ util$2.Array.prototype.slice;
+
+/**
+ * Reads a varint as an unsigned 32 bit value.
+ * @function
+ * @returns {number} Value read
+ */
+Reader$1.prototype.uint32 = (function read_uint32_setup() {
+    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
+    return function read_uint32() {
+        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
+        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;
+
+        /* istanbul ignore if */
+        if ((this.pos += 5) > this.len) {
+            this.pos = this.len;
+            throw indexOutOfRange(this, 10);
+        }
+        return value;
+    };
+})();
+
+/**
+ * Reads a varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.int32 = function read_int32() {
+    return this.uint32() | 0;
+};
+
+/**
+ * Reads a zig-zag encoded varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.sint32 = function read_sint32() {
+    var value = this.uint32();
+    return value >>> 1 ^ -(value & 1) | 0;
+};
+
+/* eslint-disable no-invalid-this */
+
+function readLongVarint() {
+    // tends to deopt with local vars for octet etc.
+    var bits = new LongBits(0, 0);
+    var i = 0;
+    if (this.len - this.pos > 4) { // fast route (lo)
+        for (; i < 4; ++i) {
+            // 1st..4th
+            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+        // 5th
+        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;
+        if (this.buf[this.pos++] < 128)
+            return bits;
+        i = 0;
+    } else {
+        for (; i < 3; ++i) {
+            /* istanbul ignore if */
+            if (this.pos >= this.len)
+                throw indexOutOfRange(this);
+            // 1st..3th
+            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+        // 4th
+        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+        return bits;
+    }
+    if (this.len - this.pos > 4) { // fast route (hi)
+        for (; i < 5; ++i) {
+            // 6th..10th
+            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+    } else {
+        for (; i < 5; ++i) {
+            /* istanbul ignore if */
+            if (this.pos >= this.len)
+                throw indexOutOfRange(this);
+            // 6th..10th
+            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+            if (this.buf[this.pos++] < 128)
+                return bits;
+        }
+    }
+    /* istanbul ignore next */
+    throw Error("invalid varint encoding");
+}
+
+/* eslint-enable no-invalid-this */
+
+/**
+ * Reads a varint as a signed 64 bit value.
+ * @name Reader#int64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a varint as an unsigned 64 bit value.
+ * @name Reader#uint64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a zig-zag encoded varint as a signed 64 bit value.
+ * @name Reader#sint64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a varint as a boolean.
+ * @returns {boolean} Value read
+ */
+Reader$1.prototype.bool = function read_bool() {
+    return this.uint32() !== 0;
+};
+
+function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
+    return (buf[end - 4]
+          | buf[end - 3] << 8
+          | buf[end - 2] << 16
+          | buf[end - 1] << 24) >>> 0;
+}
+
+/**
+ * Reads fixed 32 bits as an unsigned 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.fixed32 = function read_fixed32() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    return readFixed32_end(this.buf, this.pos += 4);
 };
 
-var reader_buffer = BufferReader;
-
-// extends Reader
-var Reader = reader;
-(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
-
-var util$1 = requireMinimal();
-
-/**
- * Constructs a new buffer reader instance.
- * @classdesc Wire format reader using node buffers.
- * @extends Reader
- * @constructor
- * @param {Buffer} buffer Buffer to read from
- */
-function BufferReader(buffer) {
-    Reader.call(this, buffer);
-
-    /**
-     * Read buffer.
-     * @name BufferReader#buf
-     * @type {Buffer}
-     */
-}
-
-BufferReader._configure = function () {
-    /* istanbul ignore else */
-    if (util$1.Buffer)
-        BufferReader.prototype._slice = util$1.Buffer.prototype.slice;
-};
-
-
-/**
- * @override
- */
-BufferReader.prototype.string = function read_string_buffer() {
-    var len = this.uint32(); // modifies pos
-    return this.buf.utf8Slice
-        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
-        : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
-};
-
-/**
- * Reads a sequence of bytes preceeded by its length as a varint.
- * @name BufferReader#bytes
- * @function
- * @returns {Buffer} Value read
- */
-
+/**
+ * Reads fixed 32 bits as a signed 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader$1.prototype.sfixed32 = function read_sfixed32() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    return readFixed32_end(this.buf, this.pos += 4) | 0;
+};
+
+/* eslint-disable no-invalid-this */
+
+function readFixed64(/* this: Reader */) {
+
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 8);
+
+    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+}
+
+/* eslint-enable no-invalid-this */
+
+/**
+ * Reads fixed 64 bits.
+ * @name Reader#fixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads zig-zag encoded fixed 64 bits.
+ * @name Reader#sfixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a float (32 bit) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader$1.prototype.float = function read_float() {
+
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    var value = util$2.float.readFloatLE(this.buf, this.pos);
+    this.pos += 4;
+    return value;
+};
+
+/**
+ * Reads a double (64 bit float) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader$1.prototype.double = function read_double() {
+
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 4);
+
+    var value = util$2.float.readDoubleLE(this.buf, this.pos);
+    this.pos += 8;
+    return value;
+};
+
+/**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @returns {Uint8Array} Value read
+ */
+Reader$1.prototype.bytes = function read_bytes() {
+    var length = this.uint32(),
+        start  = this.pos,
+        end    = this.pos + length;
+
+    /* istanbul ignore if */
+    if (end > this.len)
+        throw indexOutOfRange(this, length);
+
+    this.pos += length;
+    if (Array.isArray(this.buf)) // plain array
+        return this.buf.slice(start, end);
+
+    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1
+        var nativeBuffer = util$2.Buffer;
+        return nativeBuffer
+            ? nativeBuffer.alloc(0)
+            : new this.buf.constructor(0);
+    }
+    return this._slice.call(this.buf, start, end);
+};
+
+/**
+ * Reads a string preceeded by its byte length as a varint.
+ * @returns {string} Value read
+ */
+Reader$1.prototype.string = function read_string() {
+    var bytes = this.bytes();
+    return utf8.read(bytes, 0, bytes.length);
+};
+
+/**
+ * Skips the specified number of bytes if specified, otherwise skips a varint.
+ * @param {number} [length] Length if known, otherwise a varint is assumed
+ * @returns {Reader} `this`
+ */
+Reader$1.prototype.skip = function skip(length) {
+    if (typeof length === "number") {
+        /* istanbul ignore if */
+        if (this.pos + length > this.len)
+            throw indexOutOfRange(this, length);
+        this.pos += length;
+    } else {
+        do {
+            /* istanbul ignore if */
+            if (this.pos >= this.len)
+                throw indexOutOfRange(this);
+        } while (this.buf[this.pos++] & 128);
+    }
+    return this;
+};
+
+/**
+ * Skips the next element of the specified wire type.
+ * @param {number} wireType Wire type received
+ * @returns {Reader} `this`
+ */
+Reader$1.prototype.skipType = function(wireType) {
+    switch (wireType) {
+        case 0:
+            this.skip();
+            break;
+        case 1:
+            this.skip(8);
+            break;
+        case 2:
+            this.skip(this.uint32());
+            break;
+        case 3:
+            while ((wireType = this.uint32() & 7) !== 4) {
+                this.skipType(wireType);
+            }
+            break;
+        case 5:
+            this.skip(4);
+            break;
+
+        /* istanbul ignore next */
+        default:
+            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+    }
+    return this;
+};
+
+Reader$1._configure = function(BufferReader_) {
+    BufferReader$1 = BufferReader_;
+    Reader$1.create = create();
+    BufferReader$1._configure();
+
+    var fn = util$2.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
+    util$2.merge(Reader$1.prototype, {
+
+        int64: function read_int64() {
+            return readLongVarint.call(this)[fn](false);
+        },
+
+        uint64: function read_uint64() {
+            return readLongVarint.call(this)[fn](true);
+        },
+
+        sint64: function read_sint64() {
+            return readLongVarint.call(this).zzDecode()[fn](false);
+        },
+
+        fixed64: function read_fixed64() {
+            return readFixed64.call(this)[fn](true);
+        },
+
+        sfixed64: function read_sfixed64() {
+            return readFixed64.call(this)[fn](false);
+        }
+
+    });
+};
+
+var reader_buffer = BufferReader;
+
+// extends Reader
+var Reader = reader;
+(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+
+var util$1 = requireMinimal();
+
+/**
+ * Constructs a new buffer reader instance.
+ * @classdesc Wire format reader using node buffers.
+ * @extends Reader
+ * @constructor
+ * @param {Buffer} buffer Buffer to read from
+ */
+function BufferReader(buffer) {
+    Reader.call(this, buffer);
+
+    /**
+     * Read buffer.
+     * @name BufferReader#buf
+     * @type {Buffer}
+     */
+}
+
+BufferReader._configure = function () {
+    /* istanbul ignore else */
+    if (util$1.Buffer)
+        BufferReader.prototype._slice = util$1.Buffer.prototype.slice;
+};
+
+
+/**
+ * @override
+ */
+BufferReader.prototype.string = function read_string_buffer() {
+    var len = this.uint32(); // modifies pos
+    return this.buf.utf8Slice
+        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
+        : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+};
+
+/**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @name BufferReader#bytes
+ * @function
+ * @returns {Buffer} Value read
+ */
+
 BufferReader._configure();
 
 var rpc = {};
 
-var service = Service;
-
-var util = requireMinimal();
-
-// Extends EventEmitter
-(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
-
-/**
- * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
- *
- * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
- * @typedef rpc.ServiceMethodCallback
- * @template TRes extends Message<TRes>
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {TRes} [response] Response message
- * @returns {undefined}
- */
-
-/**
- * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
- * @typedef rpc.ServiceMethod
- * @template TReq extends Message<TReq>
- * @template TRes extends Message<TRes>
- * @type {function}
- * @param {TReq|Properties<TReq>} request Request message or plain object
- * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
- * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
- */
-
-/**
- * Constructs a new RPC service instance.
- * @classdesc An RPC service as returned by {@link Service#create}.
- * @exports rpc.Service
- * @extends util.EventEmitter
- * @constructor
- * @param {RPCImpl} rpcImpl RPC implementation
- * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
- * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
- */
-function Service(rpcImpl, requestDelimited, responseDelimited) {
-
-    if (typeof rpcImpl !== "function")
-        throw TypeError("rpcImpl must be a function");
-
-    util.EventEmitter.call(this);
-
-    /**
-     * RPC implementation. Becomes `null` once the service is ended.
-     * @type {RPCImpl|null}
-     */
-    this.rpcImpl = rpcImpl;
-
-    /**
-     * Whether requests are length-delimited.
-     * @type {boolean}
-     */
-    this.requestDelimited = Boolean(requestDelimited);
-
-    /**
-     * Whether responses are length-delimited.
-     * @type {boolean}
-     */
-    this.responseDelimited = Boolean(responseDelimited);
-}
-
-/**
- * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
- * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
- * @param {Constructor<TReq>} requestCtor Request constructor
- * @param {Constructor<TRes>} responseCtor Response constructor
- * @param {TReq|Properties<TReq>} request Request message or plain object
- * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
- * @returns {undefined}
- * @template TReq extends Message<TReq>
- * @template TRes extends Message<TRes>
- */
-Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
-
-    if (!request)
-        throw TypeError("request must be specified");
-
-    var self = this;
-    if (!callback)
-        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
-
-    if (!self.rpcImpl) {
-        setTimeout(function() { callback(Error("already ended")); }, 0);
-        return undefined;
-    }
-
-    try {
-        return self.rpcImpl(
-            method,
-            requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
-            function rpcCallback(err, response) {
-
-                if (err) {
-                    self.emit("error", err, method);
-                    return callback(err);
-                }
-
-                if (response === null) {
-                    self.end(/* endedByRPC */ true);
-                    return undefined;
-                }
-
-                if (!(response instanceof responseCtor)) {
-                    try {
-                        response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
-                    } catch (err) {
-                        self.emit("error", err, method);
-                        return callback(err);
-                    }
-                }
-
-                self.emit("data", response, method);
-                return callback(null, response);
-            }
-        );
-    } catch (err) {
-        self.emit("error", err, method);
-        setTimeout(function() { callback(err); }, 0);
-        return undefined;
-    }
-};
-
-/**
- * Ends this service and emits the `end` event.
- * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
- * @returns {rpc.Service} `this`
- */
-Service.prototype.end = function end(endedByRPC) {
-    if (this.rpcImpl) {
-        if (!endedByRPC) // signal end to rpcImpl
-            this.rpcImpl(null, null, null);
-        this.rpcImpl = null;
-        this.emit("end").off();
-    }
-    return this;
+var service = Service;
+
+var util = requireMinimal();
+
+// Extends EventEmitter
+(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+
+/**
+ * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
+ *
+ * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
+ * @typedef rpc.ServiceMethodCallback
+ * @template TRes extends Message<TRes>
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {TRes} [response] Response message
+ * @returns {undefined}
+ */
+
+/**
+ * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
+ * @typedef rpc.ServiceMethod
+ * @template TReq extends Message<TReq>
+ * @template TRes extends Message<TRes>
+ * @type {function}
+ * @param {TReq|Properties<TReq>} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
+ * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
+ */
+
+/**
+ * Constructs a new RPC service instance.
+ * @classdesc An RPC service as returned by {@link Service#create}.
+ * @exports rpc.Service
+ * @extends util.EventEmitter
+ * @constructor
+ * @param {RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+function Service(rpcImpl, requestDelimited, responseDelimited) {
+
+    if (typeof rpcImpl !== "function")
+        throw TypeError("rpcImpl must be a function");
+
+    util.EventEmitter.call(this);
+
+    /**
+     * RPC implementation. Becomes `null` once the service is ended.
+     * @type {RPCImpl|null}
+     */
+    this.rpcImpl = rpcImpl;
+
+    /**
+     * Whether requests are length-delimited.
+     * @type {boolean}
+     */
+    this.requestDelimited = Boolean(requestDelimited);
+
+    /**
+     * Whether responses are length-delimited.
+     * @type {boolean}
+     */
+    this.responseDelimited = Boolean(responseDelimited);
+}
+
+/**
+ * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
+ * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
+ * @param {Constructor<TReq>} requestCtor Request constructor
+ * @param {Constructor<TRes>} responseCtor Response constructor
+ * @param {TReq|Properties<TReq>} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
+ * @returns {undefined}
+ * @template TReq extends Message<TReq>
+ * @template TRes extends Message<TRes>
+ */
+Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+
+    if (!request)
+        throw TypeError("request must be specified");
+
+    var self = this;
+    if (!callback)
+        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
+
+    if (!self.rpcImpl) {
+        setTimeout(function() { callback(Error("already ended")); }, 0);
+        return undefined;
+    }
+
+    try {
+        return self.rpcImpl(
+            method,
+            requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
+            function rpcCallback(err, response) {
+
+                if (err) {
+                    self.emit("error", err, method);
+                    return callback(err);
+                }
+
+                if (response === null) {
+                    self.end(/* endedByRPC */ true);
+                    return undefined;
+                }
+
+                if (!(response instanceof responseCtor)) {
+                    try {
+                        response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
+                    } catch (err) {
+                        self.emit("error", err, method);
+                        return callback(err);
+                    }
+                }
+
+                self.emit("data", response, method);
+                return callback(null, response);
+            }
+        );
+    } catch (err) {
+        self.emit("error", err, method);
+        setTimeout(function() { callback(err); }, 0);
+        return undefined;
+    }
+};
+
+/**
+ * Ends this service and emits the `end` event.
+ * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
+ * @returns {rpc.Service} `this`
+ */
+Service.prototype.end = function end(endedByRPC) {
+    if (this.rpcImpl) {
+        if (!endedByRPC) // signal end to rpcImpl
+            this.rpcImpl(null, null, null);
+        this.rpcImpl = null;
+        this.emit("end").off();
+    }
+    return this;
 };
 
 (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}
-	 */
-
+
+	/**
+	 * 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         = 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
+	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));
 
@@ -3115,23 +3115,13 @@ const UpstreamMessage = $root.UpstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * SendToGroupMessage _ackId.
-         * @member {"ackId"|undefined} _ackId
-         * @memberof UpstreamMessage.SendToGroupMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(SendToGroupMessage.prototype, "_ackId", {
             get: $util.oneOfGetter($oneOfFields = ["ackId"]),
             set: $util.oneOfSetter($oneOfFields)
         });
 
-        /**
-         * SendToGroupMessage _noEcho.
-         * @member {"noEcho"|undefined} _noEcho
-         * @memberof UpstreamMessage.SendToGroupMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(SendToGroupMessage.prototype, "_noEcho", {
             get: $util.oneOfGetter($oneOfFields = ["noEcho"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -3425,12 +3415,7 @@ const UpstreamMessage = $root.UpstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * EventMessage _ackId.
-         * @member {"ackId"|undefined} _ackId
-         * @memberof UpstreamMessage.EventMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(EventMessage.prototype, "_ackId", {
             get: $util.oneOfGetter($oneOfFields = ["ackId"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -3698,12 +3683,7 @@ const UpstreamMessage = $root.UpstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * JoinGroupMessage _ackId.
-         * @member {"ackId"|undefined} _ackId
-         * @memberof UpstreamMessage.JoinGroupMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(JoinGroupMessage.prototype, "_ackId", {
             get: $util.oneOfGetter($oneOfFields = ["ackId"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -3951,12 +3931,7 @@ const UpstreamMessage = $root.UpstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * LeaveGroupMessage _ackId.
-         * @member {"ackId"|undefined} _ackId
-         * @memberof UpstreamMessage.LeaveGroupMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(LeaveGroupMessage.prototype, "_ackId", {
             get: $util.oneOfGetter($oneOfFields = ["ackId"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -4727,12 +4702,7 @@ const DownstreamMessage = $root.DownstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * AckMessage _error.
-         * @member {"error"|undefined} _error
-         * @memberof DownstreamMessage.AckMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(AckMessage.prototype, "_error", {
             get: $util.oneOfGetter($oneOfFields = ["error"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -5250,23 +5220,13 @@ const DownstreamMessage = $root.DownstreamMessage = (() => {
         // OneOf field names bound to virtual getters and setters
         let $oneOfFields;
 
-        /**
-         * DataMessage _group.
-         * @member {"group"|undefined} _group
-         * @memberof DownstreamMessage.DataMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(DataMessage.prototype, "_group", {
             get: $util.oneOfGetter($oneOfFields = ["group"]),
             set: $util.oneOfSetter($oneOfFields)
         });
 
-        /**
-         * DataMessage _sequenceId.
-         * @member {"sequenceId"|undefined} _sequenceId
-         * @memberof DownstreamMessage.DataMessage
-         * @instance
-         */
+        // Virtual OneOf for proto3 optional field
         Object.defineProperty(DataMessage.prototype, "_sequenceId", {
             get: $util.oneOfGetter($oneOfFields = ["sequenceId"]),
             set: $util.oneOfSetter($oneOfFields)
@@ -6803,7 +6763,7 @@ const google = $root.google = (() => {
 })();
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 /**
  * The "protobuf.reliable.webpubsub.azure.v1" protocol
  */
@@ -6989,7 +6949,7 @@ class WebPubSubProtobufProtocolBase {
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 /**
  * The "protobuf.reliable.webpubsub.azure.v1" protocol
  */
@@ -7021,7 +6981,7 @@ class WebPubSubProtobufProtocolImpl {
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 /**
  * The "protobuf.reliable.webpubsub.azure.v1" protocol
  */
@@ -7053,7 +7013,7 @@ class WebPubSubProtobufReliableProtocolImpl {
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+// Licensed under the MIT License.
 /**
  * Return the "protobuf.webpubsub.azure.v1" protocol
  */