@openclaw/feishu 2026.7.2-beta.7 → 2026.7.33

package/node_modules/@larksuiteoapi/node-sdk/node_modules/protobufjs/dist/minimal/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.7.1 (c) 2016, daniel wirtz
- * compiled mon, 13 jul 2026 11:04:12 utc
+ * protobuf.js v7.6.3 (c) 2016, daniel wirtz
+ * compiled tue, 09 jun 2026 20:47:47 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -38,7 +38,824 @@
         module.exports = protobuf;
 
 })/* end of prelude */({1:[function(require,module,exports){
+"use strict";
+module.exports = asPromise;
+
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+function asPromise(fn, ctx/*, varargs */) {
+    var params  = new Array(arguments.length - 1),
+        offset  = 0,
+        index   = 2,
+        pending = true;
+    while (index < arguments.length)
+        params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err/*, varargs */) {
+            if (pending) {
+                pending = false;
+                if (err)
+                    reject(err);
+                else {
+                    var params = new Array(arguments.length - 1),
+                        offset = 0;
+                    while (offset < params.length)
+                        params[offset++] = arguments[offset];
+                    resolve.apply(null, params);
+                }
+            }
+        };
+        try {
+            fn.apply(ctx || null, params);
+        } catch (err) {
+            if (pending) {
+                pending = false;
+                reject(err);
+            }
+        }
+    });
+}
+
+},{}],2:[function(require,module,exports){
+"use strict";
+
+/**
+ * A minimal base64 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var base64 = exports;
+
+/**
+ * Calculates the byte length of a base64 encoded string.
+ * @param {string} string Base64 encoded string
+ * @returns {number} Byte length
+ */
+base64.length = function length(string) {
+    var p = string.length;
+    if (!p)
+        return 0;
+    var n = 0;
+    while (--p % 4 > 1 && string.charAt(p) === "=")
+        ++n;
+    return Math.ceil(string.length * 3) / 4 - n;
+};
+
+// Base64 encoding table
+var b64 = new Array(64);
+
+// Base64 decoding table
+var s64 = new Array(123);
+
+// 65..90, 97..122, 48..57, 43, 47
+for (var i = 0; i < 64;)
+    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+/**
+ * Encodes a buffer to a base64 encoded string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} Base64 encoded string
+ */
+base64.encode = function encode(buffer, start, end) {
+    var parts = null,
+        chunk = [];
+    var i = 0, // output index
+        j = 0, // goto index
+        t;     // temporary
+    while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+            case 0:
+                chunk[i++] = b64[b >> 2];
+                t = (b & 3) << 4;
+                j = 1;
+                break;
+            case 1:
+                chunk[i++] = b64[t | b >> 4];
+                t = (b & 15) << 2;
+                j = 2;
+                break;
+            case 2:
+                chunk[i++] = b64[t | b >> 6];
+                chunk[i++] = b64[b & 63];
+                j = 0;
+                break;
+        }
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+            i = 0;
+        }
+    }
+    if (j) {
+        chunk[i++] = b64[t];
+        chunk[i++] = 61;
+        if (j === 1)
+            chunk[i++] = 61;
+    }
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
+};
+
+var invalidEncoding = "invalid encoding";
+
+/**
+ * Decodes a base64 encoded string to a buffer.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Number of bytes written
+ * @throws {Error} If encoding is invalid
+ */
+base64.decode = function decode(string, buffer, offset) {
+    var start = offset;
+    var j = 0, // goto index
+        t;     // temporary
+    for (var i = 0; i < string.length;) {
+        var c = string.charCodeAt(i++);
+        if (c === 61 && j > 1)
+            break;
+        if ((c = s64[c]) === undefined)
+            throw Error(invalidEncoding);
+        switch (j) {
+            case 0:
+                t = c;
+                j = 1;
+                break;
+            case 1:
+                buffer[offset++] = t << 2 | (c & 48) >> 4;
+                t = c;
+                j = 2;
+                break;
+            case 2:
+                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+                t = c;
+                j = 3;
+                break;
+            case 3:
+                buffer[offset++] = (t & 3) << 6 | c;
+                j = 0;
+                break;
+        }
+    }
+    if (j === 1)
+        throw Error(invalidEncoding);
+    return offset - start;
+};
+
+/**
+ * Tests if the specified string appears to be base64 encoded.
+ * @param {string} string String to test
+ * @returns {boolean} `true` if probably base64 encoded, otherwise false
+ */
+base64.test = function test(string) {
+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+};
+
+},{}],3:[function(require,module,exports){
+"use strict";
+module.exports = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
+
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = Object.create(null);
+}
+
+/**
+ * Event listener as used by {@link util.EventEmitter}.
+ * @typedef EventEmitterListener
+ * @type {function}
+ * @param {...*} args Arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {EventEmitterListener} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {this} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
+
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {this} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = Object.create(null);
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            if (!listeners)
+                return this;
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {this} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};
+
+},{}],4:[function(require,module,exports){
+"use strict";
+
+module.exports = factory(factory);
+
+/**
+ * Reads / writes floats / doubles from / to buffers.
+ * @name util.float
+ * @namespace
+ */
+
+/**
+ * Writes a 32 bit float to a buffer using little endian byte order.
+ * @name util.float.writeFloatLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Writes a 32 bit float to a buffer using big endian byte order.
+ * @name util.float.writeFloatBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Reads a 32 bit float from a buffer using little endian byte order.
+ * @name util.float.readFloatLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Reads a 32 bit float from a buffer using big endian byte order.
+ * @name util.float.readFloatBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Writes a 64 bit double to a buffer using little endian byte order.
+ * @name util.float.writeDoubleLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Writes a 64 bit double to a buffer using big endian byte order.
+ * @name util.float.writeDoubleBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Reads a 64 bit double from a buffer using little endian byte order.
+ * @name util.float.readDoubleLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Reads a 64 bit double from a buffer using big endian byte order.
+ * @name util.float.readDoubleBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+// Factory function for the purpose of node-based testing in modified global environments
+function factory(exports) {
+
+    // float: typed array
+    if (typeof Float32Array !== "undefined") (function() {
+
+        var f32 = new Float32Array([ -0 ]),
+            f8b = new Uint8Array(f32.buffer),
+            le  = f8b[3] === 128;
+
+        function writeFloat_f32_cpy(val, buf, pos) {
+            f32[0] = val;
+            buf[pos    ] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+        }
+
+        function writeFloat_f32_rev(val, buf, pos) {
+            f32[0] = val;
+            buf[pos    ] = f8b[3];
+            buf[pos + 1] = f8b[2];
+            buf[pos + 2] = f8b[1];
+            buf[pos + 3] = f8b[0];
+        }
+
+        /* istanbul ignore next */
+        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+
+        function readFloat_f32_cpy(buf, pos) {
+            f8b[0] = buf[pos    ];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            return f32[0];
+        }
+
+        function readFloat_f32_rev(buf, pos) {
+            f8b[3] = buf[pos    ];
+            f8b[2] = buf[pos + 1];
+            f8b[1] = buf[pos + 2];
+            f8b[0] = buf[pos + 3];
+            return f32[0];
+        }
+
+        /* istanbul ignore next */
+        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+
+    // float: ieee754
+    })(); else (function() {
+
+        function writeFloat_ieee754(writeUint, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0)
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
+            else if (isNaN(val))
+                writeUint(2143289344, buf, pos);
+            else if (val > 3.4028234663852886e+38) // +-Infinity
+                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+            else if (val < 1.1754943508222875e-38) // denormal
+                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
+            else {
+                var exponent = Math.floor(Math.log(val) / Math.LN2),
+                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+            }
+        }
+
+        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+
+        function readFloat_ieee754(readUint, buf, pos) {
+            var uint = readUint(buf, pos),
+                sign = (uint >> 31) * 2 + 1,
+                exponent = uint >>> 23 & 255,
+                mantissa = uint & 8388607;
+            return exponent === 255
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 1.401298464324817e-45 * mantissa
+                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+        }
+
+        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+
+    })();
+
+    // double: typed array
+    if (typeof Float64Array !== "undefined") (function() {
+
+        var f64 = new Float64Array([-0]),
+            f8b = new Uint8Array(f64.buffer),
+            le  = f8b[7] === 128;
+
+        function writeDouble_f64_cpy(val, buf, pos) {
+            f64[0] = val;
+            buf[pos    ] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+            buf[pos + 4] = f8b[4];
+            buf[pos + 5] = f8b[5];
+            buf[pos + 6] = f8b[6];
+            buf[pos + 7] = f8b[7];
+        }
+
+        function writeDouble_f64_rev(val, buf, pos) {
+            f64[0] = val;
+            buf[pos    ] = f8b[7];
+            buf[pos + 1] = f8b[6];
+            buf[pos + 2] = f8b[5];
+            buf[pos + 3] = f8b[4];
+            buf[pos + 4] = f8b[3];
+            buf[pos + 5] = f8b[2];
+            buf[pos + 6] = f8b[1];
+            buf[pos + 7] = f8b[0];
+        }
+
+        /* istanbul ignore next */
+        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+
+        function readDouble_f64_cpy(buf, pos) {
+            f8b[0] = buf[pos    ];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            f8b[4] = buf[pos + 4];
+            f8b[5] = buf[pos + 5];
+            f8b[6] = buf[pos + 6];
+            f8b[7] = buf[pos + 7];
+            return f64[0];
+        }
+
+        function readDouble_f64_rev(buf, pos) {
+            f8b[7] = buf[pos    ];
+            f8b[6] = buf[pos + 1];
+            f8b[5] = buf[pos + 2];
+            f8b[4] = buf[pos + 3];
+            f8b[3] = buf[pos + 4];
+            f8b[2] = buf[pos + 5];
+            f8b[1] = buf[pos + 6];
+            f8b[0] = buf[pos + 7];
+            return f64[0];
+        }
+
+        /* istanbul ignore next */
+        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+
+    // double: ieee754
+    })(); else (function() {
+
+        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0) {
+                writeUint(0, buf, pos + off0);
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
+            } else if (isNaN(val)) {
+                writeUint(0, buf, pos + off0);
+                writeUint(2146959360, buf, pos + off1);
+            } else if (val > 1.7976931348623157e+308) { // +-Infinity
+                writeUint(0, buf, pos + off0);
+                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+            } else {
+                var mantissa;
+                if (val < 2.2250738585072014e-308) { // denormal
+                    mantissa = val / 5e-324;
+                    writeUint(mantissa >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+                } else {
+                    var exponent = Math.floor(Math.log(val) / Math.LN2);
+                    if (exponent === 1024)
+                        exponent = 1023;
+                    mantissa = val * Math.pow(2, -exponent);
+                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+                }
+            }
+        }
+
+        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+
+        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+            var lo = readUint(buf, pos + off0),
+                hi = readUint(buf, pos + off1);
+            var sign = (hi >> 31) * 2 + 1,
+                exponent = hi >>> 20 & 2047,
+                mantissa = 4294967296 * (hi & 1048575) + lo;
+            return exponent === 2047
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 5e-324 * mantissa
+                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+        }
+
+        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+
+    })();
+
+    return exports;
+}
+
+// uint helpers
+
+function writeUintLE(val, buf, pos) {
+    buf[pos    ] =  val        & 255;
+    buf[pos + 1] =  val >>> 8  & 255;
+    buf[pos + 2] =  val >>> 16 & 255;
+    buf[pos + 3] =  val >>> 24;
+}
+
+function writeUintBE(val, buf, pos) {
+    buf[pos    ] =  val >>> 24;
+    buf[pos + 1] =  val >>> 16 & 255;
+    buf[pos + 2] =  val >>> 8  & 255;
+    buf[pos + 3] =  val        & 255;
+}
+
+function readUintLE(buf, pos) {
+    return (buf[pos    ]
+          | buf[pos + 1] << 8
+          | buf[pos + 2] << 16
+          | buf[pos + 3] << 24) >>> 0;
+}
+
+function readUintBE(buf, pos) {
+    return (buf[pos    ] << 24
+          | buf[pos + 1] << 16
+          | buf[pos + 2] << 8
+          | buf[pos + 3]) >>> 0;
+}
+
+},{}],5:[function(require,module,exports){
+"use strict";
+module.exports = inquire;
+
+/**
+ * Requires a module only if available.
+ * @memberof util
+ * @param {string} moduleName Module to require
+ * @returns {?Object} Required module if available and not empty, otherwise `null`
+ * @deprecated Legacy optional require helper. Will be removed in a future release.
+ */
+function inquire(moduleName) {
+  try {
+    if (typeof require !== "function") {
+      return null;
+    }
+    var mod = require(moduleName);
+    if (mod && (mod.length || Object.keys(mod).length)) return mod;
+    return null;
+  } catch (err) {
+    // ignore
+    return null;
+  }
+}
+
+/*
+// maybe worth a shot to prevent renaming issues:
+// see: https://github.com/webpack/webpack/blob/master/lib/dependencies/CommonJsRequireDependencyParserPlugin.js
+// triggers on:
+// - expression require.cache
+// - expression require (???)
+// - call require
+// - call require:commonjs:item
+// - call require:commonjs:context
+
+Object.defineProperty(Function.prototype, "__self", { get: function() { return this; } });
+var r = require.__self;
+delete Function.prototype.__self;
+*/
+
+},{}],6:[function(require,module,exports){
+"use strict";
+module.exports = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+function pool(alloc, slice, size) {
+    var SIZE   = size || 8192;
+    var MAX    = SIZE >>> 1;
+    var slab   = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX)
+            return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+            offset = (offset | 7) + 1;
+        return buf;
+    };
+}
+
+},{}],7:[function(require,module,exports){
+"use strict";
+
+/**
+ * A minimal UTF8 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var utf8 = exports,
+    replacementChar = "\ufffd";
+
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+utf8.length = function utf8_length(string) {
+    var len = 0,
+        c = 0;
+    for (var i = 0; i < string.length; ++i) {
+        c = string.charCodeAt(i);
+        if (c < 128)
+            len += 1;
+        else if (c < 2048)
+            len += 2;
+        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+            ++i;
+            len += 4;
+        } else
+            len += 3;
+    }
+    return len;
+};
+
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+utf8.read = function utf8_read(buffer, start, end) {
+    if (end - start < 1) {
+        return "";
+    }
+
+    var str = "";
+    for (var i = start; i < end;) {
+        var t = buffer[i++];
+        if (t <= 0x7F) {
+            str += String.fromCharCode(t);
+        } else if (t >= 0xC0 && t < 0xE0) {
+            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;
+            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;
+        } else if (t >= 0xE0 && t < 0xF0) {
+            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
+            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;
+        } else if (t >= 0xF0) {
+            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
+            if (t2 < 0x10000 || t2 > 0x10FFFF)
+                str += replacementChar;
+            else {
+                t2 -= 0x10000;
+                str += String.fromCharCode(0xD800 + (t2 >> 10));
+                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));
+            }
+        }
+    }
+
+    return str;
+};
+
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+utf8.write = function utf8_write(string, buffer, offset) {
+    var start = offset,
+        c1, // character 1
+        c2; // character 2
+    for (var i = 0; i < string.length; ++i) {
+        c1 = string.charCodeAt(i);
+        if (c1 < 128) {
+            buffer[offset++] = c1;
+        } else if (c1 < 2048) {
+            buffer[offset++] = c1 >> 6       | 192;
+            buffer[offset++] = c1       & 63 | 128;
+        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+            ++i;
+            buffer[offset++] = c1 >> 18      | 240;
+            buffer[offset++] = c1 >> 12 & 63 | 128;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        } else {
+            buffer[offset++] = c1 >> 12      | 224;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        }
+    }
+    return offset - start;
+};
+
+},{}],8:[function(require,module,exports){
 "use strict";
+var protobuf = exports;
 
 /**
  * Build type, one of `"full"`, `"light"` or `"minimal"`.
@@ -46,19 +863,19 @@
  * @type {string}
  * @const
  */
-exports.build = "minimal";
+protobuf.build = "minimal";
 
 // Serialization
-exports.Writer       = require(15);
-exports.BufferWriter = require(16);
-exports.Reader       = require(2);
-exports.BufferReader = require(3);
+protobuf.Writer       = require(16);
+protobuf.BufferWriter = require(17);
+protobuf.Reader       = require(9);
+protobuf.BufferReader = require(10);
 
 // Utility
-exports.util         = require(12);
-exports.rpc          = require(5);
-exports.roots        = require(4);
-exports.configure    = configure;
+protobuf.util         = require(15);
+protobuf.rpc          = require(12);
+protobuf.roots        = require(11);
+protobuf.configure    = configure;
 
 /* istanbul ignore next */
 /**
@@ -66,19 +883,19 @@ exports.configure    = configure;
  * @returns {undefined}
  */
 function configure() {
-    exports.util.LongBits._configure(exports.util.Long);
-    exports.Writer._configure(exports.BufferWriter);
-    exports.Reader._configure(exports.BufferReader);
+    protobuf.util._configure();
+    protobuf.Writer._configure(protobuf.BufferWriter);
+    protobuf.Reader._configure(protobuf.BufferReader);
 }
 
 // Set up buffer utility according to the environment
 configure();
 
-},{"12":12,"15":15,"16":16,"2":2,"3":3,"4":4,"5":5}],2:[function(require,module,exports){
+},{"10":10,"11":11,"12":12,"15":15,"16":16,"17":17,"9":9}],9:[function(require,module,exports){
 "use strict";
 module.exports = Reader;
 
-var util      = require(12);
+var util      = require(15);
 
 var BufferReader; // cyclic
 
@@ -92,7 +909,7 @@ function indexOutOfRange(reader, writeLength) {
 
 /**
  * Constructs a new reader instance using the specified buffer.
- * @classdesc Wire format reader using `Uint8Array`.
+ * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
  * @constructor
  * @param {Uint8Array} buffer Buffer to read from
  */
@@ -115,28 +932,20 @@ function Reader(buffer) {
      * @type {number}
      */
     this.len = buffer.length;
-
-    /**
-     * Cached DataView for packed reads.
-     * @type {DataView|null}
-     */
-    this.view = null;
-
-    /**
-     * Whether to discard unknown fields while decoding.
-     * @type {boolean}
-     */
-    this.discardUnknown = Reader.discardUnknown;
 }
 
-function create_array(buffer) {
-    // TODO: Remove plain array reader support in the next major release.
-    if (Array.isArray(buffer))
-        buffer = new Uint8Array(buffer);
-    if (buffer instanceof Uint8Array)
-        return new Reader(buffer);
-    throw Error("illegal buffer");
-}
+var create_array = typeof Uint8Array !== "undefined"
+    ? function create_typed_array(buffer) {
+        if (buffer instanceof Uint8Array || Array.isArray(buffer))
+            return new Reader(buffer);
+        throw Error("illegal buffer");
+    }
+    /* istanbul ignore next */
+    : function create_array(buffer) {
+        if (Array.isArray(buffer))
+            return new Reader(buffer);
+        throw Error("illegal buffer");
+    };
 
 var create = function create() {
     return util.Buffer
@@ -161,103 +970,30 @@ var create = function create() {
  */
 Reader.create = create();
 
-/**
- * Returns raw bytes from the backing buffer without advancing the reader.
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Uint8Array} Raw bytes
- */
-Reader.prototype.raw = function read_raw(start, end) {
-    return this.buf.subarray(start, end);
-};
+Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;
 
 /**
  * Reads a varint as an unsigned 32 bit value.
  * @function
  * @returns {number} Value read
  */
-Reader.prototype.uint32 = function read_uint32() {
-    var buf = this.buf,
-        pos = this.pos,
-        value = (buf[pos] & 127) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 127) << 7) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 127) << 14) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 127) << 21) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 15) << 28) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
+Reader.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;
 
-    for (var i = 0; i < 5; ++i) {
         /* istanbul ignore if */
-        if (pos >= this.len) {
-            this.pos = pos;
-            throw indexOutOfRange(this);
+        if ((this.pos += 5) > this.len) {
+            this.pos = this.len;
+            throw indexOutOfRange(this, 10);
         }
-        if (buf[pos++] < 128) {
-            this.pos = pos;
-            return value;
-        }
-    }
-    /* istanbul ignore next */
-    this.pos = pos;
-    throw Error("invalid varint encoding");
-};
-
-/**
- * Reads a field tag.
- * @function
- * @returns {number} Tag read
- */
-Reader.prototype.tag = function read_tag() {
-    var buf = this.buf,
-        pos = this.pos,
-        value = (buf[pos] & 127) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 127) << 7) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 127) << 14) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
         return value;
-    }
-    value = (value | (buf[pos] & 127) << 21) >>> 0;
-    if (buf[pos++] < 128) {
-        this.pos = pos;
-        return value;
-    }
-    value = (value | (buf[pos] & 15) << 28) >>> 0;
-    if (buf[pos] < 128 && (buf[pos] & 112) === 0) {
-        this.pos = pos + 1;
-        return value;
-    }
-
-    this.pos = pos + 1;
-    throw Error("invalid tag encoding");
-};
+    };
+})();
 
 /**
  * Reads a varint as a signed 32 bit value.
@@ -296,16 +1032,18 @@ function readLongVarint() {
             return bits;
         i = 0;
     } else {
-        for (; i < 4; ++i) {
+        for (; i < 3; ++i) {
             /* istanbul ignore if */
             if (this.pos >= this.len)
                 throw indexOutOfRange(this);
-            // 1st..4th
+            // 1st..3th
             bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
             if (this.buf[this.pos++] < 128)
                 return bits;
         }
-        throw indexOutOfRange(this);
+        // 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) {
@@ -357,20 +1095,7 @@ function readLongVarint() {
  * @returns {boolean} Value read
  */
 Reader.prototype.bool = function read_bool() {
-    var value = false,
-        b;
-    for (var i = 0; i < 10; ++i) {
-        /* istanbul ignore if */
-        if (this.pos >= this.len)
-            throw indexOutOfRange(this);
-        b = this.buf[this.pos++];
-        if (b & 127)
-            value = true;
-        if (b < 128)
-            return value;
-    }
-    /* istanbul ignore next */
-    throw Error("invalid varint encoding");
+    return this.uint32() !== 0;
 };
 
 function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
@@ -465,241 +1190,6 @@ Reader.prototype.double = function read_double() {
     return value;
 };
 
-/**
- * Reads a packed repeated field of unsigned 32 bit varints.
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.uint32s = function read_uint32s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.uint32());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of signed 32 bit varints.
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.int32s = function read_int32s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.int32());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of zig-zag encoded signed 32 bit varints.
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.sint32s = function read_sint32s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.sint32());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of booleans.
- * @param {boolean[]} [array] Array to read into; a new one is created if omitted
- * @returns {boolean[]} Array read into
- */
-Reader.prototype.bools = function read_bools(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.bool());
-    return array;
-};
-
-// The view allocation only pays off when amortized over enough reads
-var VIEW_THRESHOLD_FLOAT = 8,
-    VIEW_THRESHOLD_INT   = 128;
-
-function getLazyView(reader, count, threshold) {
-    var view = reader.view;
-    if (view || count < threshold)
-        return view;
-    var buf = reader.buf;
-    return reader.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-
-/**
- * Reads a packed repeated field of unsigned 32 bit fixed values.
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.fixed32s = function read_fixed32s(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 2, i = array.length, pos = this.pos;
-    array.length = i + count;
-    var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);
-    if (dv)
-        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getUint32(pos, true);
-    else {
-        var buf = this.buf;
-        for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4);
-    }
-    this.pos = pos;
-    if (pos !== end) throw indexOutOfRange(this, 4);
-    return array;
-};
-
-/**
- * Reads a packed repeated field of signed 32 bit fixed values.
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.sfixed32s = function read_sfixed32s(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 2, i = array.length, pos = this.pos;
-    array.length = i + count;
-    var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);
-    if (dv)
-        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getInt32(pos, true);
-    else {
-        var buf = this.buf;
-        for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4) | 0;
-    }
-    this.pos = pos;
-    if (pos !== end) throw indexOutOfRange(this, 4);
-    return array;
-};
-
-/**
- * Reads a packed repeated field of floats (32 bit).
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.floats = function read_floats(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 2, i = array.length, pos = this.pos;
-    array.length = i + count;
-    var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);
-    if (dv)
-        for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getFloat32(pos, true);
-    else {
-        var buf = this.buf;
-        for (var j = 0; j < count; ++j, pos += 4) array[i++] = util.float.readFloatLE(buf, pos);
-    }
-    this.pos = pos;
-    if (pos !== end) throw indexOutOfRange(this, 4);
-    return array;
-};
-
-/**
- * Reads a packed repeated field of doubles (64 bit float).
- * @param {number[]} [array] Array to read into; a new one is created if omitted
- * @returns {number[]} Array read into
- */
-Reader.prototype.doubles = function read_doubles(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 3, i = array.length, pos = this.pos;
-    array.length = i + count;
-    var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);
-    if (dv)
-        for (var k = 0; k < count; ++k, pos += 8) array[i++] = dv.getFloat64(pos, true);
-    else {
-        var buf = this.buf;
-        for (var j = 0; j < count; ++j, pos += 8) array[i++] = util.float.readDoubleLE(buf, pos);
-    }
-    this.pos = pos;
-    if (pos !== end) throw indexOutOfRange(this, 8);
-    return array;
-};
-
-/**
- * Reads a packed repeated field of unsigned 64 bit varints.
- * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
- * @returns {Array.<Long|number>} Array read into
- */
-Reader.prototype.uint64s = function read_uint64s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.uint64());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of signed 64 bit varints.
- * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
- * @returns {Array.<Long|number>} Array read into
- */
-Reader.prototype.int64s = function read_int64s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.int64());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of zig-zag encoded signed 64 bit varints.
- * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
- * @returns {Array.<Long|number>} Array read into
- */
-Reader.prototype.sint64s = function read_sint64s(array) {
-    if (array === undefined) array = [];
-    var end = this.uint32() + this.pos;
-    while (this.pos < end)
-        array.push(this.sint64());
-    return array;
-};
-
-/**
- * Reads a packed repeated field of unsigned 64 bit fixed values.
- * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
- * @returns {Array.<Long|number>} Array read into
- */
-Reader.prototype.fixed64s = function read_fixed64s(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len, i = array.length;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 3;
-    array.length = i + count; // 8 bytes per value, count is known
-    for (var j = 0; j < count; ++j)
-        array[i++] = this.fixed64();
-    if (this.pos !== end) throw indexOutOfRange(this, 8);
-    return array;
-};
-
-/**
- * Reads a packed repeated field of signed 64 bit fixed values.
- * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted
- * @returns {Array.<Long|number>} Array read into
- */
-Reader.prototype.sfixed64s = function read_sfixed64s(array) {
-    if (array === undefined) array = [];
-    var len = this.uint32(), end = this.pos + len, i = array.length;
-    /* istanbul ignore if */
-    if (end > this.len) throw indexOutOfRange(this, len);
-    var count = len >>> 3;
-    array.length = i + count; // 8 bytes per value, count is known
-    for (var j = 0; j < count; ++j)
-        array[i++] = this.sfixed64();
-    if (this.pos !== end) throw indexOutOfRange(this, 8);
-    return array;
-};
-
 /**
  * Reads a sequence of bytes preceeded by its length as a varint.
  * @returns {Uint8Array} Value read
@@ -713,8 +1203,17 @@ Reader.prototype.bytes = function read_bytes() {
     if (end > this.len)
         throw indexOutOfRange(this, length);
 
-    this.pos = end;
-    return this.raw(start, end);
+    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.Buffer;
+        return nativeBuffer
+            ? nativeBuffer.alloc(0)
+            : new this.buf.constructor(0);
+    }
+    return this._slice.call(this.buf, start, end);
 };
 
 /**
@@ -722,33 +1221,8 @@ Reader.prototype.bytes = function read_bytes() {
  * @returns {string} Value read
  */
 Reader.prototype.string = function read_string() {
-    var length = this.uint32(),
-        start  = this.pos,
-        end    = this.pos + length;
-
-    /* istanbul ignore if */
-    if (end > this.len)
-        throw indexOutOfRange(this, length);
-
-    this.pos = end;
-    return utf8.read(this.buf, start, end);
-};
-
-/**
- * Reads a string preceeded by its byte length as a varint, rejecting invalid UTF8.
- * @returns {string} Value read
- */
-Reader.prototype.stringVerify = function read_string_verify() {
-    var length = this.uint32(),
-        start  = this.pos,
-        end    = this.pos + length;
-
-    /* istanbul ignore if */
-    if (end > this.len)
-        throw indexOutOfRange(this, length);
-
-    this.pos = end;
-    return utf8.readStrict(this.buf, start, end);
+    var bytes = this.bytes();
+    return utf8.read(bytes, 0, bytes.length);
 };
 
 /**
@@ -778,25 +1252,16 @@ Reader.prototype.skip = function skip(length) {
  */
 Reader.recursionLimit = util.recursionLimit;
 
-/**
- * Whether readers discard unknown fields while decoding.
- * @type {boolean}
- */
-Reader.discardUnknown = true;
-
 /**
  * Skips the next element of the specified wire type.
  * @param {number} wireType Wire type received
  * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted
- * @param {number} [fieldNumber] Field number for validating group end tags
  * @returns {Reader} `this`
  */
-Reader.prototype.skipType = function(wireType, depth, fieldNumber) {
+Reader.prototype.skipType = function(wireType, depth) {
     if (depth === undefined) depth = 0;
     if (depth > Reader.recursionLimit)
-        throw Error("max depth exceeded");
-    if (fieldNumber === 0)
-        throw Error("illegal tag: field number 0");
+        throw Error("maximum nesting depth exceeded");
     switch (wireType) {
         case 0:
             this.skip();
@@ -808,18 +1273,8 @@ Reader.prototype.skipType = function(wireType, depth, fieldNumber) {
             this.skip(this.uint32());
             break;
         case 3:
-            while (true) {
-                var tag = this.tag();
-                var nestedField = tag >>> 3;
-                wireType = tag & 7;
-                if (!nestedField)
-                    throw Error("illegal tag: field number 0");
-                if (wireType === 4) {
-                    if (fieldNumber !== undefined && nestedField !== fieldNumber)
-                        throw Error("invalid end group tag");
-                    break;
-                }
-                this.skipType(wireType, depth + 1, nestedField);
+            while ((wireType = this.uint32() & 7) !== 4) {
+                this.skipType(wireType, depth + 1);
             }
             break;
         case 5:
@@ -864,22 +1319,15 @@ Reader._configure = function(BufferReader_) {
     });
 };
 
-},{"12":12}],3:[function(require,module,exports){
+},{"15":15}],10:[function(require,module,exports){
 "use strict";
 module.exports = BufferReader;
 
 // extends Reader
-var Reader = require(2);
-BufferReader.prototype = Object.create(Reader.prototype, {
-    constructor: {
-        value: BufferReader,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
+var Reader = require(9);
+(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 
-var util = require(12);
+var util = require(15);
 
 /**
  * Constructs a new buffer reader instance.
@@ -895,7 +1343,7 @@ function BufferReader(buffer) {
      * Read buffer.
      * @name BufferReader#buf
      * @type {Buffer}
-    */
+     */
 }
 
 BufferReader._configure = function () {
@@ -904,34 +1352,15 @@ BufferReader._configure = function () {
         BufferReader.prototype._slice = util.Buffer.prototype.slice;
 };
 
-/**
- * Returns raw bytes from the backing buffer without advancing the reader.
- * @name BufferReader#raw
- * @function
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Buffer} Raw bytes
- */
-BufferReader.prototype.raw = function read_raw_buffer(start, end) {
-    return this._slice.call(this.buf, start, end);
-};
 
 /**
  * @override
  */
 BufferReader.prototype.string = function read_string_buffer() {
-    var len = this.uint32(), // modifies pos
-        start = this.pos,
-        end = this.pos + len;
-
-    /* istanbul ignore if */
-    if (end > this.len)
-        throw RangeError("index out of range: " + this.pos + " + " + len + " > " + this.len);
-
-    this.pos = end;
+    var len = this.uint32(); // modifies pos
     return this.buf.utf8Slice
-        ? this.buf.utf8Slice(start, end)
-        : this.buf.toString("utf-8", start, end);
+        ? 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));
 };
 
 /**
@@ -943,7 +1372,7 @@ BufferReader.prototype.string = function read_string_buffer() {
 
 BufferReader._configure();
 
-},{"12":12,"2":2}],4:[function(require,module,exports){
+},{"15":15,"9":9}],11:[function(require,module,exports){
 "use strict";
 module.exports = Object.create(null);
 
@@ -963,7 +1392,7 @@ module.exports = Object.create(null);
  * var root = protobuf.roots["myroot"];
  */
 
-},{}],5:[function(require,module,exports){
+},{}],12:[function(require,module,exports){
 "use strict";
 
 /**
@@ -999,23 +1428,16 @@ var rpc = exports;
  * @returns {undefined}
  */
 
-rpc.Service = require(6);
+rpc.Service = require(13);
 
-},{"6":6}],6:[function(require,module,exports){
+},{"13":13}],13:[function(require,module,exports){
 "use strict";
 module.exports = Service;
 
-var util = require(12);
+var util = require(15);
 
 // Extends EventEmitter
-Service.prototype = Object.create(util.EventEmitter.prototype, {
-    constructor: {
-        value: Service,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
+(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -1034,16 +1456,10 @@ Service.prototype = Object.create(util.EventEmitter.prototype, {
  * @typedef rpc.ServiceMethod
  * @template TReq extends Message<TReq>
  * @template TRes extends Message<TRes>
- * @type {{
- *   (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
- *   (request: TReq|Properties<TReq>): Promise<TRes>;
- *   readonly name: string;
- *   readonly path: string;
- *   readonly requestType: string;
- *   readonly responseType: string;
- *   readonly requestStream: true|undefined;
- *   readonly responseStream: true|undefined;
- * }}
+ * @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`
  */
 
 /**
@@ -1158,724 +1574,97 @@ Service.prototype.end = function end(endedByRPC) {
     return this;
 };
 
-},{"12":12}],7:[function(require,module,exports){
+},{"15":15}],14:[function(require,module,exports){
 "use strict";
-module.exports = asPromise;
+module.exports = LongBits;
 
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
+var util = require(15);
 
 /**
- * Returns a promise from a node-style callback function.
+ * Constructs new long bits.
+ * @classdesc Helper class for working with the low and high bits of a 64 bit value.
  * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
-}
+ * @constructor
+ * @param {number} lo Low 32 bits, unsigned
+ * @param {number} hi High 32 bits, unsigned
+ */
+function LongBits(lo, hi) {
 
-},{}],8:[function(require,module,exports){
-"use strict";
+    // 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;
+}
 
 /**
- * A minimal base64 implementation for number arrays.
- * @memberof util
- * @namespace
+ * Zero bits.
+ * @memberof util.LongBits
+ * @type {util.LongBits}
  */
-var base64 = exports;
+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; };
 
 /**
- * Calculates the byte length of a base64 encoded string.
- * @param {string} string Base64 encoded string
- * @returns {number} Byte length
+ * Zero hash.
+ * @memberof util.LongBits
+ * @type {string}
  */
-base64.length = function length(string) {
-    var p = string.length;
-    if (!p)
-        return 0;
-    while (p > 0 && string.charAt(p - 1) === "=")
-        --p;
-    return Math.floor(p * 3 / 4);
-};
+var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
 
-// Base64 encoding table
-var b64 = new Array(64);
-
-// Base64 decoding table
-var s64 = new Array(123);
-
-// 65..90, 97..122, 48..57, 43, 47
-for (var i = 0; i < 64;)
-    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-s64[45] = 62; // - -> +
-s64[95] = 63; // _ -> /
-
-/**
- * Encodes a buffer to a base64 encoded string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} Base64 encoded string
- */
-base64.encode = function encode(buffer, start, end) {
-    var parts = null,
-        chunk = [];
-    var i = 0, // output index
-        j = 0, // goto index
-        t;     // temporary
-    while (start < end) {
-        var b = buffer[start++];
-        switch (j) {
-            case 0:
-                chunk[i++] = b64[b >> 2];
-                t = (b & 3) << 4;
-                j = 1;
-                break;
-            case 1:
-                chunk[i++] = b64[t | b >> 4];
-                t = (b & 15) << 2;
-                j = 2;
-                break;
-            case 2:
-                chunk[i++] = b64[t | b >> 6];
-                chunk[i++] = b64[b & 63];
-                j = 0;
-                break;
-        }
-        if (i > 8191) {
-            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-            i = 0;
+/**
+ * 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;
         }
     }
-    if (j) {
-        chunk[i++] = b64[t];
-        chunk[i++] = 61;
-        if (j === 1)
-            chunk[i++] = 61;
-    }
-    if (parts) {
-        if (i)
-            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-        return parts.join("");
-    }
-    return String.fromCharCode.apply(String, chunk.slice(0, i));
+    return new LongBits(lo, hi);
 };
 
-var invalidEncoding = "invalid encoding";
-
 /**
- * Decodes a base64 encoded string to a buffer.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Number of bytes written
- * @throws {Error} If encoding is invalid
+ * Constructs new long bits from a number, long or string.
+ * @param {Long|number|string} value Value
+ * @returns {util.LongBits} Instance
  */
-base64.decode = function decode(string, buffer, offset) {
-    var start = offset;
-    var j = 0, // goto index
-        t;     // temporary
-    for (var i = 0; i < string.length;) {
-        var c = string.charCodeAt(i++);
-        if (c === 61 && j > 1)
-            break;
-        if ((c = s64[c]) === undefined)
-            throw Error(invalidEncoding);
-        switch (j) {
-            case 0:
-                t = c;
-                j = 1;
-                break;
-            case 1:
-                buffer[offset++] = t << 2 | (c & 48) >> 4;
-                t = c;
-                j = 2;
-                break;
-            case 2:
-                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-                t = c;
-                j = 3;
-                break;
-            case 3:
-                buffer[offset++] = (t & 3) << 6 | c;
-                j = 0;
-                break;
-        }
+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));
     }
-    if (j === 1)
-        throw Error(invalidEncoding);
-    return offset - start;
-};
-
-var base64Re = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
-    base64UrlRe = /[-_]/,
-    base64UrlNoPaddingRe = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;
-
-/**
- * Tests if the specified string appears to be base64 encoded.
- * @param {string} string String to test
- * @returns {boolean} `true` if probably base64 encoded, otherwise false
- */
-base64.test = function test(string) {
-    return base64Re.test(string)
-        || base64UrlRe.test(string) && base64UrlNoPaddingRe.test(string);
-};
-
-},{}],9:[function(require,module,exports){
-"use strict";
-module.exports = EventEmitter;
-
-/**
- * Constructs a new event emitter instance.
- * @classdesc A minimal event emitter.
- * @memberof util
- * @constructor
- */
-function EventEmitter() {
-
-    /**
-     * Registered listeners.
-     * @type {Object.<string,*>}
-     * @private
-     */
-    this._listeners = Object.create(null);
-}
-
-/**
- * Event listener as used by {@link util.EventEmitter}.
- * @typedef EventEmitterListener
- * @type {function}
- * @param {...*} args Arguments
- * @returns {undefined}
- */
-
-/**
- * Registers an event listener.
- * @param {string} evt Event name
- * @param {EventEmitterListener} fn Listener
- * @param {*} [ctx] Listener context
- * @returns {this} `this`
- */
-EventEmitter.prototype.on = function on(evt, fn, ctx) {
-    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-        fn  : fn,
-        ctx : ctx || this
-    });
-    return this;
-};
-
-/**
- * Removes an event listener or any matching listeners if arguments are omitted.
- * @param {string} [evt] Event name. Removes all listeners if omitted.
- * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
- * @returns {this} `this`
- */
-EventEmitter.prototype.off = function off(evt, fn) {
-    if (evt === undefined)
-        this._listeners = Object.create(null);
-    else {
-        if (fn === undefined)
-            this._listeners[evt] = [];
-        else {
-            var listeners = this._listeners[evt];
-            if (!listeners)
-                return this;
-            for (var i = 0; i < listeners.length;)
-                if (listeners[i].fn === fn)
-                    listeners.splice(i, 1);
-                else
-                    ++i;
-        }
-    }
-    return this;
-};
-
-/**
- * Emits an event by calling its listeners with the specified arguments.
- * @param {string} evt Event name
- * @param {...*} args Arguments
- * @returns {this} `this`
- */
-EventEmitter.prototype.emit = function emit(evt) {
-    var listeners = this._listeners[evt];
-    if (listeners) {
-        var args = [],
-            i = 1;
-        for (; i < arguments.length;)
-            args.push(arguments[i++]);
-        for (i = 0; i < listeners.length;)
-            listeners[i].fn.apply(listeners[i++].ctx, args);
-    }
-    return this;
-};
-
-},{}],10:[function(require,module,exports){
-"use strict";
-
-module.exports = factory(factory);
-
-/**
- * Reads / writes floats / doubles from / to buffers.
- * @name util.float
- * @namespace
- */
-
-/**
- * Writes a 32 bit float to a buffer using little endian byte order.
- * @name util.float.writeFloatLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
-
-/**
- * Writes a 32 bit float to a buffer using big endian byte order.
- * @name util.float.writeFloatBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
-
-/**
- * Reads a 32 bit float from a buffer using little endian byte order.
- * @name util.float.readFloatLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
-
-/**
- * Reads a 32 bit float from a buffer using big endian byte order.
- * @name util.float.readFloatBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
-
-/**
- * Writes a 64 bit double to a buffer using little endian byte order.
- * @name util.float.writeDoubleLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
-
-/**
- * Writes a 64 bit double to a buffer using big endian byte order.
- * @name util.float.writeDoubleBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
-
-/**
- * Reads a 64 bit double from a buffer using little endian byte order.
- * @name util.float.readDoubleLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
-
-/**
- * Reads a 64 bit double from a buffer using big endian byte order.
- * @name util.float.readDoubleBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
-
-// Factory function for the purpose of node-based testing in modified global environments
-function factory(exports) {
-
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
-
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
-
-        function writeFloat_f32_cpy(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-        }
-
-        function writeFloat_f32_rev(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[3];
-            buf[pos + 1] = f8b[2];
-            buf[pos + 2] = f8b[1];
-            buf[pos + 3] = f8b[0];
-        }
-
-        /* istanbul ignore next */
-        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
-
-        function readFloat_f32_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            return f32[0];
-        }
-
-        function readFloat_f32_rev(buf, pos) {
-            f8b[3] = buf[pos    ];
-            f8b[2] = buf[pos + 1];
-            f8b[1] = buf[pos + 2];
-            f8b[0] = buf[pos + 3];
-            return f32[0];
-        }
-
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
-
-    // float: ieee754
-    })(); else (function() {
-
-        function writeFloat_ieee754(writeUint, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0)
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-            else if (isNaN(val))
-                writeUint(2143289344, buf, pos);
-            else if (val > 3.4028234663852886e+38) // +-Infinity
-                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-            else if (val < 1.1754943508222875e-38) // denormal
-                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-            else {
-                var exponent = Math.floor(Math.log(val) / Math.LN2),
-                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-            }
-        }
-
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
-
-        function readFloat_ieee754(readUint, buf, pos) {
-            var uint = readUint(buf, pos),
-                sign = (uint >> 31) * 2 + 1,
-                exponent = uint >>> 23 & 255,
-                mantissa = uint & 8388607;
-            return exponent === 255
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 1.401298464324817e-45 * mantissa
-                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
-        }
-
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
-
-    })();
-
-    // double: typed array
-    if (typeof Float64Array !== "undefined") (function() {
-
-        var f64 = new Float64Array([-0]),
-            f8b = new Uint8Array(f64.buffer),
-            le  = f8b[7] === 128;
-
-        function writeDouble_f64_cpy(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-            buf[pos + 4] = f8b[4];
-            buf[pos + 5] = f8b[5];
-            buf[pos + 6] = f8b[6];
-            buf[pos + 7] = f8b[7];
-        }
-
-        function writeDouble_f64_rev(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[7];
-            buf[pos + 1] = f8b[6];
-            buf[pos + 2] = f8b[5];
-            buf[pos + 3] = f8b[4];
-            buf[pos + 4] = f8b[3];
-            buf[pos + 5] = f8b[2];
-            buf[pos + 6] = f8b[1];
-            buf[pos + 7] = f8b[0];
-        }
-
-        /* istanbul ignore next */
-        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
-
-        function readDouble_f64_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            f8b[4] = buf[pos + 4];
-            f8b[5] = buf[pos + 5];
-            f8b[6] = buf[pos + 6];
-            f8b[7] = buf[pos + 7];
-            return f64[0];
-        }
-
-        function readDouble_f64_rev(buf, pos) {
-            f8b[7] = buf[pos    ];
-            f8b[6] = buf[pos + 1];
-            f8b[5] = buf[pos + 2];
-            f8b[4] = buf[pos + 3];
-            f8b[3] = buf[pos + 4];
-            f8b[2] = buf[pos + 5];
-            f8b[1] = buf[pos + 6];
-            f8b[0] = buf[pos + 7];
-            return f64[0];
-        }
-
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
-
-    // double: ieee754
-    })(); else (function() {
-
-        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0) {
-                writeUint(0, buf, pos + off0);
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-            } else if (isNaN(val)) {
-                writeUint(0, buf, pos + off0);
-                writeUint(2146959360, buf, pos + off1);
-            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-                writeUint(0, buf, pos + off0);
-                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-            } else {
-                var mantissa;
-                if (val < 2.2250738585072014e-308) { // denormal
-                    mantissa = val / 5e-324;
-                    writeUint(mantissa >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-                } else {
-                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-                    if (exponent === 1024)
-                        exponent = 1023;
-                    mantissa = val * Math.pow(2, -exponent);
-                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-                }
-            }
-        }
-
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
-
-        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
-            var lo = readUint(buf, pos + off0),
-                hi = readUint(buf, pos + off1);
-            var sign = (hi >> 31) * 2 + 1,
-                exponent = hi >>> 20 & 2047,
-                mantissa = 4294967296 * (hi & 1048575) + lo;
-            return exponent === 2047
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 5e-324 * mantissa
-                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
-        }
-
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
-
-    })();
-
-    return exports;
-}
-
-// uint helpers
-
-function writeUintLE(val, buf, pos) {
-    buf[pos    ] =  val        & 255;
-    buf[pos + 1] =  val >>> 8  & 255;
-    buf[pos + 2] =  val >>> 16 & 255;
-    buf[pos + 3] =  val >>> 24;
-}
-
-function writeUintBE(val, buf, pos) {
-    buf[pos    ] =  val >>> 24;
-    buf[pos + 1] =  val >>> 16 & 255;
-    buf[pos + 2] =  val >>> 8  & 255;
-    buf[pos + 3] =  val        & 255;
-}
-
-function readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
-
-function readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
-}
-
-},{}],11:[function(require,module,exports){
-"use strict";
-module.exports = LongBits;
-
-var Long;
-
-/**
- * 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 (typeof value === "string" || value instanceof String) {
-        /* istanbul ignore else */
-        if (Long)
-            value = Long.fromString(value);
-        else
-            return LongBits.fromNumber(parseInt(value, 10));
-    }
-    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
 };
 
 /**
@@ -1900,8 +1689,8 @@ LongBits.prototype.toNumber = function toNumber(unsigned) {
  * @returns {Long} Long
  */
 LongBits.prototype.toLong = function toLong(unsigned) {
-    return Long
-        ? new Long(this.lo | 0, this.hi | 0, Boolean(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) };
 };
@@ -1987,35 +1776,33 @@ LongBits.prototype.length = function length() {
          : part2 < 128 ? 9 : 10;
 };
 
-LongBits._configure = function(Long_) {
-    Long = Long_;
-};
-
-},{}],12:[function(require,module,exports){
+},{"15":15}],15:[function(require,module,exports){
 "use strict";
-/* global globalThis */
 var util = exports;
 
 // used to return a Promise where callback is omitted
-util.asPromise = require(7);
+util.asPromise = require(1);
 
 // converts to / from base64 encoded strings
-util.base64 = require(8);
+util.base64 = require(2);
 
 // base class of rpc.Service
-util.EventEmitter = require(9);
+util.EventEmitter = require(3);
 
 // float handling accross browsers
-util.float = require(10);
+util.float = require(4);
+
+// requires modules optionally and hides the call from bundlers
+util.inquire = require(5);
 
 // converts to / from utf8 encoded strings
-util.utf8 = require(14);
+util.utf8 = require(7);
 
 // provides a node-like buffer pool in the browser
-util.pool = require(13);
+util.pool = require(6);
 
 // utility to work with the low and high bits of a 64 bit value
-util.LongBits = require(11);
+util.LongBits = require(14);
 
 /**
  * Tests if the specified key can affect object prototypes.
@@ -2048,7 +1835,6 @@ util.isNode = Boolean(typeof global !== "undefined"
 util.global = util.isNode && global
            || typeof window !== "undefined" && window
            || typeof self   !== "undefined" && self
-           || typeof globalThis !== "undefined" && globalThis
            || this; // eslint-disable-line no-invalid-this
 
 /**
@@ -2131,59 +1917,43 @@ util.isSet = function isSet(obj, prop) {
 util.Buffer = (function() {
     try {
         var Buffer = util.global.Buffer;
-        // refuse to use non-node buffers if not explicitly assigned (perf reasons)
-        return Buffer.prototype.utf8Write || util.isNode ? Buffer : /* istanbul ignore next */ null;
+        // 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) {
-    var Buffer = util.Buffer;
     /* istanbul ignore next */
     return typeof sizeOrArray === "number"
-        ? Buffer
-            ? Buffer.allocUnsafe(sizeOrArray)
-            : new Uint8Array(sizeOrArray)
-        : Buffer
-            ? Buffer.from(sizeOrArray)
-            : new Uint8Array(sizeOrArray);
+        ? util.Buffer
+            ? util._Buffer_allocUnsafe(sizeOrArray)
+            : new util.Array(sizeOrArray)
+        : util.Buffer
+            ? util._Buffer_from(sizeOrArray)
+            : typeof Uint8Array === "undefined"
+                ? sizeOrArray
+                : new Uint8Array(sizeOrArray);
 };
 
 /**
- * Prepends a raw field tag to raw field data.
- * @param {number} id Field id
- * @param {number} wireType Wire type
- * @param {Uint8Array} data Raw field data
- * @returns {Uint8Array|Buffer} Raw field bytes
- * @ignore
- */
-util.rawField = function rawField(id, wireType, data) {
-    var out = [],
-        tag = id << 3 | wireType;
-    tag >>>= 0;
-    while (tag > 127) {
-        out.push(tag & 127 | 128);
-        tag >>>= 7;
-    }
-    out.push(tag);
-    for (var i = 0; i < data.length; ++i)
-        out.push(data[i]);
-    return util.newBuffer(out);
-};
-
-/**
- * Array implementation used in the browser.
+ * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
  * @type {Constructor<Uint8Array>}
- * @deprecated Use `Uint8Array` instead.
  */
-util.Array = Uint8Array;
+util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
 
 /**
  * Any compatible Long instance.
@@ -2215,7 +1985,7 @@ util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore
  * @type {RegExp}
  * @const
  */
-util.key2Re = /^(?:true|false|0|1)$/;
+util.key2Re = /^true|false|0|1$/;
 
 /**
  * Regular expression used to verify 32 bit (`int32` etc.) map keys.
@@ -2229,7 +1999,7 @@ util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
  * @type {RegExp}
  * @const
  */
-util.key64Re = /^(?:[\x00-\xff]{8}|-?(?:0|[1-9][0-9]*))$/; // eslint-disable-line no-control-regex
+util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
 
 /**
  * Converts a number or long to an 8 characters long hash string.
@@ -2255,27 +2025,6 @@ util.longFromHash = function longFromHash(hash, unsigned) {
     return bits.toNumber(Boolean(unsigned));
 };
 
-/**
- * Converts a 64 bit key to a long or number if it is an 8 characters long hash string.
- * @param {string} key Map key
- * @param {boolean} [unsigned=false] Whether unsigned or not
- * @returns {Long|number|string} Original value
- */
-util.longFromKey = function longFromKey(key, unsigned) {
-    return util.key64Re.test(key) && !util.key32Re.test(key)
-        ? util.longFromHash(key, unsigned)
-        : key;
-};
-
-/**
- * Converts a boolean key to a boolean value.
- * @param {string} key Map key
- * @returns {boolean} Boolean value
- */
-util.boolFromKey = function boolFromKey(key) {
-    return key === "true" || key === "1";
-};
-
 /**
  * Merges the properties of the source object into the destination object.
  * @memberof util
@@ -2292,7 +2041,7 @@ function merge(dst) { // used by converters
         if (!src)
             continue;
         for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
-            if (!isUnsafeProperty(keys[i]) && (!ifNotSet || !Object.prototype.hasOwnProperty.call(dst, keys[i]) || dst[keys[i]] === undefined))
+            if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === undefined || !ifNotSet))
                 dst[keys[i]] = src[keys[i]];
     }
     return dst;
@@ -2319,14 +2068,11 @@ util.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_
  * @memberof util
  * @param {Object.<string,*>} obj Object
  * @param {string} key Property key
- * @param {boolean} [enumerable=true] Whether the property should be enumerable
  * @returns {undefined}
  */
-util.makeProp = function makeProp(obj, key, enumerable) {
-    if (Object.prototype.hasOwnProperty.call(obj, key))
-        return;
+util.makeProp = function makeProp(obj, key) {
     Object.defineProperty(obj, key, {
-        enumerable: enumerable === undefined ? true : enumerable,
+        enumerable: true,
         configurable: true,
         writable: true
     });
@@ -2504,305 +2250,151 @@ util.toJSONOptions = {
     json: true
 };
 
-},{"10":10,"11":11,"13":13,"14":14,"7":7,"8":8,"9":9,"long":"long"}],13:[function(require,module,exports){
-"use strict";
-module.exports = pool;
-
-/**
- * An allocator as used by {@link util.pool}.
- * @typedef PoolAllocator
- * @type {function}
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
-
-/**
- * A slicer as used by {@link util.pool}.
- * @typedef PoolSlicer
- * @type {function}
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Uint8Array} Buffer slice
- * @this Uint8Array
- */
-
-/**
- * A general purpose buffer pool.
- * @memberof util
- * @function
- * @param {PoolAllocator} alloc Allocator
- * @param {PoolSlicer} slice Slicer
- * @param {number} [size=8192] Slab size
- * @returns {PoolAllocator} Pooled allocator
- */
-function pool(alloc, slice, size) {
-    var SIZE   = size || 8192;
-    var MAX    = SIZE >>> 1;
-    var slab   = null;
-    var offset = SIZE;
-    return function pool_alloc(size) {
-        if (size < 1 || size > MAX)
-            return alloc(size);
-        if (offset + size > SIZE) {
-            slab = alloc(SIZE);
-            offset = 0;
-        }
-        var buf = slice.call(slab, offset, offset += size);
-        if (offset & 7) // align to 32 bit
-            offset = (offset | 7) + 1;
-        return buf;
-    };
-}
+// 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);
+        };
+};
 
-},{}],14:[function(require,module,exports){
+},{"1":1,"14":14,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"long":"long"}],16:[function(require,module,exports){
 "use strict";
+module.exports = Writer;
 
-/**
- * A minimal UTF8 implementation.
- * @memberof util
- * @namespace
- */
-var utf8 = exports,
-    replacementChar = "\ufffd",
-    looseDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
-    strictDecoder;
-var TEXT_DECODER_MIN_LENGTH = 64;
-
-try {
-    strictDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-} catch (err) {
-    // "fatal" option is not supported on Node.js compiled without ICU
-    strictDecoder = looseDecoder;
-}
-
-/**
- * Calculates the UTF8 byte length of a string.
- * @param {string} string String
- * @returns {number} Byte length
- */
-utf8.length = function utf8_length(string) {
-    var len = 0,
-        c = 0;
-    for (var i = 0; i < string.length; ++i) {
-        c = string.charCodeAt(i);
-        if (c < 128)
-            len += 1;
-        else if (c < 2048)
-            len += 2;
-        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-            ++i;
-            len += 4;
-        } else
-            len += 3;
-    }
-    return len;
-};
+var util      = require(15);
 
-function utf8_read_js(buffer, start, end, str) {
-    for (var i = start; i < end;) {
-        var t = buffer[i++];
-        if (t <= 0x7F) {
-            str += String.fromCharCode(t);
-        } else if (t >= 0xC0 && t < 0xE0) {
-            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;
-            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;
-        } else if (t >= 0xE0 && t < 0xF0) {
-            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
-            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;
-        } else if (t >= 0xF0) {
-            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
-            if (t2 < 0x10000 || t2 > 0x10FFFF)
-                str += replacementChar;
-            else {
-                t2 -= 0x10000;
-                str += String.fromCharCode(0xD800 + (t2 >> 10));
-                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));
-            }
-        }
-    }
-    return str;
-}
+var BufferWriter; // cyclic
 
-function utf8_read_decoder(decoder, buffer, start, end) {
-    var source = start === 0 && end === buffer.length
-        ? buffer
-        : buffer.subarray(start, end);
-    return decoder.decode(source);
-}
+var LongBits  = util.LongBits,
+    base64    = util.base64,
+    utf8      = util.utf8;
 
 /**
- * Reads UTF8 bytes as a string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} String read
- */
-utf8.read = function utf8_read_loose(buffer, start, end) {
-    if (end - start < 1)
-        return "";
-    if (end - start >= TEXT_DECODER_MIN_LENGTH)
-        return utf8_read_decoder(looseDecoder, buffer, start, end);
-
-    var str = "",
-        i = start,
-        c1, c2, c3, c4, c5, c6, c7, c8;
-
-    for (; i + 7 < end; i += 8) {
-        c1 = buffer[i];
-        c2 = buffer[i + 1];
-        c3 = buffer[i + 2];
-        c4 = buffer[i + 3];
-        c5 = buffer[i + 4];
-        c6 = buffer[i + 5];
-        c7 = buffer[i + 6];
-        c8 = buffer[i + 7];
-        if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)
-            return utf8_read_js(buffer, i, end, str);
-        str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);
-    }
+ * 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) {
 
-    for (; i < end; ++i) {
-        c1 = buffer[i];
-        if (c1 & 0x80)
-            return utf8_read_js(buffer, i, end, str);
-        str += String.fromCharCode(c1);
-    }
+    /**
+     * Function to call.
+     * @type {function(Uint8Array, number, *)}
+     */
+    this.fn = fn;
 
-    return str;
-};
+    /**
+     * Value byte length.
+     * @type {number}
+     */
+    this.len = len;
 
-/**
- * Reads UTF8 bytes as a string, rejecting invalid UTF8.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} String read
- */
-utf8.readStrict = function utf8_read_strict(buffer, start, end) {
-    if (end - start < 1)
-        return "";
-    if (end - start >= TEXT_DECODER_MIN_LENGTH)
-        return utf8_read_decoder(strictDecoder, buffer, start, end);
-
-    var str = "",
-        i = start,
-        c1, c2, c3, c4, c5, c6, c7, c8;
-
-    for (; i + 7 < end; i += 8) {
-        c1 = buffer[i];
-        c2 = buffer[i + 1];
-        c3 = buffer[i + 2];
-        c4 = buffer[i + 3];
-        c5 = buffer[i + 4];
-        c6 = buffer[i + 5];
-        c7 = buffer[i + 6];
-        c8 = buffer[i + 7];
-        if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)
-            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
-        str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);
-    }
+    /**
+     * Next operation.
+     * @type {Writer.Op|undefined}
+     */
+    this.next = undefined;
 
-    for (; i < end; ++i) {
-        c1 = buffer[i];
-        if (c1 & 0x80)
-            return str + utf8_read_decoder(strictDecoder, buffer, i, end);
-        str += String.fromCharCode(c1);
-    }
+    /**
+     * Value to write.
+     * @type {*}
+     */
+    this.val = val; // type varies
+}
 
-    return str;
-};
+/* istanbul ignore next */
+function noop() {} // eslint-disable-line no-empty-function
 
 /**
- * Writes a string as UTF8 bytes.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Bytes written
- */
-utf8.write = function utf8_write(string, buffer, offset) {
-    var start = offset,
-        c1, // character 1
-        c2; // character 2
-    for (var i = 0; i < string.length; ++i) {
-        c1 = string.charCodeAt(i);
-        if (c1 < 128) {
-            buffer[offset++] = c1;
-        } else if (c1 < 2048) {
-            buffer[offset++] = c1 >> 6       | 192;
-            buffer[offset++] = c1       & 63 | 128;
-        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-            ++i;
-            buffer[offset++] = c1 >> 18      | 240;
-            buffer[offset++] = c1 >> 12 & 63 | 128;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        } else {
-            buffer[offset++] = c1 >> 12      | 224;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        }
-    }
-    return offset - start;
-};
+ * 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) {
 
-},{}],15:[function(require,module,exports){
-"use strict";
-module.exports = Writer;
+    /**
+     * Current head.
+     * @type {Writer.Op}
+     */
+    this.head = writer.head;
 
-var util      = require(12);
+    /**
+     * Current tail.
+     * @type {Writer.Op}
+     */
+    this.tail = writer.tail;
 
-var BufferWriter; // cyclic
+    /**
+     * Current buffer length.
+     * @type {number}
+     */
+    this.len = writer.len;
 
-var LongBits  = util.LongBits,
-    base64    = util.base64,
-    utf8      = util.utf8;
+    /**
+     * Next state.
+     * @type {State|null}
+     */
+    this.next = writer.states;
+}
 
 /**
  * Constructs a new writer instance.
- * @classdesc Wire format writer using `Uint8Array`.
+ * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
  * @constructor
  */
 function Writer() {
 
     /**
-     * Write cursor into {@link Writer#buf}.
+     * Current length.
      * @type {number}
      */
-    this.pos = 0;
+    this.len = 0;
 
     /**
-     * Backing buffer.
-     * @type {Uint8Array}
+     * Operations head.
+     * @type {Object}
      */
-    this.buf = this.constructor.alloc(64);
+    this.head = new Op(noop, 0, 0);
 
     /**
-     * Cached DataView over {@link Writer#buf}.
-     * @type {DataView|null}
+     * Operations tail
+     * @type {Object}
      */
-    this.view = null;
+    this.tail = this.head;
 
     /**
-     * Stack of forked length-prefix positions.
-     * @type {Array<number>|null}
+     * Linked forked states.
+     * @type {Object|null}
      */
     this.states = null;
-}
 
-/**
- * Current write position.
- * @name Writer#len
- * @type {number}
- * @deprecated Use {@link Writer#pos} instead.
- */
-Object.defineProperty(Writer.prototype, "len", {
-    configurable: true,
-    enumerable: true,
-    get: function get_len() {
-        return this.pos;
-    }
-});
+    // 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 = function create() {
     return util.Buffer
@@ -2830,48 +2422,30 @@ Writer.create = create();
  * @returns {Uint8Array} Buffer
  */
 Writer.alloc = function alloc(size) {
-    return new Uint8Array(size);
+    return new util.Array(size);
 };
 
 // Use Uint8Array buffer pool in the browser, just like node does with buffers
-Writer.alloc = util.pool(Writer.alloc, Uint8Array.prototype.subarray);
-
-/**
- * Calculates the number of bytes a value occupies as a varint.
- * @param {number} value Value to size (unsigned)
- * @returns {number} Byte length (1..5)
- * @ignore
- */
-function sizeVarint32(value) {
-    return value         < 128       ? 1
-         : value         < 16384     ? 2
-         : value         < 2097152   ? 3
-         : value         < 268435456 ? 4
-         :                             5;
-}
+/* istanbul ignore else */
+if (util.Array !== Array)
+    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
 
 /**
- * Ensures that at least `n` more bytes fit into the backing buffer, doubling it if not.
- * @param {number} n Number of additional bytes required
- * @returns {undefined}
+ * 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.prototype._reserve = function _reserve(n) {
-    var need = this.pos + n;
-    if (need > this.buf.length) {
-        var size = this.buf.length << 1;
-        if (size < need)
-            size = need;
-        var buf = this.constructor.alloc(size);
-        buf.set(this.buf.subarray(0, this.pos), 0);
-        this.buf = buf;
-        this.view = null; // invalidate
-    }
+Writer.prototype._push = function push(fn, len, val) {
+    this.tail = this.tail.next = new Op(fn, len, val);
+    this.len += len;
+    return this;
 };
 
-function writeStringAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
+function writeByte(val, buf, pos) {
+    buf[pos] = val & 255;
 }
 
 function writeVarint32(val, buf, pos) {
@@ -2880,19 +2454,42 @@ function writeVarint32(val, buf, pos) {
         val >>>= 7;
     }
     buf[pos] = val;
-    return pos + 1;
 }
 
+/**
+ * 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.prototype.uint32 = function write_uint32(value) {
-    value = value >>> 0;
-    this._reserve(5);
-    var pos = this.pos;
-    this.pos = writeVarint32(value, this.buf, pos);
+    // 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;
 };
 
@@ -2903,13 +2500,9 @@ Writer.prototype.uint32 = function write_uint32(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.int32 = function write_int32(value) {
-    if ((value |= 0) < 0) { // 10 bytes per spec
-        this._reserve(10);
-        writeVarint64(LongBits.fromNumber(value), this.buf, this.pos);
-        this.pos += 10;
-        return this;
-    }
-    return this.uint32(value);
+    return (value |= 0) < 0
+        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
+        : this.uint32(value);
 };
 
 /**
@@ -2933,8 +2526,7 @@ function writeVarint64(val, buf, pos) {
         buf[pos++] = lo & 127 | 128;
         lo = lo >>> 7;
     }
-    buf[pos] = lo;
-    return pos + 1;
+    buf[pos++] = lo;
 }
 
 /**
@@ -2945,10 +2537,7 @@ function writeVarint64(val, buf, pos) {
  */
 Writer.prototype.uint64 = function write_uint64(value) {
     var bits = LongBits.from(value);
-    this._reserve(10);
-    var pos = this.pos;
-    this.pos = writeVarint64(bits, this.buf, pos);
-    return this;
+    return this._push(writeVarint64, bits.length(), bits);
 };
 
 /**
@@ -2968,10 +2557,7 @@ Writer.prototype.int64 = Writer.prototype.uint64;
  */
 Writer.prototype.sint64 = function write_sint64(value) {
     var bits = LongBits.from(value).zzEncode();
-    this._reserve(10);
-    var pos = this.pos;
-    this.pos = writeVarint64(bits, this.buf, pos);
-    return this;
+    return this._push(writeVarint64, bits.length(), bits);
 };
 
 /**
@@ -2980,9 +2566,7 @@ Writer.prototype.sint64 = function write_sint64(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.bool = function write_bool(value) {
-    this._reserve(1);
-    this.buf[this.pos++] = value ? 1 : 0;
-    return this;
+    return this._push(writeByte, 1, value ? 1 : 0);
 };
 
 function writeFixed32(val, buf, pos) {
@@ -2998,10 +2582,7 @@ function writeFixed32(val, buf, pos) {
  * @returns {Writer} `this`
  */
 Writer.prototype.fixed32 = function write_fixed32(value) {
-    this._reserve(4);
-    writeFixed32(value >>> 0, this.buf, this.pos);
-    this.pos += 4;
-    return this;
+    return this._push(writeFixed32, 4, value >>> 0);
 };
 
 /**
@@ -3020,11 +2601,7 @@ Writer.prototype.sfixed32 = Writer.prototype.fixed32;
  */
 Writer.prototype.fixed64 = function write_fixed64(value) {
     var bits = LongBits.from(value);
-    this._reserve(8);
-    writeFixed32(bits.lo, this.buf, this.pos);
-    writeFixed32(bits.hi, this.buf, this.pos + 4);
-    this.pos += 8;
-    return this;
+    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
 };
 
 /**
@@ -3043,10 +2620,7 @@ Writer.prototype.sfixed64 = Writer.prototype.fixed64;
  * @returns {Writer} `this`
  */
 Writer.prototype.float = function write_float(value) {
-    this._reserve(4);
-    util.float.writeFloatLE(value, this.buf, this.pos);
-    this.pos += 4;
-    return this;
+    return this._push(util.float.writeFloatLE, 4, value);
 };
 
 /**
@@ -3056,12 +2630,19 @@ Writer.prototype.float = function write_float(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.double = function write_double(value) {
-    this._reserve(8);
-    util.float.writeDoubleLE(value, this.buf, this.pos);
-    this.pos += 8;
-    return this;
+    return this._push(util.float.writeDoubleLE, 8, value);
 };
 
+var writeBytes = util.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
@@ -3069,52 +2650,14 @@ Writer.prototype.double = function write_double(value) {
  */
 Writer.prototype.bytes = function write_bytes(value) {
     var len = value.length >>> 0;
-    if (!len) {
-        this._reserve(1);
-        this.buf[this.pos++] = 0;
-        return this;
-    }
+    if (!len)
+        return this._push(writeByte, 1, 0);
     if (util.isString(value)) {
         var buf = Writer.alloc(len = base64.length(value));
         base64.decode(value, buf, 0);
         value = buf;
     }
-    this.uint32(len);
-    this._reserve(len);
-    this.buf.set(value, this.pos);
-    this.pos += len;
-    return this;
-};
-
-/**
- * Writes raw bytes without a tag or length prefix.
- * @param {Uint8Array} value Raw bytes
- * @returns {Writer} `this`
- */
-Writer.prototype.raw = function write_raw(value) {
-    var len = value.length >>> 0;
-    if (!len)
-        return this;
-    this._reserve(len);
-    this.buf.set(value, this.pos);
-    this.pos += len;
-    return this;
-};
-
-/**
- * Backfills the length varint.
- * @param {number} pos Position of reserved length byte
- * @param {number} len Length of content after length varint
- * @returns {Writer} `this`
- * @private
- */
-Writer.prototype._delim = function _delim(pos, len) {
-    var n = sizeVarint32(len);
-    if (n > 1)
-        this.buf.copyWithin(pos + n, pos + 1, pos + 1 + len);
-    writeVarint32(len, this.buf, pos);
-    this.pos = pos + n + len;
-    return this;
+    return this.uint32(len)._push(writeBytes, len, value);
 };
 
 /**
@@ -3123,245 +2666,21 @@ Writer.prototype._delim = function _delim(pos, len) {
  * @returns {Writer} `this`
  */
 Writer.prototype.string = function write_string(value) {
-    var n = value.length;
-    if (!n) {
-        this._reserve(1);
-        this.buf[this.pos++] = 0;
-        return this;
-    }
-    if (n < 0x80) {
-        this._reserve(n * 3 + 5); // worst case
-        var lenPos = this.pos;
-        return this._delim(lenPos, utf8.write(value, this.buf, lenPos + 1));
-    }
     var len = utf8.length(value);
-    this.uint32(len);
-    this._reserve(len);
-    if (len === value.length)
-        writeStringAscii(value, this.buf, this.pos);
-    else
-        utf8.write(value, this.buf, this.pos);
-    this.pos += len;
-    return this;
-};
-
-/**
- * Writes an array of unsigned 32 bit values as a packed repeated field.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.uint32s = function write_uint32s(value) {
-    var n = value.length;
-    this._reserve(n * 5 + 5); // worst case: 5 bytes per value + length varint
-    var buf = this.buf, lenPos = this.pos, p = lenPos + 1;
-    for (var i = 0; i < n; ++i)
-        p = writeVarint32(value[i] >>> 0, buf, p);
-    return this._delim(lenPos, p - lenPos - 1);
-};
-
-/**
- * Writes an array of signed 32 bit values as a packed repeated field.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.int32s = function write_int32s(value) {
-    var n = value.length;
-    this._reserve(n * 10 + 5); // worst case: 10 bytes per negative value + length varint
-    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1, val;
-    for (var i = 0; i < n; ++i) {
-        if ((val = value[i] | 0) < 0) { // negatives are 10 bytes per spec
-            pos = writeVarint64(LongBits.fromNumber(val), buf, pos);
-        } else {
-            pos = writeVarint32(val, buf, pos);
-        }
-    }
-    return this._delim(lenPos, pos - lenPos - 1);
-};
-
-/**
- * Writes an array of 32 bit values as packed, zig-zag encoded varints.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.sint32s = function write_sint32s(value) {
-    var n = value.length;
-    this._reserve(n * 5 + 5);
-    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
-    for (var i = 0; i < n; ++i)
-        pos = writeVarint32((value[i] << 1 ^ value[i] >> 31) >>> 0, buf, pos);
-    return this._delim(lenPos, pos - lenPos - 1);
-};
-
-/**
- * Writes an array of unsigned 64 bit values as a packed repeated field.
- * @param {Array.<Long|number|string>} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.uint64s = function write_uint64s(value) {
-    var n = value.length;
-    this._reserve(n * 10 + 5);
-    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
-    for (var i = 0; i < n; ++i) {
-        pos = writeVarint64(LongBits.from(value[i]), buf, pos);
-    }
-    return this._delim(lenPos, pos - lenPos - 1);
-};
-
-/**
- * Writes an array of signed 64 bit values as a packed repeated field.
- * @function
- * @param {Array.<Long|number|string>} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.int64s = Writer.prototype.uint64s;
-
-/**
- * Writes an array of 64 bit values as packed, zig-zag encoded varints.
- * @param {Array.<Long|number|string>} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.sint64s = function write_sint64s(value) {
-    var n = value.length;
-    this._reserve(n * 10 + 5);
-    var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;
-    for (var i = 0; i < n; ++i) {
-        pos = writeVarint64(LongBits.from(value[i]).zzEncode(), buf, pos);
-    }
-    return this._delim(lenPos, pos - lenPos - 1);
-};
-
-/**
- * Writes an array of boolish values as a packed repeated field.
- * @param {boolean[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.bools = function write_bools(value) {
-    var n = value.length;
-    this.uint32(n); // one byte per value
-    this._reserve(n);
-    var buf = this.buf, p = this.pos;
-    for (var i = 0; i < n; ++i)
-        buf[p++] = value[i] ? 1 : 0;
-    this.pos += n;
-    return this;
-};
-
-// The view allocation only pays off when amortized over enough writes
-var VIEW_THRESHOLD_FLOAT = 16,
-    VIEW_THRESHOLD_INT   = 128;
-
-function getLazyView(writer, count, threshold) {
-    var view = writer.view;
-    if (view || count < threshold)
-        return view;
-    var buf = writer.buf;
-    return writer.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-
-/**
- * Writes an array of unsigned 32 bit values as packed, fixed 32 bits.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.fixed32s = function write_fixed32s(value) {
-    var n = value.length, bytes = n * 4;
-    this.uint32(bytes); // length is known exactly
-    this._reserve(bytes);
-    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);
-    if (dv)
-        for (i = 0; i < n; ++i) { dv.setUint32(p, value[i] >>> 0, true); p += 4; }
-    else {
-        var buf = this.buf;
-        for (i = 0; i < n; ++i) { writeFixed32(value[i] >>> 0, buf, p); p += 4; }
-    }
-    this.pos += bytes;
-    return this;
-};
-
-/**
- * Writes an array of signed 32 bit values as packed, fixed 32 bits.
- * @function
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.sfixed32s = Writer.prototype.fixed32s;
-
-/**
- * Writes an array of unsigned 64 bit values as packed, fixed 64 bits.
- * @param {Array.<Long|number|string>} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.fixed64s = function write_fixed64s(value) {
-    var n = value.length, bytes = n * 8;
-    this.uint32(bytes);
-    this._reserve(bytes);
-    var p = this.pos, i, bits, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);
-    if (dv)
-        for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); dv.setUint32(p, bits.lo, true); dv.setUint32(p + 4, bits.hi, true); p += 8; }
-    else {
-        var buf = this.buf;
-        for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); writeFixed32(bits.lo, buf, p); writeFixed32(bits.hi, buf, p + 4); p += 8; }
-    }
-    this.pos += bytes;
-    return this;
-};
-
-/**
- * Writes an array of signed 64 bit values as packed, fixed 64 bits.
- * @function
- * @param {Array.<Long|number|string>} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.sfixed64s = Writer.prototype.fixed64s;
-
-/**
- * Writes an array of floats (32 bit) as a packed repeated field.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.floats = function write_floats(value) {
-    var n = value.length, bytes = n * 4;
-    this.uint32(bytes);
-    this._reserve(bytes);
-    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);
-    if (dv)
-        for (i = 0; i < n; ++i) { dv.setFloat32(p, value[i], true); p += 4; }
-    else {
-        var buf = this.buf;
-        for (i = 0; i < n; ++i) { util.float.writeFloatLE(value[i], buf, p); p += 4; }
-    }
-    this.pos += bytes;
-    return this;
-};
-
-/**
- * Writes an array of doubles (64 bit float) as a packed repeated field.
- * @param {number[]} value Values to write
- * @returns {Writer} `this`
- */
-Writer.prototype.doubles = function write_doubles(value) {
-    var n = value.length, bytes = n * 8;
-    this.uint32(bytes);
-    this._reserve(bytes);
-    var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);
-    if (dv)
-        for (i = 0; i < n; ++i) { dv.setFloat64(p, value[i], true); p += 8; }
-    else {
-        var buf = this.buf;
-        for (i = 0; i < n; ++i) { util.float.writeDoubleLE(value[i], buf, p); p += 8; }
-    }
-    this.pos += bytes;
-    return this;
+    return len
+        ? this.uint32(len)._push(utf8.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.prototype.fork = function fork() {
-    this._reserve(1);
-    (this.states || (this.states = [])).push(this.pos);
-    this.pos += 1;
+    this.states = new State(this);
+    this.head = this.tail = new Op(noop, 0, 0);
+    this.len = 0;
     return this;
 };
 
@@ -3370,75 +2689,49 @@ Writer.prototype.fork = function fork() {
  * @returns {Writer} `this`
  */
 Writer.prototype.reset = function reset() {
-    var states = this.states;
-    if (states && states.length) {
-        this.pos = states.pop();
+    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.pos = 0;
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len  = 0;
     }
     return this;
 };
 
 /**
- * Resets to the last state and prepends the fork state's current write length as a varint.
+ * 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.prototype.ldelim = function ldelim() {
-    var states = this.states,
-        len,
-        vlen;
-    if (states && states.length) {
-        var lenPos = states.pop();
-        len = this.pos - lenPos - 1;
-        vlen = sizeVarint32(len);
-        if (vlen > 1) { // grow the reserved single byte and shift content forward
-            this._reserve(vlen - 1);
-            this.buf.copyWithin(lenPos + vlen, lenPos + 1, lenPos + 1 + len);
-            this.pos += vlen - 1;
-            writeVarint32(len, this.buf, lenPos);
-        } else {
-            this.buf[lenPos] = len;
-        }
-    } else { // not forked: prefix the entire buffer with its length
-        // TODO: Compatibility with older generated code.
-        // Remove this branch in the next major release.
-        len = this.pos;
-        vlen = sizeVarint32(len);
-        this._reserve(vlen);
-        this.buf.copyWithin(vlen, 0, len);
-        writeVarint32(len, this.buf, 0);
-        this.pos += vlen;
+    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 a buffer sized to the written data by default.
- * @param {boolean} [shared=false] Whether to return a shared view instead of a unique copy
  * @returns {Uint8Array} Finished buffer
  */
-Writer.prototype.finish = function finish(shared) {
-    if (shared)
-        return this.buf.subarray(0, this.pos);
-    var buf = this.constructor.alloc(this.pos);
-    buf.set(this.buf.subarray(0, this.pos), 0);
-    return buf;
-};
-
-/**
- * Finishes the write operation, writing into the provided buffer.
- * The caller must ensure that `buf` has enough space starting at `offset`
- * to hold {@link Writer#pos} bytes.
- * @param {T} buf Target buffer
- * @param {number} [offset=0] Offset to start writing at
- * @returns {T} The provided buffer
- * @template T extends Uint8Array
- */
-Writer.prototype.finishInto = function finishInto(buf, offset) {
-    if (offset === undefined)
-        offset = 0;
-    buf.set(this.buf.subarray(0, this.pos), offset);
+Writer.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;
 };
 
@@ -3448,22 +2741,15 @@ Writer._configure = function(BufferWriter_) {
     BufferWriter._configure();
 };
 
-},{"12":12}],16:[function(require,module,exports){
+},{"15":15}],17:[function(require,module,exports){
 "use strict";
 module.exports = BufferWriter;
 
 // extends Writer
-var Writer = require(15);
-BufferWriter.prototype = Object.create(Writer.prototype, {
-    constructor: {
-        value: BufferWriter,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
+var Writer = require(16);
+(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 
-var util = require(12);
+var util = require(15);
 
 /**
  * Constructs a new buffer writer instance.
@@ -3475,8 +2761,6 @@ function BufferWriter() {
     Writer.call(this);
 }
 
-var writeStringBuffer;
-
 BufferWriter._configure = function () {
     /**
      * Allocates a buffer of the specified size.
@@ -3484,14 +2768,19 @@ BufferWriter._configure = function () {
      * @param {number} size Buffer size
      * @returns {Buffer} Buffer
      */
-    BufferWriter.alloc = util.Buffer && util.Buffer.allocUnsafe;
+    BufferWriter.alloc = util._Buffer_allocUnsafe;
 
-    writeStringBuffer = util.Buffer && util.Buffer.prototype.utf8Write
-        ? function writeStringBuffer_utf8Write(val, buf, pos) {
-            return buf.utf8Write(val, pos);
+    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.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
         }
-        : function writeStringBuffer_write(val, buf, pos) {
-            return buf.write(val, pos);
+        /* 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++];
         };
 };
 
@@ -3501,42 +2790,31 @@ BufferWriter._configure = function () {
  */
 BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
     if (util.isString(value))
-        value = util.Buffer.from(value, "base64");
+        value = util._Buffer_from(value, "base64");
     var len = value.length >>> 0;
     this.uint32(len);
-    if (len) {
-        this._reserve(len);
-        this.buf.set(value, this.pos);
-        this.pos += 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.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 n = value.length;
-    if (!n) {
-        this._reserve(1);
-        this.buf[this.pos++] = 0;
-        return this;
-    }
-    if (n < 0x80) {
-        this._reserve(n * 3 + 5); // worst case
-        var pos = this.pos,
-            buf = this.buf;
-        return this._delim(pos,
-            n < 40
-                ? util.utf8.write(value, buf, pos + 1)
-                : writeStringBuffer(value, buf, pos + 1)
-        );
-    }
     var len = util.Buffer.byteLength(value);
     this.uint32(len);
-    this._reserve(len);
-    writeStringBuffer(value, this.buf, this.pos);
-    this.pos += len;
+    if (len)
+        this._push(writeStringBuffer, len, value);
     return this;
 };
 
@@ -3550,7 +2828,7 @@ BufferWriter.prototype.string = function write_string_buffer(value) {
 
 BufferWriter._configure();
 
-},{"12":12,"15":15}]},{},[1])
+},{"15":15,"16":16}]},{},[8])
 
 })();
 //# sourceMappingURL=protobuf.js.map