@openclaw/diagnostics-otel 2026.6.8 → 2026.6.9-beta.1

package/node_modules/protobufjs/dist/light/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.4.1 (c) 2016, daniel wirtz
- * compiled thu, 21 may 2026 18:52:08 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,8 +38,1132 @@
         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 = codegen;
+
+var reservedRe = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @param {string[]} functionParams Function parameter names
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ */
+function codegen(functionParams, functionName) {
+
+    /* istanbul ignore if */
+    if (typeof functionParams === "string") {
+        functionName = functionParams;
+        functionParams = undefined;
+    }
+
+    var body = [];
+
+    /**
+     * Appends code to the function's body or finishes generation.
+     * @typedef Codegen
+     * @type {function}
+     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+     * @param {...*} [formatParams] Format parameters
+     * @returns {Codegen|Function} Itself or the generated function if finished
+     * @throws {Error} If format parameter counts do not match
+     */
+
+    function Codegen(formatStringOrScope) {
+        // note that explicit array handling below makes this ~50% faster
+
+        // finish the function
+        if (typeof formatStringOrScope !== "string") {
+            var source = toString();
+            if (codegen.verbose)
+                console.log("codegen: " + source); // eslint-disable-line no-console
+            source = "return " + source;
+            if (formatStringOrScope) {
+                var scopeKeys   = Object.keys(formatStringOrScope),
+                    scopeParams = new Array(scopeKeys.length + 1),
+                    scopeValues = new Array(scopeKeys.length),
+                    scopeOffset = 0;
+                while (scopeOffset < scopeKeys.length) {
+                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
+                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
+                }
+                scopeParams[scopeOffset] = source;
+                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
+            }
+            return Function(source)(); // eslint-disable-line no-new-func
+        }
+
+        // otherwise append to body
+        var formatParams = new Array(arguments.length - 1),
+            formatOffset = 0;
+        while (formatOffset < formatParams.length)
+            formatParams[formatOffset] = arguments[++formatOffset];
+        formatOffset = 0;
+        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
+            var value = formatParams[formatOffset++];
+            switch ($1) {
+                case "d": case "f": return String(Number(value));
+                case "i": return String(Math.floor(value));
+                case "j": return JSON.stringify(value);
+                case "s": return String(value);
+            }
+            return "%";
+        });
+        if (formatOffset !== formatParams.length)
+            throw Error("parameter count mismatch");
+        body.push(formatStringOrScope);
+        return Codegen;
+    }
+
+    function toString(functionNameOverride) {
+        return "function " + safeFunctionName(functionNameOverride || functionName) + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
+    }
+
+    Codegen.toString = toString;
+    return Codegen;
+}
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @function codegen
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ * @variation 2
+ */
+
+/**
+ * When set to `true`, codegen will log generated code to console. Useful for debugging.
+ * @name util.codegen.verbose
+ * @type {boolean}
+ */
+codegen.verbose = false;
+
+function safeFunctionName(name) {
+    if (!name)
+        return "";
+    name = String(name).replace(/[^\w$]/g, "");
+    if (!name)
+        return "";
+    if (/^\d/.test(name))
+        name = "_" + name;
+    return reservedRe.test(name) ? name + "_" : name;
+}
+
+},{}],4:[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;
+};
+
+},{}],5:[function(require,module,exports){
+"use strict";
+module.exports = fetch;
+
+var asPromise = require(1),
+    fs        = require(6);
+
+/**
+ * Node-style callback as used by {@link util.fetch}.
+ * @typedef FetchCallback
+ * @type {function}
+ * @param {?Error} error Error, if any, otherwise `null`
+ * @param {string} [contents] File contents, if there hasn't been an error
+ * @returns {undefined}
+ */
+
+/**
+ * Options as used by {@link util.fetch}.
+ * @interface IFetchOptions
+ * @property {boolean} [binary=false] Whether expecting a binary response
+ * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
+ */
+
+/**
+ * Fetches the contents of a file.
+ * @memberof util
+ * @param {string} filename File path or url
+ * @param {IFetchOptions} options Fetch options
+ * @param {FetchCallback} callback Callback function
+ * @returns {undefined}
+ */
+function fetch(filename, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    } else if (!options)
+        options = {};
+
+    if (!callback)
+        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
+
+    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
+    if (!options.xhr && fs && fs.readFile)
+        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
+            return err && typeof XMLHttpRequest !== "undefined"
+                ? fetch.xhr(filename, options, callback)
+                : err
+                ? callback(err)
+                : callback(null, options.binary ? contents : contents.toString("utf8"));
+        });
+
+    // use the XHR version otherwise.
+    return fetch.xhr(filename, options, callback);
+}
+
+/**
+ * Fetches the contents of a file.
+ * @name util.fetch
+ * @function
+ * @param {string} path File path or url
+ * @param {FetchCallback} callback Callback function
+ * @returns {undefined}
+ * @variation 2
+ */
+
+/**
+ * Fetches the contents of a file.
+ * @name util.fetch
+ * @function
+ * @param {string} path File path or url
+ * @param {IFetchOptions} [options] Fetch options
+ * @returns {Promise<string|Uint8Array>} Promise
+ * @variation 3
+ */
+
+/**/
+fetch.xhr = function fetch_xhr(filename, options, callback) {
+    var xhr = new XMLHttpRequest();
+    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
+
+        if (xhr.readyState !== 4)
+            return undefined;
+
+        // local cors security errors return status 0 / empty string, too. afaik this cannot be
+        // reliably distinguished from an actually empty file for security reasons. feel free
+        // to send a pull request if you are aware of a solution.
+        if (xhr.status !== 0 && xhr.status !== 200)
+            return callback(Error("status " + xhr.status));
+
+        // if binary data is expected, make sure that some sort of array is returned, even if
+        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
+        if (options.binary) {
+            var buffer = xhr.response;
+            if (!buffer) {
+                buffer = [];
+                for (var i = 0; i < xhr.responseText.length; ++i)
+                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
+            }
+            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
+        }
+        return callback(null, xhr.responseText);
+    };
+
+    if (options.binary) {
+        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
+        if ("overrideMimeType" in xhr)
+            xhr.overrideMimeType("text/plain; charset=x-user-defined");
+        xhr.responseType = "arraybuffer";
+    }
+
+    xhr.open("GET", filename);
+    xhr.send();
+};
+
+},{"1":1,"6":6}],6:[function(require,module,exports){
+"use strict";
+
+var fs = null;
+try {
+    fs = require(12);
+    if (!fs || !fs.readFile || !fs.readFileSync)
+        fs = null;
+} catch (e) {
+    // `fs` is unavailable in browsers and browser-like bundles.
+}
+module.exports = fs;
+
+},{"12":12}],7:[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;
+}
+
+},{}],8:[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;
+*/
+
+},{}],9:[function(require,module,exports){
+"use strict";
+
+/**
+ * A minimal path module to resolve Unix, Windows and URL paths alike.
+ * @memberof util
+ * @namespace
+ */
+var path = exports;
+
+var isAbsolute =
+/**
+ * Tests if the specified path is absolute.
+ * @param {string} path Path to test
+ * @returns {boolean} `true` if path is absolute
+ */
+path.isAbsolute = function isAbsolute(path) {
+    return /^(?:\/|\w+:)/.test(path);
+};
+
+var normalize =
+/**
+ * Normalizes the specified path.
+ * @param {string} path Path to normalize
+ * @returns {string} Normalized path
+ */
+path.normalize = function normalize(path) {
+    path = path.replace(/\\/g, "/")
+               .replace(/\/{2,}/g, "/");
+    var parts    = path.split("/"),
+        absolute = isAbsolute(path),
+        prefix   = "";
+    if (absolute)
+        prefix = parts.shift() + "/";
+    for (var i = 0; i < parts.length;) {
+        if (parts[i] === "..") {
+            if (i > 0 && parts[i - 1] !== "..")
+                parts.splice(--i, 2);
+            else if (absolute)
+                parts.splice(i, 1);
+            else
+                ++i;
+        } else if (parts[i] === ".")
+            parts.splice(i, 1);
+        else
+            ++i;
+    }
+    return prefix + parts.join("/");
+};
+
+/**
+ * Resolves the specified include path against the specified origin path.
+ * @param {string} originPath Path to the origin file
+ * @param {string} includePath Include path relative to origin path
+ * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
+ * @returns {string} Path to the include file
+ */
+path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    if (!alreadyNormalized)
+        includePath = normalize(includePath);
+    if (isAbsolute(includePath))
+        return includePath;
+    if (!alreadyNormalized)
+        originPath = normalize(originPath);
+    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
+};
+
+},{}],10:[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;
+    };
+}
+
+},{}],11:[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;
+};
+
+},{}],12:[function(require,module,exports){
+
+},{}],13:[function(require,module,exports){
 "use strict";
 /**
  * Runtime message from/to plain object converters.
@@ -47,9 +1171,8 @@
  */
 var converter = exports;
 
-var Enum  = require(5),
-    types = require(23),
-    util  = require(24);
+var Enum = require(16),
+    util = require(35);
 
 /**
  * Generates a partial value fromObject conveter.
@@ -70,7 +1193,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
                 // enum unknown values passthrough
                 if (values[keys[i]] === field.typeDefault && !defaultAlreadyEmitted) { gen
                     ("default:")
-                        ("if(typeof d%s===\"number\"){m%s=d%s;break}", prop, prop, prop);
+                        ("if(typeof(d%s)===\"number\"){m%s=d%s;break}", prop, prop, prop);
                     if (!field.repeated) gen // fallback to default value only for
                                              // arrays, to avoid leaving holes.
                         ("break");           // for non-repeated fields, just ignore
@@ -84,9 +1207,9 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
             } gen
             ("}");
         } else gen
-            ("if(typeof d%s!==\"object\")", prop)
+            ("if(!util.isObject(d%s))", prop)
                 ("throw TypeError(%j)", field.fullName + ": object expected")
-            ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
+            ("m%s=types[%i].fromObject(d%s,n+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
@@ -122,7 +1245,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
             case "bytes": gen
                 ("if(typeof d%s===\"string\")", prop)
                     ("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)
-                ("else if(d%s.length>=0)", prop)
+                ("else if(d%s.length >= 0)", prop)
                     ("m%s=d%s", prop, prop);
                 break;
             case "string": gen
@@ -148,26 +1271,27 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
 converter.fromObject = function fromObject(mtype) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     var fields = mtype.fieldsArray;
-    var gen = util.codegen(["d", "q"], mtype.name + "$fromObject")
-    ("if(d instanceof C)")
-        ("return d")
-    ("if(q===undefined)q=0")
-    ("if(q>util.recursionLimit)")
-        ("throw Error(\"max depth exceeded\")");
+    var gen = util.codegen(["d", "n"], mtype.name + "$fromObject")
+    ("if(d instanceof this.ctor)")
+        ("return d");
     if (!fields.length) return gen
-    ("return new C");
+    ("return new this.ctor");
+    gen
+    ("if(!util.isObject(d))")
+        ("throw TypeError(%j)", mtype.fullName + ": object expected")
+    ("if(n===undefined)n=0")
+    ("if(n>util.recursionLimit)")
+        ("throw Error(\"maximum nesting depth exceeded\")");
     gen
-    ("var m=new C");
+    ("var m=new this.ctor");
     for (var i = 0; i < fields.length; ++i) {
         var field  = fields[i].resolve(),
-            prop   = util.safeProp(field.name),
-            implicitPresence = !field.hasPresence && !field.repeated && !field.map
-                && (field.resolvedType instanceof Enum || types.basic[field.type] !== undefined);
+            prop   = util.safeProp(field.name);
 
         // Map fields
         if (field.map) { gen
     ("if(d%s){", prop)
-        ("if(typeof d%s!==\"object\")", prop)
+        ("if(!util.isObject(d%s))", prop)
             ("throw TypeError(%j)", field.fullName + ": object expected")
         ("m%s={}", prop)
         ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
@@ -183,7 +1307,7 @@ converter.fromObject = function fromObject(mtype) {
     ("if(d%s){", prop)
         ("if(!Array.isArray(d%s))", prop)
             ("throw TypeError(%j)", field.fullName + ": array expected")
-        ("m%s=Array(d%s.length)", prop, prop)
+        ("m%s=[]", prop)
         ("for(var i=0;i<d%s.length;++i){", prop);
             genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
         ("}")
@@ -193,23 +1317,7 @@ converter.fromObject = function fromObject(mtype) {
         } else {
             if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
     ("if(d%s!=null){", prop); // !== undefined && !== null
-            if (implicitPresence) {
-                if (field.resolvedType instanceof Enum) gen
-    ("if(d%s!==%j&&(typeof d%s!==\"string\"||types[%i].values[d%s]!==%j)){", prop, field.typeDefault, prop, i, prop, field.typeDefault);
-                else if (field.type === "string") gen
-    ("if(typeof d%s!==\"string\"||d%s.length){", prop, prop);
-                else if (field.type === "bytes") gen
-    ("if(d%s.length){", prop);
-                else if (field.type === "bool") gen
-    ("if(d%s){", prop);
-                else if (types.long[field.type] !== undefined) gen
-    ("if(typeof d%s===\"object\"?d%s.low||d%s.high:Number(d%s)!==0){", prop, prop, prop, prop);
-                else gen
-    ("if(Number(d%s)!==0){", prop);
-            }
         genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
-            if (implicitPresence) gen
-    ("}");
             if (!(field.resolvedType instanceof Enum)) gen
     ("}");
         }
@@ -223,26 +1331,23 @@ converter.fromObject = function fromObject(mtype) {
  * @param {Codegen} gen Codegen instance
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
- * @param {string} dstProp Destination property reference
- * @param {string} [srcProp] Source property reference
+ * @param {string} prop Property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
+function genValuePartial_toObject(gen, field, fieldIndex, prop) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
-    if (!srcProp)
-        srcProp = dstProp;
     if (field.resolvedType) {
         if (field.resolvedType instanceof Enum) gen
-            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);
+            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", prop, fieldIndex, prop, prop, fieldIndex, prop, prop);
         else gen
-            ("d%s=types[%i].toObject(m%s,o,q+1)", dstProp, fieldIndex, srcProp);
+            ("d%s=types[%i].toObject(m%s,o,q+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
             case "double":
             case "float": gen
-            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", dstProp, srcProp, srcProp, srcProp);
+            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
                 break;
             case "uint64":
             case "fixed64":
@@ -252,17 +1357,17 @@ function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
             case "sint64":
             case "sfixed64": gen
             ("if(typeof BigInt!==\"undefined\"&&o.longs===BigInt)")
-                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", dstProp, srcProp, srcProp, srcProp, srcProp, isUnsigned)
-            ("else if(typeof m%s===\"number\")", srcProp)
-                ("d%s=o.longs===String?String(m%s):m%s", dstProp, srcProp, srcProp)
+                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", prop, prop, prop, prop, prop, isUnsigned)
+            ("else if(typeof m%s===\"number\")", prop)
+                ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
             ("else") // Long-like
-                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", dstProp, srcProp, srcProp, srcProp, isUnsigned ? "true": "", srcProp);
+                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
                 break;
             case "bytes": gen
-            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", dstProp, srcProp, srcProp, srcProp, srcProp);
+            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
                 break;
             default: gen
-            ("d%s=m%s", dstProp, srcProp);
+            ("d%s=m%s", prop, prop);
                 break;
         }
     }
@@ -350,28 +1455,23 @@ converter.toObject = function toObject(mtype) {
     ("var ks2");
             } gen
     ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
-        ("d%s={}", prop);
-            var longKey = types.long[field.keyType] !== undefined,
-                srcProp = prop + "[ks2[j]]";
-            gen
+        ("d%s={}", prop)
         ("for(var j=0;j<ks2.length;++j){");
-            if (longKey) gen
-            ("var k2=util.longFromKey(ks2[j],%j).toString()", field.keyType === "uint64" || field.keyType === "fixed64");
             gen
         ("if(ks2[j]===\"__proto__\")")
             ("util.makeProp(d%s,ks2[j])", prop);
-            genValuePartial_toObject(gen, field, /* sorted */ index, longKey ? prop + "[k2]" : srcProp, srcProp)
+            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
         ("}");
         } else if (field.repeated) { gen
     ("if(m%s&&m%s.length){", prop, prop)
-        ("d%s=Array(m%s.length)", prop, prop)
+        ("d%s=[]", prop)
         ("for(var j=0;j<m%s.length;++j){", prop);
             genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
         ("}");
         } else { gen
-    ("if(m%s!=null&&m.hasOwnProperty(%j)){", prop, field.name); // !== undefined && !== null
+    ("if(m%s!=null&&Object.hasOwnProperty.call(m,%j)){", prop, field.name); // !== undefined && !== null
         genValuePartial_toObject(gen, field, /* sorted */ index, prop);
-        if (field.partOf && !field.partOf.isProto3Optional) gen
+        if (field.partOf) gen
         ("if(o.oneofs)")
             ("d%s=%j", util.safeProp(field.partOf.name), field.name);
         }
@@ -383,13 +1483,13 @@ converter.toObject = function toObject(mtype) {
     /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
 };
 
-},{"23":23,"24":24,"5":5}],3:[function(require,module,exports){
+},{"16":16,"35":35}],14:[function(require,module,exports){
 "use strict";
 module.exports = decoder;
 
-var Enum    = require(5),
-    types   = require(23),
-    util    = require(24);
+var Enum    = require(16),
+    types   = require(34),
+    util    = require(35);
 
 function missing(field) {
     return "missing required '" + field.name + "'";
@@ -402,187 +1502,116 @@ function missing(field) {
  */
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    var hasMapField = false,
-        hasImplicitPresenceField = false,
-        i = 0;
-    for (; i < mtype.fieldsArray.length; ++i) {
-        var pfield = mtype._fieldsArray[i];
-        if (pfield.map)
-            hasMapField = true;
-        if (!pfield.repeated && !pfield.map && !pfield.hasPresence)
-            hasImplicitPresenceField = true;
-    }
-    var gen = util.codegen(["r", "l", "z", "q", "g"], mtype.name + "$decode")
+    var gen = util.codegen(["r", "l", "e", "n"], mtype.name + "$decode")
     ("if(!(r instanceof Reader))")
         ("r=Reader.create(r)")
-    ("if(q===undefined)q=0")
-    ("if(q>Reader.recursionLimit)")
-        ("throw Error(\"max depth exceeded\")")
-    ("var c=l===undefined?r.len:r.pos+l,m=g||new C" + (hasMapField ? ",k,v" : hasImplicitPresenceField ? ",v" : ""))
+    ("if(n===undefined)n=0")
+    ("if(n>Reader.recursionLimit)")
+        ("throw Error(\"maximum nesting depth exceeded\")")
+    ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? ",k,value" : ""))
     ("while(r.pos<c){")
-        ("var s=r.pos")
-        ("var t=r.tag()")
-        ("if(t===z){")
-            ("z=undefined")
+        ("var t=r.uint32()")
+        ("if(t===e)")
             ("break")
-        ("}");
-    if (mtype.fieldsArray.length) gen
-        ("var u=t&7")
-        ("switch(t>>>=3){");
-    for (i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
+        ("switch(t>>>3){");
+
+    var i = 0;
+    for (; i < /* initializes */ mtype.fieldsArray.length; ++i) {
         var field = mtype._fieldsArray[i].resolve(),
             type  = field.resolvedType instanceof Enum ? "int32" : field.type,
-            ref   = "m" + util.safeProp(field.name);
+            ref   = "m" + util.safeProp(field.name); gen
+            ("case %i: {", field.id);
 
         // Map fields
-        if (field.map) {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==2)")
-                    ("break")
+        if (field.map) { gen
                 ("if(%s===util.emptyObject)", ref)
                     ("%s={}", ref)
-                ("var c2=r.uint32()+r.pos");
+                ("var c2 = r.uint32()+r.pos");
 
             if (types.defaults[field.keyType] !== undefined) gen
                 ("k=%j", types.defaults[field.keyType]);
             else gen
                 ("k=null");
 
-            if (types.long[type] !== undefined) gen
-                ("v=util.Long?util.Long.fromNumber(0,%j):0", type === "uint64" || type === "fixed64");
-            else if (types.defaults[type] !== undefined) gen
-                ("v=%j", types.defaults[type]);
+            if (types.defaults[type] !== undefined) gen
+                ("value=%j", types.defaults[type]);
             else gen
-                ("v=null");
+                ("value=null");
 
             gen
                 ("while(r.pos<c2){")
-                    ("var t2=r.tag()")
-                    ("u=t2&7")
-                    ("switch(t2>>>=3){")
-                        ("case 1:")
-                            ("if(u!==%i)", types.mapKey[field.keyType])
-                                ("break")
-                            ("k=r.%s()", field.keyType)
-                            ("continue")
-                        ("case 2:")
-                            ("if(u!==%i)", types.basic[type] === undefined ? 2 : types.basic[type])
-                                ("break");
+                    ("var tag2=r.uint32()")
+                    ("switch(tag2>>>3){")
+                        ("case 1: k=r.%s(); break", field.keyType)
+                        ("case 2:");
 
             if (types.basic[type] === undefined) gen
-                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1)", i); // can't be groups
+                            ("value=types[%i].decode(r,r.uint32(),undefined,n+1)", i); // can't be groups
             else gen
-                            ("v=r.%s()", type);
+                            ("value=r.%s()", type);
 
             gen
-                            ("continue")
+                            ("break")
+                        ("default:")
+                            ("r.skipType(tag2&7,n)")
+                            ("break")
                     ("}")
-                    ("r.skipType(u,q,t2)")
                 ("}");
 
-            var val = types.basic[type] === undefined ? "v||new types[" + i + "].ctor" : "v";
             if (types.long[field.keyType] !== undefined) gen
-                ("%s[typeof k===\"object\"?util.longToHash(k):k]=%s", ref, val);
+                ("%s[typeof k===\"object\"?util.longToHash(k):k]=value", ref);
             else {
                 if (field.keyType === "string") gen
                 ("if(k===\"__proto__\")")
                     ("util.makeProp(%s,k)", ref);
                 gen
-                ("%s[k]=%s", ref, val);
+                ("%s[k]=value", ref);
             }
 
         // Repeated fields
         } else if (field.repeated) { gen
-            ("case %i:", field.id)
-            ("{");
+
+                ("if(!(%s&&%s.length))", ref, ref)
+                    ("%s=[]", ref);
 
             // Packable (always check for forward and backward compatiblity)
             if (types.packed[type] !== undefined) gen
-                ("if(u===2){")
-                    ("if(!(%s&&%s.length))", ref, ref)
-                        ("%s=[]", ref)
+                ("if((t&7)===2){")
                     ("var c2=r.uint32()+r.pos")
                     ("while(r.pos<c2)")
                         ("%s.push(r.%s())", ref, type)
-                    ("continue")
-                ("}");
+                ("}else");
 
             // Non-packed
-            gen
-                ("if(u!==%i)", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])
-                    ("break")
-                ("if(!(%s&&%s.length))", ref, ref)
-                    ("%s=[]", ref);
-            if (types.basic[type] === undefined) {
-                if (field.delimited) gen
-                    ("%s.push(types[%i].decode(r,undefined,%i,q+1))", ref, i, field.id * 8 + 4);
-                else gen
-                    ("%s.push(types[%i].decode(r,r.uint32(),undefined,q+1))", ref, i);
-            } else gen
+            if (types.basic[type] === undefined) gen(field.delimited
+                    ? "%s.push(types[%i].decode(r,undefined,((t&~7)|4),n+1))"
+                    : "%s.push(types[%i].decode(r,r.uint32(),undefined,n+1))", ref, i);
+            else gen
                     ("%s.push(r.%s())", ref, type);
 
         // Non-repeated
-        } else if (types.basic[type] === undefined) {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==%i)", field.delimited ? 3 : 2)
-                    ("break");
-            if (field.delimited) gen
-                ("%s=types[%i].decode(r,undefined,%i,q+1,%s)", ref, i, field.id * 8 + 4, ref);
-            else gen
-                ("%s=types[%i].decode(r,r.uint32(),undefined,q+1,%s)", ref, i, ref);
-        }
-        else if (field.hasPresence) {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==%i)", types.basic[type])
-                    ("break")
+        } else if (types.basic[type] === undefined) gen(field.delimited
+                ? "%s=types[%i].decode(r,undefined,((t&~7)|4),n+1)"
+                : "%s=types[%i].decode(r,r.uint32(),undefined,n+1)", ref, i);
+        else gen
                 ("%s=r.%s()", ref, type);
-        } else {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==%i)", types.basic[type])
-                    ("break");
-            if (field.resolvedType instanceof Enum && field.typeDefault !== 0) gen
-                // TODO: Protoc rejects open enums whose first value is not zero.
-                // We should do the same, but for v8 this would be a regression.
-                ("if((v=r.%s())!==%j)", type, field.typeDefault);
-            else if (type === "string" || type === "bytes") gen
-                ("if((v=r.%s()).length)", type);
-            else if (types.long[type] !== undefined) gen
-                ("if(typeof(v=r.%s())===\"object\"?v.low||v.high:v!==0)", type);
-            else if (type === "double" || type === "float") gen
-                ("if((v=r.%s())!==0)", type);
-            else gen
-                ("if(v=r.%s())", type);
-            gen
-                    ("%s=v", ref)
-                ("else")
-                    ("delete %s", ref); // rare/odd case: later default clears earlier non-default
-        }
-        if (field.partOf) gen
-                ("m%s=%j", util.safeProp(field.partOf.name), field.name);
         gen
-                ("continue")
+                ("break")
             ("}");
-    }
-    if (i) gen
-        ("}");
-    // Unknown fields
-    gen
-        ("r.skipType(%s,q,t)", i ? "u" : "t&7")
-        ("util.makeProp(m,\"$unknowns\",false);")
-        ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
-    ("}")
-    ("if(z!==undefined)")
-        ("throw Error(\"missing end group\")");
+        // Unknown fields
+    } gen
+            ("default:")
+                ("r.skipType(t&7,n)")
+                ("break")
+
+        ("}")
+    ("}");
 
     // Field presence
     for (i = 0; i < mtype._fieldsArray.length; ++i) {
         var rfield = mtype._fieldsArray[i];
         if (rfield.required) gen
-    ("if(!m.hasOwnProperty(%j))", rfield.name)
+            ("if(!Object.hasOwnProperty.call(m,%j))", rfield.name)
         ("throw util.ProtocolError(%j,{instance:m})", missing(rfield));
     }
 
@@ -591,13 +1620,13 @@ function decoder(mtype) {
     /* eslint-enable no-unexpected-multiline */
 }
 
-},{"23":23,"24":24,"5":5}],4:[function(require,module,exports){
+},{"16":16,"34":34,"35":35}],15:[function(require,module,exports){
 "use strict";
 module.exports = encoder;
 
-var Enum     = require(5),
-    types    = require(23),
-    util     = require(24);
+var Enum     = require(16),
+    types    = require(34),
+    util     = require(35);
 
 /**
  * Generates a partial message type encoder.
@@ -644,12 +1673,7 @@ function encoder(mtype) {
         if (field.map) {
             gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)){", ref, field.name) // !== undefined && !== null
-        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref);
-            if (field.keyType === "bool") gen
-            ("w.uint32(%i).fork().uint32(%i).bool(util.boolFromKey(ks[i]))", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType]);
-            else if (types.long[field.keyType] !== undefined) gen
-            ("w.uint32(%i).fork().uint32(%i).%s(util.longFromKey(ks[i],%j))", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType, field.keyType === "uint64" || field.keyType === "fixed64");
-            else gen
+        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)
             ("w.uint32(%i).fork().uint32(%i).%s(ks[i])", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);
             if (wireType === undefined) gen
             ("types[%i].encode(%s[ks[i]],w.uint32(18).fork(),q+1).ldelim().ldelim()", index, ref); // can't be groups
@@ -685,7 +1709,7 @@ function encoder(mtype) {
 
         // Non-repeated
         } else {
-            if (!field.required) gen
+            if (field.optional) gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j))", ref, field.name); // !== undefined && !== null
 
             if (wireType === undefined)
@@ -697,23 +1721,20 @@ function encoder(mtype) {
     }
 
     return gen
-    ("if(m.$unknowns!=null&&Object.hasOwnProperty.call(m,\"$unknowns\"))")
-        ("for(var i=0;i<m.$unknowns.length;++i)")
-            ("w.raw(m.$unknowns[i])")
     ("return w");
     /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
 }
 
-},{"23":23,"24":24,"5":5}],5:[function(require,module,exports){
+},{"16":16,"34":34,"35":35}],16:[function(require,module,exports){
 "use strict";
 module.exports = Enum;
 
 // extends ReflectionObject
-var ReflectionObject = require(13);
+var ReflectionObject = require(24);
 ((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";
 
-var Namespace = require(12),
-    util = require(24);
+var Namespace = require(23),
+    util = require(35);
 
 /**
  * Constructs a new enum instance.
@@ -724,7 +1745,7 @@ var Namespace = require(12),
  * @param {Object.<string,number>} [values] Enum values as an object, by name
  * @param {Object.<string,*>} [options] Declared options
  * @param {string} [comment] The comment for this enum
- * @param {Object.<string,string|null>} [comments] The value comments for this enum
+ * @param {Object.<string,string>} [comments] The value comments for this enum
  * @param {Object.<string,Object<string,*>>|undefined} [valuesOptions] The value options for this enum
  */
 function Enum(name, values, options, comment, comments, valuesOptions) {
@@ -753,7 +1774,7 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
 
     /**
      * Value comment texts, if any.
-     * @type {Object.<string,string|null>}
+     * @type {Object.<string,string>}
      */
     this.comments = comments || {};
 
@@ -803,13 +1824,8 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
 /**
  * Enum descriptor.
  * @interface IEnum
- * @property {string} [edition] Edition
  * @property {Object.<string,number>} values Enum values
  * @property {Object.<string,*>} [options] Enum options
- * @property {Object.<string,Object.<string,*>>} [valuesOptions] Enum value options
- * @property {Array.<number[]|string>} [reserved] Reserved ranges
- * @property {string|null} [comment] Enum comment
- * @property {Object.<string,string|null>} [comments] Value comments
  */
 
 /**
@@ -820,7 +1836,7 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @throws {TypeError} If arguments are invalid
  */
 Enum.fromJSON = function fromJSON(name, json) {
-    var enm = new Enum(name, json.values, json.options, json.comment, json.comments, json.valuesOptions);
+    var enm = new Enum(name, json.values, json.options, json.comment, json.comments);
     enm.reserved = json.reserved;
     if (json.edition)
         enm._edition = json.edition;
@@ -937,21 +1953,21 @@ Enum.prototype.isReservedName = function isReservedName(name) {
     return Namespace.isReservedName(this.reserved, name);
 };
 
-},{"12":12,"13":13,"24":24}],6:[function(require,module,exports){
+},{"23":23,"24":24,"35":35}],17:[function(require,module,exports){
 "use strict";
 module.exports = Field;
 
 // extends ReflectionObject
-var ReflectionObject = require(13);
+var ReflectionObject = require(24);
 ((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";
 
-var Enum  = require(5),
-    types = require(23),
-    util  = require(24);
+var Enum  = require(16),
+    types = require(34),
+    util  = require(35);
 
 var Type; // cyclic
 
-var ruleRe = /^(?:required|optional|repeated)$/;
+var ruleRe = /^required|optional|repeated$/;
 
 /**
  * Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.
@@ -1026,6 +2042,9 @@ function Field(name, id, type, rule, extend, options, comment) {
      * Field rule, if any.
      * @type {string|undefined}
      */
+    if (rule === "proto3_optional") {
+        rule = "optional";
+    }
     this.rule = rule && rule !== "optional" ? rule : undefined; // toJSON
 
     /**
@@ -1196,12 +2215,10 @@ Field.prototype.setOption = function setOption(name, value, ifNotSet) {
 /**
  * Field descriptor.
  * @interface IField
- * @property {string} [edition] Edition
  * @property {string} [rule="optional"] Field rule
  * @property {string} type Field type
  * @property {number} id Field id
  * @property {Object.<string,*>} [options] Field options
- * @property {string|null} [comment] Field comment
  */
 
 /**
@@ -1291,8 +2308,8 @@ Field.prototype.resolve = function resolve() {
         this.defaultValue = this.typeDefault;
 
     // ensure proper value on prototype
-    if (this.parent instanceof Type && this.parent._ctor)
-        this.parent._ctor.prototype[this.name] = this.defaultValue;
+    if (this.parent instanceof Type)
+        this.parent.ctor.prototype[this.name] = this.defaultValue;
 
     return ReflectionObject.prototype.resolve.call(this);
 };
@@ -1344,7 +2361,6 @@ Field.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @param {Object} prototype Target prototype
  * @param {string} fieldName Field name
  * @returns {undefined}
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -1357,7 +2373,6 @@ Field.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @param {T} [defaultValue] Default value
  * @returns {FieldDecorator} Decorator function
  * @template T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
 
@@ -1375,11 +2390,6 @@ Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
     };
 };
 
-// Sets up cyclic dependencies (called in index-light)
-Field._configure = function configure(Type_) {
-    Type = Type_;
-};
-
 /**
  * Field decorator (TypeScript).
  * @name Field.d
@@ -1390,13 +2400,17 @@ Field._configure = function configure(Type_) {
  * @returns {FieldDecorator} Decorator function
  * @template T extends Message<T>
  * @variation 2
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 // like Field.d but without a default value
 
-},{"13":13,"23":23,"24":24,"5":5}],7:[function(require,module,exports){
+// Sets up cyclic dependencies (called in index-light)
+Field._configure = function configure(Type_) {
+    Type = Type_;
+};
+
+},{"16":16,"24":24,"34":34,"35":35}],18:[function(require,module,exports){
 "use strict";
-var protobuf = module.exports = require(8);
+var protobuf = module.exports = require(19);
 
 protobuf.build = "light";
 
@@ -1469,38 +2483,38 @@ function loadSync(filename, root) {
 protobuf.loadSync = loadSync;
 
 // Serialization
-protobuf.encoder          = require(4);
-protobuf.decoder          = require(3);
-protobuf.verifier         = require(39);
-protobuf.converter        = require(2);
+protobuf.encoder          = require(15);
+protobuf.decoder          = require(14);
+protobuf.verifier         = require(40);
+protobuf.converter        = require(13);
 
 // Reflection
-protobuf.ReflectionObject = require(13);
-protobuf.Namespace        = require(12);
-protobuf.Root             = require(17);
-protobuf.Enum             = require(5);
-protobuf.Type             = require(22);
-protobuf.Field            = require(6);
-protobuf.OneOf            = require(14);
-protobuf.MapField         = require(9);
-protobuf.Service          = require(21);
-protobuf.Method           = require(11);
+protobuf.ReflectionObject = require(24);
+protobuf.Namespace        = require(23);
+protobuf.Root             = require(28);
+protobuf.Enum             = require(16);
+protobuf.Type             = require(33);
+protobuf.Field            = require(17);
+protobuf.OneOf            = require(25);
+protobuf.MapField         = require(20);
+protobuf.Service          = require(32);
+protobuf.Method           = require(22);
 
 // Runtime
-protobuf.Message          = require(10);
-protobuf.wrappers         = require(40);
+protobuf.Message          = require(21);
+protobuf.wrappers         = require(41);
 
 // Utility
-protobuf.types            = require(23);
-protobuf.util             = require(24);
+protobuf.types            = require(34);
+protobuf.util             = require(35);
 
 // Set up possibly cyclic reflection dependencies
 protobuf.ReflectionObject._configure(protobuf.Root);
 protobuf.Namespace._configure(protobuf.Type, protobuf.Service, protobuf.Enum);
-protobuf.Root._configure(protobuf.Type, undefined, {});
+protobuf.Root._configure(protobuf.Type);
 protobuf.Field._configure(protobuf.Type);
 
-},{"10":10,"11":11,"12":12,"13":13,"14":14,"17":17,"2":2,"21":21,"22":22,"23":23,"24":24,"3":3,"39":39,"4":4,"40":40,"5":5,"6":6,"8":8,"9":9}],8:[function(require,module,exports){
+},{"13":13,"14":14,"15":15,"16":16,"17":17,"19":19,"20":20,"21":21,"22":22,"23":23,"24":24,"25":25,"28":28,"32":32,"33":33,"34":34,"35":35,"40":40,"41":41}],19:[function(require,module,exports){
 "use strict";
 var protobuf = exports;
 
@@ -1513,15 +2527,15 @@ var protobuf = exports;
 protobuf.build = "minimal";
 
 // Serialization
-protobuf.Writer       = require(41);
-protobuf.BufferWriter = require(42);
-protobuf.Reader       = require(15);
-protobuf.BufferReader = require(16);
+protobuf.Writer       = require(42);
+protobuf.BufferWriter = require(43);
+protobuf.Reader       = require(26);
+protobuf.BufferReader = require(27);
 
 // Utility
-protobuf.util         = require(34);
-protobuf.rpc          = require(19);
-protobuf.roots        = require(18);
+protobuf.util         = require(38);
+protobuf.rpc          = require(30);
+protobuf.roots        = require(29);
 protobuf.configure    = configure;
 
 /* istanbul ignore next */
@@ -1538,16 +2552,16 @@ function configure() {
 // Set up buffer utility according to the environment
 configure();
 
-},{"15":15,"16":16,"18":18,"19":19,"34":34,"41":41,"42":42}],9:[function(require,module,exports){
+},{"26":26,"27":27,"29":29,"30":30,"38":38,"42":42,"43":43}],20:[function(require,module,exports){
 "use strict";
 module.exports = MapField;
 
 // extends Field
-var Field = require(6);
+var Field = require(17);
 ((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";
 
-var types   = require(23),
-    util    = require(24);
+var types   = require(34),
+    util    = require(35);
 
 /**
  * Constructs a new map field instance.
@@ -1649,7 +2663,6 @@ MapField.prototype.resolve = function resolve() {
  * @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"|"bytes"|Object|Constructor<{}>} fieldValueType Field value type
  * @returns {FieldDecorator} Decorator function
  * @template T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 MapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {
 
@@ -1667,26 +2680,28 @@ MapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {
     };
 };
 
-},{"23":23,"24":24,"6":6}],10:[function(require,module,exports){
+},{"17":17,"34":34,"35":35}],21:[function(require,module,exports){
 "use strict";
 module.exports = Message;
 
-var util = require(34);
+var util = require(38);
 
 /**
  * Constructs a new message instance.
  * @classdesc Abstract runtime message.
  * @constructor
  * @param {Properties<T>} [properties] Properties to set
- * @property {Array.<Uint8Array>} [$unknowns] Unknown fields preserved while decoding
  * @template T extends object = object
  */
 function Message(properties) {
     // not used internally
     if (properties)
-        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-            if (properties[keys[i]] != null && keys[i] !== "__proto__")
-                this[keys[i]] = properties[keys[i]];
+        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) {
+            var key = keys[i];
+            if (key === "__proto__")
+                continue;
+            this[key] = properties[key];
+        }
 }
 
 /**
@@ -1703,10 +2718,12 @@ function Message(properties) {
  * @readonly
  */
 
+/*eslint-disable valid-jsdoc*/
+
 /**
  * Creates a new message of this type using the specified properties.
  * @param {Object.<string,*>} [properties] Properties to set
- * @returns {T} Message instance
+ * @returns {Message<T>} Message instance
  * @template T extends Message<T>
  * @this Constructor<T>
  */
@@ -1806,15 +2823,17 @@ Message.prototype.toJSON = function toJSON() {
     return this.$type.toObject(this, util.toJSONOptions);
 };
 
-},{"34":34}],11:[function(require,module,exports){
+/*eslint-enable valid-jsdoc*/
+
+},{"38":38}],22:[function(require,module,exports){
 "use strict";
 module.exports = Method;
 
 // extends ReflectionObject
-var ReflectionObject = require(13);
+var ReflectionObject = require(24);
 ((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";
 
-var util = require(24);
+var util = require(35);
 
 /**
  * Constructs a new service method instance.
@@ -1829,7 +2848,7 @@ var util = require(24);
  * @param {boolean|Object.<string,*>} [responseStream] Whether the response is streamed
  * @param {Object.<string,*>} [options] Declared options
  * @param {string} [comment] The comment for this method
- * @param {Array.<Object.<string,*>>} [parsedOptions] Declared options, properly parsed into objects
+ * @param {Object.<string,*>} [parsedOptions] Declared options, properly parsed into an object
  */
 function Method(name, type, requestType, responseType, requestStream, responseStream, options, comment, parsedOptions) {
 
@@ -1905,8 +2924,7 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
     this.comment = comment;
 
     /**
-     * Options properly parsed into objects
-     * @type {Array.<Object.<string,*>>|undefined}
+     * Options properly parsed into an object
      */
     this.parsedOptions = parsedOptions;
 }
@@ -1920,8 +2938,8 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
  * @property {boolean} [requestStream=false] Whether requests are streamed
  * @property {boolean} [responseStream=false] Whether responses are streamed
  * @property {Object.<string,*>} [options] Method options
- * @property {string|null} [comment] Method comment
- * @property {Array.<Object.<string,*>>} [parsedOptions] Method options properly parsed into objects
+ * @property {string} comment Method comments
+ * @property {Object.<string,*>} [parsedOptions] Method options properly parsed into an object
  */
 
 /**
@@ -1969,17 +2987,17 @@ Method.prototype.resolve = function resolve() {
     return ReflectionObject.prototype.resolve.call(this);
 };
 
-},{"13":13,"24":24}],12:[function(require,module,exports){
+},{"24":24,"35":35}],23:[function(require,module,exports){
 "use strict";
 module.exports = Namespace;
 
 // extends ReflectionObject
-var ReflectionObject = require(13);
+var ReflectionObject = require(24);
 ((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";
 
-var Field    = require(6),
-    util     = require(24),
-    OneOf    = require(14);
+var Field    = require(17),
+    util     = require(35),
+    OneOf    = require(25);
 
 var Type,    // cyclic
     Service,
@@ -2006,10 +3024,7 @@ var Type,    // cyclic
  * @throws {TypeError} If arguments are invalid
  */
 Namespace.fromJSON = function fromJSON(name, json, depth) {
-    if (depth === undefined)
-        depth = 0;
-    if (depth > util.recursionLimit)
-        throw Error("max depth exceeded");
+    depth = util.checkDepth(depth);
     return new Namespace(name, json.options).addJSON(json.nested, depth);
 };
 
@@ -2172,10 +3187,7 @@ Namespace.prototype.toJSON = function toJSON(toJSONOptions) {
  * @returns {Namespace} `this`
  */
 Namespace.prototype.addJSON = function addJSON(nestedJson, depth) {
-    if (depth === undefined)
-        depth = 0;
-    if (depth > util.recursionLimit)
-        throw Error("max depth exceeded");
+    depth = util.checkDepth(depth);
     var ns = this;
     /* istanbul ignore else */
     if (nestedJson) {
@@ -2340,8 +3352,7 @@ Namespace.prototype.define = function define(path, json) {
 Namespace.prototype.resolveAll = function resolveAll() {
     if (!this._needsRecursiveResolve) return this;
 
-    if (this._needsRecursiveFeatureResolution)
-        this._resolveFeaturesRecursive(this._edition);
+    this._resolveFeaturesRecursive(this._edition);
 
     var nested = this.nestedArray, i = 0;
     this.resolve();
@@ -2536,23 +3547,22 @@ Namespace._configure = function(Type_, Service_, Enum_) {
     Enum    = Enum_;
 };
 
-},{"13":13,"14":14,"24":24,"6":6}],13:[function(require,module,exports){
+},{"17":17,"24":24,"25":25,"35":35}],24:[function(require,module,exports){
 "use strict";
 module.exports = ReflectionObject;
 
 ReflectionObject.className = "ReflectionObject";
 
-const OneOf = require(14);
-var util = require(24);
+const OneOf = require(25);
+var util = require(35);
 
 var Root; // cyclic
 
 /* eslint-disable no-warning-comments */
 // TODO: Replace with embedded proto.
-var editions2024Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE2024", default_symbol_visibility: "EXPORT_TOP_LEVEL" };
-var editions2023Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
-var proto2Defaults = {enum_type: "CLOSED", field_presence: "EXPLICIT", json_format: "LEGACY_BEST_EFFORT", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "EXPANDED", utf8_validation: "NONE", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
-var proto3Defaults = {enum_type: "OPEN", field_presence: "IMPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
+var editions2023Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY"};
+var proto2Defaults = {enum_type: "CLOSED", field_presence: "EXPLICIT", json_format: "LEGACY_BEST_EFFORT", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "EXPANDED", utf8_validation: "NONE"};
+var proto3Defaults = {enum_type: "OPEN", field_presence: "IMPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY"};
 
 /**
  * Constructs a new reflection object instance.
@@ -2681,6 +3691,7 @@ Object.defineProperties(ReflectionObject.prototype, {
 /**
  * Converts this reflection object to its descriptor representation.
  * @returns {Object.<string,*>} Descriptor
+ * @abstract
  */
 ReflectionObject.prototype.toJSON = /* istanbul ignore next */ function toJSON() {
     throw Error(); // not implemented, shouldn't happen
@@ -2764,27 +3775,27 @@ ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition)
             defaults = Object.assign({}, proto3Defaults);
         } else if (edition === "2023") {
             defaults = Object.assign({}, editions2023Defaults);
-        } else if (edition === "2024") {
-            defaults = Object.assign({}, editions2024Defaults);
         } else {
             throw new Error("Unknown edition: " + edition);
         }
         this._features = util.merge(defaults, protoFeatures);
+        this._featuresResolved = true;
+        return;
+    }
+
+    // fields in Oneofs aren't actually children of them, so we have to
+    // special-case it
+    /* istanbul ignore else */
+    if (this.partOf instanceof OneOf) {
+        var lexicalParentFeaturesCopy = util.merge({}, this.partOf._features);
+        this._features = util.merge(lexicalParentFeaturesCopy, protoFeatures);
+    } else if (this.declaringField) {
+        // Skip feature resolution of sister fields.
+    } else if (this.parent) {
+        var parentFeaturesCopy = util.merge({}, this.parent._features);
+        this._features = util.merge(parentFeaturesCopy, protoFeatures);
     } else {
-        // fields in Oneofs aren't actually children of them, so we have to
-        // special-case it
-        /* istanbul ignore else */
-        if (this.partOf instanceof OneOf) {
-            var lexicalParentFeaturesCopy = util.merge({}, this.partOf._features);
-            this._features = util.merge(lexicalParentFeaturesCopy, protoFeatures);
-        } else if (this.declaringField) {
-            // Skip feature resolution of sister fields.
-        } else if (this.parent) {
-            var parentFeaturesCopy = util.merge({}, this.parent._features);
-            this._features = util.merge(parentFeaturesCopy, protoFeatures);
-        } else {
-            throw new Error("Unable to find a parent for " + this.fullName);
-        }
+        throw new Error("Unable to find a parent for " + this.fullName);
     }
     if (this.extensionField) {
         // Sister fields should have the same features as their extensions.
@@ -2920,16 +3931,16 @@ ReflectionObject._configure = function(Root_) {
     Root = Root_;
 };
 
-},{"14":14,"24":24}],14:[function(require,module,exports){
+},{"25":25,"35":35}],25:[function(require,module,exports){
 "use strict";
 module.exports = OneOf;
 
 // extends ReflectionObject
-var ReflectionObject = require(13);
+var ReflectionObject = require(24);
 ((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";
 
-var Field = require(6),
-    util  = require(24);
+var Field = require(17),
+    util  = require(35);
 
 /**
  * Constructs a new oneof instance.
@@ -2977,7 +3988,6 @@ function OneOf(name, fieldNames, options, comment) {
  * @interface IOneOf
  * @property {Array.<string>} oneof Oneof field names
  * @property {Object.<string,*>} [options] Oneof options
- * @property {string|null} [comment] Oneof comment
  */
 
 /**
@@ -3121,7 +4131,6 @@ Object.defineProperty(OneOf.prototype, "isProto3Optional", {
  * @param {Object} prototype Target prototype
  * @param {string} oneofName OneOf name
  * @returns {undefined}
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -3130,7 +4139,6 @@ Object.defineProperty(OneOf.prototype, "isProto3Optional", {
  * @param {...string} fieldNames Field names
  * @returns {OneOfDecorator} Decorator function
  * @template T extends string
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 OneOf.d = function decorateOneOf() {
     var fieldNames = new Array(arguments.length),
@@ -3147,11 +4155,11 @@ OneOf.d = function decorateOneOf() {
     };
 };
 
-},{"13":13,"24":24,"6":6}],15:[function(require,module,exports){
+},{"17":17,"24":24,"35":35}],26:[function(require,module,exports){
 "use strict";
 module.exports = Reader;
 
-var util      = require(34);
+var util      = require(38);
 
 var BufferReader; // cyclic
 
@@ -3228,108 +4236,28 @@ Reader.create = create();
 
 Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;
 
-/**
- * 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) {
-    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
-        return new this.buf.constructor(0);
-    return this._slice.call(this.buf, start, end);
-};
-
 /**
  * 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 (buf[pos++] < 128) {
-            this.pos = pos;
-            return value;
+        if ((this.pos += 5) > this.len) {
+            this.pos = this.len;
+            throw indexOutOfRange(this, 10);
         }
-    }
-    /* 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.
@@ -3431,20 +4359,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`
@@ -3552,8 +4467,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);
 };
 
 /**
@@ -3561,16 +4485,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);
+    var bytes = this.bytes();
+    return utf8.read(bytes, 0, bytes.length);
 };
 
 /**
@@ -3604,15 +4520,12 @@ Reader.recursionLimit = util.recursionLimit;
  * 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();
@@ -3624,18 +4537,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:
@@ -3680,15 +4583,15 @@ Reader._configure = function(BufferReader_) {
     });
 };
 
-},{"34":34}],16:[function(require,module,exports){
+},{"38":38}],27:[function(require,module,exports){
 "use strict";
 module.exports = BufferReader;
 
 // extends Reader
-var Reader = require(15);
+var Reader = require(26);
 (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 
-var util = require(34);
+var util = require(38);
 
 /**
  * Constructs a new buffer reader instance.
@@ -3713,36 +4616,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) {
-    if (start === end)
-        return util.Buffer.alloc(0);
-    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));
 };
 
 /**
@@ -3754,18 +4636,18 @@ BufferReader.prototype.string = function read_string_buffer() {
 
 BufferReader._configure();
 
-},{"15":15,"34":34}],17:[function(require,module,exports){
+},{"26":26,"38":38}],28:[function(require,module,exports){
 "use strict";
 module.exports = Root;
 
 // extends Namespace
-var Namespace = require(12);
+var Namespace = require(23);
 ((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = "Root";
 
-var Field   = require(6),
-    Enum    = require(5),
-    OneOf   = require(14),
-    util    = require(24);
+var Field   = require(17),
+    Enum    = require(16),
+    OneOf   = require(25),
+    util    = require(35);
 
 var Type,   // cyclic
     parse,  // might be excluded
@@ -3816,10 +4698,7 @@ function Root(options) {
  * @returns {Root} Root namespace
  */
 Root.fromJSON = function fromJSON(json, root, depth) {
-    if (depth === undefined)
-        depth = 0;
-    if (depth > util.recursionLimit)
-        throw Error("max depth exceeded");
+    depth = util.checkDepth(depth);
     if (!root)
         root = new Root();
     if (json.options)
@@ -3892,9 +4771,8 @@ Root.prototype.load = function load(filename, options, callback) {
         var idx = filename.lastIndexOf("google/protobuf/");
         if (idx > -1) {
             var altname = filename.substring(idx);
-            if (Object.prototype.hasOwnProperty.call(common, altname)) return altname;
+            if (altname in common) return altname;
         }
-        if (Object.prototype.hasOwnProperty.call(common, filename)) return filename;
         return null;
     }
 
@@ -3944,7 +4822,7 @@ Root.prototype.load = function load(filename, options, callback) {
         self.files.push(filename);
 
         // Shortcut bundled definitions
-        if (Object.prototype.hasOwnProperty.call(common, filename)) {
+        if (filename in common) {
             if (sync) {
                 process(filename, common[filename], depth);
             } else {
@@ -4172,9 +5050,9 @@ Root._configure = function(Type_, parse_, common_) {
     common = common_;
 };
 
-},{"12":12,"14":14,"24":24,"5":5,"6":6}],18:[function(require,module,exports){
+},{"16":16,"17":17,"23":23,"25":25,"35":35}],29:[function(require,module,exports){
 "use strict";
-module.exports = {};
+module.exports = Object.create(null);
 
 /**
  * Named roots.
@@ -4192,7 +5070,7 @@ module.exports = {};
  * var root = protobuf.roots["myroot"];
  */
 
-},{}],19:[function(require,module,exports){
+},{}],30:[function(require,module,exports){
 "use strict";
 
 /**
@@ -4228,13 +5106,13 @@ var rpc = exports;
  * @returns {undefined}
  */
 
-rpc.Service = require(20);
+rpc.Service = require(31);
 
-},{"20":20}],20:[function(require,module,exports){
+},{"31":31}],31:[function(require,module,exports){
 "use strict";
 module.exports = Service;
 
-var util = require(34);
+var util = require(38);
 
 // Extends EventEmitter
 (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
@@ -4374,19 +5252,17 @@ Service.prototype.end = function end(endedByRPC) {
     return this;
 };
 
-},{"34":34}],21:[function(require,module,exports){
+},{"38":38}],32:[function(require,module,exports){
 "use strict";
 module.exports = Service;
 
 // extends Namespace
-var Namespace = require(12);
+var Namespace = require(23);
 ((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
 
-var Method = require(11),
-    util   = require(24),
-    rpc    = require(19);
-
-var reservedRe = util.patterns.reservedRe;
+var Method = require(22),
+    util   = require(35),
+    rpc    = require(30);
 
 /**
  * Constructs a new service instance.
@@ -4418,9 +5294,7 @@ function Service(name, options) {
  * Service descriptor.
  * @interface IService
  * @extends INamespace
- * @property {string} [edition] Edition
  * @property {Object.<string,IMethod>} methods Method descriptors
- * @property {string|null} [comment] Service comment
  */
 
 /**
@@ -4432,10 +5306,7 @@ function Service(name, options) {
  * @throws {TypeError} If arguments are invalid
  */
 Service.fromJSON = function fromJSON(name, json, depth) {
-    if (depth === undefined)
-        depth = 0;
-    if (depth > util.recursionLimit)
-        throw Error("max depth exceeded");
+    depth = util.checkDepth(depth);
     var service = new Service(name, json.options);
     /* istanbul ignore else */
     if (json.methods)
@@ -4567,37 +5438,37 @@ Service.prototype.create = function create(rpcImpl, requestDelimited, responseDe
     var rpcService = new rpc.Service(rpcImpl, requestDelimited, responseDelimited);
     for (var i = 0, method; i < /* initializes */ this.methodsArray.length; ++i) {
         var methodName = util.lcFirst((method = this._methodsArray[i]).resolve().name).replace(/[^$\w_]/g, "");
-        rpcService[methodName] = util.codegen(["r","c"], reservedRe.test(methodName) ? methodName + "_" : methodName)("return this.rpcCall(m,q,s,r,c)")({
-            m: method,
-            q: method.resolvedRequestType.ctor,
-            s: method.resolvedResponseType.ctor
-        });
+        rpcService[methodName] = (function(method, requestType, responseType) {
+            return function rpcMethod(request, callback) {
+                return rpc.Service.prototype.rpcCall.call(this, method, requestType, responseType, request, callback);
+            };
+        })(method, method.resolvedRequestType.ctor, method.resolvedResponseType.ctor);
     }
     return rpcService;
 };
 
-},{"11":11,"12":12,"19":19,"24":24}],22:[function(require,module,exports){
+},{"22":22,"23":23,"30":30,"35":35}],33:[function(require,module,exports){
 "use strict";
 module.exports = Type;
 
 // extends Namespace
-var Namespace = require(12);
+var Namespace = require(23);
 ((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";
 
-var Enum      = require(5),
-    OneOf     = require(14),
-    Field     = require(6),
-    MapField  = require(9),
-    Service   = require(21),
-    Message   = require(10),
-    Reader    = require(15),
-    Writer    = require(41),
-    util      = require(24),
-    encoder   = require(4),
-    decoder   = require(3),
-    verifier  = require(39),
-    converter = require(2),
-    wrappers  = require(40);
+var Enum      = require(16),
+    OneOf     = require(25),
+    Field     = require(17),
+    MapField  = require(20),
+    Service   = require(32),
+    Message   = require(21),
+    Reader    = require(26),
+    Writer    = require(42),
+    util      = require(35),
+    encoder   = require(15),
+    decoder   = require(14),
+    verifier  = require(40),
+    converter = require(13),
+    wrappers  = require(41);
 
 /**
  * Constructs a new reflected message type instance.
@@ -4750,15 +5621,11 @@ Object.defineProperties(Type.prototype, {
             util.merge(ctor, Message, true);
 
             this._ctor = ctor;
-            delete this.decode;
-            delete this.fromObject;
 
             // Messages have non-enumerable default values on their prototype
             var i = 0;
-            for (var field; i < /* initializes */ this.fieldsArray.length; ++i) {
-                field = this._fieldsArray[i].resolve(); // ensures a proper value
-                ctor.prototype[field.name] = field.defaultValue;
-            }
+            for (; i < /* initializes */ this.fieldsArray.length; ++i)
+                this._fieldsArray[i].resolve(); // ensures a proper value
 
             // Messages have non-enumerable getters and setters for each virtual oneof field
             var ctorProperties = {};
@@ -4805,13 +5672,11 @@ function clearCache(type) {
  * Message type descriptor.
  * @interface IType
  * @extends INamespace
- * @property {string} [edition] Edition
  * @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors
  * @property {Object.<string,IField>} fields Field descriptors
  * @property {number[][]} [extensions] Extension ranges
  * @property {Array.<number[]|string>} [reserved] Reserved ranges
  * @property {boolean} [group=false] Whether a legacy group or not
- * @property {string|null} [comment] Message type comment
  */
 
 /**
@@ -4958,7 +5823,7 @@ Type.prototype.add = function add(object) {
             throw Error("duplicate id " + object.id + " in " + this);
         if (this.isReservedId(object.id))
             throw Error("id " + object.id + " is reserved in " + this);
-        if (this.isReservedName(object.name))
+        if (this.isReservedName(object.name) || object.name.charAt(0) === "$")
             throw Error("name '" + object.name + "' is reserved in " + this);
         if (object.name === "__proto__")
             return this;
@@ -4971,6 +5836,8 @@ Type.prototype.add = function add(object) {
         return clearCache(this);
     }
     if (object instanceof OneOf) {
+        if (object.name.charAt(0) === "$")
+            throw Error("name '" + object.name + "' is reserved in " + this);
         if (object.name === "__proto__")
             return this;
         if (!this.oneofs)
@@ -5037,7 +5904,7 @@ Type.prototype.isReservedName = function isReservedName(name) {
 /**
  * Creates a new message of this type using the specified properties.
  * @param {Object.<string,*>} [properties] Properties to set
- * @returns {ReflectedMessage} Message instance
+ * @returns {Message<{}>} Message instance
  */
 Type.prototype.create = function create(properties) {
     return new this.ctor(properties);
@@ -5065,8 +5932,7 @@ Type.prototype.setup = function setup() {
     this.decode = decoder(this)({
         Reader : Reader,
         types  : types,
-        util   : util,
-        C      : this.ctor
+        util   : util
     });
     this.verify = verifier(this)({
         types : types,
@@ -5074,8 +5940,7 @@ Type.prototype.setup = function setup() {
     });
     this.fromObject = converter.fromObject(this)({
         types : types,
-        util  : util,
-        C     : this.ctor
+        util  : util
     });
     this.toObject = converter.toObject(this)({
         types : types,
@@ -5085,13 +5950,15 @@ Type.prototype.setup = function setup() {
     // Inject custom wrappers for common types
     var wrapper = wrappers[fullName];
     if (wrapper) {
-        var wrapperThis = Object.create(this);
-        // Reuse this type's runtime constructor in wrapper fromObject/toObject
-        wrapperThis._ctor = this.ctor;
-        wrapperThis.fromObject = this.fromObject;
-        this.fromObject = wrapper.fromObject.bind(wrapperThis);
-        wrapperThis.toObject = this.toObject;
-        this.toObject = wrapper.toObject.bind(wrapperThis);
+        var originalThis = Object.create(this);
+        // if (wrapper.fromObject) {
+            originalThis.fromObject = this.fromObject;
+            this.fromObject = wrapper.fromObject.bind(originalThis);
+        // }
+        // if (wrapper.toObject) {
+            originalThis.toObject = this.toObject;
+            this.toObject = wrapper.toObject.bind(originalThis);
+        // }
     }
 
     return this;
@@ -5121,18 +5988,20 @@ Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
  * Decodes a message of this type.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
  * @param {number} [length] Length of the message, if known beforehand
- * @returns {ReflectedMessage} Decoded message
+ * @param {number} [end] Expected group end tag, if decoding a group
+ * @param {number} [depth] Current nesting depth
+ * @returns {Message<{}>} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError<{}>} If required fields are missing
  */
-Type.prototype.decode = function decode_setup(reader, length) { // eslint-disable-line no-unused-vars
-    return this.setup().decode.apply(this, arguments); // overrides this method
+Type.prototype.decode = function decode_setup(reader, length, end, depth) {
+    return this.setup().decode(reader, length, end, depth); // overrides this method
 };
 
 /**
  * Decodes a message of this type preceeded by its byte length as a varint.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
- * @returns {ReflectedMessage} Decoded message
+ * @returns {Message<{}>} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError} If required fields are missing
  */
@@ -5145,19 +6014,21 @@ Type.prototype.decodeDelimited = function decodeDelimited(reader) {
 /**
  * Verifies that field values are valid and that required fields are present.
  * @param {Object.<string,*>} message Plain object to verify
+ * @param {number} [depth] Current nesting depth
  * @returns {null|string} `null` if valid, otherwise the reason why it is not
  */
-Type.prototype.verify = function verify_setup(message) { // eslint-disable-line no-unused-vars
-    return this.setup().verify.apply(this, arguments); // overrides this method
+Type.prototype.verify = function verify_setup(message, depth) {
+    return this.setup().verify(message, depth); // overrides this method
 };
 
 /**
  * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
  * @param {Object.<string,*>} object Plain object to convert
- * @returns {ReflectedMessage} Message instance
+ * @param {number} [depth] Current nesting depth
+ * @returns {Message<{}>} Message instance
  */
-Type.prototype.fromObject = function fromObject(object) { // eslint-disable-line no-unused-vars
-    return this.setup().fromObject.apply(this, arguments);
+Type.prototype.fromObject = function fromObject(object, depth) {
+    return this.setup().fromObject(object, depth);
 };
 
 /**
@@ -5189,18 +6060,6 @@ Type.prototype.toObject = function toObject(message, options) { // eslint-disabl
     return this.setup().toObject.apply(this, arguments);
 };
 
-/**
- * Gets the type url for this type.
- * @param {string} [prefix] Custom type url prefix, defaults to `"type.googleapis.com"`
- * @returns {string} The type url
- */
-Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
-    if (prefix === undefined)
-        prefix = "type.googleapis.com";
-    var fullName = this.fullName;
-    return prefix + "/" + (fullName.charAt(0) === "." ? fullName.substring(1) : fullName);
-};
-
 /**
  * Decorator function as returned by {@link Type.d} (TypeScript).
  * @typedef TypeDecorator
@@ -5208,7 +6067,6 @@ Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
  * @param {Constructor<T>} target Target constructor
  * @returns {undefined}
  * @template T extends Message<T>
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -5216,7 +6074,6 @@ Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
  * @param {string} [typeName] Type name, defaults to the constructor's name
  * @returns {TypeDecorator<T>} Decorator function
  * @template T extends Message<T>
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Type.d = function decorateType(typeName) {
     return function typeDecorator(target) {
@@ -5224,7 +6081,7 @@ Type.d = function decorateType(typeName) {
     };
 };
 
-},{"10":10,"12":12,"14":14,"15":15,"2":2,"21":21,"24":24,"3":3,"39":39,"4":4,"40":40,"41":41,"5":5,"6":6,"9":9}],23:[function(require,module,exports){
+},{"13":13,"14":14,"15":15,"16":16,"17":17,"20":20,"21":21,"23":23,"25":25,"26":26,"32":32,"35":35,"40":40,"41":41,"42":42}],34:[function(require,module,exports){
 "use strict";
 
 /**
@@ -5233,7 +6090,7 @@ Type.d = function decorateType(typeName) {
  */
 var types = exports;
 
-var util = require(24);
+var util = require(35);
 
 var s = [
     "double",   // 0
@@ -5422,24 +6279,24 @@ types.packed = bake([
     /* bool     */ 0
 ]);
 
-},{"24":24}],24:[function(require,module,exports){
+},{"35":35}],35:[function(require,module,exports){
 "use strict";
 
 /**
  * Various utility functions.
  * @namespace
  */
-var util = module.exports = require(34);
+var util = module.exports = require(38);
 
-var roots = require(18);
+var roots = require(29);
 
 var Type, // cyclic
     Enum;
 
-util.codegen  = require(27);
-util.fetch    = require(29);
-util.path     = require(35);
-util.patterns = require(36);
+util.codegen = require(3);
+util.fetch   = require(5);
+util.path    = require(9);
+util.patterns = require(39);
 
 var reservedRe = util.patterns.reservedRe;
 
@@ -5447,7 +6304,21 @@ var reservedRe = util.patterns.reservedRe;
  * Node's fs module if available.
  * @type {Object.<string,*>}
  */
-util.fs = require(31);
+util.fs = require(36);
+
+/**
+ * Checks a recursion depth.
+ * @param {number|undefined} depth Depth of recursion
+ * @returns {number} Depth of recursion
+ * @throws {Error} If depth exceeds util.recursionLimit
+ */
+util.checkDepth = function checkDepth(depth) {
+    if (depth === undefined)
+        depth = 0;
+    if (depth > util.recursionLimit)
+        throw Error("max depth exceeded");
+    return depth;
+};
 
 /**
  * Converts an object's values to an array.
@@ -5542,7 +6413,6 @@ util.compareFieldsById = function compareFieldsById(a, b) {
  * @returns {Type} Reflected type
  * @template T extends Message<T>
  * @property {Root} root Decorators root
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 util.decorateType = function decorateType(ctor, typeName) {
 
@@ -5558,7 +6428,7 @@ util.decorateType = function decorateType(ctor, typeName) {
 
     /* istanbul ignore next */
     if (!Type)
-        Type = require(22);
+        Type = require(33);
 
     var type = new Type(typeName || ctor.name);
     util.decorateRoot.add(type);
@@ -5574,7 +6444,6 @@ var decorateEnumIndex = 0;
  * Decorator helper for enums (TypeScript).
  * @param {Object} object Enum object
  * @returns {Enum} Reflected enum
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 util.decorateEnum = function decorateEnum(object) {
 
@@ -5584,7 +6453,7 @@ util.decorateEnum = function decorateEnum(object) {
 
     /* istanbul ignore next */
     if (!Enum)
-        Enum = require(5);
+        Enum = require(16);
 
     var enm = new Enum("Enum" + decorateEnumIndex++, object);
     util.decorateRoot.add(enm);
@@ -5635,970 +6504,73 @@ util.setProperty = function setProperty(dst, path, value, ifNotSet) {
  * @name util.decorateRoot
  * @type {Root}
  * @readonly
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Object.defineProperty(util, "decorateRoot", {
     get: function() {
-        return roots["decorated"] || (roots["decorated"] = new (require(17))());
+        return roots["decorated"] || (roots["decorated"] = new (require(28))());
     }
 });
 
-},{"17":17,"18":18,"22":22,"27":27,"29":29,"31":31,"34":34,"35":35,"36":36,"5":5}],25:[function(require,module,exports){
+},{"16":16,"28":28,"29":29,"3":3,"33":33,"36":36,"38":38,"39":39,"5":5,"9":9}],36:[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);
-            }
-        }
-    });
+var fs = null;
+try {
+    fs = require(12);
+    if (!fs || !fs.readFile || !fs.readFileSync)
+        fs = null;
+} catch (e) {
+    // `fs` is unavailable in browsers and browser-like bundles.
 }
+module.exports = fs;
 
-},{}],26:[function(require,module,exports){
+},{"12":12}],37:[function(require,module,exports){
 "use strict";
+module.exports = LongBits;
 
-/**
- * A minimal base64 implementation for number arrays.
- * @memberof util
- * @namespace
- */
-var base64 = exports;
+var util = require(38);
 
 /**
- * Calculates the byte length of a base64 encoded string.
- * @param {string} string Base64 encoded string
- * @returns {number} Byte length
+ * 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
  */
-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);
-};
-
-// Base64 encoding table
-var b64 = new Array(64);
+function LongBits(lo, hi) {
 
-// Base64 decoding table
-var s64 = new Array(123);
+    // 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.
 
-// 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++;
+    /**
+     * Low bits.
+     * @type {number}
+     */
+    this.lo = lo >>> 0;
 
-s64[45] = 62; // - -> +
-s64[95] = 63; // _ -> /
+    /**
+     * High bits.
+     * @type {number}
+     */
+    this.hi = hi >>> 0;
+}
 
 /**
- * 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
+ * Zero bits.
+ * @memberof util.LongBits
+ * @type {util.LongBits}
  */
-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 zero = LongBits.zero = new LongBits(0, 0);
 
-var invalidEncoding = "invalid encoding";
+zero.toNumber = function() { return 0; };
+zero.zzEncode = zero.zzDecode = function() { return this; };
+zero.length = function() { return 1; };
 
 /**
- * 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;
-};
-
-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);
-};
-
-},{}],27:[function(require,module,exports){
-"use strict";
-module.exports = codegen;
-
-var patterns = require(36);
-var reservedRe = patterns.reservedRe;
-
-/**
- * Begins generating a function.
- * @memberof util
- * @param {string[]} functionParams Function parameter names
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- */
-function codegen(functionParams, functionName) {
-
-    /* istanbul ignore if */
-    if (typeof functionParams === "string") {
-        functionName = functionParams;
-        functionParams = undefined;
-    }
-
-    var body = [];
-
-    /**
-     * Appends code to the function's body or finishes generation.
-     * @typedef Codegen
-     * @type {function}
-     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
-     * @param {...*} [formatParams] Format parameters
-     * @returns {Codegen|Function} Itself or the generated function if finished
-     * @throws {Error} If format parameter counts do not match
-     */
-
-    function Codegen(formatStringOrScope) {
-        // note that explicit array handling below makes this ~50% faster
-
-        // finish the function
-        if (typeof formatStringOrScope !== "string") {
-            var source = toString();
-            if (codegen.verbose)
-                console.log("codegen: " + source); // eslint-disable-line no-console
-            source = "return " + source;
-            if (formatStringOrScope) {
-                var scopeKeys   = Object.keys(formatStringOrScope),
-                    scopeParams = new Array(scopeKeys.length + 1),
-                    scopeValues = new Array(scopeKeys.length),
-                    scopeOffset = 0;
-                while (scopeOffset < scopeKeys.length) {
-                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
-                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
-                }
-                scopeParams[scopeOffset] = source;
-                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
-            }
-            return Function(source)(); // eslint-disable-line no-new-func
-        }
-
-        // otherwise append to body
-        var formatParams = new Array(arguments.length - 1),
-            formatOffset = 0;
-        while (formatOffset < formatParams.length)
-            formatParams[formatOffset] = arguments[++formatOffset];
-        formatOffset = 0;
-        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
-            var value = formatParams[formatOffset++];
-            switch ($1) {
-                case "d": case "f": return String(Number(value));
-                case "i": return String(Math.floor(value));
-                case "j": return JSON.stringify(value);
-                case "s": return String(value);
-            }
-            return "%";
-        });
-        if (formatOffset !== formatParams.length)
-            throw Error("parameter count mismatch");
-        body.push(formatStringOrScope);
-        return Codegen;
-    }
-
-    function toString(functionNameOverride) {
-        return "function " + safeFunctionName(functionNameOverride || functionName) + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
-    }
-
-    Codegen.toString = toString;
-    return Codegen;
-}
-
-/**
- * Begins generating a function.
- * @memberof util
- * @function codegen
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- * @variation 2
- */
-
-/**
- * When set to `true`, codegen will log generated code to console. Useful for debugging.
- * @name util.codegen.verbose
- * @type {boolean}
- */
-codegen.verbose = false;
-
-function safeFunctionName(name) {
-    if (!name)
-        return "";
-    name = String(name).replace(/[^\w$]/g, "");
-    if (!name)
-        return "";
-    if (/^\d/.test(name))
-        name = "_" + name;
-    return reservedRe.test(name) ? name + "_" : name;
-}
-
-},{"36":36}],28:[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;
-};
-
-},{}],29:[function(require,module,exports){
-"use strict";
-module.exports = fetch;
-
-var asPromise = require(25),
-    fs        = require(31);
-
-/**
- * Node-style callback as used by {@link util.fetch}.
- * @typedef FetchCallback
- * @type {function}
- * @param {?Error} error Error, if any, otherwise `null`
- * @param {string} [contents] File contents, if there hasn't been an error
- * @returns {undefined}
- */
-
-/**
- * Options as used by {@link util.fetch}.
- * @interface IFetchOptions
- * @property {boolean} [binary=false] Whether expecting a binary response
- * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
- */
-
-/**
- * Fetches the contents of a file.
- * @memberof util
- * @param {string} filename File path or url
- * @param {IFetchOptions} options Fetch options
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- */
-function fetch(filename, options, callback) {
-    if (typeof options === "function") {
-        callback = options;
-        options = {};
-    } else if (!options)
-        options = {};
-
-    if (!callback)
-        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
-
-    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
-    if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
-            return err && typeof XMLHttpRequest !== "undefined"
-                ? fetch.xhr(filename, options, callback)
-                : err
-                ? callback(err)
-                : callback(null, options.binary ? contents : contents.toString("utf8"));
-        });
-
-    // use the XHR version otherwise.
-    return fetch.xhr(filename, options, callback);
-}
-
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- * @variation 2
- */
-
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {IFetchOptions} [options] Fetch options
- * @returns {Promise<string|Uint8Array>} Promise
- * @variation 3
- */
-
-/**/
-fetch.xhr = function fetch_xhr(filename, options, callback) {
-    var xhr = new XMLHttpRequest();
-    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
-
-        if (xhr.readyState !== 4)
-            return undefined;
-
-        // local cors security errors return status 0 / empty string, too. afaik this cannot be
-        // reliably distinguished from an actually empty file for security reasons. feel free
-        // to send a pull request if you are aware of a solution.
-        if (xhr.status !== 0 && xhr.status !== 200)
-            return callback(Error("status " + xhr.status));
-
-        // if binary data is expected, make sure that some sort of array is returned, even if
-        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
-        if (options.binary) {
-            var buffer = xhr.response;
-            if (!buffer) {
-                buffer = [];
-                for (var i = 0; i < xhr.responseText.length; ++i)
-                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
-            }
-            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
-        }
-        return callback(null, xhr.responseText);
-    };
-
-    if (options.binary) {
-        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
-        if ("overrideMimeType" in xhr)
-            xhr.overrideMimeType("text/plain; charset=x-user-defined");
-        xhr.responseType = "arraybuffer";
-    }
-
-    xhr.open("GET", filename);
-    xhr.send();
-};
-
-},{"25":25,"31":31}],30:[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;
-}
-
-},{}],31:[function(require,module,exports){
-"use strict";
-
-var fs = null;
-try {
-    fs = require(1);
-    if (!fs || !fs.readFile || !fs.readFileSync)
-        fs = null;
-} catch (e) {
-    // `fs` is unavailable in browsers and browser-like bundles.
-}
-module.exports = fs;
-
-},{"1":1}],32:[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;
-*/
-
-},{}],33:[function(require,module,exports){
-"use strict";
-module.exports = LongBits;
-
-var util = require(34);
-
-/**
- * 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}
+ * Zero hash.
+ * @memberof util.LongBits
+ * @type {string}
  */
 var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
 
@@ -6754,33 +6726,33 @@ LongBits.prototype.length = function length() {
          : part2 < 128 ? 9 : 10;
 };
 
-},{"34":34}],34:[function(require,module,exports){
+},{"38":38}],38:[function(require,module,exports){
 "use strict";
 var util = exports;
 
 // used to return a Promise where callback is omitted
-util.asPromise = require(25);
+util.asPromise = require(1);
 
 // converts to / from base64 encoded strings
-util.base64 = require(26);
+util.base64 = require(2);
 
 // base class of rpc.Service
-util.EventEmitter = require(28);
+util.EventEmitter = require(4);
 
 // float handling accross browsers
-util.float = require(30);
+util.float = require(7);
 
 // requires modules optionally and hides the call from bundlers
-util.inquire = require(32);
+util.inquire = require(8);
 
 // converts to / from utf8 encoded strings
-util.utf8 = require(38);
+util.utf8 = require(11);
 
 // provides a node-like buffer pool in the browser
-util.pool = require(37);
+util.pool = require(10);
 
 // utility to work with the low and high bits of a 64 bit value
-util.LongBits = require(33);
+util.LongBits = require(37);
 
 /**
  * Tests if the specified key can affect object prototypes.
@@ -6876,7 +6848,7 @@ util.isset =
  */
 util.isSet = function isSet(obj, prop) {
     var value = obj[prop];
-    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
+    if (value != null && Object.hasOwnProperty.call(obj, prop)) // eslint-disable-line eqeqeq
         return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
     return false;
 };
@@ -6963,7 +6935,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.
@@ -6977,7 +6949,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.
@@ -7003,27 +6975,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
@@ -7067,14 +7018,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
     });
@@ -7274,81 +7222,7 @@ util._configure = function() {
         };
 };
 
-},{"25":25,"26":26,"28":28,"30":30,"32":32,"33":33,"37":37,"38":38,"long":"long"}],35:[function(require,module,exports){
-"use strict";
-
-/**
- * A minimal path module to resolve Unix, Windows and URL paths alike.
- * @memberof util
- * @namespace
- */
-var path = exports;
-
-var isAbsolute =
-/**
- * Tests if the specified path is absolute.
- * @param {string} path Path to test
- * @returns {boolean} `true` if path is absolute
- */
-path.isAbsolute = function isAbsolute(path) {
-    return /^(?:\/|\w+:|\\\\\w+)/.test(path);
-};
-
-var normalize =
-/**
- * Normalizes the specified path.
- * @param {string} path Path to normalize
- * @returns {string} Normalized path
- */
-path.normalize = function normalize(path) {
-    var firstTwoCharacters = path.substring(0,2);
-    var uncPrefix = "";
-    if (firstTwoCharacters === "\\\\") {
-        uncPrefix = firstTwoCharacters;
-        path = path.substring(2);
-    }
-
-    path = path.replace(/\\/g, "/")
-               .replace(/\/{2,}/g, "/");
-    var parts    = path.split("/"),
-        absolute = isAbsolute(path),
-        prefix   = "";
-    if (absolute)
-        prefix = parts.shift() + "/";
-    for (var i = 0; i < parts.length;) {
-        if (parts[i] === "..") {
-            if (i > 0 && parts[i - 1] !== "..")
-                parts.splice(--i, 2);
-            else if (absolute)
-                parts.splice(i, 1);
-            else
-                ++i;
-        } else if (parts[i] === ".")
-            parts.splice(i, 1);
-        else
-            ++i;
-    }
-    return uncPrefix + prefix + parts.join("/");
-};
-
-/**
- * Resolves the specified include path against the specified origin path.
- * @param {string} originPath Path to the origin file
- * @param {string} includePath Include path relative to origin path
- * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
- * @returns {string} Path to the include file
- */
-path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
-    if (!alreadyNormalized)
-        includePath = normalize(includePath);
-    if (isAbsolute(includePath))
-        return includePath;
-    if (!alreadyNormalized)
-        originPath = normalize(originPath);
-    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
-};
-
-},{}],36:[function(require,module,exports){
+},{"1":1,"10":10,"11":11,"2":2,"37":37,"4":4,"7":7,"8":8,"long":"long"}],39:[function(require,module,exports){
 "use strict";
 
 var patterns = exports;
@@ -7357,194 +7231,12 @@ patterns.numberRe    = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/;
 patterns.typeRefRe   = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/;
 patterns.reservedRe  = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;
 
-},{}],37:[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;
-    };
-}
-
-},{}],38:[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;
-};
-
-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;
-}
-
-/**
- * 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_ascii(buffer, start, end) {
-    if (end - start < 1)
-        return "";
-
-    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);
-    }
-
-    for (; i < end; ++i) {
-        c1 = buffer[i];
-        if (c1 & 0x80)
-            return utf8_read_js(buffer, i, end, str);
-        str += String.fromCharCode(c1);
-    }
-
-    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;
-};
-
-},{}],39:[function(require,module,exports){
+},{}],40:[function(require,module,exports){
 "use strict";
 module.exports = verifier;
 
-var Enum      = require(5),
-    util      = require(24);
+var Enum      = require(16),
+    util      = require(35);
 
 function invalid(field, expected) {
     return field.name + ": " + expected + (field.repeated && expected !== "array" ? "[]" : field.map && expected !== "object" ? "{k:"+field.keyType+"}" : "") + " expected";
@@ -7574,7 +7266,7 @@ function genVerifyValue(gen, field, fieldIndex, ref) {
         } else {
             gen
             ("{")
-                ("var e=types[%i].verify(%s,q+1);", fieldIndex, ref)
+                ("var e=types[%i].verify(%s,n+1);", fieldIndex, ref)
                 ("if(e)")
                     ("return%j+e", field.name + ".")
             ("}");
@@ -7664,12 +7356,12 @@ function genVerifyKey(gen, field, ref) {
 function verifier(mtype) {
     /* eslint-disable no-unexpected-multiline */
 
-    var gen = util.codegen(["m", "q"], mtype.name + "$verify")
+    var gen = util.codegen(["m", "n"], mtype.name + "$verify")
     ("if(typeof m!==\"object\"||m===null)")
         ("return%j", "object expected")
-    ("if(q===undefined)q=0")
-    ("if(q>util.recursionLimit)")
-        ("return%j", "max depth exceeded");
+    ("if(n===undefined)n=0")
+    ("if(n>util.recursionLimit)")
+        ("return%j", "maximum nesting depth exceeded");
     var oneofs = mtype.oneofsArray,
         seenFirstField = {};
     if (oneofs.length) gen
@@ -7680,7 +7372,7 @@ function verifier(mtype) {
             ref   = "m" + util.safeProp(field.name);
 
         if (field.optional) gen
-        ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name); // !== undefined && !== null
+        ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)){", ref, field.name); // !== undefined && !== null
 
         // map fields
         if (field.map) { gen
@@ -7721,7 +7413,7 @@ function verifier(mtype) {
     /* eslint-enable no-unexpected-multiline */
 }
 
-},{"24":24,"5":5}],40:[function(require,module,exports){
+},{"16":16,"35":35}],41:[function(require,module,exports){
 "use strict";
 
 /**
@@ -7731,8 +7423,8 @@ function verifier(mtype) {
  */
 var wrappers = exports;
 
-var Message = require(10),
-    util    = require(34);
+var Message = require(21),
+    util    = require(38);
 
 /**
  * From object converter part of an {@link IWrapper}.
@@ -7799,6 +7491,7 @@ wrappers[".google.protobuf.Any"] = {
         var googleApi = "type.googleapis.com/";
         var prefix = "";
         var name = "";
+
         // decode value if requested and unmapped
         if (options && options.json && message.type_url && message.value) {
             // Only use fully qualified type name after the last '/'
@@ -7829,11 +7522,11 @@ wrappers[".google.protobuf.Any"] = {
     }
 };
 
-},{"10":10,"34":34}],41:[function(require,module,exports){
+},{"21":21,"38":38}],42:[function(require,module,exports){
 "use strict";
 module.exports = Writer;
 
-var util      = require(34);
+var util      = require(38);
 
 var BufferWriter; // cyclic
 
@@ -8005,11 +7698,6 @@ function writeByte(val, buf, pos) {
     buf[pos] = val & 255;
 }
 
-function writeStringAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
-}
-
 function writeVarint32(val, buf, pos) {
     while (val > 127) {
         buf[pos++] = val & 127 | 128;
@@ -8062,7 +7750,7 @@ Writer.prototype.uint32 = function write_uint32(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.int32 = function write_int32(value) {
-    return value < 0
+    return (value |= 0) < 0
         ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
         : this.uint32(value);
 };
@@ -8077,16 +7765,18 @@ Writer.prototype.sint32 = function write_sint32(value) {
 };
 
 function writeVarint64(val, buf, pos) {
-    while (val.hi) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
-        val.hi >>>= 7;
-    }
-    while (val.lo > 127) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = val.lo >>> 7;
-    }
-    buf[pos++] = val.lo;
+    var lo = val.lo,
+        hi = val.hi;
+    while (hi) {
+        buf[pos++] = lo & 127 | 128;
+        lo = (lo >>> 7 | hi << 25) >>> 0;
+        hi >>>= 7;
+    }
+    while (lo > 127) {
+        buf[pos++] = lo & 127 | 128;
+        lo = lo >>> 7;
+    }
+    buf[pos++] = lo;
 }
 
 /**
@@ -8220,16 +7910,6 @@ Writer.prototype.bytes = function write_bytes(value) {
     return this.uint32(len)._push(writeBytes, len, value);
 };
 
-/**
- * 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;
-    return len ? this._push(writeBytes, len, value) : this;
-};
-
 /**
  * Writes a string.
  * @param {string} value Value to write
@@ -8238,7 +7918,7 @@ Writer.prototype.raw = function write_raw(value) {
 Writer.prototype.string = function write_string(value) {
     var len = utf8.length(value);
     return len
-        ? this.uint32(len)._push(len === value.length ? writeStringAscii : utf8.write, len, value)
+        ? this.uint32(len)._push(utf8.write, len, value)
         : this._push(writeByte, 1, 0);
 };
 
@@ -8293,28 +7973,15 @@ Writer.prototype.ldelim = function ldelim() {
  * @returns {Uint8Array} Finished buffer
  */
 Writer.prototype.finish = function finish() {
-    return this.finishInto(this.constructor.alloc(this.len), 0);
-};
-
-/**
- * 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#len} 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;
-    var head = this.head.next,
-        pos  = offset;
+    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;
 };
 
@@ -8324,15 +7991,15 @@ Writer._configure = function(BufferWriter_) {
     BufferWriter._configure();
 };
 
-},{"34":34}],42:[function(require,module,exports){
+},{"38":38}],43:[function(require,module,exports){
 "use strict";
 module.exports = BufferWriter;
 
 // extends Writer
-var Writer = require(41);
+var Writer = require(42);
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 
-var util = require(34);
+var util = require(38);
 
 /**
  * Constructs a new buffer writer instance.
@@ -8381,23 +8048,6 @@ BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
     return this;
 };
 
-/**
- * Writes raw bytes without a tag or length prefix.
- * @name BufferWriter#raw
- * @function
- * @param {Uint8Array} value Raw bytes
- * @returns {BufferWriter} `this`
- */
-BufferWriter.prototype.raw = function write_raw_buffer(value) {
-    var len = value.length >>> 0;
-    return len ? this._push(BufferWriter.writeBytesBuffer, len, value) : this;
-};
-
-function writeStringBufferAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
-}
-
 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);
@@ -8414,7 +8064,7 @@ BufferWriter.prototype.string = function write_string_buffer(value) {
     var len = util.Buffer.byteLength(value);
     this.uint32(len);
     if (len)
-        this._push(len === value.length && len < 40 ? writeStringBufferAscii : writeStringBuffer, len, value);
+        this._push(writeStringBuffer, len, value);
     return this;
 };
 
@@ -8428,7 +8078,7 @@ BufferWriter.prototype.string = function write_string_buffer(value) {
 
 BufferWriter._configure();
 
-},{"34":34,"41":41}]},{},[7])
+},{"38":38,"42":42}]},{},[18])
 
 })();
 //# sourceMappingURL=protobuf.js.map